fix：删除node_modules

node_modules/.bin/cssesc

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

node_modules/.bin/cssesc.cmd

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

node_modules/.bin/cssesc.ps1

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

node_modules/.bin/esbuild

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

node_modules/.bin/esbuild.cmd

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

node_modules/.bin/esbuild.ps1

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

node_modules/.bin/json5

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

node_modules/.bin/json5.cmd

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

node_modules/.bin/json5.ps1

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

node_modules/.bin/parser

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

node_modules/.bin/parser.cmd

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

node_modules/.bin/parser.ps1

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

node_modules/.bin/rollup

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

node_modules/.bin/rollup.cmd

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

node_modules/.bin/rollup.ps1

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

node_modules/.bin/vite

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

node_modules/.bin/vite.cmd

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

node_modules/.bin/vite.ps1

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

node_modules/@babel/helper-validator-identifier/LICENSE

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

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

@@ -1,19 +0,0 @@
-# @babel/helper-validator-identifier
-
-> Validate identifier/keywords name
-
-See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/en/babel-helper-validator-identifier) for more information.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/helper-validator-identifier
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/helper-validator-identifier --dev
-```

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

@@ -1,57 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "isIdentifierName", {
-  enumerable: true,
-  get: function () {
-    return _identifier.isIdentifierName;
-  }
-});
-Object.defineProperty(exports, "isIdentifierChar", {
-  enumerable: true,
-  get: function () {
-    return _identifier.isIdentifierChar;
-  }
-});
-Object.defineProperty(exports, "isIdentifierStart", {
-  enumerable: true,
-  get: function () {
-    return _identifier.isIdentifierStart;
-  }
-});
-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;
-  }
-});
-Object.defineProperty(exports, "isKeyword", {
-  enumerable: true,
-  get: function () {
-    return _keyword.isKeyword;
-  }
-});
-
-var _identifier = require("./identifier");
-
-var _keyword = require("./keyword");

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

@@ -1,38 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isReservedWord = isReservedWord;
-exports.isStrictReservedWord = isStrictReservedWord;
-exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
-exports.isStrictBindReservedWord = isStrictBindReservedWord;
-exports.isKeyword = isKeyword;
-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);
-}

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

@@ -1,53 +0,0 @@
-{
-  "_args": [
-    [
-      "@babel/helper-validator-identifier@7.12.11",
-      "J:\\Github\\CURD-TS"
-    ]
-  ],
-  "_from": "@babel/helper-validator-identifier@7.12.11",
-  "_id": "@babel/helper-validator-identifier@7.12.11",
-  "_inBundle": false,
-  "_integrity": "sha1-yaHwIZF9y1zPDU5FPjmQIpgfye0=",
-  "_location": "/@babel/helper-validator-identifier",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "@babel/helper-validator-identifier@7.12.11",
-    "name": "@babel/helper-validator-identifier",
-    "escapedName": "@babel%2fhelper-validator-identifier",
-    "scope": "@babel",
-    "rawSpec": "7.12.11",
-    "saveSpec": null,
-    "fetchSpec": "7.12.11"
-  },
-  "_requiredBy": [
-    "/@babel/types"
-  ],
-  "_resolved": "http://192.168.250.101:4873/@babel%2fhelper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz",
-  "_spec": "7.12.11",
-  "_where": "J:\\Github\\CURD-TS",
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues"
-  },
-  "description": "Validate identifier/keywords name",
-  "devDependencies": {
-    "charcodes": "^0.2.0",
-    "unicode-13.0.0": "^0.8.0"
-  },
-  "exports": "./lib/index.js",
-  "homepage": "https://github.com/babel/babel#readme",
-  "license": "MIT",
-  "main": "./lib/index.js",
-  "name": "@babel/helper-validator-identifier",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/babel/babel.git",
-    "directory": "packages/babel-helper-validator-identifier"
-  },
-  "version": "7.12.11"
-}

node_modules/@babel/helper-validator-identifier/scripts/generate-identifier-regex.js

@@ -1,75 +0,0 @@
-"use strict";
-
-// Always use the latest available version of Unicode!
-// https://tc39.github.io/ecma262/#sec-conformance
-const version = "13.0.0";
-
-const start = require("unicode-" +
-  version +
-  "/Binary_Property/ID_Start/code-points.js").filter(function (ch) {
-  return ch > 0x7f;
-});
-let last = -1;
-const cont = [0x200c, 0x200d].concat(
-  require("unicode-" +
-    version +
-    "/Binary_Property/ID_Continue/code-points.js").filter(function (ch) {
-    return ch > 0x7f && search(start, ch, last + 1) == -1;
-  })
-);
-
-function search(arr, ch, starting) {
-  for (let i = starting; arr[i] <= ch && i < arr.length; last = i++) {
-    if (arr[i] === ch) return i;
-  }
-  return -1;
-}
-
-function pad(str, width) {
-  while (str.length < width) str = "0" + str;
-  return str;
-}
-
-function esc(code) {
-  const hex = code.toString(16);
-  if (hex.length <= 2) return "\\x" + pad(hex, 2);
-  else return "\\u" + pad(hex, 4);
-}
-
-function generate(chars) {
-  const astral = [];
-  let re = "";
-  for (let i = 0, at = 0x10000; i < chars.length; i++) {
-    const from = chars[i];
-    let to = from;
-    while (i < chars.length - 1 && chars[i + 1] == to + 1) {
-      i++;
-      to++;
-    }
-    if (to <= 0xffff) {
-      if (from == to) re += esc(from);
-      else if (from + 1 == to) re += esc(from) + esc(to);
-      else re += esc(from) + "-" + esc(to);
-    } else {
-      astral.push(from - at, to - from);
-      at = to;
-    }
-  }
-  return { nonASCII: re, astral: astral };
-}
-
-const startData = generate(start);
-const contData = generate(cont);
-
-console.log("/* prettier-ignore */");
-console.log('let nonASCIIidentifierStartChars = "' + startData.nonASCII + '";');
-console.log("/* prettier-ignore */");
-console.log('let nonASCIIidentifierChars = "' + contData.nonASCII + '";');
-console.log("/* prettier-ignore */");
-console.log(
-  "const astralIdentifierStartCodes = " + JSON.stringify(startData.astral) + ";"
-);
-console.log("/* prettier-ignore */");
-console.log(
-  "const astralIdentifierCodes = " + JSON.stringify(contData.astral) + ";"
-);

node_modules/@babel/parser/CHANGELOG.md

@@ -1,1073 +0,0 @@
-# Changelog
-
-> **Tags:**
-> - :boom:       [Breaking Change]
-> - :eyeglasses: [Spec Compliance]
-> - :rocket:     [New Feature]
-> - :bug:        [Bug Fix]
-> - :memo:       [Documentation]
-> - :house:      [Internal]
-> - :nail_care:  [Polish]
-
-> Semver Policy: https://github.com/babel/babel/tree/main/packages/babel-parser#semver
-
-_Note: Gaps between patch versions are faulty, broken or test releases._
-
-See the [Babel Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) for the pre-6.8.0 version Changelog.
-
-## 6.17.1 (2017-05-10)
-
-### :bug: Bug Fix
- * Fix typo in flow spread operator error (Brian Ng)
- * Fixed invalid number literal parsing ([#473](https://github.com/babel/babylon/pull/473)) (Alex Kuzmenko)
- * Fix number parser ([#433](https://github.com/babel/babylon/pull/433)) (Alex Kuzmenko)
- * Ensure non pattern shorthand props are checked for reserved words ([#479](https://github.com/babel/babylon/pull/479)) (Brian Ng)
- * Remove jsx context when parsing arrow functions ([#475](https://github.com/babel/babylon/pull/475)) (Brian Ng)
- * Allow super in class properties ([#499](https://github.com/babel/babylon/pull/499)) (Brian Ng)
- * Allow flow class field to be named constructor ([#510](https://github.com/babel/babylon/pull/510)) (Brian Ng)
-
-## 6.17.0 (2017-04-20)
-
-### :bug: Bug Fix
- * Cherry-pick #418 to 6.x ([#476](https://github.com/babel/babylon/pull/476)) (Sebastian McKenzie)
- * Add support for invalid escapes in tagged templates ([#274](https://github.com/babel/babylon/pull/274)) (Kevin Gibbons)
- * Throw error if new.target is used outside of a function ([#402](https://github.com/babel/babylon/pull/402)) (Brian Ng)
- * Fix parsing of class properties ([#351](https://github.com/babel/babylon/pull/351)) (Kevin Gibbons)
- * Fix parsing yield with dynamicImport ([#383](https://github.com/babel/babylon/pull/383)) (Brian Ng)
- * Ensure consistent start args for parseParenItem ([#386](https://github.com/babel/babylon/pull/386)) (Brian Ng)
-
-## 7.0.0-beta.8 (2017-04-04)
-
-### New Feature
-* Add support for flow type spread (#418) (Conrad Buck)
-* Allow statics in flow interfaces (#427) (Brian Ng)
-
-### Bug Fix
-* Fix predicate attachment to match flow parser (#428) (Brian Ng)
-* Add extra.raw back to JSXText and JSXAttribute (#344) (Alex Rattray)
-* Fix rest parameters with array and objects (#424) (Brian Ng)
-* Fix number parser (#433) (Alex Kuzmenko)
-
-### Docs
-* Fix CONTRIBUTING.md [skip ci] (#432) (Alex Kuzmenko)
-
-### Internal
-* Use babel-register script when running babel smoke tests (#442) (Brian Ng)
-
-## 7.0.0-beta.7 (2017-03-22)
-
-### Spec Compliance
-* Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu)
-
-### Bug Fix
-
-* Fix push-pop logic in flow (#405) (Daniel Tschinder)
-
-## 7.0.0-beta.6 (2017-03-21)
-
-### New Feature
-* Add support for invalid escapes in tagged templates (#274) (Kevin Gibbons)
-
-### Polish
-* Improves error message when super is called outside of constructor (#408) (Arshabh Kumar Agarwal)
-
-### Docs
-
-* [7.0] Moved value field in spec from ObjectMember to ObjectProperty as ObjectMethod's don't have it (#415) [skip ci] (James Browning)
-
-## 7.0.0-beta.5 (2017-03-21)
-
-### Bug Fix
-* Throw error if new.target is used outside of a function (#402) (Brian Ng)
-* Fix parsing of class properties (#351) (Kevin Gibbons)
-
-### Other
- * Test runner: Detect extra property in 'actual' but not in 'expected'. (#407) (Andy)
- * Optimize travis builds (#419) (Daniel Tschinder)
- * Update codecov to 2.0 (#412) (Daniel Tschinder)
- * Fix spec for ClassMethod: It doesn't have a function, it *is* a function. (#406) [skip ci] (Andy)
- * Changed Non-existent RestPattern to RestElement which is what is actually parsed (#409) [skip ci] (James Browning)
- * Upgrade flow to 0.41 (Daniel Tschinder)
- * Fix watch command (#403) (Brian Ng)
- * Update yarn lock (Daniel Tschinder)
- * Fix watch command (#403) (Brian Ng)
- * chore(package): update flow-bin to version 0.41.0 (#395) (greenkeeper[bot])
- * Add estree test for correct order of directives (Daniel Tschinder)
- * Add DoExpression to spec (#364) (Alex Kuzmenko)
- * Mention cloning of repository in CONTRIBUTING.md (#391) [skip ci] (Sumedh Nimkarde)
- * Explain how to run only one test (#389) [skip ci] (Aaron Ang)
-
- ## 7.0.0-beta.4 (2017-03-01)
-
-* Don't consume async when checking for async func decl (#377) (Brian Ng)
-* add `ranges` option [skip ci] (Henry Zhu)
-* Don't parse class properties without initializers when classProperties is disabled and Flow is enabled (#300) (Andrew Levine)
-
-## 7.0.0-beta.3 (2017-02-28)
-
-- [7.0] Change RestProperty/SpreadProperty to RestElement/SpreadElement (#384)
-- Merge changes from 6.x
-
-## 7.0.0-beta.2 (2017-02-20)
-
-- estree: correctly change literals in all cases (#368) (Daniel Tschinder)
-
-## 7.0.0-beta.1 (2017-02-20)
-
-- Fix negative number literal typeannotations (#366) (Daniel Tschinder)
-- Update contributing with more test info [skip ci] (#355) (Brian Ng)
-
-## 7.0.0-beta.0 (2017-02-15)
-
-- Reintroduce Variance node (#333) (Daniel Tschinder)
-- Rename NumericLiteralTypeAnnotation to NumberLiteralTypeAnnotation (#332) (Charles Pick)
-- [7.0] Remove ForAwaitStatement, add await flag to ForOfStatement (#349) (Brandon Dail)
-- chore(package): update ava to version 0.18.0 (#345) (greenkeeper[bot])
-- chore(package): update babel-plugin-istanbul to version 4.0.0 (#350) (greenkeeper[bot])
-- Change location of ObjectTypeIndexer to match flow (#228) (Daniel Tschinder)
-- Rename flow AST Type ExistentialTypeParam to ExistsTypeAnnotation (#322) (Toru Kobayashi)
-- Revert "Temporary rollback for erroring on trailing comma with spread (#154)" (#290) (Daniel Tschinder)
-- Remove classConstructorCall plugin (#291) (Brian Ng)
-- Update yarn.lock (Daniel Tschinder)
-- Update cross-env to 3.x (Daniel Tschinder)
-- [7.0] Remove node 0.10, 0.12 and 5 from Travis (#284) (Sergey Rubanov)
-- Remove `String.fromCodePoint` shim (#279) (Mathias Bynens)
-
-## 6.16.1 (2017-02-23)
-
-### :bug: Regression
-
-- Revert "Fix export default async function to be FunctionDeclaration" ([#375](https://github.com/babel/babylon/pull/375))
-
-Need to modify Babel for this AST node change, so moving to 7.0.
-
-- Revert "Don't parse class properties without initializers when classProperties plugin is disabled, and Flow is enabled" ([#376](https://github.com/babel/babylon/pull/376))
-
-[react-native](https://github.com/facebook/react-native/issues/12542) broke with this so we reverted.
-
-## 6.16.0 (2017-02-23)
-
-### :rocket: New Feature
-
-***ESTree*** compatibility as plugin ([#277](https://github.com/babel/babylon/pull/277)) (Daniel Tschinder)
-
-We finally introduce a new compatibility layer for ESTree. To put babylon into ESTree-compatible mode the new plugin `estree` can be enabled. In this mode the parser will output an AST that is compliant to the specs of [ESTree](https://github.com/estree/estree/)
-
-We highly recommend everyone who uses babylon outside of babel to use this plugin. This will make it much easier for users to switch between different ESTree-compatible parsers. We so far tested several projects with different parsers and exchanged their parser to babylon and in nearly all cases it worked out of the box. Some other estree-compatible parsers include `acorn`, `esprima`, `espree`, `flow-parser`, etc.
-
-To enable `estree` mode simply add the plugin in the config:
-```json
-{
-  "plugins": [ "estree" ]
-}
-```
-
-If you want to migrate your project from non-ESTree mode to ESTree, have a look at our [Readme](https://github.com/babel/babylon/#output), where all deviations are mentioned.
-
-Add a parseExpression public method ([#213](https://github.com/babel/babylon/pull/213)) (jeromew)
-
-Babylon exports a new function to parse a single expression
-
-```js
-import { parseExpression } from 'babylon';
-
-const ast = parseExpression('x || y && z', options);
-```
-
-The returned AST will only consist of the expression. The options are the same as for `parse()`
-
-Add startLine option ([#346](https://github.com/babel/babylon/pull/346)) (Raphael Mu)
-
-A new option was added to babylon allowing to change the initial linenumber for the first line which is usually `1`.
-Changing this for example to `100` will make line `1` of the input source to be marked as line `100`, line `2` as `101`, line `3` as `102`, ...
-
-Function predicate declaration ([#103](https://github.com/babel/babylon/pull/103)) (Panagiotis Vekris)
-
-Added support for function predicates which flow introduced in version 0.33.0
-
-```js
-declare function is_number(x: mixed): boolean %checks(typeof x === "number");
-```
-
-Allow imports in declare module ([#315](https://github.com/babel/babylon/pull/315)) (Daniel Tschinder)
-
-Added support for imports within module declarations which flow introduced in version 0.37.0
-
-```js
-declare module "C" {
-  import type { DT } from "D";
-  declare export type CT = { D: DT };
-}
-```
-
-### :eyeglasses: Spec Compliance
-
-Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons)
-
-This example now correctly throws an error when there is a semicolon after the decorator:
-
-```js
-class A {
-@a;
-foo(){}
-}
-```
-
-Keywords are not allowed as local specifier ([#307](https://github.com/babel/babylon/pull/307)) (Daniel Tschinder)
-
-Using keywords in imports is not allowed anymore:
-
-```js
-import { default } from "foo";
-import { a as debugger } from "foo";
-```
-
-Do not allow overwritting of primitive types ([#314](https://github.com/babel/babylon/pull/314)) (Daniel Tschinder)
-
-In flow it is now forbidden to overwrite the primitive types `"any"`, `"mixed"`, `"empty"`, `"bool"`, `"boolean"`, `"number"`, `"string"`, `"void"` and `"null"` with your own type declaration.
-
-Disallow import type { type a } from … ([#305](https://github.com/babel/babylon/pull/305)) (Daniel Tschinder)
-
-The following code now correctly throws an error
-
-```js
-import type { type a } from "foo";
-```
-
-Don't parse class properties without initializers when classProperties is disabled and Flow is enabled ([#300](https://github.com/babel/babylon/pull/300)) (Andrew Levine)
-
-Ensure that you enable the `classProperties` plugin in order to enable correct parsing of class properties. Prior to this version it was possible to parse them by enabling the `flow` plugin but this was not intended the behaviour.
-
-If you enable the flow plugin you can only define the type of the class properties, but not initialize them.
-
-Fix export default async function to be FunctionDeclaration ([#324](https://github.com/babel/babylon/pull/324)) (Daniel Tschinder)
-
-Parsing the following code now returns a `FunctionDeclaration` AST node instead of `FunctionExpression`.
-
-```js
-export default async function bar() {};
-```
-
-### :nail_care: Polish
-
-Improve error message on attempt to destructure named import ([#288](https://github.com/babel/babylon/pull/288)) (Brian Ng)
-
-### :bug: Bug Fix
-
-Fix negative number literal typeannotations ([#366](https://github.com/babel/babylon/pull/366)) (Daniel Tschinder)
-
-Ensure takeDecorators is called on exported class ([#358](https://github.com/babel/babylon/pull/358)) (Brian Ng)
-
-ESTree: correctly change literals in all cases ([#368](https://github.com/babel/babylon/pull/368)) (Daniel Tschinder)
-
-Correctly convert RestProperty to Assignable ([#339](https://github.com/babel/babylon/pull/339)) (Daniel Tschinder)
-
-Fix #321 by allowing question marks in type params ([#338](https://github.com/babel/babylon/pull/338)) (Daniel Tschinder)
-
-Fix #336 by correctly setting arrow-param ([#337](https://github.com/babel/babylon/pull/337)) (Daniel Tschinder)
-
-Fix parse error when destructuring `set` with default value ([#317](https://github.com/babel/babylon/pull/317)) (Brian Ng)
-
-Fix ObjectTypeCallProperty static ([#298](https://github.com/babel/babylon/pull/298)) (Dan Harper)
-
-
-### :house: Internal
-
-Fix generator-method-with-computed-name spec ([#360](https://github.com/babel/babylon/pull/360)) (Alex Rattray)
-
-Fix flow type-parameter-declaration test with unintended semantic ([#361](https://github.com/babel/babylon/pull/361)) (Alex Rattray)
-
-Cleanup and splitup parser functions ([#295](https://github.com/babel/babylon/pull/295)) (Daniel Tschinder)
-
-chore(package): update flow-bin to version 0.38.0 ([#313](https://github.com/babel/babylon/pull/313)) (greenkeeper[bot])
-
-Call inner function instead of 1:1 copy to plugin ([#294](https://github.com/babel/babylon/pull/294)) (Daniel Tschinder)
-
-Update eslint-config-babel to the latest version 🚀 ([#299](https://github.com/babel/babylon/pull/299)) (greenkeeper[bot])
-
-Update eslint-config-babel to the latest version 🚀 ([#293](https://github.com/babel/babylon/pull/293)) (greenkeeper[bot])
-
-devDeps: remove eslint-plugin-babel ([#292](https://github.com/babel/babylon/pull/292)) (Kai Cataldo)
-
-Correct indent eslint rule config ([#276](https://github.com/babel/babylon/pull/276)) (Daniel Tschinder)
-
-Fail tests that have expected.json and throws-option ([#285](https://github.com/babel/babylon/pull/285)) (Daniel Tschinder)
-
-### :memo: Documentation
-
-Update contributing with more test info [skip ci] ([#355](https://github.com/babel/babylon/pull/355)) (Brian Ng)
-
-Update API documentation ([#330](https://github.com/babel/babylon/pull/330)) (Timothy Gu)
-
-Added keywords to package.json ([#323](https://github.com/babel/babylon/pull/323)) (Dmytro)
-
-AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon/pull/318)) (Mathias Bynens)
-
-## 6.15.0 (2017-01-10)
-
-### :eyeglasses: Spec Compliance
-
-Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)
-
-This change implements flows new shorthand import syntax
-and where previously you had to write this code:
-
-```js
-import {someValue} from "blah";
-import type {someType} from "blah";
-import typeof {someOtherValue} from "blah";
-```
-
-you can now write it like this:
-
-```js
-import {
-  someValue,
-  type someType,
-  typeof someOtherValue,
-} from "blah";
-```
-
-For more information look at [this](https://github.com/facebook/flow/pull/2890) pull request.
-
-flow: allow leading pipes in all positions ([#256](https://github.com/babel/babylon/pull/256)) (Vladimir Kurchatkin)
-
-This change now allows a leading pipe everywhere types can be used:
-```js
-var f = (x): | 1 | 2 => 1;
-```
-
-Throw error when exporting non-declaration ([#241](https://github.com/babel/babylon/pull/241)) (Kai Cataldo)
-
-Previously babylon parsed the following exports, although they are not valid:
-```js
-export typeof foo;
-export new Foo();
-export function() {};
-export for (;;);
-export while(foo);
-```
-
-### :bug: Bug Fix
-
-Don't set inType flag when parsing property names ([#266](https://github.com/babel/babylon/pull/266)) (Vladimir Kurchatkin)
-
-This fixes parsing of this case:
-
-```js
-const map = {
-  [age <= 17] : 'Too young'
-};
-```
-
-Fix source location for JSXEmptyExpression nodes (fixes #248) ([#249](https://github.com/babel/babylon/pull/249)) (James Long)
-
-The following case produced an invalid AST
-```js
-<div>{/* foo */}</div>
-```
-
-Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy)
-
-When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.
-
-Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant)
-
-Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray)
-
-### :house: Internal
-
-User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder)
-
-Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo)
-
-Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine)
-
-Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder)
-
-Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine)
-
-Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU)
-
-Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot])
-
-chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot])
-
-chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot])
-
-## 6.14.1 (2016-11-17)
-
-### :bug: Bug Fix
-
-Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder)
-
-```js
-{
-  "plugins": ["*"]
-}
-```
-
-Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.
-
-## 6.14.0 (2016-11-16)
-
-### :eyeglasses: Spec Compliance
-
-Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
-
-[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words)
-
-Babylon will throw for more reserved words such as `enum` or `await` (in strict mode).
-
-```
-class enum {} // throws
-class await {} // throws in strict mode (module)
-```
-
-Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi)
-
-So where you used to have to write
-
-```js
-type A = (x: string, y: boolean) => number;
-type B = (z: string) => number;
-type C = { [key: string]: number };
-```
-
-you can now write (with flow 0.34.0)
-
-```js
-type A = (string, boolean) => number;
-type B = string => number;
-type C = { [string]: number };
-```
-
-Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner)
-
-Supports these form now of specifying array types:
-
-```js
-var a: number[][][][];
-var b: string[][];
-```
-
-### :bug: Bug Fix
-
-Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223))  (Daniel Tschinder)
-
-```
-declare module "foo" { declare module.exports: number }
-declare module "foo" { declare module.exports: number; }  // also allowed now
-```
-
-### :house: Internal
-
- * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman)
- * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger)
- * Add node 7 (Daniel Tschinder)
- * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper)
-
-## v6.13.1 (2016-10-26)
-
-### :nail_care: Polish
-
-- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML))
-
-```js
-const babylon = require('babylon');
-const ast = babylon.parse('var foo = "lol";');
-```
-
-With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.
-
-**Without bundling**
-![image](https://cloud.githubusercontent.com/assets/5233399/19420264/3133497e-93ad-11e6-9a6a-2da59c4f5c13.png)
-
-**With bundling**
-![image](https://cloud.githubusercontent.com/assets/5233399/19420267/388f556e-93ad-11e6-813e-7c5c396be322.png)
-
-- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu)
-- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu)
-
-## v6.13.0 (2016-10-21)
-
-### :eyeglasses: Spec Compliance
-
-Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
-
-> See https://flowtype.org/docs/variance.html for more information
-
-```js
-type T = { +p: T };
-interface T { -p: T };
-declare class T { +[k:K]: V };
-class T { -[k:K]: V };
-class C2 { +p: T = e };
-```
-
-Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman)
-
-```js
-({ __proto__: 1, __proto__: 2 }) // Throws an error now
-```
-
-### :bug: Bug Fix
-
-Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman)
-
-```js
-declare class A {
-  static: T;
-}
-```
-
-Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine)
-
-```js
-var foo = { async, bar };
-```
-
-### :nail_care: Polish
-
-Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder)
-
-> This improves the performance slightly (because of hidden classes)
-
-### :house: Internal
-
-Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman)
-
-Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman)
-
-Readd missin .eslinignore for IDEs (Daniel Tschinder)
-
-Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman)
-
-Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman)
-
-Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman)
-
-## v6.12.0 (2016-10-14)
-
-### :eyeglasses: Spec Compliance
-
-Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
-
-#### Dynamic Import
-
-- Proposal Repo: https://github.com/domenic/proposal-dynamic-import
-- Championed by [@domenic](https://github.com/domenic)
-- stage-2
-- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import)
-
-> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript
-
-```js
-import(`./section-modules/${link.dataset.entryModule}.js`)
-.then(module => {
-  module.loadPageInto(main);
-})
-```
-
-Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman)
-
-#### EmptyTypeAnnotation
-
-Just wasn't covered before.
-
-```js
-type T = empty;
-```
-
-### :bug: Bug Fix
-
-Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
-
-```js
-// was failing due to sparse array
-export const { foo: [ ,, qux7 ] } = bar;
-```
-
-Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper)
-
-```js
-declare class X {
-  foobar<T>(): void;
-  static foobar<T>(): void;
-}
-```
-
-Allow keyword in object/class property names with Flow type parameters ([#145](https://github.com/babel/babylon/pull/145)) (Dan Harper)
-
-```js
-class Foo {
-  delete<T>(item: T): T {
-    return item;
-  }
-}
-```
-
-Allow typeAnnotations for yield expressions ([#174](https://github.com/babel/babylon/pull/174))) (Daniel Tschinder)
-
-```js
-function *foo() {
-  const x = (yield 5: any);
-}
-```
-
-### :nail_care: Polish
-
-Annotate more errors with expected token ([#172](https://github.com/babel/babylon/pull/172))) (Moti Zilberman)
-
-```js
-// Unexpected token, expected ; (1:6)
-{ set 1 }
-```
-
-### :house: Internal
-
-Remove kcheck ([#173](https://github.com/babel/babylon/pull/173)))  (Daniel Tschinder)
-
-Also run flow, linting, babel tests on separate instances (add back node 0.10)
-
-## v6.11.6 (2016-10-12)
-
-### :bug: Bug Fix/Regression
-
-Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
-
-```js
-// was failing with `Cannot read property 'type' of null` because of null identifiers
-export const { foo: [ ,, qux7 ] } = bar;
-```
-
-## v6.11.5 (2016-10-12)
-
-### :eyeglasses: Spec Compliance
-
-Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo)
-
-```js
-// `foo` has already been exported. Exported identifiers must be unique. (2:20)
-export function foo() {};
-export const { a: [{foo}] } = bar;
-```
-
-Fix: Check for duplicate named exports in exported rest elements/properties ([#164](https://github.com/babel/babylon/pull/164)) (Kai Cataldo)
-
-```js
-// `foo` has already been exported. Exported identifiers must be unique. (2:22)
-export const foo = 1;
-export const [bar, ...foo] = baz;
-```
-
-### :bug: Bug Fix
-
-Fix: Allow identifier `async` for default param in arrow expression ([#165](https://github.com/babel/babylon/pull/165)) (Kai Cataldo)
-
-```js
-// this is ok now
-const test = ({async = true}) => {};
-```
-
-### :nail_care: Polish
-
-Babylon will now print out the token it's expecting if there's a `SyntaxError` ([#150](https://github.com/babel/babylon/pull/150)) (Daniel Tschinder)
-
-```bash
-# So in the case of a missing ending curly (`}`)
-Module build failed: SyntaxError: Unexpected token, expected } (30:0)
-  28 |   }
-  29 |
-> 30 |
-     | ^
-```
-
-## v6.11.4 (2016-10-03)
-
-Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)
-
-## v6.11.3 (2016-10-01)
-
-### :eyeglasses: Spec Compliance
-
-Add static errors for object rest (#149) ([@danez](https://github.com/danez))
-
-> https://github.com/sebmarkbage/ecmascript-rest-spread
-
-Object rest copies the *rest* of properties from the right hand side `obj` starting from the left to right.
-
-```js
-let { x, y, ...z } =  { x: 1, y: 2, z: 3 };
-// x = 1
-// y = 2
-// z = { z: 3 }
-```
-
-#### New Syntax Errors:
-
-**SyntaxError**: The rest element has to be the last element when destructuring (1:10)
-```bash
-> 1 | let { ...x, y, z } = { x: 1, y: 2, z: 3};
-    |           ^
-# Previous behavior:
-# x = { x: 1, y: 2, z: 3 }
-# y = 2
-# z = 3
-```
-
-Before, this was just a more verbose way of shallow copying `obj` since it doesn't actually do what you think.
-
-**SyntaxError**: Cannot have multiple rest elements when destructuring (1:13)
-
-```bash
-> 1 | let { x, ...y, ...z } = { x: 1, y: 2, z: 3};
-    |              ^
-# Previous behavior:
-# x = 1
-# y = { y: 2, z: 3 }
-# z = { y: 2, z: 3 }
-```
-
-Before y and z would just be the same value anyway so there is no reason to need to have both.
-
-**SyntaxError**: A trailing comma is not permitted after the rest element (1:16)
-
-```js
-let { x, y, ...z, } = obj;
-```
-
-The rationale for this is that the use case for trailing comma is that you can add something at the end without affecting the line above. Since a RestProperty always has to be the last property it doesn't make sense.
-
----
-
-get / set are valid property names in default assignment (#142) ([@jezell](https://github.com/jezell))
-
-```js
-// valid
-function something({ set = null, get = null }) {}
-```
-
-## v6.11.2 (2016-09-23)
-
-### Bug Fix
-
-- [#139](https://github.com/babel/babylon/issues/139) Don't do the duplicate check if not an identifier (#140) @hzoo
-
-```js
-// regression with duplicate export check
-SyntaxError: ./typography.js: `undefined` has already been exported. Exported identifiers must be unique. (22:13)
-  20 |
-  21 | export const { rhythm } = typography;
-> 22 | export const { TypographyStyle } = typography
-```
-
-Bail out for now, and make a change to account for destructuring in the next release.
-
-## 6.11.1 (2016-09-22)
-
-### Bug Fix
-- [#137](https://github.com/babel/babylon/pull/137) - Fix a regression with duplicate exports - it was erroring on all keys in `Object.prototype`. @danez
-
-```javascript
-export toString from './toString';
-```
-
-```bash
-`toString` has already been exported. Exported identifiers must be unique. (1:7)
-> 1 | export toString from './toString';
-    |        ^
-  2 |
-```
-
-## 6.11.0 (2016-09-22)
-
-### Spec Compliance (will break CI)
-
-- Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo
-
-```js
-// Only one default export allowed per module. (2:9)
-export default function() {};
-export { foo as default };
-
-// Only one default export allowed per module. (2:0)
-export default {};
-export default function() {};
-
-// `Foo` has already been exported. Exported identifiers must be unique. (2:0)
-export { Foo };
-export class Foo {};
-```
-
-### New Feature (Syntax)
-
-- Add support for computed class property names ([#121](https://github.com/babel/babylon/pull/121)) @motiz88
-
-```js
-// AST
-interface ClassProperty <: Node {
-  type: "ClassProperty";
-  key: Identifier;
-  value: Expression;
-  computed: boolean; // added
-}
-```
-
-```js
-// with "plugins": ["classProperties"]
-class Foo {
-  [x]
-  ['y']
-}
-
-class Bar {
-  [p]
-  [m] () {}
-}
- ```
-
-### Bug Fix
-
-- Fix `static` property falling through in the declare class Flow AST ([#135](https://github.com/babel/babylon/pull/135)) @danharper
-
-```js
-declare class X {
-    a: number;
-    static b: number; // static
-    c: number; // this was being marked as static in the AST as well
-}
-```
-
-### Polish
-
-- Rephrase "assigning/binding to rvalue" errors to include context ([#119](https://github.com/babel/babylon/pull/119)) @motiz88
-
-```js
-// Used to error with:
-// SyntaxError: Assigning to rvalue (1:0)
-
-// Now:
-// Invalid left-hand side in assignment expression (1:0)
-3 = 4
-
-// Invalid left-hand side in for-in statement (1:5)
-for (+i in {});
-```
-
-### Internal
-
-- Fix call to `this.parseMaybeAssign` with correct arguments ([#133](https://github.com/babel/babylon/pull/133)) @danez
-- Add semver note to changelog ([#131](https://github.com/babel/babylon/pull/131)) @hzoo
-
-## 6.10.0 (2016-09-19)
-
-> We plan to include some spec compliance bugs in patch versions. An example was the multiple default exports issue.
-
-### Spec Compliance
-
-* Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu)
-
-> It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. https://tc39.github.io/ecma262/2016/#sec-function-definitions-static-semantics-early-errors
-
-More Context: [tc39-notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2015-07/july-29.md#611-the-scope-of-use-strict-with-respect-to-destructuring-in-parameter-lists)
-
-For example:
-
-```js
-// this errors because it uses destructuring and default parameters
-// in a function with a "use strict" directive
-function a([ option1, option2 ] = []) {
-  "use strict";
-}
- ```
-
-The solution would be to use a top level "use strict" or to remove the destructuring or default parameters when using a function + "use strict" or to.
-
-### New Feature
-
-* Exact object type annotations for Flow plugin ([#104](https://github.com/babel/babylon/pull/104)) (Basil Hosmer)
-
-Added to flow in https://github.com/facebook/flow/commit/c710c40aa2a115435098d6c0dfeaadb023cd39b8
-
-Looks like:
-
-```js
-var a : {| x: number, y: string |} = { x: 0, y: 'foo' };
-```
-
-### Bug Fixes
-
-* Include `typeParameter` location in `ArrowFunctionExpression` ([#126](https://github.com/babel/babylon/pull/126)) (Daniel Tschinder)
-* Error on invalid flow type annotation with default assignment ([#122](https://github.com/babel/babylon/pull/122)) (Dan Harper)
-* Fix Flow return types on arrow functions ([#124](https://github.com/babel/babylon/pull/124)) (Dan Harper)
-
-### Misc
-
-* Add tests for export extensions ([#127](https://github.com/babel/babylon/pull/127)) (Daniel Tschinder)
-* Fix Contributing guidelines [skip ci] (Daniel Tschinder)
-
-## 6.9.2 (2016-09-09)
-
-The only change is to remove the `babel-runtime` dependency by compiling with Babel's ES2015 loose mode. So using babylon standalone should be smaller.
-
-## 6.9.1 (2016-08-23)
-
-This release contains mainly small bugfixes but also updates babylons default mode to es2017. The features for `exponentiationOperator`, `asyncFunctions` and `trailingFunctionCommas` which previously needed to be activated via plugin are now enabled by default and the plugins are now no-ops.
-
-### Bug Fixes
-
-- Fix issues with default object params in async functions ([#96](https://github.com/babel/babylon/pull/96)) @danez
-- Fix issues with flow-types and async function ([#95](https://github.com/babel/babylon/pull/95)) @danez
-- Fix arrow functions with destructuring, types & default value ([#94](https://github.com/babel/babylon/pull/94)) @danharper
-- Fix declare class with qualified type identifier ([#97](https://github.com/babel/babylon/pull/97)) @danez
-- Remove exponentiationOperator, asyncFunctions, trailingFunctionCommas plugins and enable them by default ([#98](https://github.com/babel/babylon/pull/98)) @danez
-
-## 6.9.0 (2016-08-16)
-
-### New syntax support
-
-- Add JSX spread children ([#42](https://github.com/babel/babylon/pull/42)) @calebmer
-
-(Be aware that React is not going to support this syntax)
-
-```js
-<div>
-  {...todos.map(todo => <Todo key={todo.id} todo={todo}/>)}
-</div>
-```
-
-- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez
-
-```js
-declare module "foo" {
-  declare module.exports: {}
-}
-```
-
-### New Features
-
-- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain
-- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens
-
-### Bug Fixes
-
-- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez
-- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez
-- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi
-- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez
-- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi
-- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez
-- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez
-
-### Internal
-
-- Add codecoverage to tests @danez
-- Fix tests to not save expected output if we expect the test to fail @danez
-- Make a shallow clone of babel for testing @danez
-- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot
-- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot
-- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot
-- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot
-
-## 6.8.4 (2016-07-06)
-
-### Bug Fixes
-
-- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez
-
-## 6.8.3 (2016-07-02)
-
-### Bug Fixes
-
-- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez
-
-## 6.8.2 (2016-06-24)
-
-### Bug Fixes
-
-- Fix parse error with yielding jsx elements in generators `function* it() { yield <a></a>; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal
-- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez
-- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez
-- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez
-- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez
-- Support negative numeric type literals @kittens
-- Remove line terminator restriction after await keyword @kittens
-- Remove grouped type arrow restriction as it seems flow no longer has it @kittens
-- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin
-- Fix parse error with arrow functions that have flow type parameter declarations `<T>(x: T): T => x;` ([#54](https://github.com/babel/babylon/pull/54)) @gabelevi
-
-### Documentation
-
-- Document AST differences from ESTree ([#41](https://github.com/babel/babylon/pull/41)) @nene
-- Move ast spec from babel/babel ([#46](https://github.com/babel/babylon/pull/46)) @hzoo
-
-### Internal
-
-- Enable skipped tests ([#16](https://github.com/babel/babylon/pull/16)) @danez
-- Add script to test latest version of babylon with babel ([#21](https://github.com/babel/babylon/pull/21)) @danez
-- Upgrade test runner ava @kittens
-- Add missing generate-identifier-regex script @kittens
-- Rename parser context types @kittens
-- Add node v6 to travis testing @hzoo
-- Update to Unicode v9 ([#45](https://github.com/babel/babylon/pull/45)) @mathiasbynens
-
-## 6.8.1 (2016-06-06)
-
-### New Feature
-
-- Parse type parameter declarations with defaults like `type Foo<T = string> = T`
-
-### Bug Fixes
-- Type parameter declarations need 1 or more type parameters.
-- The existential type `*` is not a valid type parameter.
-- The existential type `*` is a primary type
-
-### Spec Compliance
-- The param list for type parameter declarations now consists of `TypeParameter` nodes
-- New `TypeParameter` AST Node (replaces using the `Identifier` node before)
-
-```
-interface TypeParameter <: Node {
-  bound: TypeAnnotation;
-  default: TypeAnnotation;
-  name: string;
-  variance: "plus" | "minus";
-}
-```
-
-## 6.8.0 (2016-05-02)
-
-#### New Feature
-
-##### Parse Method Parameter Decorators ([#12](https://github.com/babel/babylon/pull/12))
-
-> [Method Parameter Decorators](https://goo.gl/8MmCMG) is now a TC39 [stage 0 proposal](https://github.com/tc39/ecma262/blob/master/stage0.md).
-
-Examples:
-
-```js
-class Foo {
-  constructor(@foo() x, @bar({ a: 123 }) @baz() y) {}
-}
-
-export default function func(@foo() x, @bar({ a: 123 }) @baz() y) {}
-
-var obj = {
-  method(@foo() x, @bar({ a: 123 }) @baz() y) {}
-};
-```
-
-##### Parse for-await statements (w/ `asyncGenerators` plugin) ([#17](https://github.com/babel/babylon/pull/17))
-
-There is also a new node type, `ForAwaitStatement`.
-
-> [Async generators and for-await](https://github.com/tc39/proposal-async-iteration) are now a [stage 2 proposal](https://github.com/tc39/ecma262#current-proposals).
-
-Example:
-
-```js
-async function f() {
-  for await (let x of y);
-}
-```

node_modules/@babel/parser/LICENSE

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

node_modules/@babel/parser/README.md

@@ -1,19 +0,0 @@
-# @babel/parser
-
-> A JavaScript parser
-
-See our website [@babel/parser](https://babeljs.io/docs/en/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%20(babylon)%22+is%3Aopen) associated with this package.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/parser
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/parser --dev
-```

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

@@ -1,15 +0,0 @@
-#!/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

@@ -1,79 +0,0 @@
-{
-  "_args": [
-    [
-      "@babel/parser@7.12.11",
-      "J:\\Github\\CURD-TS"
-    ]
-  ],
-  "_from": "@babel/parser@7.12.11",
-  "_id": "@babel/parser@7.12.11",
-  "_inBundle": false,
-  "_integrity": "sha1-nONZW810vFxGaQXobFNbiyUBHnk=",
-  "_location": "/@babel/parser",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "@babel/parser@7.12.11",
-    "name": "@babel/parser",
-    "escapedName": "@babel%2fparser",
-    "scope": "@babel",
-    "rawSpec": "7.12.11",
-    "saveSpec": null,
-    "fetchSpec": "7.12.11"
-  },
-  "_requiredBy": [
-    "/@vue/compiler-core",
-    "/@vue/compiler-sfc"
-  ],
-  "_resolved": "http://192.168.250.101:4873/@babel%2fparser/-/parser-7.12.11.tgz",
-  "_spec": "7.12.11",
-  "_where": "J:\\Github\\CURD-TS",
-  "author": {
-    "name": "Sebastian McKenzie",
-    "email": "sebmck@gmail.com"
-  },
-  "bin": {
-    "parser": "./bin/babel-parser.js"
-  },
-  "bugs": {
-    "url": "https://github.com/babel/babel/issues"
-  },
-  "description": "A JavaScript parser",
-  "devDependencies": {
-    "@babel/code-frame": "7.12.11",
-    "@babel/helper-fixtures": "7.12.10",
-    "@babel/helper-validator-identifier": "7.12.11",
-    "charcodes": "^0.2.0"
-  },
-  "engines": {
-    "node": ">=6.0.0"
-  },
-  "files": [
-    "bin",
-    "lib",
-    "typings"
-  ],
-  "homepage": "https://babeljs.io/",
-  "keywords": [
-    "babel",
-    "javascript",
-    "parser",
-    "tc39",
-    "ecmascript",
-    "@babel/parser"
-  ],
-  "license": "MIT",
-  "main": "lib/index.js",
-  "name": "@babel/parser",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/babel/babel.git",
-    "directory": "packages/babel-parser"
-  },
-  "types": "typings/babel-parser.d.ts",
-  "version": "7.12.11"
-}

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

@@ -1,162 +0,0 @@
-// 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
-): import("@babel/types").File;
-
-/**
- * Parse the provided code as a single expression.
- */
-export function parseExpression(
-  input: string,
-  options?: ParserOptions
-): 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;
-
-  /**
-   * 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;
-
-  /**
-   * 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 =
-  | "asyncGenerators"
-  | "bigInt"
-  | "classPrivateMethods"
-  | "classPrivateProperties"
-  | "classProperties"
-  | "classStaticBlock"
-  | "decimal"
-  | "decorators"
-  | "decorators-legacy"
-  | "doExpressions"
-  | "dynamicImport"
-  | "estree"
-  | "exportDefaultFrom"
-  | "exportNamespaceFrom" // deprecated
-  | "flow"
-  | "flowComments"
-  | "functionBind"
-  | "functionSent"
-  | "importMeta"
-  | "jsx"
-  | "logicalAssignment"
-  | "importAssertions"
-  | "moduleStringNames"
-  | "nullishCoalescingOperator"
-  | "numericSeparator"
-  | "objectRestSpread"
-  | "optionalCatchBinding"
-  | "optionalChaining"
-  | "partialApplication"
-  | "pipelineOperator"
-  | "placeholders"
-  | "privateIn"
-  | "throwExpressions"
-  | "topLevelAwait"
-  | "typescript"
-  | "v8intrinsic"
-  | ParserPluginWithOptions;
-
-export type ParserPluginWithOptions =
-  | ["decorators", DecoratorsPluginOptions]
-  | ["pipelineOperator", PipelineOperatorPluginOptions]
-  | ["recordAndTuple", RecordAndTuplePluginOptions]
-  | ["flow", FlowPluginOptions];
-
-export interface DecoratorsPluginOptions {
-  decoratorsBeforeExport?: boolean;
-}
-
-export interface PipelineOperatorPluginOptions {
-  proposal: "fsharp" | "minimal" | "smart";
-}
-
-export interface RecordAndTuplePluginOptions {
-  syntaxType: "bar" | "hash";
-}
-
-export interface FlowPluginOptions {
-  all?: boolean;
-}

node_modules/@babel/types/LICENSE

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

node_modules/@babel/types/README.md

@@ -1,19 +0,0 @@
-# @babel/types
-
-> Babel Types is a Lodash-esque utility library for AST nodes
-
-See our website [@babel/types](https://babeljs.io/docs/en/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
-
-## Install
-
-Using npm:
-
-```sh
-npm install --save-dev @babel/types
-```
-
-or using yarn:
-
-```sh
-yarn add @babel/types --dev
-```

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

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = assertNode;
-
-var _isNode = _interopRequireDefault(require("../validators/isNode"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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}"`);
-  }
-}

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

@@ -1,1474 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.assertArrayExpression = assertArrayExpression;
-exports.assertAssignmentExpression = assertAssignmentExpression;
-exports.assertBinaryExpression = assertBinaryExpression;
-exports.assertInterpreterDirective = assertInterpreterDirective;
-exports.assertDirective = assertDirective;
-exports.assertDirectiveLiteral = assertDirectiveLiteral;
-exports.assertBlockStatement = assertBlockStatement;
-exports.assertBreakStatement = assertBreakStatement;
-exports.assertCallExpression = assertCallExpression;
-exports.assertCatchClause = assertCatchClause;
-exports.assertConditionalExpression = assertConditionalExpression;
-exports.assertContinueStatement = assertContinueStatement;
-exports.assertDebuggerStatement = assertDebuggerStatement;
-exports.assertDoWhileStatement = assertDoWhileStatement;
-exports.assertEmptyStatement = assertEmptyStatement;
-exports.assertExpressionStatement = assertExpressionStatement;
-exports.assertFile = assertFile;
-exports.assertForInStatement = assertForInStatement;
-exports.assertForStatement = assertForStatement;
-exports.assertFunctionDeclaration = assertFunctionDeclaration;
-exports.assertFunctionExpression = assertFunctionExpression;
-exports.assertIdentifier = assertIdentifier;
-exports.assertIfStatement = assertIfStatement;
-exports.assertLabeledStatement = assertLabeledStatement;
-exports.assertStringLiteral = assertStringLiteral;
-exports.assertNumericLiteral = assertNumericLiteral;
-exports.assertNullLiteral = assertNullLiteral;
-exports.assertBooleanLiteral = assertBooleanLiteral;
-exports.assertRegExpLiteral = assertRegExpLiteral;
-exports.assertLogicalExpression = assertLogicalExpression;
-exports.assertMemberExpression = assertMemberExpression;
-exports.assertNewExpression = assertNewExpression;
-exports.assertProgram = assertProgram;
-exports.assertObjectExpression = assertObjectExpression;
-exports.assertObjectMethod = assertObjectMethod;
-exports.assertObjectProperty = assertObjectProperty;
-exports.assertRestElement = assertRestElement;
-exports.assertReturnStatement = assertReturnStatement;
-exports.assertSequenceExpression = assertSequenceExpression;
-exports.assertParenthesizedExpression = assertParenthesizedExpression;
-exports.assertSwitchCase = assertSwitchCase;
-exports.assertSwitchStatement = assertSwitchStatement;
-exports.assertThisExpression = assertThisExpression;
-exports.assertThrowStatement = assertThrowStatement;
-exports.assertTryStatement = assertTryStatement;
-exports.assertUnaryExpression = assertUnaryExpression;
-exports.assertUpdateExpression = assertUpdateExpression;
-exports.assertVariableDeclaration = assertVariableDeclaration;
-exports.assertVariableDeclarator = assertVariableDeclarator;
-exports.assertWhileStatement = assertWhileStatement;
-exports.assertWithStatement = assertWithStatement;
-exports.assertAssignmentPattern = assertAssignmentPattern;
-exports.assertArrayPattern = assertArrayPattern;
-exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
-exports.assertClassBody = assertClassBody;
-exports.assertClassExpression = assertClassExpression;
-exports.assertClassDeclaration = assertClassDeclaration;
-exports.assertExportAllDeclaration = assertExportAllDeclaration;
-exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
-exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
-exports.assertExportSpecifier = assertExportSpecifier;
-exports.assertForOfStatement = assertForOfStatement;
-exports.assertImportDeclaration = assertImportDeclaration;
-exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
-exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
-exports.assertImportSpecifier = assertImportSpecifier;
-exports.assertMetaProperty = assertMetaProperty;
-exports.assertClassMethod = assertClassMethod;
-exports.assertObjectPattern = assertObjectPattern;
-exports.assertSpreadElement = assertSpreadElement;
-exports.assertSuper = assertSuper;
-exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
-exports.assertTemplateElement = assertTemplateElement;
-exports.assertTemplateLiteral = assertTemplateLiteral;
-exports.assertYieldExpression = assertYieldExpression;
-exports.assertAwaitExpression = assertAwaitExpression;
-exports.assertImport = assertImport;
-exports.assertBigIntLiteral = assertBigIntLiteral;
-exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
-exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
-exports.assertOptionalCallExpression = assertOptionalCallExpression;
-exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
-exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
-exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
-exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
-exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
-exports.assertClassImplements = assertClassImplements;
-exports.assertDeclareClass = assertDeclareClass;
-exports.assertDeclareFunction = assertDeclareFunction;
-exports.assertDeclareInterface = assertDeclareInterface;
-exports.assertDeclareModule = assertDeclareModule;
-exports.assertDeclareModuleExports = assertDeclareModuleExports;
-exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
-exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
-exports.assertDeclareVariable = assertDeclareVariable;
-exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
-exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
-exports.assertDeclaredPredicate = assertDeclaredPredicate;
-exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
-exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
-exports.assertFunctionTypeParam = assertFunctionTypeParam;
-exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
-exports.assertInferredPredicate = assertInferredPredicate;
-exports.assertInterfaceExtends = assertInterfaceExtends;
-exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
-exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
-exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
-exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
-exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
-exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
-exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
-exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
-exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
-exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
-exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
-exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
-exports.assertObjectTypeProperty = assertObjectTypeProperty;
-exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
-exports.assertOpaqueType = assertOpaqueType;
-exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
-exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
-exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
-exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
-exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
-exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
-exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
-exports.assertTypeAlias = assertTypeAlias;
-exports.assertTypeAnnotation = assertTypeAnnotation;
-exports.assertTypeCastExpression = assertTypeCastExpression;
-exports.assertTypeParameter = assertTypeParameter;
-exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
-exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
-exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
-exports.assertVariance = assertVariance;
-exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
-exports.assertEnumDeclaration = assertEnumDeclaration;
-exports.assertEnumBooleanBody = assertEnumBooleanBody;
-exports.assertEnumNumberBody = assertEnumNumberBody;
-exports.assertEnumStringBody = assertEnumStringBody;
-exports.assertEnumSymbolBody = assertEnumSymbolBody;
-exports.assertEnumBooleanMember = assertEnumBooleanMember;
-exports.assertEnumNumberMember = assertEnumNumberMember;
-exports.assertEnumStringMember = assertEnumStringMember;
-exports.assertEnumDefaultedMember = assertEnumDefaultedMember;
-exports.assertJSXAttribute = assertJSXAttribute;
-exports.assertJSXClosingElement = assertJSXClosingElement;
-exports.assertJSXElement = assertJSXElement;
-exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
-exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
-exports.assertJSXSpreadChild = assertJSXSpreadChild;
-exports.assertJSXIdentifier = assertJSXIdentifier;
-exports.assertJSXMemberExpression = assertJSXMemberExpression;
-exports.assertJSXNamespacedName = assertJSXNamespacedName;
-exports.assertJSXOpeningElement = assertJSXOpeningElement;
-exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
-exports.assertJSXText = assertJSXText;
-exports.assertJSXFragment = assertJSXFragment;
-exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
-exports.assertJSXClosingFragment = assertJSXClosingFragment;
-exports.assertNoop = assertNoop;
-exports.assertPlaceholder = assertPlaceholder;
-exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;
-exports.assertArgumentPlaceholder = assertArgumentPlaceholder;
-exports.assertBindExpression = assertBindExpression;
-exports.assertClassProperty = assertClassProperty;
-exports.assertPipelineTopicExpression = assertPipelineTopicExpression;
-exports.assertPipelineBareFunction = assertPipelineBareFunction;
-exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
-exports.assertClassPrivateProperty = assertClassPrivateProperty;
-exports.assertClassPrivateMethod = assertClassPrivateMethod;
-exports.assertImportAttribute = assertImportAttribute;
-exports.assertDecorator = assertDecorator;
-exports.assertDoExpression = assertDoExpression;
-exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
-exports.assertPrivateName = assertPrivateName;
-exports.assertRecordExpression = assertRecordExpression;
-exports.assertTupleExpression = assertTupleExpression;
-exports.assertDecimalLiteral = assertDecimalLiteral;
-exports.assertStaticBlock = assertStaticBlock;
-exports.assertTSParameterProperty = assertTSParameterProperty;
-exports.assertTSDeclareFunction = assertTSDeclareFunction;
-exports.assertTSDeclareMethod = assertTSDeclareMethod;
-exports.assertTSQualifiedName = assertTSQualifiedName;
-exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
-exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
-exports.assertTSPropertySignature = assertTSPropertySignature;
-exports.assertTSMethodSignature = assertTSMethodSignature;
-exports.assertTSIndexSignature = assertTSIndexSignature;
-exports.assertTSAnyKeyword = assertTSAnyKeyword;
-exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
-exports.assertTSBigIntKeyword = assertTSBigIntKeyword;
-exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;
-exports.assertTSNeverKeyword = assertTSNeverKeyword;
-exports.assertTSNullKeyword = assertTSNullKeyword;
-exports.assertTSNumberKeyword = assertTSNumberKeyword;
-exports.assertTSObjectKeyword = assertTSObjectKeyword;
-exports.assertTSStringKeyword = assertTSStringKeyword;
-exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
-exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
-exports.assertTSUnknownKeyword = assertTSUnknownKeyword;
-exports.assertTSVoidKeyword = assertTSVoidKeyword;
-exports.assertTSThisType = assertTSThisType;
-exports.assertTSFunctionType = assertTSFunctionType;
-exports.assertTSConstructorType = assertTSConstructorType;
-exports.assertTSTypeReference = assertTSTypeReference;
-exports.assertTSTypePredicate = assertTSTypePredicate;
-exports.assertTSTypeQuery = assertTSTypeQuery;
-exports.assertTSTypeLiteral = assertTSTypeLiteral;
-exports.assertTSArrayType = assertTSArrayType;
-exports.assertTSTupleType = assertTSTupleType;
-exports.assertTSOptionalType = assertTSOptionalType;
-exports.assertTSRestType = assertTSRestType;
-exports.assertTSNamedTupleMember = assertTSNamedTupleMember;
-exports.assertTSUnionType = assertTSUnionType;
-exports.assertTSIntersectionType = assertTSIntersectionType;
-exports.assertTSConditionalType = assertTSConditionalType;
-exports.assertTSInferType = assertTSInferType;
-exports.assertTSParenthesizedType = assertTSParenthesizedType;
-exports.assertTSTypeOperator = assertTSTypeOperator;
-exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
-exports.assertTSMappedType = assertTSMappedType;
-exports.assertTSLiteralType = assertTSLiteralType;
-exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
-exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
-exports.assertTSInterfaceBody = assertTSInterfaceBody;
-exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
-exports.assertTSAsExpression = assertTSAsExpression;
-exports.assertTSTypeAssertion = assertTSTypeAssertion;
-exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
-exports.assertTSEnumMember = assertTSEnumMember;
-exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
-exports.assertTSModuleBlock = assertTSModuleBlock;
-exports.assertTSImportType = assertTSImportType;
-exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
-exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
-exports.assertTSNonNullExpression = assertTSNonNullExpression;
-exports.assertTSExportAssignment = assertTSExportAssignment;
-exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
-exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
-exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
-exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
-exports.assertTSTypeParameter = assertTSTypeParameter;
-exports.assertExpression = assertExpression;
-exports.assertBinary = assertBinary;
-exports.assertScopable = assertScopable;
-exports.assertBlockParent = assertBlockParent;
-exports.assertBlock = assertBlock;
-exports.assertStatement = assertStatement;
-exports.assertTerminatorless = assertTerminatorless;
-exports.assertCompletionStatement = assertCompletionStatement;
-exports.assertConditional = assertConditional;
-exports.assertLoop = assertLoop;
-exports.assertWhile = assertWhile;
-exports.assertExpressionWrapper = assertExpressionWrapper;
-exports.assertFor = assertFor;
-exports.assertForXStatement = assertForXStatement;
-exports.assertFunction = assertFunction;
-exports.assertFunctionParent = assertFunctionParent;
-exports.assertPureish = assertPureish;
-exports.assertDeclaration = assertDeclaration;
-exports.assertPatternLike = assertPatternLike;
-exports.assertLVal = assertLVal;
-exports.assertTSEntityName = assertTSEntityName;
-exports.assertLiteral = assertLiteral;
-exports.assertImmutable = assertImmutable;
-exports.assertUserWhitespacable = assertUserWhitespacable;
-exports.assertMethod = assertMethod;
-exports.assertObjectMember = assertObjectMember;
-exports.assertProperty = assertProperty;
-exports.assertUnaryLike = assertUnaryLike;
-exports.assertPattern = assertPattern;
-exports.assertClass = assertClass;
-exports.assertModuleDeclaration = assertModuleDeclaration;
-exports.assertExportDeclaration = assertExportDeclaration;
-exports.assertModuleSpecifier = assertModuleSpecifier;
-exports.assertFlow = assertFlow;
-exports.assertFlowType = assertFlowType;
-exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
-exports.assertFlowDeclaration = assertFlowDeclaration;
-exports.assertFlowPredicate = assertFlowPredicate;
-exports.assertEnumBody = assertEnumBody;
-exports.assertEnumMember = assertEnumMember;
-exports.assertJSX = assertJSX;
-exports.assertPrivate = assertPrivate;
-exports.assertTSTypeElement = assertTSTypeElement;
-exports.assertTSType = assertTSType;
-exports.assertTSBaseType = assertTSBaseType;
-exports.assertNumberLiteral = assertNumberLiteral;
-exports.assertRegexLiteral = assertRegexLiteral;
-exports.assertRestProperty = assertRestProperty;
-exports.assertSpreadProperty = assertSpreadProperty;
-
-var _is = _interopRequireDefault(require("../../validators/is"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function assert(type, node, opts) {
-  if (!(0, _is.default)(type, node, opts)) {
-    throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`);
-  }
-}
-
-function assertArrayExpression(node, opts) {
-  assert("ArrayExpression", node, opts);
-}
-
-function assertAssignmentExpression(node, opts) {
-  assert("AssignmentExpression", node, opts);
-}
-
-function assertBinaryExpression(node, opts) {
-  assert("BinaryExpression", node, opts);
-}
-
-function assertInterpreterDirective(node, opts) {
-  assert("InterpreterDirective", node, opts);
-}
-
-function assertDirective(node, opts) {
-  assert("Directive", node, opts);
-}
-
-function assertDirectiveLiteral(node, opts) {
-  assert("DirectiveLiteral", node, opts);
-}
-
-function assertBlockStatement(node, opts) {
-  assert("BlockStatement", node, opts);
-}
-
-function assertBreakStatement(node, opts) {
-  assert("BreakStatement", node, opts);
-}
-
-function assertCallExpression(node, opts) {
-  assert("CallExpression", node, opts);
-}
-
-function assertCatchClause(node, opts) {
-  assert("CatchClause", node, opts);
-}
-
-function assertConditionalExpression(node, opts) {
-  assert("ConditionalExpression", node, opts);
-}
-
-function assertContinueStatement(node, opts) {
-  assert("ContinueStatement", node, opts);
-}
-
-function assertDebuggerStatement(node, opts) {
-  assert("DebuggerStatement", node, opts);
-}
-
-function assertDoWhileStatement(node, opts) {
-  assert("DoWhileStatement", node, opts);
-}
-
-function assertEmptyStatement(node, opts) {
-  assert("EmptyStatement", node, opts);
-}
-
-function assertExpressionStatement(node, opts) {
-  assert("ExpressionStatement", node, opts);
-}
-
-function assertFile(node, opts) {
-  assert("File", node, opts);
-}
-
-function assertForInStatement(node, opts) {
-  assert("ForInStatement", node, opts);
-}
-
-function assertForStatement(node, opts) {
-  assert("ForStatement", node, opts);
-}
-
-function assertFunctionDeclaration(node, opts) {
-  assert("FunctionDeclaration", node, opts);
-}
-
-function assertFunctionExpression(node, opts) {
-  assert("FunctionExpression", node, opts);
-}
-
-function assertIdentifier(node, opts) {
-  assert("Identifier", node, opts);
-}
-
-function assertIfStatement(node, opts) {
-  assert("IfStatement", node, opts);
-}
-
-function assertLabeledStatement(node, opts) {
-  assert("LabeledStatement", node, opts);
-}
-
-function assertStringLiteral(node, opts) {
-  assert("StringLiteral", node, opts);
-}
-
-function assertNumericLiteral(node, opts) {
-  assert("NumericLiteral", node, opts);
-}
-
-function assertNullLiteral(node, opts) {
-  assert("NullLiteral", node, opts);
-}
-
-function assertBooleanLiteral(node, opts) {
-  assert("BooleanLiteral", node, opts);
-}
-
-function assertRegExpLiteral(node, opts) {
-  assert("RegExpLiteral", node, opts);
-}
-
-function assertLogicalExpression(node, opts) {
-  assert("LogicalExpression", node, opts);
-}
-
-function assertMemberExpression(node, opts) {
-  assert("MemberExpression", node, opts);
-}
-
-function assertNewExpression(node, opts) {
-  assert("NewExpression", node, opts);
-}
-
-function assertProgram(node, opts) {
-  assert("Program", node, opts);
-}
-
-function assertObjectExpression(node, opts) {
-  assert("ObjectExpression", node, opts);
-}
-
-function assertObjectMethod(node, opts) {
-  assert("ObjectMethod", node, opts);
-}
-
-function assertObjectProperty(node, opts) {
-  assert("ObjectProperty", node, opts);
-}
-
-function assertRestElement(node, opts) {
-  assert("RestElement", node, opts);
-}
-
-function assertReturnStatement(node, opts) {
-  assert("ReturnStatement", node, opts);
-}
-
-function assertSequenceExpression(node, opts) {
-  assert("SequenceExpression", node, opts);
-}
-
-function assertParenthesizedExpression(node, opts) {
-  assert("ParenthesizedExpression", node, opts);
-}
-
-function assertSwitchCase(node, opts) {
-  assert("SwitchCase", node, opts);
-}
-
-function assertSwitchStatement(node, opts) {
-  assert("SwitchStatement", node, opts);
-}
-
-function assertThisExpression(node, opts) {
-  assert("ThisExpression", node, opts);
-}
-
-function assertThrowStatement(node, opts) {
-  assert("ThrowStatement", node, opts);
-}
-
-function assertTryStatement(node, opts) {
-  assert("TryStatement", node, opts);
-}
-
-function assertUnaryExpression(node, opts) {
-  assert("UnaryExpression", node, opts);
-}
-
-function assertUpdateExpression(node, opts) {
-  assert("UpdateExpression", node, opts);
-}
-
-function assertVariableDeclaration(node, opts) {
-  assert("VariableDeclaration", node, opts);
-}
-
-function assertVariableDeclarator(node, opts) {
-  assert("VariableDeclarator", node, opts);
-}
-
-function assertWhileStatement(node, opts) {
-  assert("WhileStatement", node, opts);
-}
-
-function assertWithStatement(node, opts) {
-  assert("WithStatement", node, opts);
-}
-
-function assertAssignmentPattern(node, opts) {
-  assert("AssignmentPattern", node, opts);
-}
-
-function assertArrayPattern(node, opts) {
-  assert("ArrayPattern", node, opts);
-}
-
-function assertArrowFunctionExpression(node, opts) {
-  assert("ArrowFunctionExpression", node, opts);
-}
-
-function assertClassBody(node, opts) {
-  assert("ClassBody", node, opts);
-}
-
-function assertClassExpression(node, opts) {
-  assert("ClassExpression", node, opts);
-}
-
-function assertClassDeclaration(node, opts) {
-  assert("ClassDeclaration", node, opts);
-}
-
-function assertExportAllDeclaration(node, opts) {
-  assert("ExportAllDeclaration", node, opts);
-}
-
-function assertExportDefaultDeclaration(node, opts) {
-  assert("ExportDefaultDeclaration", node, opts);
-}
-
-function assertExportNamedDeclaration(node, opts) {
-  assert("ExportNamedDeclaration", node, opts);
-}
-
-function assertExportSpecifier(node, opts) {
-  assert("ExportSpecifier", node, opts);
-}
-
-function assertForOfStatement(node, opts) {
-  assert("ForOfStatement", node, opts);
-}
-
-function assertImportDeclaration(node, opts) {
-  assert("ImportDeclaration", node, opts);
-}
-
-function assertImportDefaultSpecifier(node, opts) {
-  assert("ImportDefaultSpecifier", node, opts);
-}
-
-function assertImportNamespaceSpecifier(node, opts) {
-  assert("ImportNamespaceSpecifier", node, opts);
-}
-
-function assertImportSpecifier(node, opts) {
-  assert("ImportSpecifier", node, opts);
-}
-
-function assertMetaProperty(node, opts) {
-  assert("MetaProperty", node, opts);
-}
-
-function assertClassMethod(node, opts) {
-  assert("ClassMethod", node, opts);
-}
-
-function assertObjectPattern(node, opts) {
-  assert("ObjectPattern", node, opts);
-}
-
-function assertSpreadElement(node, opts) {
-  assert("SpreadElement", node, opts);
-}
-
-function assertSuper(node, opts) {
-  assert("Super", node, opts);
-}
-
-function assertTaggedTemplateExpression(node, opts) {
-  assert("TaggedTemplateExpression", node, opts);
-}
-
-function assertTemplateElement(node, opts) {
-  assert("TemplateElement", node, opts);
-}
-
-function assertTemplateLiteral(node, opts) {
-  assert("TemplateLiteral", node, opts);
-}
-
-function assertYieldExpression(node, opts) {
-  assert("YieldExpression", node, opts);
-}
-
-function assertAwaitExpression(node, opts) {
-  assert("AwaitExpression", node, opts);
-}
-
-function assertImport(node, opts) {
-  assert("Import", node, opts);
-}
-
-function assertBigIntLiteral(node, opts) {
-  assert("BigIntLiteral", node, opts);
-}
-
-function assertExportNamespaceSpecifier(node, opts) {
-  assert("ExportNamespaceSpecifier", node, opts);
-}
-
-function assertOptionalMemberExpression(node, opts) {
-  assert("OptionalMemberExpression", node, opts);
-}
-
-function assertOptionalCallExpression(node, opts) {
-  assert("OptionalCallExpression", node, opts);
-}
-
-function assertAnyTypeAnnotation(node, opts) {
-  assert("AnyTypeAnnotation", node, opts);
-}
-
-function assertArrayTypeAnnotation(node, opts) {
-  assert("ArrayTypeAnnotation", node, opts);
-}
-
-function assertBooleanTypeAnnotation(node, opts) {
-  assert("BooleanTypeAnnotation", node, opts);
-}
-
-function assertBooleanLiteralTypeAnnotation(node, opts) {
-  assert("BooleanLiteralTypeAnnotation", node, opts);
-}
-
-function assertNullLiteralTypeAnnotation(node, opts) {
-  assert("NullLiteralTypeAnnotation", node, opts);
-}
-
-function assertClassImplements(node, opts) {
-  assert("ClassImplements", node, opts);
-}
-
-function assertDeclareClass(node, opts) {
-  assert("DeclareClass", node, opts);
-}
-
-function assertDeclareFunction(node, opts) {
-  assert("DeclareFunction", node, opts);
-}
-
-function assertDeclareInterface(node, opts) {
-  assert("DeclareInterface", node, opts);
-}
-
-function assertDeclareModule(node, opts) {
-  assert("DeclareModule", node, opts);
-}
-
-function assertDeclareModuleExports(node, opts) {
-  assert("DeclareModuleExports", node, opts);
-}
-
-function assertDeclareTypeAlias(node, opts) {
-  assert("DeclareTypeAlias", node, opts);
-}
-
-function assertDeclareOpaqueType(node, opts) {
-  assert("DeclareOpaqueType", node, opts);
-}
-
-function assertDeclareVariable(node, opts) {
-  assert("DeclareVariable", node, opts);
-}
-
-function assertDeclareExportDeclaration(node, opts) {
-  assert("DeclareExportDeclaration", node, opts);
-}
-
-function assertDeclareExportAllDeclaration(node, opts) {
-  assert("DeclareExportAllDeclaration", node, opts);
-}
-
-function assertDeclaredPredicate(node, opts) {
-  assert("DeclaredPredicate", node, opts);
-}
-
-function assertExistsTypeAnnotation(node, opts) {
-  assert("ExistsTypeAnnotation", node, opts);
-}
-
-function assertFunctionTypeAnnotation(node, opts) {
-  assert("FunctionTypeAnnotation", node, opts);
-}
-
-function assertFunctionTypeParam(node, opts) {
-  assert("FunctionTypeParam", node, opts);
-}
-
-function assertGenericTypeAnnotation(node, opts) {
-  assert("GenericTypeAnnotation", node, opts);
-}
-
-function assertInferredPredicate(node, opts) {
-  assert("InferredPredicate", node, opts);
-}
-
-function assertInterfaceExtends(node, opts) {
-  assert("InterfaceExtends", node, opts);
-}
-
-function assertInterfaceDeclaration(node, opts) {
-  assert("InterfaceDeclaration", node, opts);
-}
-
-function assertInterfaceTypeAnnotation(node, opts) {
-  assert("InterfaceTypeAnnotation", node, opts);
-}
-
-function assertIntersectionTypeAnnotation(node, opts) {
-  assert("IntersectionTypeAnnotation", node, opts);
-}
-
-function assertMixedTypeAnnotation(node, opts) {
-  assert("MixedTypeAnnotation", node, opts);
-}
-
-function assertEmptyTypeAnnotation(node, opts) {
-  assert("EmptyTypeAnnotation", node, opts);
-}
-
-function assertNullableTypeAnnotation(node, opts) {
-  assert("NullableTypeAnnotation", node, opts);
-}
-
-function assertNumberLiteralTypeAnnotation(node, opts) {
-  assert("NumberLiteralTypeAnnotation", node, opts);
-}
-
-function assertNumberTypeAnnotation(node, opts) {
-  assert("NumberTypeAnnotation", node, opts);
-}
-
-function assertObjectTypeAnnotation(node, opts) {
-  assert("ObjectTypeAnnotation", node, opts);
-}
-
-function assertObjectTypeInternalSlot(node, opts) {
-  assert("ObjectTypeInternalSlot", node, opts);
-}
-
-function assertObjectTypeCallProperty(node, opts) {
-  assert("ObjectTypeCallProperty", node, opts);
-}
-
-function assertObjectTypeIndexer(node, opts) {
-  assert("ObjectTypeIndexer", node, opts);
-}
-
-function assertObjectTypeProperty(node, opts) {
-  assert("ObjectTypeProperty", node, opts);
-}
-
-function assertObjectTypeSpreadProperty(node, opts) {
-  assert("ObjectTypeSpreadProperty", node, opts);
-}
-
-function assertOpaqueType(node, opts) {
-  assert("OpaqueType", node, opts);
-}
-
-function assertQualifiedTypeIdentifier(node, opts) {
-  assert("QualifiedTypeIdentifier", node, opts);
-}
-
-function assertStringLiteralTypeAnnotation(node, opts) {
-  assert("StringLiteralTypeAnnotation", node, opts);
-}
-
-function assertStringTypeAnnotation(node, opts) {
-  assert("StringTypeAnnotation", node, opts);
-}
-
-function assertSymbolTypeAnnotation(node, opts) {
-  assert("SymbolTypeAnnotation", node, opts);
-}
-
-function assertThisTypeAnnotation(node, opts) {
-  assert("ThisTypeAnnotation", node, opts);
-}
-
-function assertTupleTypeAnnotation(node, opts) {
-  assert("TupleTypeAnnotation", node, opts);
-}
-
-function assertTypeofTypeAnnotation(node, opts) {
-  assert("TypeofTypeAnnotation", node, opts);
-}
-
-function assertTypeAlias(node, opts) {
-  assert("TypeAlias", node, opts);
-}
-
-function assertTypeAnnotation(node, opts) {
-  assert("TypeAnnotation", node, opts);
-}
-
-function assertTypeCastExpression(node, opts) {
-  assert("TypeCastExpression", node, opts);
-}
-
-function assertTypeParameter(node, opts) {
-  assert("TypeParameter", node, opts);
-}
-
-function assertTypeParameterDeclaration(node, opts) {
-  assert("TypeParameterDeclaration", node, opts);
-}
-
-function assertTypeParameterInstantiation(node, opts) {
-  assert("TypeParameterInstantiation", node, opts);
-}
-
-function assertUnionTypeAnnotation(node, opts) {
-  assert("UnionTypeAnnotation", node, opts);
-}
-
-function assertVariance(node, opts) {
-  assert("Variance", node, opts);
-}
-
-function assertVoidTypeAnnotation(node, opts) {
-  assert("VoidTypeAnnotation", node, opts);
-}
-
-function assertEnumDeclaration(node, opts) {
-  assert("EnumDeclaration", node, opts);
-}
-
-function assertEnumBooleanBody(node, opts) {
-  assert("EnumBooleanBody", node, opts);
-}
-
-function assertEnumNumberBody(node, opts) {
-  assert("EnumNumberBody", node, opts);
-}
-
-function assertEnumStringBody(node, opts) {
-  assert("EnumStringBody", node, opts);
-}
-
-function assertEnumSymbolBody(node, opts) {
-  assert("EnumSymbolBody", node, opts);
-}
-
-function assertEnumBooleanMember(node, opts) {
-  assert("EnumBooleanMember", node, opts);
-}
-
-function assertEnumNumberMember(node, opts) {
-  assert("EnumNumberMember", node, opts);
-}
-
-function assertEnumStringMember(node, opts) {
-  assert("EnumStringMember", node, opts);
-}
-
-function assertEnumDefaultedMember(node, opts) {
-  assert("EnumDefaultedMember", node, opts);
-}
-
-function assertJSXAttribute(node, opts) {
-  assert("JSXAttribute", node, opts);
-}
-
-function assertJSXClosingElement(node, opts) {
-  assert("JSXClosingElement", node, opts);
-}
-
-function assertJSXElement(node, opts) {
-  assert("JSXElement", node, opts);
-}
-
-function assertJSXEmptyExpression(node, opts) {
-  assert("JSXEmptyExpression", node, opts);
-}
-
-function assertJSXExpressionContainer(node, opts) {
-  assert("JSXExpressionContainer", node, opts);
-}
-
-function assertJSXSpreadChild(node, opts) {
-  assert("JSXSpreadChild", node, opts);
-}
-
-function assertJSXIdentifier(node, opts) {
-  assert("JSXIdentifier", node, opts);
-}
-
-function assertJSXMemberExpression(node, opts) {
-  assert("JSXMemberExpression", node, opts);
-}
-
-function assertJSXNamespacedName(node, opts) {
-  assert("JSXNamespacedName", node, opts);
-}
-
-function assertJSXOpeningElement(node, opts) {
-  assert("JSXOpeningElement", node, opts);
-}
-
-function assertJSXSpreadAttribute(node, opts) {
-  assert("JSXSpreadAttribute", node, opts);
-}
-
-function assertJSXText(node, opts) {
-  assert("JSXText", node, opts);
-}
-
-function assertJSXFragment(node, opts) {
-  assert("JSXFragment", node, opts);
-}
-
-function assertJSXOpeningFragment(node, opts) {
-  assert("JSXOpeningFragment", node, opts);
-}
-
-function assertJSXClosingFragment(node, opts) {
-  assert("JSXClosingFragment", node, opts);
-}
-
-function assertNoop(node, opts) {
-  assert("Noop", node, opts);
-}
-
-function assertPlaceholder(node, opts) {
-  assert("Placeholder", node, opts);
-}
-
-function assertV8IntrinsicIdentifier(node, opts) {
-  assert("V8IntrinsicIdentifier", node, opts);
-}
-
-function assertArgumentPlaceholder(node, opts) {
-  assert("ArgumentPlaceholder", node, opts);
-}
-
-function assertBindExpression(node, opts) {
-  assert("BindExpression", node, opts);
-}
-
-function assertClassProperty(node, opts) {
-  assert("ClassProperty", node, opts);
-}
-
-function assertPipelineTopicExpression(node, opts) {
-  assert("PipelineTopicExpression", node, opts);
-}
-
-function assertPipelineBareFunction(node, opts) {
-  assert("PipelineBareFunction", node, opts);
-}
-
-function assertPipelinePrimaryTopicReference(node, opts) {
-  assert("PipelinePrimaryTopicReference", node, opts);
-}
-
-function assertClassPrivateProperty(node, opts) {
-  assert("ClassPrivateProperty", node, opts);
-}
-
-function assertClassPrivateMethod(node, opts) {
-  assert("ClassPrivateMethod", node, opts);
-}
-
-function assertImportAttribute(node, opts) {
-  assert("ImportAttribute", node, opts);
-}
-
-function assertDecorator(node, opts) {
-  assert("Decorator", node, opts);
-}
-
-function assertDoExpression(node, opts) {
-  assert("DoExpression", node, opts);
-}
-
-function assertExportDefaultSpecifier(node, opts) {
-  assert("ExportDefaultSpecifier", node, opts);
-}
-
-function assertPrivateName(node, opts) {
-  assert("PrivateName", node, opts);
-}
-
-function assertRecordExpression(node, opts) {
-  assert("RecordExpression", node, opts);
-}
-
-function assertTupleExpression(node, opts) {
-  assert("TupleExpression", node, opts);
-}
-
-function assertDecimalLiteral(node, opts) {
-  assert("DecimalLiteral", node, opts);
-}
-
-function assertStaticBlock(node, opts) {
-  assert("StaticBlock", node, opts);
-}
-
-function assertTSParameterProperty(node, opts) {
-  assert("TSParameterProperty", node, opts);
-}
-
-function assertTSDeclareFunction(node, opts) {
-  assert("TSDeclareFunction", node, opts);
-}
-
-function assertTSDeclareMethod(node, opts) {
-  assert("TSDeclareMethod", node, opts);
-}
-
-function assertTSQualifiedName(node, opts) {
-  assert("TSQualifiedName", node, opts);
-}
-
-function assertTSCallSignatureDeclaration(node, opts) {
-  assert("TSCallSignatureDeclaration", node, opts);
-}
-
-function assertTSConstructSignatureDeclaration(node, opts) {
-  assert("TSConstructSignatureDeclaration", node, opts);
-}
-
-function assertTSPropertySignature(node, opts) {
-  assert("TSPropertySignature", node, opts);
-}
-
-function assertTSMethodSignature(node, opts) {
-  assert("TSMethodSignature", node, opts);
-}
-
-function assertTSIndexSignature(node, opts) {
-  assert("TSIndexSignature", node, opts);
-}
-
-function assertTSAnyKeyword(node, opts) {
-  assert("TSAnyKeyword", node, opts);
-}
-
-function assertTSBooleanKeyword(node, opts) {
-  assert("TSBooleanKeyword", node, opts);
-}
-
-function assertTSBigIntKeyword(node, opts) {
-  assert("TSBigIntKeyword", node, opts);
-}
-
-function assertTSIntrinsicKeyword(node, opts) {
-  assert("TSIntrinsicKeyword", node, opts);
-}
-
-function assertTSNeverKeyword(node, opts) {
-  assert("TSNeverKeyword", node, opts);
-}
-
-function assertTSNullKeyword(node, opts) {
-  assert("TSNullKeyword", node, opts);
-}
-
-function assertTSNumberKeyword(node, opts) {
-  assert("TSNumberKeyword", node, opts);
-}
-
-function assertTSObjectKeyword(node, opts) {
-  assert("TSObjectKeyword", node, opts);
-}
-
-function assertTSStringKeyword(node, opts) {
-  assert("TSStringKeyword", node, opts);
-}
-
-function assertTSSymbolKeyword(node, opts) {
-  assert("TSSymbolKeyword", node, opts);
-}
-
-function assertTSUndefinedKeyword(node, opts) {
-  assert("TSUndefinedKeyword", node, opts);
-}
-
-function assertTSUnknownKeyword(node, opts) {
-  assert("TSUnknownKeyword", node, opts);
-}
-
-function assertTSVoidKeyword(node, opts) {
-  assert("TSVoidKeyword", node, opts);
-}
-
-function assertTSThisType(node, opts) {
-  assert("TSThisType", node, opts);
-}
-
-function assertTSFunctionType(node, opts) {
-  assert("TSFunctionType", node, opts);
-}
-
-function assertTSConstructorType(node, opts) {
-  assert("TSConstructorType", node, opts);
-}
-
-function assertTSTypeReference(node, opts) {
-  assert("TSTypeReference", node, opts);
-}
-
-function assertTSTypePredicate(node, opts) {
-  assert("TSTypePredicate", node, opts);
-}
-
-function assertTSTypeQuery(node, opts) {
-  assert("TSTypeQuery", node, opts);
-}
-
-function assertTSTypeLiteral(node, opts) {
-  assert("TSTypeLiteral", node, opts);
-}
-
-function assertTSArrayType(node, opts) {
-  assert("TSArrayType", node, opts);
-}
-
-function assertTSTupleType(node, opts) {
-  assert("TSTupleType", node, opts);
-}
-
-function assertTSOptionalType(node, opts) {
-  assert("TSOptionalType", node, opts);
-}
-
-function assertTSRestType(node, opts) {
-  assert("TSRestType", node, opts);
-}
-
-function assertTSNamedTupleMember(node, opts) {
-  assert("TSNamedTupleMember", node, opts);
-}
-
-function assertTSUnionType(node, opts) {
-  assert("TSUnionType", node, opts);
-}
-
-function assertTSIntersectionType(node, opts) {
-  assert("TSIntersectionType", node, opts);
-}
-
-function assertTSConditionalType(node, opts) {
-  assert("TSConditionalType", node, opts);
-}
-
-function assertTSInferType(node, opts) {
-  assert("TSInferType", node, opts);
-}
-
-function assertTSParenthesizedType(node, opts) {
-  assert("TSParenthesizedType", node, opts);
-}
-
-function assertTSTypeOperator(node, opts) {
-  assert("TSTypeOperator", node, opts);
-}
-
-function assertTSIndexedAccessType(node, opts) {
-  assert("TSIndexedAccessType", node, opts);
-}
-
-function assertTSMappedType(node, opts) {
-  assert("TSMappedType", node, opts);
-}
-
-function assertTSLiteralType(node, opts) {
-  assert("TSLiteralType", node, opts);
-}
-
-function assertTSExpressionWithTypeArguments(node, opts) {
-  assert("TSExpressionWithTypeArguments", node, opts);
-}
-
-function assertTSInterfaceDeclaration(node, opts) {
-  assert("TSInterfaceDeclaration", node, opts);
-}
-
-function assertTSInterfaceBody(node, opts) {
-  assert("TSInterfaceBody", node, opts);
-}
-
-function assertTSTypeAliasDeclaration(node, opts) {
-  assert("TSTypeAliasDeclaration", node, opts);
-}
-
-function assertTSAsExpression(node, opts) {
-  assert("TSAsExpression", node, opts);
-}
-
-function assertTSTypeAssertion(node, opts) {
-  assert("TSTypeAssertion", node, opts);
-}
-
-function assertTSEnumDeclaration(node, opts) {
-  assert("TSEnumDeclaration", node, opts);
-}
-
-function assertTSEnumMember(node, opts) {
-  assert("TSEnumMember", node, opts);
-}
-
-function assertTSModuleDeclaration(node, opts) {
-  assert("TSModuleDeclaration", node, opts);
-}
-
-function assertTSModuleBlock(node, opts) {
-  assert("TSModuleBlock", node, opts);
-}
-
-function assertTSImportType(node, opts) {
-  assert("TSImportType", node, opts);
-}
-
-function assertTSImportEqualsDeclaration(node, opts) {
-  assert("TSImportEqualsDeclaration", node, opts);
-}
-
-function assertTSExternalModuleReference(node, opts) {
-  assert("TSExternalModuleReference", node, opts);
-}
-
-function assertTSNonNullExpression(node, opts) {
-  assert("TSNonNullExpression", node, opts);
-}
-
-function assertTSExportAssignment(node, opts) {
-  assert("TSExportAssignment", node, opts);
-}
-
-function assertTSNamespaceExportDeclaration(node, opts) {
-  assert("TSNamespaceExportDeclaration", node, opts);
-}
-
-function assertTSTypeAnnotation(node, opts) {
-  assert("TSTypeAnnotation", node, opts);
-}
-
-function assertTSTypeParameterInstantiation(node, opts) {
-  assert("TSTypeParameterInstantiation", node, opts);
-}
-
-function assertTSTypeParameterDeclaration(node, opts) {
-  assert("TSTypeParameterDeclaration", node, opts);
-}
-
-function assertTSTypeParameter(node, opts) {
-  assert("TSTypeParameter", node, opts);
-}
-
-function assertExpression(node, opts) {
-  assert("Expression", node, opts);
-}
-
-function assertBinary(node, opts) {
-  assert("Binary", node, opts);
-}
-
-function assertScopable(node, opts) {
-  assert("Scopable", node, opts);
-}
-
-function assertBlockParent(node, opts) {
-  assert("BlockParent", node, opts);
-}
-
-function assertBlock(node, opts) {
-  assert("Block", node, opts);
-}
-
-function assertStatement(node, opts) {
-  assert("Statement", node, opts);
-}
-
-function assertTerminatorless(node, opts) {
-  assert("Terminatorless", node, opts);
-}
-
-function assertCompletionStatement(node, opts) {
-  assert("CompletionStatement", node, opts);
-}
-
-function assertConditional(node, opts) {
-  assert("Conditional", node, opts);
-}
-
-function assertLoop(node, opts) {
-  assert("Loop", node, opts);
-}
-
-function assertWhile(node, opts) {
-  assert("While", node, opts);
-}
-
-function assertExpressionWrapper(node, opts) {
-  assert("ExpressionWrapper", node, opts);
-}
-
-function assertFor(node, opts) {
-  assert("For", node, opts);
-}
-
-function assertForXStatement(node, opts) {
-  assert("ForXStatement", node, opts);
-}
-
-function assertFunction(node, opts) {
-  assert("Function", node, opts);
-}
-
-function assertFunctionParent(node, opts) {
-  assert("FunctionParent", node, opts);
-}
-
-function assertPureish(node, opts) {
-  assert("Pureish", node, opts);
-}
-
-function assertDeclaration(node, opts) {
-  assert("Declaration", node, opts);
-}
-
-function assertPatternLike(node, opts) {
-  assert("PatternLike", node, opts);
-}
-
-function assertLVal(node, opts) {
-  assert("LVal", node, opts);
-}
-
-function assertTSEntityName(node, opts) {
-  assert("TSEntityName", node, opts);
-}
-
-function assertLiteral(node, opts) {
-  assert("Literal", node, opts);
-}
-
-function assertImmutable(node, opts) {
-  assert("Immutable", node, opts);
-}
-
-function assertUserWhitespacable(node, opts) {
-  assert("UserWhitespacable", node, opts);
-}
-
-function assertMethod(node, opts) {
-  assert("Method", node, opts);
-}
-
-function assertObjectMember(node, opts) {
-  assert("ObjectMember", node, opts);
-}
-
-function assertProperty(node, opts) {
-  assert("Property", node, opts);
-}
-
-function assertUnaryLike(node, opts) {
-  assert("UnaryLike", node, opts);
-}
-
-function assertPattern(node, opts) {
-  assert("Pattern", node, opts);
-}
-
-function assertClass(node, opts) {
-  assert("Class", node, opts);
-}
-
-function assertModuleDeclaration(node, opts) {
-  assert("ModuleDeclaration", node, opts);
-}
-
-function assertExportDeclaration(node, opts) {
-  assert("ExportDeclaration", node, opts);
-}
-
-function assertModuleSpecifier(node, opts) {
-  assert("ModuleSpecifier", node, opts);
-}
-
-function assertFlow(node, opts) {
-  assert("Flow", node, opts);
-}
-
-function assertFlowType(node, opts) {
-  assert("FlowType", node, opts);
-}
-
-function assertFlowBaseAnnotation(node, opts) {
-  assert("FlowBaseAnnotation", node, opts);
-}
-
-function assertFlowDeclaration(node, opts) {
-  assert("FlowDeclaration", node, opts);
-}
-
-function assertFlowPredicate(node, opts) {
-  assert("FlowPredicate", node, opts);
-}
-
-function assertEnumBody(node, opts) {
-  assert("EnumBody", node, opts);
-}
-
-function assertEnumMember(node, opts) {
-  assert("EnumMember", node, opts);
-}
-
-function assertJSX(node, opts) {
-  assert("JSX", node, opts);
-}
-
-function assertPrivate(node, opts) {
-  assert("Private", node, opts);
-}
-
-function assertTSTypeElement(node, opts) {
-  assert("TSTypeElement", node, opts);
-}
-
-function assertTSType(node, opts) {
-  assert("TSType", node, opts);
-}
-
-function assertTSBaseType(node, opts) {
-  assert("TSBaseType", node, opts);
-}
-
-function assertNumberLiteral(node, opts) {
-  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
-  assert("NumberLiteral", node, opts);
-}
-
-function assertRegexLiteral(node, opts) {
-  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
-  assert("RegexLiteral", node, opts);
-}
-
-function assertRestProperty(node, opts) {
-  console.trace("The node type RestProperty has been renamed to RestElement");
-  assert("RestProperty", node, opts);
-}
-
-function assertSpreadProperty(node, opts) {
-  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
-  assert("SpreadProperty", node, opts);
-}

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

@@ -1,42 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = builder;
-
-var _clone = _interopRequireDefault(require("lodash/clone"));
-
-var _definitions = require("../definitions");
-
-var _validate = _interopRequireDefault(require("../validators/validate"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function builder(type, ...args) {
-  const keys = _definitions.BUILDER_KEYS[type];
-  const countArgs = args.length;
-
-  if (countArgs > keys.length) {
-    throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`);
-  }
-
-  const node = {
-    type
-  };
-  let i = 0;
-  keys.forEach(key => {
-    const field = _definitions.NODE_FIELDS[type][key];
-    let arg;
-    if (i < countArgs) arg = args[i];
-    if (arg === undefined) arg = (0, _clone.default)(field.default);
-    node[key] = arg;
-    i++;
-  });
-
-  for (const key of Object.keys(node)) {
-    (0, _validate.default)(node, key, node[key]);
-  }
-
-  return node;
-}

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

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

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

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createTypeAnnotationBasedOnTypeof;
-
-var _generated = require("../generated");
-
-function createTypeAnnotationBasedOnTypeof(type) {
-  if (type === "string") {
-    return (0, _generated.stringTypeAnnotation)();
-  } else if (type === "number") {
-    return (0, _generated.numberTypeAnnotation)();
-  } else if (type === "undefined") {
-    return (0, _generated.voidTypeAnnotation)();
-  } else if (type === "boolean") {
-    return (0, _generated.booleanTypeAnnotation)();
-  } else if (type === "function") {
-    return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
-  } else if (type === "object") {
-    return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
-  } else if (type === "symbol") {
-    return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
-  } else {
-    throw new Error("Invalid typeof value");
-  }
-}

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

@@ -1,1243 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.arrayExpression = arrayExpression;
-exports.assignmentExpression = assignmentExpression;
-exports.binaryExpression = binaryExpression;
-exports.interpreterDirective = interpreterDirective;
-exports.directive = directive;
-exports.directiveLiteral = directiveLiteral;
-exports.blockStatement = blockStatement;
-exports.breakStatement = breakStatement;
-exports.callExpression = callExpression;
-exports.catchClause = catchClause;
-exports.conditionalExpression = conditionalExpression;
-exports.continueStatement = continueStatement;
-exports.debuggerStatement = debuggerStatement;
-exports.doWhileStatement = doWhileStatement;
-exports.emptyStatement = emptyStatement;
-exports.expressionStatement = expressionStatement;
-exports.file = file;
-exports.forInStatement = forInStatement;
-exports.forStatement = forStatement;
-exports.functionDeclaration = functionDeclaration;
-exports.functionExpression = functionExpression;
-exports.identifier = identifier;
-exports.ifStatement = ifStatement;
-exports.labeledStatement = labeledStatement;
-exports.stringLiteral = stringLiteral;
-exports.numericLiteral = numericLiteral;
-exports.nullLiteral = nullLiteral;
-exports.booleanLiteral = booleanLiteral;
-exports.regExpLiteral = regExpLiteral;
-exports.logicalExpression = logicalExpression;
-exports.memberExpression = memberExpression;
-exports.newExpression = newExpression;
-exports.program = program;
-exports.objectExpression = objectExpression;
-exports.objectMethod = objectMethod;
-exports.objectProperty = objectProperty;
-exports.restElement = restElement;
-exports.returnStatement = returnStatement;
-exports.sequenceExpression = sequenceExpression;
-exports.parenthesizedExpression = parenthesizedExpression;
-exports.switchCase = switchCase;
-exports.switchStatement = switchStatement;
-exports.thisExpression = thisExpression;
-exports.throwStatement = throwStatement;
-exports.tryStatement = tryStatement;
-exports.unaryExpression = unaryExpression;
-exports.updateExpression = updateExpression;
-exports.variableDeclaration = variableDeclaration;
-exports.variableDeclarator = variableDeclarator;
-exports.whileStatement = whileStatement;
-exports.withStatement = withStatement;
-exports.assignmentPattern = assignmentPattern;
-exports.arrayPattern = arrayPattern;
-exports.arrowFunctionExpression = arrowFunctionExpression;
-exports.classBody = classBody;
-exports.classExpression = classExpression;
-exports.classDeclaration = classDeclaration;
-exports.exportAllDeclaration = exportAllDeclaration;
-exports.exportDefaultDeclaration = exportDefaultDeclaration;
-exports.exportNamedDeclaration = exportNamedDeclaration;
-exports.exportSpecifier = exportSpecifier;
-exports.forOfStatement = forOfStatement;
-exports.importDeclaration = importDeclaration;
-exports.importDefaultSpecifier = importDefaultSpecifier;
-exports.importNamespaceSpecifier = importNamespaceSpecifier;
-exports.importSpecifier = importSpecifier;
-exports.metaProperty = metaProperty;
-exports.classMethod = classMethod;
-exports.objectPattern = objectPattern;
-exports.spreadElement = spreadElement;
-exports.super = _super;
-exports.taggedTemplateExpression = taggedTemplateExpression;
-exports.templateElement = templateElement;
-exports.templateLiteral = templateLiteral;
-exports.yieldExpression = yieldExpression;
-exports.awaitExpression = awaitExpression;
-exports.import = _import;
-exports.bigIntLiteral = bigIntLiteral;
-exports.exportNamespaceSpecifier = exportNamespaceSpecifier;
-exports.optionalMemberExpression = optionalMemberExpression;
-exports.optionalCallExpression = optionalCallExpression;
-exports.anyTypeAnnotation = anyTypeAnnotation;
-exports.arrayTypeAnnotation = arrayTypeAnnotation;
-exports.booleanTypeAnnotation = booleanTypeAnnotation;
-exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
-exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
-exports.classImplements = classImplements;
-exports.declareClass = declareClass;
-exports.declareFunction = declareFunction;
-exports.declareInterface = declareInterface;
-exports.declareModule = declareModule;
-exports.declareModuleExports = declareModuleExports;
-exports.declareTypeAlias = declareTypeAlias;
-exports.declareOpaqueType = declareOpaqueType;
-exports.declareVariable = declareVariable;
-exports.declareExportDeclaration = declareExportDeclaration;
-exports.declareExportAllDeclaration = declareExportAllDeclaration;
-exports.declaredPredicate = declaredPredicate;
-exports.existsTypeAnnotation = existsTypeAnnotation;
-exports.functionTypeAnnotation = functionTypeAnnotation;
-exports.functionTypeParam = functionTypeParam;
-exports.genericTypeAnnotation = genericTypeAnnotation;
-exports.inferredPredicate = inferredPredicate;
-exports.interfaceExtends = interfaceExtends;
-exports.interfaceDeclaration = interfaceDeclaration;
-exports.interfaceTypeAnnotation = interfaceTypeAnnotation;
-exports.intersectionTypeAnnotation = intersectionTypeAnnotation;
-exports.mixedTypeAnnotation = mixedTypeAnnotation;
-exports.emptyTypeAnnotation = emptyTypeAnnotation;
-exports.nullableTypeAnnotation = nullableTypeAnnotation;
-exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
-exports.numberTypeAnnotation = numberTypeAnnotation;
-exports.objectTypeAnnotation = objectTypeAnnotation;
-exports.objectTypeInternalSlot = objectTypeInternalSlot;
-exports.objectTypeCallProperty = objectTypeCallProperty;
-exports.objectTypeIndexer = objectTypeIndexer;
-exports.objectTypeProperty = objectTypeProperty;
-exports.objectTypeSpreadProperty = objectTypeSpreadProperty;
-exports.opaqueType = opaqueType;
-exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
-exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
-exports.stringTypeAnnotation = stringTypeAnnotation;
-exports.symbolTypeAnnotation = symbolTypeAnnotation;
-exports.thisTypeAnnotation = thisTypeAnnotation;
-exports.tupleTypeAnnotation = tupleTypeAnnotation;
-exports.typeofTypeAnnotation = typeofTypeAnnotation;
-exports.typeAlias = typeAlias;
-exports.typeAnnotation = typeAnnotation;
-exports.typeCastExpression = typeCastExpression;
-exports.typeParameter = typeParameter;
-exports.typeParameterDeclaration = typeParameterDeclaration;
-exports.typeParameterInstantiation = typeParameterInstantiation;
-exports.unionTypeAnnotation = unionTypeAnnotation;
-exports.variance = variance;
-exports.voidTypeAnnotation = voidTypeAnnotation;
-exports.enumDeclaration = enumDeclaration;
-exports.enumBooleanBody = enumBooleanBody;
-exports.enumNumberBody = enumNumberBody;
-exports.enumStringBody = enumStringBody;
-exports.enumSymbolBody = enumSymbolBody;
-exports.enumBooleanMember = enumBooleanMember;
-exports.enumNumberMember = enumNumberMember;
-exports.enumStringMember = enumStringMember;
-exports.enumDefaultedMember = enumDefaultedMember;
-exports.jSXAttribute = exports.jsxAttribute = jsxAttribute;
-exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;
-exports.jSXElement = exports.jsxElement = jsxElement;
-exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;
-exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;
-exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;
-exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier;
-exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;
-exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;
-exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;
-exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;
-exports.jSXText = exports.jsxText = jsxText;
-exports.jSXFragment = exports.jsxFragment = jsxFragment;
-exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;
-exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;
-exports.noop = noop;
-exports.placeholder = placeholder;
-exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
-exports.argumentPlaceholder = argumentPlaceholder;
-exports.bindExpression = bindExpression;
-exports.classProperty = classProperty;
-exports.pipelineTopicExpression = pipelineTopicExpression;
-exports.pipelineBareFunction = pipelineBareFunction;
-exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
-exports.classPrivateProperty = classPrivateProperty;
-exports.classPrivateMethod = classPrivateMethod;
-exports.importAttribute = importAttribute;
-exports.decorator = decorator;
-exports.doExpression = doExpression;
-exports.exportDefaultSpecifier = exportDefaultSpecifier;
-exports.privateName = privateName;
-exports.recordExpression = recordExpression;
-exports.tupleExpression = tupleExpression;
-exports.decimalLiteral = decimalLiteral;
-exports.staticBlock = staticBlock;
-exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;
-exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;
-exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;
-exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;
-exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
-exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
-exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;
-exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;
-exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;
-exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;
-exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;
-exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;
-exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;
-exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;
-exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;
-exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;
-exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;
-exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;
-exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;
-exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;
-exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;
-exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;
-exports.tSThisType = exports.tsThisType = tsThisType;
-exports.tSFunctionType = exports.tsFunctionType = tsFunctionType;
-exports.tSConstructorType = exports.tsConstructorType = tsConstructorType;
-exports.tSTypeReference = exports.tsTypeReference = tsTypeReference;
-exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;
-exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;
-exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;
-exports.tSArrayType = exports.tsArrayType = tsArrayType;
-exports.tSTupleType = exports.tsTupleType = tsTupleType;
-exports.tSOptionalType = exports.tsOptionalType = tsOptionalType;
-exports.tSRestType = exports.tsRestType = tsRestType;
-exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;
-exports.tSUnionType = exports.tsUnionType = tsUnionType;
-exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;
-exports.tSConditionalType = exports.tsConditionalType = tsConditionalType;
-exports.tSInferType = exports.tsInferType = tsInferType;
-exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;
-exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;
-exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;
-exports.tSMappedType = exports.tsMappedType = tsMappedType;
-exports.tSLiteralType = exports.tsLiteralType = tsLiteralType;
-exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
-exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;
-exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;
-exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
-exports.tSAsExpression = exports.tsAsExpression = tsAsExpression;
-exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;
-exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;
-exports.tSEnumMember = exports.tsEnumMember = tsEnumMember;
-exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;
-exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;
-exports.tSImportType = exports.tsImportType = tsImportType;
-exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
-exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;
-exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;
-exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;
-exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
-exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;
-exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
-exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
-exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;
-exports.numberLiteral = NumberLiteral;
-exports.regexLiteral = RegexLiteral;
-exports.restProperty = RestProperty;
-exports.spreadProperty = SpreadProperty;
-
-var _builder = _interopRequireDefault(require("../builder"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function arrayExpression(elements) {
-  return (0, _builder.default)("ArrayExpression", ...arguments);
-}
-
-function assignmentExpression(operator, left, right) {
-  return (0, _builder.default)("AssignmentExpression", ...arguments);
-}
-
-function binaryExpression(operator, left, right) {
-  return (0, _builder.default)("BinaryExpression", ...arguments);
-}
-
-function interpreterDirective(value) {
-  return (0, _builder.default)("InterpreterDirective", ...arguments);
-}
-
-function directive(value) {
-  return (0, _builder.default)("Directive", ...arguments);
-}
-
-function directiveLiteral(value) {
-  return (0, _builder.default)("DirectiveLiteral", ...arguments);
-}
-
-function blockStatement(body, directives) {
-  return (0, _builder.default)("BlockStatement", ...arguments);
-}
-
-function breakStatement(label) {
-  return (0, _builder.default)("BreakStatement", ...arguments);
-}
-
-function callExpression(callee, _arguments) {
-  return (0, _builder.default)("CallExpression", ...arguments);
-}
-
-function catchClause(param, body) {
-  return (0, _builder.default)("CatchClause", ...arguments);
-}
-
-function conditionalExpression(test, consequent, alternate) {
-  return (0, _builder.default)("ConditionalExpression", ...arguments);
-}
-
-function continueStatement(label) {
-  return (0, _builder.default)("ContinueStatement", ...arguments);
-}
-
-function debuggerStatement() {
-  return (0, _builder.default)("DebuggerStatement", ...arguments);
-}
-
-function doWhileStatement(test, body) {
-  return (0, _builder.default)("DoWhileStatement", ...arguments);
-}
-
-function emptyStatement() {
-  return (0, _builder.default)("EmptyStatement", ...arguments);
-}
-
-function expressionStatement(expression) {
-  return (0, _builder.default)("ExpressionStatement", ...arguments);
-}
-
-function file(program, comments, tokens) {
-  return (0, _builder.default)("File", ...arguments);
-}
-
-function forInStatement(left, right, body) {
-  return (0, _builder.default)("ForInStatement", ...arguments);
-}
-
-function forStatement(init, test, update, body) {
-  return (0, _builder.default)("ForStatement", ...arguments);
-}
-
-function functionDeclaration(id, params, body, generator, async) {
-  return (0, _builder.default)("FunctionDeclaration", ...arguments);
-}
-
-function functionExpression(id, params, body, generator, async) {
-  return (0, _builder.default)("FunctionExpression", ...arguments);
-}
-
-function identifier(name) {
-  return (0, _builder.default)("Identifier", ...arguments);
-}
-
-function ifStatement(test, consequent, alternate) {
-  return (0, _builder.default)("IfStatement", ...arguments);
-}
-
-function labeledStatement(label, body) {
-  return (0, _builder.default)("LabeledStatement", ...arguments);
-}
-
-function stringLiteral(value) {
-  return (0, _builder.default)("StringLiteral", ...arguments);
-}
-
-function numericLiteral(value) {
-  return (0, _builder.default)("NumericLiteral", ...arguments);
-}
-
-function nullLiteral() {
-  return (0, _builder.default)("NullLiteral", ...arguments);
-}
-
-function booleanLiteral(value) {
-  return (0, _builder.default)("BooleanLiteral", ...arguments);
-}
-
-function regExpLiteral(pattern, flags) {
-  return (0, _builder.default)("RegExpLiteral", ...arguments);
-}
-
-function logicalExpression(operator, left, right) {
-  return (0, _builder.default)("LogicalExpression", ...arguments);
-}
-
-function memberExpression(object, property, computed, optional) {
-  return (0, _builder.default)("MemberExpression", ...arguments);
-}
-
-function newExpression(callee, _arguments) {
-  return (0, _builder.default)("NewExpression", ...arguments);
-}
-
-function program(body, directives, sourceType, interpreter) {
-  return (0, _builder.default)("Program", ...arguments);
-}
-
-function objectExpression(properties) {
-  return (0, _builder.default)("ObjectExpression", ...arguments);
-}
-
-function objectMethod(kind, key, params, body, computed, generator, async) {
-  return (0, _builder.default)("ObjectMethod", ...arguments);
-}
-
-function objectProperty(key, value, computed, shorthand, decorators) {
-  return (0, _builder.default)("ObjectProperty", ...arguments);
-}
-
-function restElement(argument) {
-  return (0, _builder.default)("RestElement", ...arguments);
-}
-
-function returnStatement(argument) {
-  return (0, _builder.default)("ReturnStatement", ...arguments);
-}
-
-function sequenceExpression(expressions) {
-  return (0, _builder.default)("SequenceExpression", ...arguments);
-}
-
-function parenthesizedExpression(expression) {
-  return (0, _builder.default)("ParenthesizedExpression", ...arguments);
-}
-
-function switchCase(test, consequent) {
-  return (0, _builder.default)("SwitchCase", ...arguments);
-}
-
-function switchStatement(discriminant, cases) {
-  return (0, _builder.default)("SwitchStatement", ...arguments);
-}
-
-function thisExpression() {
-  return (0, _builder.default)("ThisExpression", ...arguments);
-}
-
-function throwStatement(argument) {
-  return (0, _builder.default)("ThrowStatement", ...arguments);
-}
-
-function tryStatement(block, handler, finalizer) {
-  return (0, _builder.default)("TryStatement", ...arguments);
-}
-
-function unaryExpression(operator, argument, prefix) {
-  return (0, _builder.default)("UnaryExpression", ...arguments);
-}
-
-function updateExpression(operator, argument, prefix) {
-  return (0, _builder.default)("UpdateExpression", ...arguments);
-}
-
-function variableDeclaration(kind, declarations) {
-  return (0, _builder.default)("VariableDeclaration", ...arguments);
-}
-
-function variableDeclarator(id, init) {
-  return (0, _builder.default)("VariableDeclarator", ...arguments);
-}
-
-function whileStatement(test, body) {
-  return (0, _builder.default)("WhileStatement", ...arguments);
-}
-
-function withStatement(object, body) {
-  return (0, _builder.default)("WithStatement", ...arguments);
-}
-
-function assignmentPattern(left, right) {
-  return (0, _builder.default)("AssignmentPattern", ...arguments);
-}
-
-function arrayPattern(elements) {
-  return (0, _builder.default)("ArrayPattern", ...arguments);
-}
-
-function arrowFunctionExpression(params, body, async) {
-  return (0, _builder.default)("ArrowFunctionExpression", ...arguments);
-}
-
-function classBody(body) {
-  return (0, _builder.default)("ClassBody", ...arguments);
-}
-
-function classExpression(id, superClass, body, decorators) {
-  return (0, _builder.default)("ClassExpression", ...arguments);
-}
-
-function classDeclaration(id, superClass, body, decorators) {
-  return (0, _builder.default)("ClassDeclaration", ...arguments);
-}
-
-function exportAllDeclaration(source) {
-  return (0, _builder.default)("ExportAllDeclaration", ...arguments);
-}
-
-function exportDefaultDeclaration(declaration) {
-  return (0, _builder.default)("ExportDefaultDeclaration", ...arguments);
-}
-
-function exportNamedDeclaration(declaration, specifiers, source) {
-  return (0, _builder.default)("ExportNamedDeclaration", ...arguments);
-}
-
-function exportSpecifier(local, exported) {
-  return (0, _builder.default)("ExportSpecifier", ...arguments);
-}
-
-function forOfStatement(left, right, body, _await) {
-  return (0, _builder.default)("ForOfStatement", ...arguments);
-}
-
-function importDeclaration(specifiers, source) {
-  return (0, _builder.default)("ImportDeclaration", ...arguments);
-}
-
-function importDefaultSpecifier(local) {
-  return (0, _builder.default)("ImportDefaultSpecifier", ...arguments);
-}
-
-function importNamespaceSpecifier(local) {
-  return (0, _builder.default)("ImportNamespaceSpecifier", ...arguments);
-}
-
-function importSpecifier(local, imported) {
-  return (0, _builder.default)("ImportSpecifier", ...arguments);
-}
-
-function metaProperty(meta, property) {
-  return (0, _builder.default)("MetaProperty", ...arguments);
-}
-
-function classMethod(kind, key, params, body, computed, _static, generator, async) {
-  return (0, _builder.default)("ClassMethod", ...arguments);
-}
-
-function objectPattern(properties) {
-  return (0, _builder.default)("ObjectPattern", ...arguments);
-}
-
-function spreadElement(argument) {
-  return (0, _builder.default)("SpreadElement", ...arguments);
-}
-
-function _super() {
-  return (0, _builder.default)("Super", ...arguments);
-}
-
-function taggedTemplateExpression(tag, quasi) {
-  return (0, _builder.default)("TaggedTemplateExpression", ...arguments);
-}
-
-function templateElement(value, tail) {
-  return (0, _builder.default)("TemplateElement", ...arguments);
-}
-
-function templateLiteral(quasis, expressions) {
-  return (0, _builder.default)("TemplateLiteral", ...arguments);
-}
-
-function yieldExpression(argument, delegate) {
-  return (0, _builder.default)("YieldExpression", ...arguments);
-}
-
-function awaitExpression(argument) {
-  return (0, _builder.default)("AwaitExpression", ...arguments);
-}
-
-function _import() {
-  return (0, _builder.default)("Import", ...arguments);
-}
-
-function bigIntLiteral(value) {
-  return (0, _builder.default)("BigIntLiteral", ...arguments);
-}
-
-function exportNamespaceSpecifier(exported) {
-  return (0, _builder.default)("ExportNamespaceSpecifier", ...arguments);
-}
-
-function optionalMemberExpression(object, property, computed, optional) {
-  return (0, _builder.default)("OptionalMemberExpression", ...arguments);
-}
-
-function optionalCallExpression(callee, _arguments, optional) {
-  return (0, _builder.default)("OptionalCallExpression", ...arguments);
-}
-
-function anyTypeAnnotation() {
-  return (0, _builder.default)("AnyTypeAnnotation", ...arguments);
-}
-
-function arrayTypeAnnotation(elementType) {
-  return (0, _builder.default)("ArrayTypeAnnotation", ...arguments);
-}
-
-function booleanTypeAnnotation() {
-  return (0, _builder.default)("BooleanTypeAnnotation", ...arguments);
-}
-
-function booleanLiteralTypeAnnotation(value) {
-  return (0, _builder.default)("BooleanLiteralTypeAnnotation", ...arguments);
-}
-
-function nullLiteralTypeAnnotation() {
-  return (0, _builder.default)("NullLiteralTypeAnnotation", ...arguments);
-}
-
-function classImplements(id, typeParameters) {
-  return (0, _builder.default)("ClassImplements", ...arguments);
-}
-
-function declareClass(id, typeParameters, _extends, body) {
-  return (0, _builder.default)("DeclareClass", ...arguments);
-}
-
-function declareFunction(id) {
-  return (0, _builder.default)("DeclareFunction", ...arguments);
-}
-
-function declareInterface(id, typeParameters, _extends, body) {
-  return (0, _builder.default)("DeclareInterface", ...arguments);
-}
-
-function declareModule(id, body, kind) {
-  return (0, _builder.default)("DeclareModule", ...arguments);
-}
-
-function declareModuleExports(typeAnnotation) {
-  return (0, _builder.default)("DeclareModuleExports", ...arguments);
-}
-
-function declareTypeAlias(id, typeParameters, right) {
-  return (0, _builder.default)("DeclareTypeAlias", ...arguments);
-}
-
-function declareOpaqueType(id, typeParameters, supertype) {
-  return (0, _builder.default)("DeclareOpaqueType", ...arguments);
-}
-
-function declareVariable(id) {
-  return (0, _builder.default)("DeclareVariable", ...arguments);
-}
-
-function declareExportDeclaration(declaration, specifiers, source) {
-  return (0, _builder.default)("DeclareExportDeclaration", ...arguments);
-}
-
-function declareExportAllDeclaration(source) {
-  return (0, _builder.default)("DeclareExportAllDeclaration", ...arguments);
-}
-
-function declaredPredicate(value) {
-  return (0, _builder.default)("DeclaredPredicate", ...arguments);
-}
-
-function existsTypeAnnotation() {
-  return (0, _builder.default)("ExistsTypeAnnotation", ...arguments);
-}
-
-function functionTypeAnnotation(typeParameters, params, rest, returnType) {
-  return (0, _builder.default)("FunctionTypeAnnotation", ...arguments);
-}
-
-function functionTypeParam(name, typeAnnotation) {
-  return (0, _builder.default)("FunctionTypeParam", ...arguments);
-}
-
-function genericTypeAnnotation(id, typeParameters) {
-  return (0, _builder.default)("GenericTypeAnnotation", ...arguments);
-}
-
-function inferredPredicate() {
-  return (0, _builder.default)("InferredPredicate", ...arguments);
-}
-
-function interfaceExtends(id, typeParameters) {
-  return (0, _builder.default)("InterfaceExtends", ...arguments);
-}
-
-function interfaceDeclaration(id, typeParameters, _extends, body) {
-  return (0, _builder.default)("InterfaceDeclaration", ...arguments);
-}
-
-function interfaceTypeAnnotation(_extends, body) {
-  return (0, _builder.default)("InterfaceTypeAnnotation", ...arguments);
-}
-
-function intersectionTypeAnnotation(types) {
-  return (0, _builder.default)("IntersectionTypeAnnotation", ...arguments);
-}
-
-function mixedTypeAnnotation() {
-  return (0, _builder.default)("MixedTypeAnnotation", ...arguments);
-}
-
-function emptyTypeAnnotation() {
-  return (0, _builder.default)("EmptyTypeAnnotation", ...arguments);
-}
-
-function nullableTypeAnnotation(typeAnnotation) {
-  return (0, _builder.default)("NullableTypeAnnotation", ...arguments);
-}
-
-function numberLiteralTypeAnnotation(value) {
-  return (0, _builder.default)("NumberLiteralTypeAnnotation", ...arguments);
-}
-
-function numberTypeAnnotation() {
-  return (0, _builder.default)("NumberTypeAnnotation", ...arguments);
-}
-
-function objectTypeAnnotation(properties, indexers, callProperties, internalSlots, exact) {
-  return (0, _builder.default)("ObjectTypeAnnotation", ...arguments);
-}
-
-function objectTypeInternalSlot(id, value, optional, _static, method) {
-  return (0, _builder.default)("ObjectTypeInternalSlot", ...arguments);
-}
-
-function objectTypeCallProperty(value) {
-  return (0, _builder.default)("ObjectTypeCallProperty", ...arguments);
-}
-
-function objectTypeIndexer(id, key, value, variance) {
-  return (0, _builder.default)("ObjectTypeIndexer", ...arguments);
-}
-
-function objectTypeProperty(key, value, variance) {
-  return (0, _builder.default)("ObjectTypeProperty", ...arguments);
-}
-
-function objectTypeSpreadProperty(argument) {
-  return (0, _builder.default)("ObjectTypeSpreadProperty", ...arguments);
-}
-
-function opaqueType(id, typeParameters, supertype, impltype) {
-  return (0, _builder.default)("OpaqueType", ...arguments);
-}
-
-function qualifiedTypeIdentifier(id, qualification) {
-  return (0, _builder.default)("QualifiedTypeIdentifier", ...arguments);
-}
-
-function stringLiteralTypeAnnotation(value) {
-  return (0, _builder.default)("StringLiteralTypeAnnotation", ...arguments);
-}
-
-function stringTypeAnnotation() {
-  return (0, _builder.default)("StringTypeAnnotation", ...arguments);
-}
-
-function symbolTypeAnnotation() {
-  return (0, _builder.default)("SymbolTypeAnnotation", ...arguments);
-}
-
-function thisTypeAnnotation() {
-  return (0, _builder.default)("ThisTypeAnnotation", ...arguments);
-}
-
-function tupleTypeAnnotation(types) {
-  return (0, _builder.default)("TupleTypeAnnotation", ...arguments);
-}
-
-function typeofTypeAnnotation(argument) {
-  return (0, _builder.default)("TypeofTypeAnnotation", ...arguments);
-}
-
-function typeAlias(id, typeParameters, right) {
-  return (0, _builder.default)("TypeAlias", ...arguments);
-}
-
-function typeAnnotation(typeAnnotation) {
-  return (0, _builder.default)("TypeAnnotation", ...arguments);
-}
-
-function typeCastExpression(expression, typeAnnotation) {
-  return (0, _builder.default)("TypeCastExpression", ...arguments);
-}
-
-function typeParameter(bound, _default, variance) {
-  return (0, _builder.default)("TypeParameter", ...arguments);
-}
-
-function typeParameterDeclaration(params) {
-  return (0, _builder.default)("TypeParameterDeclaration", ...arguments);
-}
-
-function typeParameterInstantiation(params) {
-  return (0, _builder.default)("TypeParameterInstantiation", ...arguments);
-}
-
-function unionTypeAnnotation(types) {
-  return (0, _builder.default)("UnionTypeAnnotation", ...arguments);
-}
-
-function variance(kind) {
-  return (0, _builder.default)("Variance", ...arguments);
-}
-
-function voidTypeAnnotation() {
-  return (0, _builder.default)("VoidTypeAnnotation", ...arguments);
-}
-
-function enumDeclaration(id, body) {
-  return (0, _builder.default)("EnumDeclaration", ...arguments);
-}
-
-function enumBooleanBody(members) {
-  return (0, _builder.default)("EnumBooleanBody", ...arguments);
-}
-
-function enumNumberBody(members) {
-  return (0, _builder.default)("EnumNumberBody", ...arguments);
-}
-
-function enumStringBody(members) {
-  return (0, _builder.default)("EnumStringBody", ...arguments);
-}
-
-function enumSymbolBody(members) {
-  return (0, _builder.default)("EnumSymbolBody", ...arguments);
-}
-
-function enumBooleanMember(id) {
-  return (0, _builder.default)("EnumBooleanMember", ...arguments);
-}
-
-function enumNumberMember(id, init) {
-  return (0, _builder.default)("EnumNumberMember", ...arguments);
-}
-
-function enumStringMember(id, init) {
-  return (0, _builder.default)("EnumStringMember", ...arguments);
-}
-
-function enumDefaultedMember(id) {
-  return (0, _builder.default)("EnumDefaultedMember", ...arguments);
-}
-
-function jsxAttribute(name, value) {
-  return (0, _builder.default)("JSXAttribute", ...arguments);
-}
-
-function jsxClosingElement(name) {
-  return (0, _builder.default)("JSXClosingElement", ...arguments);
-}
-
-function jsxElement(openingElement, closingElement, children, selfClosing) {
-  return (0, _builder.default)("JSXElement", ...arguments);
-}
-
-function jsxEmptyExpression() {
-  return (0, _builder.default)("JSXEmptyExpression", ...arguments);
-}
-
-function jsxExpressionContainer(expression) {
-  return (0, _builder.default)("JSXExpressionContainer", ...arguments);
-}
-
-function jsxSpreadChild(expression) {
-  return (0, _builder.default)("JSXSpreadChild", ...arguments);
-}
-
-function jsxIdentifier(name) {
-  return (0, _builder.default)("JSXIdentifier", ...arguments);
-}
-
-function jsxMemberExpression(object, property) {
-  return (0, _builder.default)("JSXMemberExpression", ...arguments);
-}
-
-function jsxNamespacedName(namespace, name) {
-  return (0, _builder.default)("JSXNamespacedName", ...arguments);
-}
-
-function jsxOpeningElement(name, attributes, selfClosing) {
-  return (0, _builder.default)("JSXOpeningElement", ...arguments);
-}
-
-function jsxSpreadAttribute(argument) {
-  return (0, _builder.default)("JSXSpreadAttribute", ...arguments);
-}
-
-function jsxText(value) {
-  return (0, _builder.default)("JSXText", ...arguments);
-}
-
-function jsxFragment(openingFragment, closingFragment, children) {
-  return (0, _builder.default)("JSXFragment", ...arguments);
-}
-
-function jsxOpeningFragment() {
-  return (0, _builder.default)("JSXOpeningFragment", ...arguments);
-}
-
-function jsxClosingFragment() {
-  return (0, _builder.default)("JSXClosingFragment", ...arguments);
-}
-
-function noop() {
-  return (0, _builder.default)("Noop", ...arguments);
-}
-
-function placeholder(expectedNode, name) {
-  return (0, _builder.default)("Placeholder", ...arguments);
-}
-
-function v8IntrinsicIdentifier(name) {
-  return (0, _builder.default)("V8IntrinsicIdentifier", ...arguments);
-}
-
-function argumentPlaceholder() {
-  return (0, _builder.default)("ArgumentPlaceholder", ...arguments);
-}
-
-function bindExpression(object, callee) {
-  return (0, _builder.default)("BindExpression", ...arguments);
-}
-
-function classProperty(key, value, typeAnnotation, decorators, computed, _static) {
-  return (0, _builder.default)("ClassProperty", ...arguments);
-}
-
-function pipelineTopicExpression(expression) {
-  return (0, _builder.default)("PipelineTopicExpression", ...arguments);
-}
-
-function pipelineBareFunction(callee) {
-  return (0, _builder.default)("PipelineBareFunction", ...arguments);
-}
-
-function pipelinePrimaryTopicReference() {
-  return (0, _builder.default)("PipelinePrimaryTopicReference", ...arguments);
-}
-
-function classPrivateProperty(key, value, decorators, _static) {
-  return (0, _builder.default)("ClassPrivateProperty", ...arguments);
-}
-
-function classPrivateMethod(kind, key, params, body, _static) {
-  return (0, _builder.default)("ClassPrivateMethod", ...arguments);
-}
-
-function importAttribute(key, value) {
-  return (0, _builder.default)("ImportAttribute", ...arguments);
-}
-
-function decorator(expression) {
-  return (0, _builder.default)("Decorator", ...arguments);
-}
-
-function doExpression(body) {
-  return (0, _builder.default)("DoExpression", ...arguments);
-}
-
-function exportDefaultSpecifier(exported) {
-  return (0, _builder.default)("ExportDefaultSpecifier", ...arguments);
-}
-
-function privateName(id) {
-  return (0, _builder.default)("PrivateName", ...arguments);
-}
-
-function recordExpression(properties) {
-  return (0, _builder.default)("RecordExpression", ...arguments);
-}
-
-function tupleExpression(elements) {
-  return (0, _builder.default)("TupleExpression", ...arguments);
-}
-
-function decimalLiteral(value) {
-  return (0, _builder.default)("DecimalLiteral", ...arguments);
-}
-
-function staticBlock(body) {
-  return (0, _builder.default)("StaticBlock", ...arguments);
-}
-
-function tsParameterProperty(parameter) {
-  return (0, _builder.default)("TSParameterProperty", ...arguments);
-}
-
-function tsDeclareFunction(id, typeParameters, params, returnType) {
-  return (0, _builder.default)("TSDeclareFunction", ...arguments);
-}
-
-function tsDeclareMethod(decorators, key, typeParameters, params, returnType) {
-  return (0, _builder.default)("TSDeclareMethod", ...arguments);
-}
-
-function tsQualifiedName(left, right) {
-  return (0, _builder.default)("TSQualifiedName", ...arguments);
-}
-
-function tsCallSignatureDeclaration(typeParameters, parameters, typeAnnotation) {
-  return (0, _builder.default)("TSCallSignatureDeclaration", ...arguments);
-}
-
-function tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation) {
-  return (0, _builder.default)("TSConstructSignatureDeclaration", ...arguments);
-}
-
-function tsPropertySignature(key, typeAnnotation, initializer) {
-  return (0, _builder.default)("TSPropertySignature", ...arguments);
-}
-
-function tsMethodSignature(key, typeParameters, parameters, typeAnnotation) {
-  return (0, _builder.default)("TSMethodSignature", ...arguments);
-}
-
-function tsIndexSignature(parameters, typeAnnotation) {
-  return (0, _builder.default)("TSIndexSignature", ...arguments);
-}
-
-function tsAnyKeyword() {
-  return (0, _builder.default)("TSAnyKeyword", ...arguments);
-}
-
-function tsBooleanKeyword() {
-  return (0, _builder.default)("TSBooleanKeyword", ...arguments);
-}
-
-function tsBigIntKeyword() {
-  return (0, _builder.default)("TSBigIntKeyword", ...arguments);
-}
-
-function tsIntrinsicKeyword() {
-  return (0, _builder.default)("TSIntrinsicKeyword", ...arguments);
-}
-
-function tsNeverKeyword() {
-  return (0, _builder.default)("TSNeverKeyword", ...arguments);
-}
-
-function tsNullKeyword() {
-  return (0, _builder.default)("TSNullKeyword", ...arguments);
-}
-
-function tsNumberKeyword() {
-  return (0, _builder.default)("TSNumberKeyword", ...arguments);
-}
-
-function tsObjectKeyword() {
-  return (0, _builder.default)("TSObjectKeyword", ...arguments);
-}
-
-function tsStringKeyword() {
-  return (0, _builder.default)("TSStringKeyword", ...arguments);
-}
-
-function tsSymbolKeyword() {
-  return (0, _builder.default)("TSSymbolKeyword", ...arguments);
-}
-
-function tsUndefinedKeyword() {
-  return (0, _builder.default)("TSUndefinedKeyword", ...arguments);
-}
-
-function tsUnknownKeyword() {
-  return (0, _builder.default)("TSUnknownKeyword", ...arguments);
-}
-
-function tsVoidKeyword() {
-  return (0, _builder.default)("TSVoidKeyword", ...arguments);
-}
-
-function tsThisType() {
-  return (0, _builder.default)("TSThisType", ...arguments);
-}
-
-function tsFunctionType(typeParameters, parameters, typeAnnotation) {
-  return (0, _builder.default)("TSFunctionType", ...arguments);
-}
-
-function tsConstructorType(typeParameters, parameters, typeAnnotation) {
-  return (0, _builder.default)("TSConstructorType", ...arguments);
-}
-
-function tsTypeReference(typeName, typeParameters) {
-  return (0, _builder.default)("TSTypeReference", ...arguments);
-}
-
-function tsTypePredicate(parameterName, typeAnnotation, asserts) {
-  return (0, _builder.default)("TSTypePredicate", ...arguments);
-}
-
-function tsTypeQuery(exprName) {
-  return (0, _builder.default)("TSTypeQuery", ...arguments);
-}
-
-function tsTypeLiteral(members) {
-  return (0, _builder.default)("TSTypeLiteral", ...arguments);
-}
-
-function tsArrayType(elementType) {
-  return (0, _builder.default)("TSArrayType", ...arguments);
-}
-
-function tsTupleType(elementTypes) {
-  return (0, _builder.default)("TSTupleType", ...arguments);
-}
-
-function tsOptionalType(typeAnnotation) {
-  return (0, _builder.default)("TSOptionalType", ...arguments);
-}
-
-function tsRestType(typeAnnotation) {
-  return (0, _builder.default)("TSRestType", ...arguments);
-}
-
-function tsNamedTupleMember(label, elementType, optional) {
-  return (0, _builder.default)("TSNamedTupleMember", ...arguments);
-}
-
-function tsUnionType(types) {
-  return (0, _builder.default)("TSUnionType", ...arguments);
-}
-
-function tsIntersectionType(types) {
-  return (0, _builder.default)("TSIntersectionType", ...arguments);
-}
-
-function tsConditionalType(checkType, extendsType, trueType, falseType) {
-  return (0, _builder.default)("TSConditionalType", ...arguments);
-}
-
-function tsInferType(typeParameter) {
-  return (0, _builder.default)("TSInferType", ...arguments);
-}
-
-function tsParenthesizedType(typeAnnotation) {
-  return (0, _builder.default)("TSParenthesizedType", ...arguments);
-}
-
-function tsTypeOperator(typeAnnotation) {
-  return (0, _builder.default)("TSTypeOperator", ...arguments);
-}
-
-function tsIndexedAccessType(objectType, indexType) {
-  return (0, _builder.default)("TSIndexedAccessType", ...arguments);
-}
-
-function tsMappedType(typeParameter, typeAnnotation, nameType) {
-  return (0, _builder.default)("TSMappedType", ...arguments);
-}
-
-function tsLiteralType(literal) {
-  return (0, _builder.default)("TSLiteralType", ...arguments);
-}
-
-function tsExpressionWithTypeArguments(expression, typeParameters) {
-  return (0, _builder.default)("TSExpressionWithTypeArguments", ...arguments);
-}
-
-function tsInterfaceDeclaration(id, typeParameters, _extends, body) {
-  return (0, _builder.default)("TSInterfaceDeclaration", ...arguments);
-}
-
-function tsInterfaceBody(body) {
-  return (0, _builder.default)("TSInterfaceBody", ...arguments);
-}
-
-function tsTypeAliasDeclaration(id, typeParameters, typeAnnotation) {
-  return (0, _builder.default)("TSTypeAliasDeclaration", ...arguments);
-}
-
-function tsAsExpression(expression, typeAnnotation) {
-  return (0, _builder.default)("TSAsExpression", ...arguments);
-}
-
-function tsTypeAssertion(typeAnnotation, expression) {
-  return (0, _builder.default)("TSTypeAssertion", ...arguments);
-}
-
-function tsEnumDeclaration(id, members) {
-  return (0, _builder.default)("TSEnumDeclaration", ...arguments);
-}
-
-function tsEnumMember(id, initializer) {
-  return (0, _builder.default)("TSEnumMember", ...arguments);
-}
-
-function tsModuleDeclaration(id, body) {
-  return (0, _builder.default)("TSModuleDeclaration", ...arguments);
-}
-
-function tsModuleBlock(body) {
-  return (0, _builder.default)("TSModuleBlock", ...arguments);
-}
-
-function tsImportType(argument, qualifier, typeParameters) {
-  return (0, _builder.default)("TSImportType", ...arguments);
-}
-
-function tsImportEqualsDeclaration(id, moduleReference) {
-  return (0, _builder.default)("TSImportEqualsDeclaration", ...arguments);
-}
-
-function tsExternalModuleReference(expression) {
-  return (0, _builder.default)("TSExternalModuleReference", ...arguments);
-}
-
-function tsNonNullExpression(expression) {
-  return (0, _builder.default)("TSNonNullExpression", ...arguments);
-}
-
-function tsExportAssignment(expression) {
-  return (0, _builder.default)("TSExportAssignment", ...arguments);
-}
-
-function tsNamespaceExportDeclaration(id) {
-  return (0, _builder.default)("TSNamespaceExportDeclaration", ...arguments);
-}
-
-function tsTypeAnnotation(typeAnnotation) {
-  return (0, _builder.default)("TSTypeAnnotation", ...arguments);
-}
-
-function tsTypeParameterInstantiation(params) {
-  return (0, _builder.default)("TSTypeParameterInstantiation", ...arguments);
-}
-
-function tsTypeParameterDeclaration(params) {
-  return (0, _builder.default)("TSTypeParameterDeclaration", ...arguments);
-}
-
-function tsTypeParameter(constraint, _default, name) {
-  return (0, _builder.default)("TSTypeParameter", ...arguments);
-}
-
-function NumberLiteral(...args) {
-  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
-  return (0, _builder.default)("NumberLiteral", ...args);
-}
-
-function RegexLiteral(...args) {
-  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
-  return (0, _builder.default)("RegexLiteral", ...args);
-}
-
-function RestProperty(...args) {
-  console.trace("The node type RestProperty has been renamed to RestElement");
-  return (0, _builder.default)("RestProperty", ...args);
-}
-
-function SpreadProperty(...args) {
-  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
-  return (0, _builder.default)("SpreadProperty", ...args);
-}

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

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = buildChildren;
-
-var _generated = require("../../validators/generated");
-
-var _cleanJSXElementLiteralChild = _interopRequireDefault(require("../../utils/react/cleanJSXElementLiteralChild"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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;
-}

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

@@ -1,23 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createTSUnionType;
-
-var _generated = require("../generated");
-
-var _removeTypeDuplicates = _interopRequireDefault(require("../../modifications/typescript/removeTypeDuplicates"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function createTSUnionType(typeAnnotations) {
-  const types = typeAnnotations.map(type => type.typeAnnotation);
-  const flattened = (0, _removeTypeDuplicates.default)(types);
-
-  if (flattened.length === 1) {
-    return flattened[0];
-  } else {
-    return (0, _generated.tsUnionType)(flattened);
-  }
-}

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

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

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

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

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

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

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

@@ -1,103 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = cloneNode;
-
-var _definitions = require("../definitions");
-
-var _generated = require("../validators/generated");
-
-const has = Function.call.bind(Object.prototype.hasOwnProperty);
-
-function cloneIfNode(obj, deep, withoutLoc) {
-  if (obj && typeof obj.type === "string") {
-    return cloneNode(obj, deep, withoutLoc);
-  }
-
-  return obj;
-}
-
-function cloneIfNodeOrArray(obj, deep, withoutLoc) {
-  if (Array.isArray(obj)) {
-    return obj.map(node => cloneIfNode(node, deep, withoutLoc));
-  }
-
-  return cloneIfNode(obj, deep, withoutLoc);
-}
-
-function cloneNode(node, deep = true, withoutLoc = false) {
-  if (!node) return node;
-  const {
-    type
-  } = node;
-  const newNode = {
-    type: node.type
-  };
-
-  if ((0, _generated.isIdentifier)(node)) {
-    newNode.name = node.name;
-
-    if (has(node, "optional") && typeof node.optional === "boolean") {
-      newNode.optional = node.optional;
-    }
-
-    if (has(node, "typeAnnotation")) {
-      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc) : node.typeAnnotation;
-    }
-  } else if (!has(_definitions.NODE_FIELDS, type)) {
-    throw new Error(`Unknown node type: "${type}"`);
-  } else {
-    for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
-      if (has(node, field)) {
-        if (deep) {
-          newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc) : cloneIfNodeOrArray(node[field], true, withoutLoc);
-        } else {
-          newNode[field] = node[field];
-        }
-      }
-    }
-  }
-
-  if (has(node, "loc")) {
-    if (withoutLoc) {
-      newNode.loc = null;
-    } else {
-      newNode.loc = node.loc;
-    }
-  }
-
-  if (has(node, "leadingComments")) {
-    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc);
-  }
-
-  if (has(node, "innerComments")) {
-    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc);
-  }
-
-  if (has(node, "trailingComments")) {
-    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc);
-  }
-
-  if (has(node, "extra")) {
-    newNode.extra = Object.assign({}, node.extra);
-  }
-
-  return newNode;
-}
-
-function cloneCommentsWithoutLoc(comments) {
-  return comments.map(({
-    type,
-    value
-  }) => ({
-    type,
-    value,
-    loc: null
-  }));
-}
-
-function maybeCloneComments(comments, deep, withoutLoc) {
-  return deep && withoutLoc ? cloneCommentsWithoutLoc(comments) : comments;
-}

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

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

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

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

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

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

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

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inheritInnerComments;
-
-var _inherit = _interopRequireDefault(require("../utils/inherit"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function inheritInnerComments(child, parent) {
-  (0, _inherit.default)("innerComments", child, parent);
-}

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

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inheritLeadingComments;
-
-var _inherit = _interopRequireDefault(require("../utils/inherit"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function inheritLeadingComments(child, parent) {
-  (0, _inherit.default)("leadingComments", child, parent);
-}

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

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inheritTrailingComments;
-
-var _inherit = _interopRequireDefault(require("../utils/inherit"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function inheritTrailingComments(child, parent) {
-  (0, _inherit.default)("trailingComments", child, parent);
-}

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

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

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

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

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

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

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

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

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

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

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

@@ -1,77 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = gatherSequenceExpressions;
-
-var _getBindingIdentifiers = _interopRequireDefault(require("../retrievers/getBindingIdentifiers"));
-
-var _generated = require("../validators/generated");
-
-var _generated2 = require("../builders/generated");
-
-var _cloneNode = _interopRequireDefault(require("../clone/cloneNode"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function gatherSequenceExpressions(nodes, scope, declars) {
-  const exprs = [];
-  let ensureLastUndefined = true;
-
-  for (const node of nodes) {
-    if (!(0, _generated.isEmptyStatement)(node)) {
-      ensureLastUndefined = false;
-    }
-
-    if ((0, _generated.isExpression)(node)) {
-      exprs.push(node);
-    } else if ((0, _generated.isExpressionStatement)(node)) {
-      exprs.push(node.expression);
-    } else if ((0, _generated.isVariableDeclaration)(node)) {
-      if (node.kind !== "var") return;
-
-      for (const declar of node.declarations) {
-        const bindings = (0, _getBindingIdentifiers.default)(declar);
-
-        for (const key of Object.keys(bindings)) {
-          declars.push({
-            kind: node.kind,
-            id: (0, _cloneNode.default)(bindings[key])
-          });
-        }
-
-        if (declar.init) {
-          exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
-        }
-      }
-
-      ensureLastUndefined = true;
-    } else if ((0, _generated.isIfStatement)(node)) {
-      const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
-      const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
-      if (!consequent || !alternate) return;
-      exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
-    } else if ((0, _generated.isBlockStatement)(node)) {
-      const body = gatherSequenceExpressions(node.body, scope, declars);
-      if (!body) return;
-      exprs.push(body);
-    } else if ((0, _generated.isEmptyStatement)(node)) {
-      if (nodes.indexOf(node) === 0) {
-        ensureLastUndefined = true;
-      }
-    } else {
-      return;
-    }
-  }
-
-  if (ensureLastUndefined) {
-    exprs.push(scope.buildUndefinedNode());
-  }
-
-  if (exprs.length === 1) {
-    return exprs[0];
-  } else {
-    return (0, _generated2.sequenceExpression)(exprs);
-  }
-}

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

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

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

@@ -1,34 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = toBlock;
-
-var _generated = require("../validators/generated");
-
-var _generated2 = require("../builders/generated");
-
-function toBlock(node, parent) {
-  if ((0, _generated.isBlockStatement)(node)) {
-    return node;
-  }
-
-  let blockNodes = [];
-
-  if ((0, _generated.isEmptyStatement)(node)) {
-    blockNodes = [];
-  } else {
-    if (!(0, _generated.isStatement)(node)) {
-      if ((0, _generated.isFunction)(parent)) {
-        node = (0, _generated2.returnStatement)(node);
-      } else {
-        node = (0, _generated2.expressionStatement)(node);
-      }
-    }
-
-    blockNodes = [node];
-  }
-
-  return (0, _generated2.blockStatement)(blockNodes);
-}

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

@@ -1,15 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = toComputedKey;
-
-var _generated = require("../validators/generated");
-
-var _generated2 = require("../builders/generated");
-
-function toComputedKey(node, key = node.key || node.property) {
-  if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name);
-  return key;
-}

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

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _generated = require("../validators/generated");
-
-var _default = toExpression;
-exports.default = _default;
-
-function toExpression(node) {
-  if ((0, _generated.isExpressionStatement)(node)) {
-    node = node.expression;
-  }
-
-  if ((0, _generated.isExpression)(node)) {
-    return node;
-  }
-
-  if ((0, _generated.isClass)(node)) {
-    node.type = "ClassExpression";
-  } else if ((0, _generated.isFunction)(node)) {
-    node.type = "FunctionExpression";
-  }
-
-  if (!(0, _generated.isExpression)(node)) {
-    throw new Error(`cannot turn ${node.type} to an expression`);
-  }
-
-  return node;
-}

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

@@ -1,25 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = toIdentifier;
-
-var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function toIdentifier(name) {
-  name = name + "";
-  name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
-  name = name.replace(/^[-0-9]+/, "");
-  name = name.replace(/[-\s]+(.)?/g, function (match, c) {
-    return c ? c.toUpperCase() : "";
-  });
-
-  if (!(0, _isValidIdentifier.default)(name)) {
-    name = `_${name}`;
-  }
-
-  return name || "_";
-}

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

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = toKeyAlias;
-
-var _generated = require("../validators/generated");
-
-var _cloneNode = _interopRequireDefault(require("../clone/cloneNode"));
-
-var _removePropertiesDeep = _interopRequireDefault(require("../modifications/removePropertiesDeep"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function toKeyAlias(node, key = node.key) {
-  let alias;
-
-  if (node.kind === "method") {
-    return toKeyAlias.increment() + "";
-  } else if ((0, _generated.isIdentifier)(key)) {
-    alias = key.name;
-  } else if ((0, _generated.isStringLiteral)(key)) {
-    alias = JSON.stringify(key.value);
-  } else {
-    alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
-  }
-
-  if (node.computed) {
-    alias = `[${alias}]`;
-  }
-
-  if (node.static) {
-    alias = `static:${alias}`;
-  }
-
-  return alias;
-}
-
-toKeyAlias.uid = 0;
-
-toKeyAlias.increment = function () {
-  if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
-    return toKeyAlias.uid = 0;
-  } else {
-    return toKeyAlias.uid++;
-  }
-};

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

@@ -1,23 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = toSequenceExpression;
-
-var _gatherSequenceExpressions = _interopRequireDefault(require("./gatherSequenceExpressions"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function toSequenceExpression(nodes, scope) {
-  if (!(nodes == null ? void 0 : nodes.length)) return;
-  const declars = [];
-  const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
-  if (!result) return;
-
-  for (const declar of declars) {
-    scope.push(declar);
-  }
-
-  return result;
-}

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

@@ -1,47 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _generated = require("../validators/generated");
-
-var _generated2 = require("../builders/generated");
-
-var _default = toStatement;
-exports.default = _default;
-
-function toStatement(node, ignore) {
-  if ((0, _generated.isStatement)(node)) {
-    return node;
-  }
-
-  let mustHaveId = false;
-  let newType;
-
-  if ((0, _generated.isClass)(node)) {
-    mustHaveId = true;
-    newType = "ClassDeclaration";
-  } else if ((0, _generated.isFunction)(node)) {
-    mustHaveId = true;
-    newType = "FunctionDeclaration";
-  } else if ((0, _generated.isAssignmentExpression)(node)) {
-    return (0, _generated2.expressionStatement)(node);
-  }
-
-  if (mustHaveId && !node.id) {
-    newType = false;
-  }
-
-  if (!newType) {
-    if (ignore) {
-      return false;
-    } else {
-      throw new Error(`cannot turn ${node.type} to a statement`);
-    }
-  }
-
-  node.type = newType;
-  return node;
-}

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

@@ -1,91 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
-
-var _isRegExp = _interopRequireDefault(require("lodash/isRegExp"));
-
-var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
-
-var _generated = require("../builders/generated");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var _default = valueToNode;
-exports.default = _default;
-
-function valueToNode(value) {
-  if (value === undefined) {
-    return (0, _generated.identifier)("undefined");
-  }
-
-  if (value === true || value === false) {
-    return (0, _generated.booleanLiteral)(value);
-  }
-
-  if (value === null) {
-    return (0, _generated.nullLiteral)();
-  }
-
-  if (typeof value === "string") {
-    return (0, _generated.stringLiteral)(value);
-  }
-
-  if (typeof value === "number") {
-    let result;
-
-    if (Number.isFinite(value)) {
-      result = (0, _generated.numericLiteral)(Math.abs(value));
-    } else {
-      let numerator;
-
-      if (Number.isNaN(value)) {
-        numerator = (0, _generated.numericLiteral)(0);
-      } else {
-        numerator = (0, _generated.numericLiteral)(1);
-      }
-
-      result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0));
-    }
-
-    if (value < 0 || Object.is(value, -0)) {
-      result = (0, _generated.unaryExpression)("-", result);
-    }
-
-    return result;
-  }
-
-  if ((0, _isRegExp.default)(value)) {
-    const pattern = value.source;
-    const flags = value.toString().match(/\/([a-z]+|)$/)[1];
-    return (0, _generated.regExpLiteral)(pattern, flags);
-  }
-
-  if (Array.isArray(value)) {
-    return (0, _generated.arrayExpression)(value.map(valueToNode));
-  }
-
-  if ((0, _isPlainObject.default)(value)) {
-    const props = [];
-
-    for (const key of Object.keys(value)) {
-      let nodeKey;
-
-      if ((0, _isValidIdentifier.default)(key)) {
-        nodeKey = (0, _generated.identifier)(key);
-      } else {
-        nodeKey = (0, _generated.stringLiteral)(key);
-      }
-
-      props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key])));
-    }
-
-    return (0, _generated.objectExpression)(props);
-  }
-
-  throw new Error("don't know how to turn this value into a node");
-}

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

@@ -1,1489 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0;
-
-var _is = _interopRequireDefault(require("../validators/is"));
-
-var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
-
-var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
-
-var _constants = require("../constants");
-
-var _utils = _interopRequireWildcard(require("./utils"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-(0, _utils.default)("ArrayExpression", {
-  fields: {
-    elements: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
-      default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined
-    }
-  },
-  visitor: ["elements"],
-  aliases: ["Expression"]
-});
-(0, _utils.default)("AssignmentExpression", {
-  fields: {
-    operator: {
-      validate: function () {
-        if (!process.env.BABEL_TYPES_8_BREAKING) {
-          return (0, _utils.assertValueType)("string");
-        }
-
-        const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS);
-        const pattern = (0, _utils.assertOneOf)("=");
-        return function (node, key, val) {
-          const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier;
-          validator(node, key, val);
-        };
-      }()
-    },
-    left: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
-    },
-    right: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  },
-  builder: ["operator", "left", "right"],
-  visitor: ["left", "right"],
-  aliases: ["Expression"]
-});
-(0, _utils.default)("BinaryExpression", {
-  builder: ["operator", "left", "right"],
-  fields: {
-    operator: {
-      validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
-    },
-    left: {
-      validate: function () {
-        const expression = (0, _utils.assertNodeType)("Expression");
-        const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName");
-
-        const validator = function (node, key, val) {
-          const validator = node.operator === "in" ? inOp : expression;
-          validator(node, key, val);
-        };
-
-        validator.oneOfNodeTypes = ["Expression", "PrivateName"];
-        return validator;
-      }()
-    },
-    right: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  },
-  visitor: ["left", "right"],
-  aliases: ["Binary", "Expression"]
-});
-(0, _utils.default)("InterpreterDirective", {
-  builder: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  }
-});
-(0, _utils.default)("Directive", {
-  visitor: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertNodeType)("DirectiveLiteral")
-    }
-  }
-});
-(0, _utils.default)("DirectiveLiteral", {
-  builder: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  }
-});
-(0, _utils.default)("BlockStatement", {
-  builder: ["body", "directives"],
-  visitor: ["directives", "body"],
-  fields: {
-    directives: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
-      default: []
-    },
-    body: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
-    }
-  },
-  aliases: ["Scopable", "BlockParent", "Block", "Statement"]
-});
-(0, _utils.default)("BreakStatement", {
-  visitor: ["label"],
-  fields: {
-    label: {
-      validate: (0, _utils.assertNodeType)("Identifier"),
-      optional: true
-    }
-  },
-  aliases: ["Statement", "Terminatorless", "CompletionStatement"]
-});
-(0, _utils.default)("CallExpression", {
-  visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
-  builder: ["callee", "arguments"],
-  aliases: ["Expression"],
-  fields: Object.assign({
-    callee: {
-      validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier")
-    },
-    arguments: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
-    }
-  }, !process.env.BABEL_TYPES_8_BREAKING ? {
-    optional: {
-      validate: (0, _utils.assertOneOf)(true, false),
-      optional: true
-    }
-  } : {}, {
-    typeArguments: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
-      optional: true
-    },
-    typeParameters: {
-      validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
-      optional: true
-    }
-  })
-});
-(0, _utils.default)("CatchClause", {
-  visitor: ["param", "body"],
-  fields: {
-    param: {
-      validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
-      optional: true
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  },
-  aliases: ["Scopable", "BlockParent"]
-});
-(0, _utils.default)("ConditionalExpression", {
-  visitor: ["test", "consequent", "alternate"],
-  fields: {
-    test: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    consequent: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    alternate: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  },
-  aliases: ["Expression", "Conditional"]
-});
-(0, _utils.default)("ContinueStatement", {
-  visitor: ["label"],
-  fields: {
-    label: {
-      validate: (0, _utils.assertNodeType)("Identifier"),
-      optional: true
-    }
-  },
-  aliases: ["Statement", "Terminatorless", "CompletionStatement"]
-});
-(0, _utils.default)("DebuggerStatement", {
-  aliases: ["Statement"]
-});
-(0, _utils.default)("DoWhileStatement", {
-  visitor: ["test", "body"],
-  fields: {
-    test: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    }
-  },
-  aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
-});
-(0, _utils.default)("EmptyStatement", {
-  aliases: ["Statement"]
-});
-(0, _utils.default)("ExpressionStatement", {
-  visitor: ["expression"],
-  fields: {
-    expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  },
-  aliases: ["Statement", "ExpressionWrapper"]
-});
-(0, _utils.default)("File", {
-  builder: ["program", "comments", "tokens"],
-  visitor: ["program"],
-  fields: {
-    program: {
-      validate: (0, _utils.assertNodeType)("Program")
-    },
-    comments: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, {
-        each: {
-          oneOfNodeTypes: ["CommentBlock", "CommentLine"]
-        }
-      }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")),
-      optional: true
-    },
-    tokens: {
-      validate: (0, _utils.assertEach)(Object.assign(() => {}, {
-        type: "any"
-      })),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("ForInStatement", {
-  visitor: ["left", "right", "body"],
-  aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
-  fields: {
-    left: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
-    },
-    right: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    }
-  }
-});
-(0, _utils.default)("ForStatement", {
-  visitor: ["init", "test", "update", "body"],
-  aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
-  fields: {
-    init: {
-      validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
-      optional: true
-    },
-    test: {
-      validate: (0, _utils.assertNodeType)("Expression"),
-      optional: true
-    },
-    update: {
-      validate: (0, _utils.assertNodeType)("Expression"),
-      optional: true
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    }
-  }
-});
-const functionCommon = {
-  params: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
-  },
-  generator: {
-    default: false
-  },
-  async: {
-    default: false
-  }
-};
-exports.functionCommon = functionCommon;
-const functionTypeAnnotationCommon = {
-  returnType: {
-    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-    optional: true
-  },
-  typeParameters: {
-    validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
-    optional: true
-  }
-};
-exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
-const functionDeclarationCommon = Object.assign({}, functionCommon, {
-  declare: {
-    validate: (0, _utils.assertValueType)("boolean"),
-    optional: true
-  },
-  id: {
-    validate: (0, _utils.assertNodeType)("Identifier"),
-    optional: true
-  }
-});
-exports.functionDeclarationCommon = functionDeclarationCommon;
-(0, _utils.default)("FunctionDeclaration", {
-  builder: ["id", "params", "body", "generator", "async"],
-  visitor: ["id", "params", "body", "returnType", "typeParameters"],
-  fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  }),
-  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
-  validate: function () {
-    if (!process.env.BABEL_TYPES_8_BREAKING) return () => {};
-    const identifier = (0, _utils.assertNodeType)("Identifier");
-    return function (parent, key, node) {
-      if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
-        identifier(node, "id", node.id);
-      }
-    };
-  }()
-});
-(0, _utils.default)("FunctionExpression", {
-  inherits: "FunctionDeclaration",
-  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
-    id: {
-      validate: (0, _utils.assertNodeType)("Identifier"),
-      optional: true
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  })
-});
-const patternLikeCommon = {
-  typeAnnotation: {
-    validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-    optional: true
-  },
-  decorators: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
-  }
-};
-exports.patternLikeCommon = patternLikeCommon;
-(0, _utils.default)("Identifier", {
-  builder: ["name"],
-  visitor: ["typeAnnotation", "decorators"],
-  aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
-  fields: Object.assign({}, patternLikeCommon, {
-    name: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-        if (!(0, _isValidIdentifier.default)(val, false)) {
-          throw new TypeError(`"${val}" is not a valid identifier name`);
-        }
-      }, {
-        type: "string"
-      }))
-    },
-    optional: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    }
-  }),
-
-  validate(parent, key, node) {
-    if (!process.env.BABEL_TYPES_8_BREAKING) return;
-    const match = /\.(\w+)$/.exec(key);
-    if (!match) return;
-    const [, parentKey] = match;
-    const nonComp = {
-      computed: false
-    };
-
-    if (parentKey === "property") {
-      if ((0, _is.default)("MemberExpression", parent, nonComp)) return;
-      if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return;
-    } else if (parentKey === "key") {
-      if ((0, _is.default)("Property", parent, nonComp)) return;
-      if ((0, _is.default)("Method", parent, nonComp)) return;
-    } else if (parentKey === "exported") {
-      if ((0, _is.default)("ExportSpecifier", parent)) return;
-    } else if (parentKey === "imported") {
-      if ((0, _is.default)("ImportSpecifier", parent, {
-        imported: node
-      })) return;
-    } else if (parentKey === "meta") {
-      if ((0, _is.default)("MetaProperty", parent, {
-        meta: node
-      })) return;
-    }
-
-    if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") {
-      throw new TypeError(`"${node.name}" is not a valid identifier`);
-    }
-  }
-
-});
-(0, _utils.default)("IfStatement", {
-  visitor: ["test", "consequent", "alternate"],
-  aliases: ["Statement", "Conditional"],
-  fields: {
-    test: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    consequent: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    },
-    alternate: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("Statement")
-    }
-  }
-});
-(0, _utils.default)("LabeledStatement", {
-  visitor: ["label", "body"],
-  aliases: ["Statement"],
-  fields: {
-    label: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    }
-  }
-});
-(0, _utils.default)("StringLiteral", {
-  builder: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  },
-  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-});
-(0, _utils.default)("NumericLiteral", {
-  builder: ["value"],
-  deprecatedAlias: "NumberLiteral",
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("number")
-    }
-  },
-  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-});
-(0, _utils.default)("NullLiteral", {
-  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-});
-(0, _utils.default)("BooleanLiteral", {
-  builder: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("boolean")
-    }
-  },
-  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-});
-(0, _utils.default)("RegExpLiteral", {
-  builder: ["pattern", "flags"],
-  deprecatedAlias: "RegexLiteral",
-  aliases: ["Expression", "Pureish", "Literal"],
-  fields: {
-    pattern: {
-      validate: (0, _utils.assertValueType)("string")
-    },
-    flags: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-        const invalid = /[^gimsuy]/.exec(val);
-
-        if (invalid) {
-          throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
-        }
-      }, {
-        type: "string"
-      })),
-      default: ""
-    }
-  }
-});
-(0, _utils.default)("LogicalExpression", {
-  builder: ["operator", "left", "right"],
-  visitor: ["left", "right"],
-  aliases: ["Binary", "Expression"],
-  fields: {
-    operator: {
-      validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
-    },
-    left: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    right: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("MemberExpression", {
-  builder: ["object", "property", "computed", "optional"],
-  visitor: ["object", "property"],
-  aliases: ["Expression", "LVal"],
-  fields: Object.assign({
-    object: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    property: {
-      validate: function () {
-        const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
-        const computed = (0, _utils.assertNodeType)("Expression");
-
-        const validator = function (node, key, val) {
-          const validator = node.computed ? computed : normal;
-          validator(node, key, val);
-        };
-
-        validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"];
-        return validator;
-      }()
-    },
-    computed: {
-      default: false
-    }
-  }, !process.env.BABEL_TYPES_8_BREAKING ? {
-    optional: {
-      validate: (0, _utils.assertOneOf)(true, false),
-      optional: true
-    }
-  } : {})
-});
-(0, _utils.default)("NewExpression", {
-  inherits: "CallExpression"
-});
-(0, _utils.default)("Program", {
-  visitor: ["directives", "body"],
-  builder: ["body", "directives", "sourceType", "interpreter"],
-  fields: {
-    sourceFile: {
-      validate: (0, _utils.assertValueType)("string")
-    },
-    sourceType: {
-      validate: (0, _utils.assertOneOf)("script", "module"),
-      default: "script"
-    },
-    interpreter: {
-      validate: (0, _utils.assertNodeType)("InterpreterDirective"),
-      default: null,
-      optional: true
-    },
-    directives: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
-      default: []
-    },
-    body: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
-    }
-  },
-  aliases: ["Scopable", "BlockParent", "Block"]
-});
-(0, _utils.default)("ObjectExpression", {
-  visitor: ["properties"],
-  aliases: ["Expression"],
-  fields: {
-    properties: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
-    }
-  }
-});
-(0, _utils.default)("ObjectMethod", {
-  builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
-  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
-    kind: Object.assign({
-      validate: (0, _utils.assertOneOf)("method", "get", "set")
-    }, !process.env.BABEL_TYPES_8_BREAKING ? {
-      default: "method"
-    } : {}),
-    computed: {
-      default: false
-    },
-    key: {
-      validate: function () {
-        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
-        const computed = (0, _utils.assertNodeType)("Expression");
-
-        const validator = function (node, key, val) {
-          const validator = node.computed ? computed : normal;
-          validator(node, key, val);
-        };
-
-        validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
-        return validator;
-      }()
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  }),
-  visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
-  aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
-});
-(0, _utils.default)("ObjectProperty", {
-  builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])],
-  fields: {
-    computed: {
-      default: false
-    },
-    key: {
-      validate: function () {
-        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
-        const computed = (0, _utils.assertNodeType)("Expression");
-
-        const validator = function (node, key, val) {
-          const validator = node.computed ? computed : normal;
-          validator(node, key, val);
-        };
-
-        validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
-        return validator;
-      }()
-    },
-    value: {
-      validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
-    },
-    shorthand: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-        if (val && node.computed) {
-          throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
-        }
-      }, {
-        type: "boolean"
-      }), function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-        if (val && !(0, _is.default)("Identifier", node.key)) {
-          throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
-        }
-      }),
-      default: false
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    }
-  },
-  visitor: ["key", "value", "decorators"],
-  aliases: ["UserWhitespacable", "Property", "ObjectMember"],
-  validate: function () {
-    const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern");
-    const expression = (0, _utils.assertNodeType)("Expression");
-    return function (parent, key, node) {
-      if (!process.env.BABEL_TYPES_8_BREAKING) return;
-      const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
-      validator(node, "value", node.value);
-    };
-  }()
-});
-(0, _utils.default)("RestElement", {
-  visitor: ["argument", "typeAnnotation"],
-  builder: ["argument"],
-  aliases: ["LVal", "PatternLike"],
-  deprecatedAlias: "RestProperty",
-  fields: Object.assign({}, patternLikeCommon, {
-    argument: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "Pattern", "MemberExpression")
-    }
-  }),
-
-  validate(parent, key) {
-    if (!process.env.BABEL_TYPES_8_BREAKING) return;
-    const match = /(\w+)\[(\d+)\]/.exec(key);
-    if (!match) throw new Error("Internal Babel error: malformed key.");
-    const [, listKey, index] = match;
-
-    if (parent[listKey].length > index + 1) {
-      throw new TypeError(`RestElement must be last element of ${listKey}`);
-    }
-  }
-
-});
-(0, _utils.default)("ReturnStatement", {
-  visitor: ["argument"],
-  aliases: ["Statement", "Terminatorless", "CompletionStatement"],
-  fields: {
-    argument: {
-      validate: (0, _utils.assertNodeType)("Expression"),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("SequenceExpression", {
-  visitor: ["expressions"],
-  fields: {
-    expressions: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
-    }
-  },
-  aliases: ["Expression"]
-});
-(0, _utils.default)("ParenthesizedExpression", {
-  visitor: ["expression"],
-  aliases: ["Expression", "ExpressionWrapper"],
-  fields: {
-    expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("SwitchCase", {
-  visitor: ["test", "consequent"],
-  fields: {
-    test: {
-      validate: (0, _utils.assertNodeType)("Expression"),
-      optional: true
-    },
-    consequent: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
-    }
-  }
-});
-(0, _utils.default)("SwitchStatement", {
-  visitor: ["discriminant", "cases"],
-  aliases: ["Statement", "BlockParent", "Scopable"],
-  fields: {
-    discriminant: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    cases: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
-    }
-  }
-});
-(0, _utils.default)("ThisExpression", {
-  aliases: ["Expression"]
-});
-(0, _utils.default)("ThrowStatement", {
-  visitor: ["argument"],
-  aliases: ["Statement", "Terminatorless", "CompletionStatement"],
-  fields: {
-    argument: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("TryStatement", {
-  visitor: ["block", "handler", "finalizer"],
-  aliases: ["Statement"],
-  fields: {
-    block: {
-      validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-        if (!node.handler && !node.finalizer) {
-          throw new TypeError("TryStatement expects either a handler or finalizer, or both");
-        }
-      }, {
-        oneOfNodeTypes: ["BlockStatement"]
-      }))
-    },
-    handler: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("CatchClause")
-    },
-    finalizer: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  }
-});
-(0, _utils.default)("UnaryExpression", {
-  builder: ["operator", "argument", "prefix"],
-  fields: {
-    prefix: {
-      default: true
-    },
-    argument: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    operator: {
-      validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
-    }
-  },
-  visitor: ["argument"],
-  aliases: ["UnaryLike", "Expression"]
-});
-(0, _utils.default)("UpdateExpression", {
-  builder: ["operator", "argument", "prefix"],
-  fields: {
-    prefix: {
-      default: false
-    },
-    argument: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
-    },
-    operator: {
-      validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
-    }
-  },
-  visitor: ["argument"],
-  aliases: ["Expression"]
-});
-(0, _utils.default)("VariableDeclaration", {
-  builder: ["kind", "declarations"],
-  visitor: ["declarations"],
-  aliases: ["Statement", "Declaration"],
-  fields: {
-    declare: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    },
-    kind: {
-      validate: (0, _utils.assertOneOf)("var", "let", "const")
-    },
-    declarations: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
-    }
-  },
-
-  validate(parent, key, node) {
-    if (!process.env.BABEL_TYPES_8_BREAKING) return;
-    if (!(0, _is.default)("ForXStatement", parent, {
-      left: node
-    })) return;
-
-    if (node.declarations.length !== 1) {
-      throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
-    }
-  }
-
-});
-(0, _utils.default)("VariableDeclarator", {
-  visitor: ["id", "init"],
-  fields: {
-    id: {
-      validate: function () {
-        if (!process.env.BABEL_TYPES_8_BREAKING) {
-          return (0, _utils.assertNodeType)("LVal");
-        }
-
-        const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
-        const without = (0, _utils.assertNodeType)("Identifier");
-        return function (node, key, val) {
-          const validator = node.init ? normal : without;
-          validator(node, key, val);
-        };
-      }()
-    },
-    definite: {
-      optional: true,
-      validate: (0, _utils.assertValueType)("boolean")
-    },
-    init: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("WhileStatement", {
-  visitor: ["test", "body"],
-  aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
-  fields: {
-    test: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    }
-  }
-});
-(0, _utils.default)("WithStatement", {
-  visitor: ["object", "body"],
-  aliases: ["Statement"],
-  fields: {
-    object: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    }
-  }
-});
-(0, _utils.default)("AssignmentPattern", {
-  visitor: ["left", "right", "decorators"],
-  builder: ["left", "right"],
-  aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: Object.assign({}, patternLikeCommon, {
-    left: {
-      validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression")
-    },
-    right: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    }
-  })
-});
-(0, _utils.default)("ArrayPattern", {
-  visitor: ["elements", "typeAnnotation"],
-  builder: ["elements"],
-  aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: Object.assign({}, patternLikeCommon, {
-    elements: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike")))
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    }
-  })
-});
-(0, _utils.default)("ArrowFunctionExpression", {
-  builder: ["params", "body", "async"],
-  visitor: ["params", "body", "returnType", "typeParameters"],
-  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
-  fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
-    expression: {
-      validate: (0, _utils.assertValueType)("boolean")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
-    }
-  })
-});
-(0, _utils.default)("ClassBody", {
-  visitor: ["body"],
-  fields: {
-    body: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature")))
-    }
-  }
-});
-(0, _utils.default)("ClassExpression", {
-  builder: ["id", "superClass", "body", "decorators"],
-  visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
-  aliases: ["Scopable", "Class", "Expression"],
-  fields: {
-    id: {
-      validate: (0, _utils.assertNodeType)("Identifier"),
-      optional: true
-    },
-    typeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
-      optional: true
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("ClassBody")
-    },
-    superClass: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    superTypeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-      optional: true
-    },
-    implements: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
-      optional: true
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    },
-    mixins: {
-      validate: (0, _utils.assertNodeType)("InterfaceExtends"),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("ClassDeclaration", {
-  inherits: "ClassExpression",
-  aliases: ["Scopable", "Class", "Statement", "Declaration"],
-  fields: {
-    id: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    },
-    typeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
-      optional: true
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("ClassBody")
-    },
-    superClass: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    superTypeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-      optional: true
-    },
-    implements: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
-      optional: true
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    },
-    mixins: {
-      validate: (0, _utils.assertNodeType)("InterfaceExtends"),
-      optional: true
-    },
-    declare: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    },
-    abstract: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    }
-  },
-  validate: function () {
-    const identifier = (0, _utils.assertNodeType)("Identifier");
-    return function (parent, key, node) {
-      if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-      if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
-        identifier(node, "id", node.id);
-      }
-    };
-  }()
-});
-(0, _utils.default)("ExportAllDeclaration", {
-  visitor: ["source"],
-  aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
-  fields: {
-    source: {
-      validate: (0, _utils.assertNodeType)("StringLiteral")
-    },
-    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")),
-    assertions: {
-      optional: true,
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertNodeType)("ImportAttribute"))
-    }
-  }
-});
-(0, _utils.default)("ExportDefaultDeclaration", {
-  visitor: ["declaration"],
-  aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
-  fields: {
-    declaration: {
-      validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression")
-    }
-  }
-});
-(0, _utils.default)("ExportNamedDeclaration", {
-  visitor: ["declaration", "specifiers", "source"],
-  aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
-  fields: {
-    declaration: {
-      optional: true,
-      validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-        if (val && node.specifiers.length) {
-          throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
-        }
-      }, {
-        oneOfNodeTypes: ["Declaration"]
-      }), function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-        if (val && node.source) {
-          throw new TypeError("Cannot export a declaration from a source");
-        }
-      })
-    },
-    assertions: {
-      optional: true,
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertNodeType)("ImportAttribute"))
-    },
-    specifiers: {
-      default: [],
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () {
-        const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
-        const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
-        if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;
-        return function (node, key, val) {
-          const validator = node.source ? sourced : sourceless;
-          validator(node, key, val);
-        };
-      }()))
-    },
-    source: {
-      validate: (0, _utils.assertNodeType)("StringLiteral"),
-      optional: true
-    },
-    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
-  }
-});
-(0, _utils.default)("ExportSpecifier", {
-  visitor: ["local", "exported"],
-  aliases: ["ModuleSpecifier"],
-  fields: {
-    local: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    },
-    exported: {
-      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
-    }
-  }
-});
-(0, _utils.default)("ForOfStatement", {
-  visitor: ["left", "right", "body"],
-  builder: ["left", "right", "body", "await"],
-  aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
-  fields: {
-    left: {
-      validate: function () {
-        if (!process.env.BABEL_TYPES_8_BREAKING) {
-          return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
-        }
-
-        const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
-        const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern");
-        return function (node, key, val) {
-          if ((0, _is.default)("VariableDeclaration", val)) {
-            declaration(node, key, val);
-          } else {
-            lval(node, key, val);
-          }
-        };
-      }()
-    },
-    right: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("Statement")
-    },
-    await: {
-      default: false
-    }
-  }
-});
-(0, _utils.default)("ImportDeclaration", {
-  visitor: ["specifiers", "source"],
-  aliases: ["Statement", "Declaration", "ModuleDeclaration"],
-  fields: {
-    assertions: {
-      optional: true,
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertNodeType)("ImportAttribute"))
-    },
-    specifiers: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
-    },
-    source: {
-      validate: (0, _utils.assertNodeType)("StringLiteral")
-    },
-    importKind: {
-      validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("ImportDefaultSpecifier", {
-  visitor: ["local"],
-  aliases: ["ModuleSpecifier"],
-  fields: {
-    local: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    }
-  }
-});
-(0, _utils.default)("ImportNamespaceSpecifier", {
-  visitor: ["local"],
-  aliases: ["ModuleSpecifier"],
-  fields: {
-    local: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    }
-  }
-});
-(0, _utils.default)("ImportSpecifier", {
-  visitor: ["local", "imported"],
-  aliases: ["ModuleSpecifier"],
-  fields: {
-    local: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    },
-    imported: {
-      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
-    },
-    importKind: {
-      validate: (0, _utils.assertOneOf)("type", "typeof"),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("MetaProperty", {
-  visitor: ["meta", "property"],
-  aliases: ["Expression"],
-  fields: {
-    meta: {
-      validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-        let property;
-
-        switch (val.name) {
-          case "function":
-            property = "sent";
-            break;
-
-          case "new":
-            property = "target";
-            break;
-
-          case "import":
-            property = "meta";
-            break;
-        }
-
-        if (!(0, _is.default)("Identifier", node.property, {
-          name: property
-        })) {
-          throw new TypeError("Unrecognised MetaProperty");
-        }
-      }, {
-        oneOfNodeTypes: ["Identifier"]
-      }))
-    },
-    property: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    }
-  }
-});
-const classMethodOrPropertyCommon = {
-  abstract: {
-    validate: (0, _utils.assertValueType)("boolean"),
-    optional: true
-  },
-  accessibility: {
-    validate: (0, _utils.assertOneOf)("public", "private", "protected"),
-    optional: true
-  },
-  static: {
-    default: false
-  },
-  computed: {
-    default: false
-  },
-  optional: {
-    validate: (0, _utils.assertValueType)("boolean"),
-    optional: true
-  },
-  key: {
-    validate: (0, _utils.chain)(function () {
-      const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
-      const computed = (0, _utils.assertNodeType)("Expression");
-      return function (node, key, val) {
-        const validator = node.computed ? computed : normal;
-        validator(node, key, val);
-      };
-    }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
-  }
-};
-exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
-const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, classMethodOrPropertyCommon, {
-  kind: {
-    validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
-    default: "method"
-  },
-  access: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
-    optional: true
-  },
-  decorators: {
-    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-    optional: true
-  }
-});
-exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
-(0, _utils.default)("ClassMethod", {
-  aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
-  builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
-  visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
-  fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  })
-});
-(0, _utils.default)("ObjectPattern", {
-  visitor: ["properties", "typeAnnotation", "decorators"],
-  builder: ["properties"],
-  aliases: ["Pattern", "PatternLike", "LVal"],
-  fields: Object.assign({}, patternLikeCommon, {
-    properties: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
-    }
-  })
-});
-(0, _utils.default)("SpreadElement", {
-  visitor: ["argument"],
-  aliases: ["UnaryLike"],
-  deprecatedAlias: "SpreadProperty",
-  fields: {
-    argument: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("Super", {
-  aliases: ["Expression"]
-});
-(0, _utils.default)("TaggedTemplateExpression", {
-  visitor: ["tag", "quasi"],
-  aliases: ["Expression"],
-  fields: {
-    tag: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    quasi: {
-      validate: (0, _utils.assertNodeType)("TemplateLiteral")
-    },
-    typeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("TemplateElement", {
-  builder: ["value", "tail"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertShape)({
-        raw: {
-          validate: (0, _utils.assertValueType)("string")
-        },
-        cooked: {
-          validate: (0, _utils.assertValueType)("string"),
-          optional: true
-        }
-      })
-    },
-    tail: {
-      default: false
-    }
-  }
-});
-(0, _utils.default)("TemplateLiteral", {
-  visitor: ["quasis", "expressions"],
-  aliases: ["Expression", "Literal"],
-  fields: {
-    quasis: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
-    },
-    expressions: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) {
-        if (node.quasis.length !== val.length + 1) {
-          throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);
-        }
-      })
-    }
-  }
-});
-(0, _utils.default)("YieldExpression", {
-  builder: ["argument", "delegate"],
-  visitor: ["argument"],
-  aliases: ["Expression", "Terminatorless"],
-  fields: {
-    delegate: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
-        if (!process.env.BABEL_TYPES_8_BREAKING) return;
-
-        if (val && !node.argument) {
-          throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
-        }
-      }, {
-        type: "boolean"
-      })),
-      default: false
-    },
-    argument: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("AwaitExpression", {
-  builder: ["argument"],
-  visitor: ["argument"],
-  aliases: ["Expression", "Terminatorless"],
-  fields: {
-    argument: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("Import", {
-  aliases: ["Expression"]
-});
-(0, _utils.default)("BigIntLiteral", {
-  builder: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  },
-  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-});
-(0, _utils.default)("ExportNamespaceSpecifier", {
-  visitor: ["exported"],
-  aliases: ["ModuleSpecifier"],
-  fields: {
-    exported: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    }
-  }
-});
-(0, _utils.default)("OptionalMemberExpression", {
-  builder: ["object", "property", "computed", "optional"],
-  visitor: ["object", "property"],
-  aliases: ["Expression"],
-  fields: {
-    object: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    property: {
-      validate: function () {
-        const normal = (0, _utils.assertNodeType)("Identifier");
-        const computed = (0, _utils.assertNodeType)("Expression");
-
-        const validator = function (node, key, val) {
-          const validator = node.computed ? computed : normal;
-          validator(node, key, val);
-        };
-
-        validator.oneOfNodeTypes = ["Expression", "Identifier"];
-        return validator;
-      }()
-    },
-    computed: {
-      default: false
-    },
-    optional: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
-    }
-  }
-});
-(0, _utils.default)("OptionalCallExpression", {
-  visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
-  builder: ["callee", "arguments", "optional"],
-  aliases: ["Expression"],
-  fields: {
-    callee: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    arguments: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
-    },
-    optional: {
-      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
-    },
-    typeArguments: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
-      optional: true
-    },
-    typeParameters: {
-      validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
-      optional: true
-    }
-  }
-});

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

@@ -1,204 +0,0 @@
-"use strict";
-
-var _utils = _interopRequireWildcard(require("./utils"));
-
-var _core = require("./core");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-(0, _utils.default)("ArgumentPlaceholder", {});
-(0, _utils.default)("BindExpression", {
-  visitor: ["object", "callee"],
-  aliases: ["Expression"],
-  fields: !process.env.BABEL_TYPES_8_BREAKING ? {
-    object: {
-      validate: Object.assign(() => {}, {
-        oneOfNodeTypes: ["Expression"]
-      })
-    },
-    callee: {
-      validate: Object.assign(() => {}, {
-        oneOfNodeTypes: ["Expression"]
-      })
-    }
-  } : {
-    object: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    },
-    callee: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("ClassProperty", {
-  visitor: ["key", "value", "typeAnnotation", "decorators"],
-  builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
-  aliases: ["Property"],
-  fields: Object.assign({}, _core.classMethodOrPropertyCommon, {
-    value: {
-      validate: (0, _utils.assertNodeType)("Expression"),
-      optional: true
-    },
-    definite: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    },
-    typeAnnotation: {
-      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-      optional: true
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    },
-    readonly: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    },
-    declare: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    }
-  })
-});
-(0, _utils.default)("PipelineTopicExpression", {
-  builder: ["expression"],
-  visitor: ["expression"],
-  fields: {
-    expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("PipelineBareFunction", {
-  builder: ["callee"],
-  visitor: ["callee"],
-  fields: {
-    callee: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("PipelinePrimaryTopicReference", {
-  aliases: ["Expression"]
-});
-(0, _utils.default)("ClassPrivateProperty", {
-  visitor: ["key", "value", "decorators"],
-  builder: ["key", "value", "decorators", "static"],
-  aliases: ["Property", "Private"],
-  fields: {
-    key: {
-      validate: (0, _utils.assertNodeType)("PrivateName")
-    },
-    value: {
-      validate: (0, _utils.assertNodeType)("Expression"),
-      optional: true
-    },
-    typeAnnotation: {
-      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
-      optional: true
-    },
-    decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("ClassPrivateMethod", {
-  builder: ["kind", "key", "params", "body", "static"],
-  visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
-  aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
-  fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, _core.functionTypeAnnotationCommon, {
-    key: {
-      validate: (0, _utils.assertNodeType)("PrivateName")
-    },
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  })
-});
-(0, _utils.default)("ImportAttribute", {
-  visitor: ["key", "value"],
-  fields: {
-    key: {
-      validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
-    },
-    value: {
-      validate: (0, _utils.assertNodeType)("StringLiteral")
-    }
-  }
-});
-(0, _utils.default)("Decorator", {
-  visitor: ["expression"],
-  fields: {
-    expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("DoExpression", {
-  visitor: ["body"],
-  aliases: ["Expression"],
-  fields: {
-    body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
-    }
-  }
-});
-(0, _utils.default)("ExportDefaultSpecifier", {
-  visitor: ["exported"],
-  aliases: ["ModuleSpecifier"],
-  fields: {
-    exported: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    }
-  }
-});
-(0, _utils.default)("PrivateName", {
-  visitor: ["id"],
-  aliases: ["Private"],
-  fields: {
-    id: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    }
-  }
-});
-(0, _utils.default)("RecordExpression", {
-  visitor: ["properties"],
-  aliases: ["Expression"],
-  fields: {
-    properties: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
-    }
-  }
-});
-(0, _utils.default)("TupleExpression", {
-  fields: {
-    elements: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
-      default: []
-    }
-  },
-  visitor: ["elements"],
-  aliases: ["Expression"]
-});
-(0, _utils.default)("DecimalLiteral", {
-  builder: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  },
-  aliases: ["Expression", "Pureish", "Literal", "Immutable"]
-});
-(0, _utils.default)("StaticBlock", {
-  visitor: ["body"],
-  fields: {
-    body: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
-    }
-  },
-  aliases: ["Scopable", "BlockParent"]
-});

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

@@ -1,462 +0,0 @@
-"use strict";
-
-var _utils = _interopRequireWildcard(require("./utils"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const defineInterfaceishType = (name, typeParameterType = "TypeParameterDeclaration") => {
-  (0, _utils.default)(name, {
-    builder: ["id", "typeParameters", "extends", "body"],
-    visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
-    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-    fields: {
-      id: (0, _utils.validateType)("Identifier"),
-      typeParameters: (0, _utils.validateOptionalType)(typeParameterType),
-      extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
-      mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
-      implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
-      body: (0, _utils.validateType)("ObjectTypeAnnotation")
-    }
-  });
-};
-
-(0, _utils.default)("AnyTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("ArrayTypeAnnotation", {
-  visitor: ["elementType"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    elementType: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("BooleanTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("BooleanLiteralTypeAnnotation", {
-  builder: ["value"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
-  }
-});
-(0, _utils.default)("NullLiteralTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("ClassImplements", {
-  visitor: ["id", "typeParameters"],
-  aliases: ["Flow"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
-  }
-});
-defineInterfaceishType("DeclareClass");
-(0, _utils.default)("DeclareFunction", {
-  visitor: ["id"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
-  }
-});
-defineInterfaceishType("DeclareInterface");
-(0, _utils.default)("DeclareModule", {
-  builder: ["id", "body", "kind"],
-  visitor: ["id", "body"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
-    body: (0, _utils.validateType)("BlockStatement"),
-    kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
-  }
-});
-(0, _utils.default)("DeclareModuleExports", {
-  visitor: ["typeAnnotation"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
-  }
-});
-(0, _utils.default)("DeclareTypeAlias", {
-  visitor: ["id", "typeParameters", "right"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
-    right: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("DeclareOpaqueType", {
-  visitor: ["id", "typeParameters", "supertype"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
-    supertype: (0, _utils.validateOptionalType)("FlowType")
-  }
-});
-(0, _utils.default)("DeclareVariable", {
-  visitor: ["id"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier")
-  }
-});
-(0, _utils.default)("DeclareExportDeclaration", {
-  visitor: ["declaration", "specifiers", "source"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    declaration: (0, _utils.validateOptionalType)("Flow"),
-    specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
-    source: (0, _utils.validateOptionalType)("StringLiteral"),
-    default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
-  }
-});
-(0, _utils.default)("DeclareExportAllDeclaration", {
-  visitor: ["source"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    source: (0, _utils.validateType)("StringLiteral"),
-    exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
-  }
-});
-(0, _utils.default)("DeclaredPredicate", {
-  visitor: ["value"],
-  aliases: ["Flow", "FlowPredicate"],
-  fields: {
-    value: (0, _utils.validateType)("Flow")
-  }
-});
-(0, _utils.default)("ExistsTypeAnnotation", {
-  aliases: ["Flow", "FlowType"]
-});
-(0, _utils.default)("FunctionTypeAnnotation", {
-  visitor: ["typeParameters", "params", "rest", "returnType"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
-    params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
-    rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
-    returnType: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("FunctionTypeParam", {
-  visitor: ["name", "typeAnnotation"],
-  aliases: ["Flow"],
-  fields: {
-    name: (0, _utils.validateOptionalType)("Identifier"),
-    typeAnnotation: (0, _utils.validateType)("FlowType"),
-    optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
-  }
-});
-(0, _utils.default)("GenericTypeAnnotation", {
-  visitor: ["id", "typeParameters"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
-  }
-});
-(0, _utils.default)("InferredPredicate", {
-  aliases: ["Flow", "FlowPredicate"]
-});
-(0, _utils.default)("InterfaceExtends", {
-  visitor: ["id", "typeParameters"],
-  aliases: ["Flow"],
-  fields: {
-    id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
-  }
-});
-defineInterfaceishType("InterfaceDeclaration");
-(0, _utils.default)("InterfaceTypeAnnotation", {
-  visitor: ["extends", "body"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
-    body: (0, _utils.validateType)("ObjectTypeAnnotation")
-  }
-});
-(0, _utils.default)("IntersectionTypeAnnotation", {
-  visitor: ["types"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
-  }
-});
-(0, _utils.default)("MixedTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("EmptyTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("NullableTypeAnnotation", {
-  visitor: ["typeAnnotation"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    typeAnnotation: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("NumberLiteralTypeAnnotation", {
-  builder: ["value"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
-  }
-});
-(0, _utils.default)("NumberTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("ObjectTypeAnnotation", {
-  visitor: ["properties", "indexers", "callProperties", "internalSlots"],
-  aliases: ["Flow", "FlowType"],
-  builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
-  fields: {
-    properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
-    indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
-    callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
-    internalSlots: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeInternalSlot")),
-    exact: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      default: false
-    },
-    inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
-  }
-});
-(0, _utils.default)("ObjectTypeInternalSlot", {
-  visitor: ["id", "value", "optional", "static", "method"],
-  aliases: ["Flow", "UserWhitespacable"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    value: (0, _utils.validateType)("FlowType"),
-    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
-  }
-});
-(0, _utils.default)("ObjectTypeCallProperty", {
-  visitor: ["value"],
-  aliases: ["Flow", "UserWhitespacable"],
-  fields: {
-    value: (0, _utils.validateType)("FlowType"),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
-  }
-});
-(0, _utils.default)("ObjectTypeIndexer", {
-  visitor: ["id", "key", "value", "variance"],
-  aliases: ["Flow", "UserWhitespacable"],
-  fields: {
-    id: (0, _utils.validateOptionalType)("Identifier"),
-    key: (0, _utils.validateType)("FlowType"),
-    value: (0, _utils.validateType)("FlowType"),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    variance: (0, _utils.validateOptionalType)("Variance")
-  }
-});
-(0, _utils.default)("ObjectTypeProperty", {
-  visitor: ["key", "value", "variance"],
-  aliases: ["Flow", "UserWhitespacable"],
-  fields: {
-    key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
-    value: (0, _utils.validateType)("FlowType"),
-    kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
-    static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    variance: (0, _utils.validateOptionalType)("Variance"),
-    method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
-  }
-});
-(0, _utils.default)("ObjectTypeSpreadProperty", {
-  visitor: ["argument"],
-  aliases: ["Flow", "UserWhitespacable"],
-  fields: {
-    argument: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("OpaqueType", {
-  visitor: ["id", "typeParameters", "supertype", "impltype"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
-    supertype: (0, _utils.validateOptionalType)("FlowType"),
-    impltype: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("QualifiedTypeIdentifier", {
-  visitor: ["id", "qualification"],
-  aliases: ["Flow"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
-  }
-});
-(0, _utils.default)("StringLiteralTypeAnnotation", {
-  builder: ["value"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
-  }
-});
-(0, _utils.default)("StringTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("SymbolTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("ThisTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("TupleTypeAnnotation", {
-  visitor: ["types"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
-  }
-});
-(0, _utils.default)("TypeofTypeAnnotation", {
-  visitor: ["argument"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    argument: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("TypeAlias", {
-  visitor: ["id", "typeParameters", "right"],
-  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
-    right: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("TypeAnnotation", {
-  aliases: ["Flow"],
-  visitor: ["typeAnnotation"],
-  fields: {
-    typeAnnotation: (0, _utils.validateType)("FlowType")
-  }
-});
-(0, _utils.default)("TypeCastExpression", {
-  visitor: ["expression", "typeAnnotation"],
-  aliases: ["Flow", "ExpressionWrapper", "Expression"],
-  fields: {
-    expression: (0, _utils.validateType)("Expression"),
-    typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
-  }
-});
-(0, _utils.default)("TypeParameter", {
-  aliases: ["Flow"],
-  visitor: ["bound", "default", "variance"],
-  fields: {
-    name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
-    bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
-    default: (0, _utils.validateOptionalType)("FlowType"),
-    variance: (0, _utils.validateOptionalType)("Variance")
-  }
-});
-(0, _utils.default)("TypeParameterDeclaration", {
-  aliases: ["Flow"],
-  visitor: ["params"],
-  fields: {
-    params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
-  }
-});
-(0, _utils.default)("TypeParameterInstantiation", {
-  aliases: ["Flow"],
-  visitor: ["params"],
-  fields: {
-    params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
-  }
-});
-(0, _utils.default)("UnionTypeAnnotation", {
-  visitor: ["types"],
-  aliases: ["Flow", "FlowType"],
-  fields: {
-    types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
-  }
-});
-(0, _utils.default)("Variance", {
-  aliases: ["Flow"],
-  builder: ["kind"],
-  fields: {
-    kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
-  }
-});
-(0, _utils.default)("VoidTypeAnnotation", {
-  aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
-});
-(0, _utils.default)("EnumDeclaration", {
-  aliases: ["Statement", "Declaration"],
-  visitor: ["id", "body"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
-  }
-});
-(0, _utils.default)("EnumBooleanBody", {
-  aliases: ["EnumBody"],
-  visitor: ["members"],
-  fields: {
-    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    members: (0, _utils.validateArrayOfType)("EnumBooleanMember")
-  }
-});
-(0, _utils.default)("EnumNumberBody", {
-  aliases: ["EnumBody"],
-  visitor: ["members"],
-  fields: {
-    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    members: (0, _utils.validateArrayOfType)("EnumNumberMember")
-  }
-});
-(0, _utils.default)("EnumStringBody", {
-  aliases: ["EnumBody"],
-  visitor: ["members"],
-  fields: {
-    explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
-    members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"])
-  }
-});
-(0, _utils.default)("EnumSymbolBody", {
-  aliases: ["EnumBody"],
-  visitor: ["members"],
-  fields: {
-    members: (0, _utils.validateArrayOfType)("EnumDefaultedMember")
-  }
-});
-(0, _utils.default)("EnumBooleanMember", {
-  aliases: ["EnumMember"],
-  visitor: ["id"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    init: (0, _utils.validateType)("BooleanLiteral")
-  }
-});
-(0, _utils.default)("EnumNumberMember", {
-  aliases: ["EnumMember"],
-  visitor: ["id", "init"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    init: (0, _utils.validateType)("NumericLiteral")
-  }
-});
-(0, _utils.default)("EnumStringMember", {
-  aliases: ["EnumMember"],
-  visitor: ["id", "init"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier"),
-    init: (0, _utils.validateType)("StringLiteral")
-  }
-});
-(0, _utils.default)("EnumDefaultedMember", {
-  aliases: ["EnumMember"],
-  visitor: ["id"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier")
-  }
-});

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

@@ -1,97 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "VISITOR_KEYS", {
-  enumerable: true,
-  get: function () {
-    return _utils.VISITOR_KEYS;
-  }
-});
-Object.defineProperty(exports, "ALIAS_KEYS", {
-  enumerable: true,
-  get: function () {
-    return _utils.ALIAS_KEYS;
-  }
-});
-Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
-  enumerable: true,
-  get: function () {
-    return _utils.FLIPPED_ALIAS_KEYS;
-  }
-});
-Object.defineProperty(exports, "NODE_FIELDS", {
-  enumerable: true,
-  get: function () {
-    return _utils.NODE_FIELDS;
-  }
-});
-Object.defineProperty(exports, "BUILDER_KEYS", {
-  enumerable: true,
-  get: function () {
-    return _utils.BUILDER_KEYS;
-  }
-});
-Object.defineProperty(exports, "DEPRECATED_KEYS", {
-  enumerable: true,
-  get: function () {
-    return _utils.DEPRECATED_KEYS;
-  }
-});
-Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
-  enumerable: true,
-  get: function () {
-    return _utils.NODE_PARENT_VALIDATIONS;
-  }
-});
-Object.defineProperty(exports, "PLACEHOLDERS", {
-  enumerable: true,
-  get: function () {
-    return _placeholders.PLACEHOLDERS;
-  }
-});
-Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
-  enumerable: true,
-  get: function () {
-    return _placeholders.PLACEHOLDERS_ALIAS;
-  }
-});
-Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", {
-  enumerable: true,
-  get: function () {
-    return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;
-  }
-});
-exports.TYPES = void 0;
-
-var _toFastProperties = _interopRequireDefault(require("to-fast-properties"));
-
-require("./core");
-
-require("./flow");
-
-require("./jsx");
-
-require("./misc");
-
-require("./experimental");
-
-require("./typescript");
-
-var _utils = require("./utils");
-
-var _placeholders = require("./placeholders");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-(0, _toFastProperties.default)(_utils.VISITOR_KEYS);
-(0, _toFastProperties.default)(_utils.ALIAS_KEYS);
-(0, _toFastProperties.default)(_utils.FLIPPED_ALIAS_KEYS);
-(0, _toFastProperties.default)(_utils.NODE_FIELDS);
-(0, _toFastProperties.default)(_utils.BUILDER_KEYS);
-(0, _toFastProperties.default)(_utils.DEPRECATED_KEYS);
-(0, _toFastProperties.default)(_placeholders.PLACEHOLDERS_ALIAS);
-(0, _toFastProperties.default)(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS);
-const TYPES = Object.keys(_utils.VISITOR_KEYS).concat(Object.keys(_utils.FLIPPED_ALIAS_KEYS)).concat(Object.keys(_utils.DEPRECATED_KEYS));
-exports.TYPES = TYPES;

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

@@ -1,165 +0,0 @@
-"use strict";
-
-var _utils = _interopRequireWildcard(require("./utils"));
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-(0, _utils.default)("JSXAttribute", {
-  visitor: ["name", "value"],
-  aliases: ["JSX", "Immutable"],
-  fields: {
-    name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
-    },
-    value: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
-    }
-  }
-});
-(0, _utils.default)("JSXClosingElement", {
-  visitor: ["name"],
-  aliases: ["JSX", "Immutable"],
-  fields: {
-    name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
-    }
-  }
-});
-(0, _utils.default)("JSXElement", {
-  builder: ["openingElement", "closingElement", "children", "selfClosing"],
-  visitor: ["openingElement", "children", "closingElement"],
-  aliases: ["JSX", "Immutable", "Expression"],
-  fields: {
-    openingElement: {
-      validate: (0, _utils.assertNodeType)("JSXOpeningElement")
-    },
-    closingElement: {
-      optional: true,
-      validate: (0, _utils.assertNodeType)("JSXClosingElement")
-    },
-    children: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
-    },
-    selfClosing: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("JSXEmptyExpression", {
-  aliases: ["JSX"]
-});
-(0, _utils.default)("JSXExpressionContainer", {
-  visitor: ["expression"],
-  aliases: ["JSX", "Immutable"],
-  fields: {
-    expression: {
-      validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
-    }
-  }
-});
-(0, _utils.default)("JSXSpreadChild", {
-  visitor: ["expression"],
-  aliases: ["JSX", "Immutable"],
-  fields: {
-    expression: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("JSXIdentifier", {
-  builder: ["name"],
-  aliases: ["JSX"],
-  fields: {
-    name: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  }
-});
-(0, _utils.default)("JSXMemberExpression", {
-  visitor: ["object", "property"],
-  aliases: ["JSX"],
-  fields: {
-    object: {
-      validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
-    },
-    property: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier")
-    }
-  }
-});
-(0, _utils.default)("JSXNamespacedName", {
-  visitor: ["namespace", "name"],
-  aliases: ["JSX"],
-  fields: {
-    namespace: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier")
-    },
-    name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier")
-    }
-  }
-});
-(0, _utils.default)("JSXOpeningElement", {
-  builder: ["name", "attributes", "selfClosing"],
-  visitor: ["name", "attributes"],
-  aliases: ["JSX", "Immutable"],
-  fields: {
-    name: {
-      validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
-    },
-    selfClosing: {
-      default: false
-    },
-    attributes: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
-    },
-    typeParameters: {
-      validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
-      optional: true
-    }
-  }
-});
-(0, _utils.default)("JSXSpreadAttribute", {
-  visitor: ["argument"],
-  aliases: ["JSX"],
-  fields: {
-    argument: {
-      validate: (0, _utils.assertNodeType)("Expression")
-    }
-  }
-});
-(0, _utils.default)("JSXText", {
-  aliases: ["JSX", "Immutable"],
-  builder: ["value"],
-  fields: {
-    value: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  }
-});
-(0, _utils.default)("JSXFragment", {
-  builder: ["openingFragment", "closingFragment", "children"],
-  visitor: ["openingFragment", "children", "closingFragment"],
-  aliases: ["JSX", "Immutable", "Expression"],
-  fields: {
-    openingFragment: {
-      validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
-    },
-    closingFragment: {
-      validate: (0, _utils.assertNodeType)("JSXClosingFragment")
-    },
-    children: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
-    }
-  }
-});
-(0, _utils.default)("JSXOpeningFragment", {
-  aliases: ["JSX", "Immutable"]
-});
-(0, _utils.default)("JSXClosingFragment", {
-  aliases: ["JSX", "Immutable"]
-});

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

@@ -1,33 +0,0 @@
-"use strict";
-
-var _utils = _interopRequireWildcard(require("./utils"));
-
-var _placeholders = require("./placeholders");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-(0, _utils.default)("Noop", {
-  visitor: []
-});
-(0, _utils.default)("Placeholder", {
-  visitor: [],
-  builder: ["expectedNode", "name"],
-  fields: {
-    name: {
-      validate: (0, _utils.assertNodeType)("Identifier")
-    },
-    expectedNode: {
-      validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
-    }
-  }
-});
-(0, _utils.default)("V8IntrinsicIdentifier", {
-  builder: ["name"],
-  fields: {
-    name: {
-      validate: (0, _utils.assertValueType)("string")
-    }
-  }
-});

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

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

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

@@ -1,428 +0,0 @@
-"use strict";
-
-var _utils = _interopRequireWildcard(require("./utils"));
-
-var _core = require("./core");
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const bool = (0, _utils.assertValueType)("boolean");
-const tSFunctionTypeAnnotationCommon = {
-  returnType: {
-    validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
-    optional: true
-  },
-  typeParameters: {
-    validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
-    optional: true
-  }
-};
-(0, _utils.default)("TSParameterProperty", {
-  aliases: ["LVal"],
-  visitor: ["parameter"],
-  fields: {
-    accessibility: {
-      validate: (0, _utils.assertOneOf)("public", "private", "protected"),
-      optional: true
-    },
-    readonly: {
-      validate: (0, _utils.assertValueType)("boolean"),
-      optional: true
-    },
-    parameter: {
-      validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
-    }
-  }
-});
-(0, _utils.default)("TSDeclareFunction", {
-  aliases: ["Statement", "Declaration"],
-  visitor: ["id", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
-});
-(0, _utils.default)("TSDeclareMethod", {
-  visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
-  fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
-});
-(0, _utils.default)("TSQualifiedName", {
-  aliases: ["TSEntityName"],
-  visitor: ["left", "right"],
-  fields: {
-    left: (0, _utils.validateType)("TSEntityName"),
-    right: (0, _utils.validateType)("Identifier")
-  }
-});
-const signatureDeclarationCommon = {
-  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
-  parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
-  typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
-};
-const callConstructSignatureDeclaration = {
-  aliases: ["TSTypeElement"],
-  visitor: ["typeParameters", "parameters", "typeAnnotation"],
-  fields: signatureDeclarationCommon
-};
-(0, _utils.default)("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
-(0, _utils.default)("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
-const namedTypeElementCommon = {
-  key: (0, _utils.validateType)("Expression"),
-  computed: (0, _utils.validate)(bool),
-  optional: (0, _utils.validateOptional)(bool)
-};
-(0, _utils.default)("TSPropertySignature", {
-  aliases: ["TSTypeElement"],
-  visitor: ["key", "typeAnnotation", "initializer"],
-  fields: Object.assign({}, namedTypeElementCommon, {
-    readonly: (0, _utils.validateOptional)(bool),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
-    initializer: (0, _utils.validateOptionalType)("Expression")
-  })
-});
-(0, _utils.default)("TSMethodSignature", {
-  aliases: ["TSTypeElement"],
-  visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
-  fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon)
-});
-(0, _utils.default)("TSIndexSignature", {
-  aliases: ["TSTypeElement"],
-  visitor: ["parameters", "typeAnnotation"],
-  fields: {
-    readonly: (0, _utils.validateOptional)(bool),
-    parameters: (0, _utils.validateArrayOfType)("Identifier"),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
-  }
-});
-const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
-
-for (const type of tsKeywordTypes) {
-  (0, _utils.default)(type, {
-    aliases: ["TSType", "TSBaseType"],
-    visitor: [],
-    fields: {}
-  });
-}
-
-(0, _utils.default)("TSThisType", {
-  aliases: ["TSType", "TSBaseType"],
-  visitor: [],
-  fields: {}
-});
-const fnOrCtr = {
-  aliases: ["TSType"],
-  visitor: ["typeParameters", "parameters", "typeAnnotation"],
-  fields: signatureDeclarationCommon
-};
-(0, _utils.default)("TSFunctionType", fnOrCtr);
-(0, _utils.default)("TSConstructorType", fnOrCtr);
-(0, _utils.default)("TSTypeReference", {
-  aliases: ["TSType"],
-  visitor: ["typeName", "typeParameters"],
-  fields: {
-    typeName: (0, _utils.validateType)("TSEntityName"),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
-  }
-});
-(0, _utils.default)("TSTypePredicate", {
-  aliases: ["TSType"],
-  visitor: ["parameterName", "typeAnnotation"],
-  builder: ["parameterName", "typeAnnotation", "asserts"],
-  fields: {
-    parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
-    asserts: (0, _utils.validateOptional)(bool)
-  }
-});
-(0, _utils.default)("TSTypeQuery", {
-  aliases: ["TSType"],
-  visitor: ["exprName"],
-  fields: {
-    exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"])
-  }
-});
-(0, _utils.default)("TSTypeLiteral", {
-  aliases: ["TSType"],
-  visitor: ["members"],
-  fields: {
-    members: (0, _utils.validateArrayOfType)("TSTypeElement")
-  }
-});
-(0, _utils.default)("TSArrayType", {
-  aliases: ["TSType"],
-  visitor: ["elementType"],
-  fields: {
-    elementType: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSTupleType", {
-  aliases: ["TSType"],
-  visitor: ["elementTypes"],
-  fields: {
-    elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
-  }
-});
-(0, _utils.default)("TSOptionalType", {
-  aliases: ["TSType"],
-  visitor: ["typeAnnotation"],
-  fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSRestType", {
-  aliases: ["TSType"],
-  visitor: ["typeAnnotation"],
-  fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSNamedTupleMember", {
-  visitor: ["label", "elementType"],
-  builder: ["label", "elementType", "optional"],
-  fields: {
-    label: (0, _utils.validateType)("Identifier"),
-    optional: {
-      validate: bool,
-      default: false
-    },
-    elementType: (0, _utils.validateType)("TSType")
-  }
-});
-const unionOrIntersection = {
-  aliases: ["TSType"],
-  visitor: ["types"],
-  fields: {
-    types: (0, _utils.validateArrayOfType)("TSType")
-  }
-};
-(0, _utils.default)("TSUnionType", unionOrIntersection);
-(0, _utils.default)("TSIntersectionType", unionOrIntersection);
-(0, _utils.default)("TSConditionalType", {
-  aliases: ["TSType"],
-  visitor: ["checkType", "extendsType", "trueType", "falseType"],
-  fields: {
-    checkType: (0, _utils.validateType)("TSType"),
-    extendsType: (0, _utils.validateType)("TSType"),
-    trueType: (0, _utils.validateType)("TSType"),
-    falseType: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSInferType", {
-  aliases: ["TSType"],
-  visitor: ["typeParameter"],
-  fields: {
-    typeParameter: (0, _utils.validateType)("TSTypeParameter")
-  }
-});
-(0, _utils.default)("TSParenthesizedType", {
-  aliases: ["TSType"],
-  visitor: ["typeAnnotation"],
-  fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSTypeOperator", {
-  aliases: ["TSType"],
-  visitor: ["typeAnnotation"],
-  fields: {
-    operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
-    typeAnnotation: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSIndexedAccessType", {
-  aliases: ["TSType"],
-  visitor: ["objectType", "indexType"],
-  fields: {
-    objectType: (0, _utils.validateType)("TSType"),
-    indexType: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSMappedType", {
-  aliases: ["TSType"],
-  visitor: ["typeParameter", "typeAnnotation", "nameType"],
-  fields: {
-    readonly: (0, _utils.validateOptional)(bool),
-    typeParameter: (0, _utils.validateType)("TSTypeParameter"),
-    optional: (0, _utils.validateOptional)(bool),
-    typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
-    nameType: (0, _utils.validateOptionalType)("TSType")
-  }
-});
-(0, _utils.default)("TSLiteralType", {
-  aliases: ["TSType", "TSBaseType"],
-  visitor: ["literal"],
-  fields: {
-    literal: (0, _utils.validateType)(["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral"])
-  }
-});
-(0, _utils.default)("TSExpressionWithTypeArguments", {
-  aliases: ["TSType"],
-  visitor: ["expression", "typeParameters"],
-  fields: {
-    expression: (0, _utils.validateType)("TSEntityName"),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
-  }
-});
-(0, _utils.default)("TSInterfaceDeclaration", {
-  aliases: ["Statement", "Declaration"],
-  visitor: ["id", "typeParameters", "extends", "body"],
-  fields: {
-    declare: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)("Identifier"),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
-    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
-    body: (0, _utils.validateType)("TSInterfaceBody")
-  }
-});
-(0, _utils.default)("TSInterfaceBody", {
-  visitor: ["body"],
-  fields: {
-    body: (0, _utils.validateArrayOfType)("TSTypeElement")
-  }
-});
-(0, _utils.default)("TSTypeAliasDeclaration", {
-  aliases: ["Statement", "Declaration"],
-  visitor: ["id", "typeParameters", "typeAnnotation"],
-  fields: {
-    declare: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)("Identifier"),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
-    typeAnnotation: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSAsExpression", {
-  aliases: ["Expression"],
-  visitor: ["expression", "typeAnnotation"],
-  fields: {
-    expression: (0, _utils.validateType)("Expression"),
-    typeAnnotation: (0, _utils.validateType)("TSType")
-  }
-});
-(0, _utils.default)("TSTypeAssertion", {
-  aliases: ["Expression"],
-  visitor: ["typeAnnotation", "expression"],
-  fields: {
-    typeAnnotation: (0, _utils.validateType)("TSType"),
-    expression: (0, _utils.validateType)("Expression")
-  }
-});
-(0, _utils.default)("TSEnumDeclaration", {
-  aliases: ["Statement", "Declaration"],
-  visitor: ["id", "members"],
-  fields: {
-    declare: (0, _utils.validateOptional)(bool),
-    const: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)("Identifier"),
-    members: (0, _utils.validateArrayOfType)("TSEnumMember"),
-    initializer: (0, _utils.validateOptionalType)("Expression")
-  }
-});
-(0, _utils.default)("TSEnumMember", {
-  visitor: ["id", "initializer"],
-  fields: {
-    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
-    initializer: (0, _utils.validateOptionalType)("Expression")
-  }
-});
-(0, _utils.default)("TSModuleDeclaration", {
-  aliases: ["Statement", "Declaration"],
-  visitor: ["id", "body"],
-  fields: {
-    declare: (0, _utils.validateOptional)(bool),
-    global: (0, _utils.validateOptional)(bool),
-    id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
-    body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
-  }
-});
-(0, _utils.default)("TSModuleBlock", {
-  aliases: ["Scopable", "Block", "BlockParent"],
-  visitor: ["body"],
-  fields: {
-    body: (0, _utils.validateArrayOfType)("Statement")
-  }
-});
-(0, _utils.default)("TSImportType", {
-  aliases: ["TSType"],
-  visitor: ["argument", "qualifier", "typeParameters"],
-  fields: {
-    argument: (0, _utils.validateType)("StringLiteral"),
-    qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
-    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
-  }
-});
-(0, _utils.default)("TSImportEqualsDeclaration", {
-  aliases: ["Statement"],
-  visitor: ["id", "moduleReference"],
-  fields: {
-    isExport: (0, _utils.validate)(bool),
-    id: (0, _utils.validateType)("Identifier"),
-    moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"])
-  }
-});
-(0, _utils.default)("TSExternalModuleReference", {
-  visitor: ["expression"],
-  fields: {
-    expression: (0, _utils.validateType)("StringLiteral")
-  }
-});
-(0, _utils.default)("TSNonNullExpression", {
-  aliases: ["Expression"],
-  visitor: ["expression"],
-  fields: {
-    expression: (0, _utils.validateType)("Expression")
-  }
-});
-(0, _utils.default)("TSExportAssignment", {
-  aliases: ["Statement"],
-  visitor: ["expression"],
-  fields: {
-    expression: (0, _utils.validateType)("Expression")
-  }
-});
-(0, _utils.default)("TSNamespaceExportDeclaration", {
-  aliases: ["Statement"],
-  visitor: ["id"],
-  fields: {
-    id: (0, _utils.validateType)("Identifier")
-  }
-});
-(0, _utils.default)("TSTypeAnnotation", {
-  visitor: ["typeAnnotation"],
-  fields: {
-    typeAnnotation: {
-      validate: (0, _utils.assertNodeType)("TSType")
-    }
-  }
-});
-(0, _utils.default)("TSTypeParameterInstantiation", {
-  visitor: ["params"],
-  fields: {
-    params: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
-    }
-  }
-});
-(0, _utils.default)("TSTypeParameterDeclaration", {
-  visitor: ["params"],
-  fields: {
-    params: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
-    }
-  }
-});
-(0, _utils.default)("TSTypeParameter", {
-  builder: ["constraint", "default", "name"],
-  visitor: ["constraint", "default"],
-  fields: {
-    name: {
-      validate: (0, _utils.assertValueType)("string")
-    },
-    constraint: {
-      validate: (0, _utils.assertNodeType)("TSType"),
-      optional: true
-    },
-    default: {
-      validate: (0, _utils.assertNodeType)("TSType"),
-      optional: true
-    }
-  }
-});

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

@@ -1,315 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validate = validate;
-exports.typeIs = typeIs;
-exports.validateType = validateType;
-exports.validateOptional = validateOptional;
-exports.validateOptionalType = validateOptionalType;
-exports.arrayOf = arrayOf;
-exports.arrayOfType = arrayOfType;
-exports.validateArrayOfType = validateArrayOfType;
-exports.assertEach = assertEach;
-exports.assertOneOf = assertOneOf;
-exports.assertNodeType = assertNodeType;
-exports.assertNodeOrValueType = assertNodeOrValueType;
-exports.assertValueType = assertValueType;
-exports.assertShape = assertShape;
-exports.assertOptionalChainStart = assertOptionalChainStart;
-exports.chain = chain;
-exports.default = defineType;
-exports.NODE_PARENT_VALIDATIONS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = void 0;
-
-var _is = _interopRequireDefault(require("../validators/is"));
-
-var _validate = require("../validators/validate");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const VISITOR_KEYS = {};
-exports.VISITOR_KEYS = VISITOR_KEYS;
-const ALIAS_KEYS = {};
-exports.ALIAS_KEYS = ALIAS_KEYS;
-const FLIPPED_ALIAS_KEYS = {};
-exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
-const NODE_FIELDS = {};
-exports.NODE_FIELDS = NODE_FIELDS;
-const BUILDER_KEYS = {};
-exports.BUILDER_KEYS = BUILDER_KEYS;
-const DEPRECATED_KEYS = {};
-exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
-const NODE_PARENT_VALIDATIONS = {};
-exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
-
-function getType(val) {
-  if (Array.isArray(val)) {
-    return "array";
-  } else if (val === null) {
-    return "null";
-  } else {
-    return typeof val;
-  }
-}
-
-function validate(validate) {
-  return {
-    validate
-  };
-}
-
-function typeIs(typeName) {
-  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
-}
-
-function validateType(typeName) {
-  return validate(typeIs(typeName));
-}
-
-function validateOptional(validate) {
-  return {
-    validate,
-    optional: true
-  };
-}
-
-function validateOptionalType(typeName) {
-  return {
-    validate: typeIs(typeName),
-    optional: true
-  };
-}
-
-function arrayOf(elementType) {
-  return chain(assertValueType("array"), assertEach(elementType));
-}
-
-function arrayOfType(typeName) {
-  return arrayOf(typeIs(typeName));
-}
-
-function validateArrayOfType(typeName) {
-  return validate(arrayOfType(typeName));
-}
-
-function assertEach(callback) {
-  function validator(node, key, val) {
-    if (!Array.isArray(val)) return;
-
-    for (let i = 0; i < val.length; i++) {
-      const subkey = `${key}[${i}]`;
-      const v = val[i];
-      callback(node, subkey, v);
-      if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v);
-    }
-  }
-
-  validator.each = callback;
-  return validator;
-}
-
-function assertOneOf(...values) {
-  function validate(node, key, val) {
-    if (values.indexOf(val) < 0) {
-      throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
-    }
-  }
-
-  validate.oneOf = values;
-  return validate;
-}
-
-function assertNodeType(...types) {
-  function validate(node, key, val) {
-    for (const type of types) {
-      if ((0, _is.default)(type, val)) {
-        (0, _validate.validateChild)(node, key, val);
-        return;
-      }
-    }
-
-    throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
-  }
-
-  validate.oneOfNodeTypes = types;
-  return validate;
-}
-
-function assertNodeOrValueType(...types) {
-  function validate(node, key, val) {
-    for (const type of types) {
-      if (getType(val) === type || (0, _is.default)(type, val)) {
-        (0, _validate.validateChild)(node, key, val);
-        return;
-      }
-    }
-
-    throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
-  }
-
-  validate.oneOfNodeOrValueTypes = types;
-  return validate;
-}
-
-function assertValueType(type) {
-  function validate(node, key, val) {
-    const valid = getType(val) === type;
-
-    if (!valid) {
-      throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
-    }
-  }
-
-  validate.type = type;
-  return validate;
-}
-
-function assertShape(shape) {
-  function validate(node, key, val) {
-    const errors = [];
-
-    for (const property of Object.keys(shape)) {
-      try {
-        (0, _validate.validateField)(node, property, val[property], shape[property]);
-      } catch (error) {
-        if (error instanceof TypeError) {
-          errors.push(error.message);
-          continue;
-        }
-
-        throw error;
-      }
-    }
-
-    if (errors.length) {
-      throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`);
-    }
-  }
-
-  validate.shapeOf = shape;
-  return validate;
-}
-
-function assertOptionalChainStart() {
-  function validate(node) {
-    var _current;
-
-    let current = node;
-
-    while (node) {
-      const {
-        type
-      } = current;
-
-      if (type === "OptionalCallExpression") {
-        if (current.optional) return;
-        current = current.callee;
-        continue;
-      }
-
-      if (type === "OptionalMemberExpression") {
-        if (current.optional) return;
-        current = current.object;
-        continue;
-      }
-
-      break;
-    }
-
-    throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`);
-  }
-
-  return validate;
-}
-
-function chain(...fns) {
-  const validate = function (...args) {
-    for (const fn of fns) {
-      fn(...args);
-    }
-  };
-
-  validate.chainOf = fns;
-  return validate;
-}
-
-const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"];
-const validFieldKeys = ["default", "optional", "validate"];
-
-function defineType(type, opts = {}) {
-  const inherits = opts.inherits && store[opts.inherits] || {};
-  let fields = opts.fields;
-
-  if (!fields) {
-    fields = {};
-
-    if (inherits.fields) {
-      const keys = Object.getOwnPropertyNames(inherits.fields);
-
-      for (const key of keys) {
-        const field = inherits.fields[key];
-        fields[key] = {
-          default: field.default,
-          optional: field.optional,
-          validate: field.validate
-        };
-      }
-    }
-  }
-
-  const visitor = opts.visitor || inherits.visitor || [];
-  const aliases = opts.aliases || inherits.aliases || [];
-  const builder = opts.builder || inherits.builder || opts.visitor || [];
-
-  for (const k of Object.keys(opts)) {
-    if (validTypeOpts.indexOf(k) === -1) {
-      throw new Error(`Unknown type option "${k}" on ${type}`);
-    }
-  }
-
-  if (opts.deprecatedAlias) {
-    DEPRECATED_KEYS[opts.deprecatedAlias] = type;
-  }
-
-  for (const key of visitor.concat(builder)) {
-    fields[key] = fields[key] || {};
-  }
-
-  for (const key of Object.keys(fields)) {
-    const field = fields[key];
-
-    if (field.default !== undefined && builder.indexOf(key) === -1) {
-      field.optional = true;
-    }
-
-    if (field.default === undefined) {
-      field.default = null;
-    } else if (!field.validate && field.default != null) {
-      field.validate = assertValueType(getType(field.default));
-    }
-
-    for (const k of Object.keys(field)) {
-      if (validFieldKeys.indexOf(k) === -1) {
-        throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
-      }
-    }
-  }
-
-  VISITOR_KEYS[type] = opts.visitor = visitor;
-  BUILDER_KEYS[type] = opts.builder = builder;
-  NODE_FIELDS[type] = opts.fields = fields;
-  ALIAS_KEYS[type] = opts.aliases = aliases;
-  aliases.forEach(alias => {
-    FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
-    FLIPPED_ALIAS_KEYS[alias].push(type);
-  });
-
-  if (opts.validate) {
-    NODE_PARENT_VALIDATIONS[type] = opts.validate;
-  }
-
-  store[type] = opts;
-}
-
-const store = {};

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

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

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

@@ -1,2482 +0,0 @@
-// NOTE: This file is autogenerated. Do not modify.
-// See packages/babel-types/scripts/generators/flow.js for script used.
-
-declare class BabelNodeComment {
-  value: string;
-  start: number;
-  end: number;
-  loc: BabelNodeSourceLocation;
-}
-
-declare class BabelNodeCommentBlock extends BabelNodeComment {
-  type: "CommentBlock";
-}
-
-declare class BabelNodeCommentLine extends BabelNodeComment {
-  type: "CommentLine";
-}
-
-declare class BabelNodeSourceLocation {
-  start: {
-    line: number;
-    column: number;
-  };
-
-  end: {
-    line: number;
-    column: number;
-  };
-}
-
-declare class BabelNode {
-  leadingComments?: Array<BabelNodeComment>;
-  innerComments?: Array<BabelNodeComment>;
-  trailingComments?: Array<BabelNodeComment>;
-  start: ?number;
-  end: ?number;
-  loc: ?BabelNodeSourceLocation;
-  extra?: { [string]: mixed };
-}
-
-declare class BabelNodeArrayExpression extends BabelNode {
-  type: "ArrayExpression";
-  elements?: Array<null | BabelNodeExpression | BabelNodeSpreadElement>;
-}
-
-declare class BabelNodeAssignmentExpression extends BabelNode {
-  type: "AssignmentExpression";
-  operator: string;
-  left: BabelNodeLVal;
-  right: BabelNodeExpression;
-}
-
-declare class BabelNodeBinaryExpression extends BabelNode {
-  type: "BinaryExpression";
-  operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
-  left: BabelNodeExpression | BabelNodePrivateName;
-  right: BabelNodeExpression;
-}
-
-declare class BabelNodeInterpreterDirective extends BabelNode {
-  type: "InterpreterDirective";
-  value: string;
-}
-
-declare class BabelNodeDirective extends BabelNode {
-  type: "Directive";
-  value: BabelNodeDirectiveLiteral;
-}
-
-declare class BabelNodeDirectiveLiteral extends BabelNode {
-  type: "DirectiveLiteral";
-  value: string;
-}
-
-declare class BabelNodeBlockStatement extends BabelNode {
-  type: "BlockStatement";
-  body: Array<BabelNodeStatement>;
-  directives?: Array<BabelNodeDirective>;
-}
-
-declare class BabelNodeBreakStatement extends BabelNode {
-  type: "BreakStatement";
-  label?: BabelNodeIdentifier;
-}
-
-declare class BabelNodeCallExpression extends BabelNode {
-  type: "CallExpression";
-  callee: BabelNodeExpression | BabelNodeV8IntrinsicIdentifier;
-  arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>;
-  optional?: true | false;
-  typeArguments?: BabelNodeTypeParameterInstantiation;
-  typeParameters?: BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeCatchClause extends BabelNode {
-  type: "CatchClause";
-  param?: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern;
-  body: BabelNodeBlockStatement;
-}
-
-declare class BabelNodeConditionalExpression extends BabelNode {
-  type: "ConditionalExpression";
-  test: BabelNodeExpression;
-  consequent: BabelNodeExpression;
-  alternate: BabelNodeExpression;
-}
-
-declare class BabelNodeContinueStatement extends BabelNode {
-  type: "ContinueStatement";
-  label?: BabelNodeIdentifier;
-}
-
-declare class BabelNodeDebuggerStatement extends BabelNode {
-  type: "DebuggerStatement";
-}
-
-declare class BabelNodeDoWhileStatement extends BabelNode {
-  type: "DoWhileStatement";
-  test: BabelNodeExpression;
-  body: BabelNodeStatement;
-}
-
-declare class BabelNodeEmptyStatement extends BabelNode {
-  type: "EmptyStatement";
-}
-
-declare class BabelNodeExpressionStatement extends BabelNode {
-  type: "ExpressionStatement";
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodeFile extends BabelNode {
-  type: "File";
-  program: BabelNodeProgram;
-  comments?: Array<BabelNodeCommentBlock | BabelNodeCommentLine>;
-  tokens?: Array<any>;
-}
-
-declare class BabelNodeForInStatement extends BabelNode {
-  type: "ForInStatement";
-  left: BabelNodeVariableDeclaration | BabelNodeLVal;
-  right: BabelNodeExpression;
-  body: BabelNodeStatement;
-}
-
-declare class BabelNodeForStatement extends BabelNode {
-  type: "ForStatement";
-  init?: BabelNodeVariableDeclaration | BabelNodeExpression;
-  test?: BabelNodeExpression;
-  update?: BabelNodeExpression;
-  body: BabelNodeStatement;
-}
-
-declare class BabelNodeFunctionDeclaration extends BabelNode {
-  type: "FunctionDeclaration";
-  id?: BabelNodeIdentifier;
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  body: BabelNodeBlockStatement;
-  generator?: boolean;
-  async?: boolean;
-  declare?: boolean;
-  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeFunctionExpression extends BabelNode {
-  type: "FunctionExpression";
-  id?: BabelNodeIdentifier;
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  body: BabelNodeBlockStatement;
-  generator?: boolean;
-  async?: boolean;
-  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeIdentifier extends BabelNode {
-  type: "Identifier";
-  name: string;
-  decorators?: Array<BabelNodeDecorator>;
-  optional?: boolean;
-  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-}
-
-declare class BabelNodeIfStatement extends BabelNode {
-  type: "IfStatement";
-  test: BabelNodeExpression;
-  consequent: BabelNodeStatement;
-  alternate?: BabelNodeStatement;
-}
-
-declare class BabelNodeLabeledStatement extends BabelNode {
-  type: "LabeledStatement";
-  label: BabelNodeIdentifier;
-  body: BabelNodeStatement;
-}
-
-declare class BabelNodeStringLiteral extends BabelNode {
-  type: "StringLiteral";
-  value: string;
-}
-
-declare class BabelNodeNumericLiteral extends BabelNode {
-  type: "NumericLiteral";
-  value: number;
-}
-
-declare class BabelNodeNullLiteral extends BabelNode {
-  type: "NullLiteral";
-}
-
-declare class BabelNodeBooleanLiteral extends BabelNode {
-  type: "BooleanLiteral";
-  value: boolean;
-}
-
-declare class BabelNodeRegExpLiteral extends BabelNode {
-  type: "RegExpLiteral";
-  pattern: string;
-  flags?: string;
-}
-
-declare class BabelNodeLogicalExpression extends BabelNode {
-  type: "LogicalExpression";
-  operator: "||" | "&&" | "??";
-  left: BabelNodeExpression;
-  right: BabelNodeExpression;
-}
-
-declare class BabelNodeMemberExpression extends BabelNode {
-  type: "MemberExpression";
-  object: BabelNodeExpression;
-  property: BabelNodeExpression | BabelNodeIdentifier | BabelNodePrivateName;
-  computed?: boolean;
-  optional?: true | false;
-}
-
-declare class BabelNodeNewExpression extends BabelNode {
-  type: "NewExpression";
-  callee: BabelNodeExpression | BabelNodeV8IntrinsicIdentifier;
-  arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>;
-  optional?: true | false;
-  typeArguments?: BabelNodeTypeParameterInstantiation;
-  typeParameters?: BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeProgram extends BabelNode {
-  type: "Program";
-  body: Array<BabelNodeStatement>;
-  directives?: Array<BabelNodeDirective>;
-  sourceType?: "script" | "module";
-  interpreter?: BabelNodeInterpreterDirective;
-  sourceFile: string;
-}
-
-declare class BabelNodeObjectExpression extends BabelNode {
-  type: "ObjectExpression";
-  properties: Array<BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement>;
-}
-
-declare class BabelNodeObjectMethod extends BabelNode {
-  type: "ObjectMethod";
-  kind?: "method" | "get" | "set";
-  key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral;
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  body: BabelNodeBlockStatement;
-  computed?: boolean;
-  generator?: boolean;
-  async?: boolean;
-  decorators?: Array<BabelNodeDecorator>;
-  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeObjectProperty extends BabelNode {
-  type: "ObjectProperty";
-  key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral;
-  value: BabelNodeExpression | BabelNodePatternLike;
-  computed?: boolean;
-  shorthand?: boolean;
-  decorators?: Array<BabelNodeDecorator>;
-}
-
-declare class BabelNodeRestElement extends BabelNode {
-  type: "RestElement";
-  argument: BabelNodeLVal;
-  decorators?: Array<BabelNodeDecorator>;
-  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-}
-
-declare class BabelNodeReturnStatement extends BabelNode {
-  type: "ReturnStatement";
-  argument?: BabelNodeExpression;
-}
-
-declare class BabelNodeSequenceExpression extends BabelNode {
-  type: "SequenceExpression";
-  expressions: Array<BabelNodeExpression>;
-}
-
-declare class BabelNodeParenthesizedExpression extends BabelNode {
-  type: "ParenthesizedExpression";
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodeSwitchCase extends BabelNode {
-  type: "SwitchCase";
-  test?: BabelNodeExpression;
-  consequent: Array<BabelNodeStatement>;
-}
-
-declare class BabelNodeSwitchStatement extends BabelNode {
-  type: "SwitchStatement";
-  discriminant: BabelNodeExpression;
-  cases: Array<BabelNodeSwitchCase>;
-}
-
-declare class BabelNodeThisExpression extends BabelNode {
-  type: "ThisExpression";
-}
-
-declare class BabelNodeThrowStatement extends BabelNode {
-  type: "ThrowStatement";
-  argument: BabelNodeExpression;
-}
-
-declare class BabelNodeTryStatement extends BabelNode {
-  type: "TryStatement";
-  block: BabelNodeBlockStatement;
-  handler?: BabelNodeCatchClause;
-  finalizer?: BabelNodeBlockStatement;
-}
-
-declare class BabelNodeUnaryExpression extends BabelNode {
-  type: "UnaryExpression";
-  operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
-  argument: BabelNodeExpression;
-  prefix?: boolean;
-}
-
-declare class BabelNodeUpdateExpression extends BabelNode {
-  type: "UpdateExpression";
-  operator: "++" | "--";
-  argument: BabelNodeExpression;
-  prefix?: boolean;
-}
-
-declare class BabelNodeVariableDeclaration extends BabelNode {
-  type: "VariableDeclaration";
-  kind: "var" | "let" | "const";
-  declarations: Array<BabelNodeVariableDeclarator>;
-  declare?: boolean;
-}
-
-declare class BabelNodeVariableDeclarator extends BabelNode {
-  type: "VariableDeclarator";
-  id: BabelNodeLVal;
-  init?: BabelNodeExpression;
-  definite?: boolean;
-}
-
-declare class BabelNodeWhileStatement extends BabelNode {
-  type: "WhileStatement";
-  test: BabelNodeExpression;
-  body: BabelNodeStatement;
-}
-
-declare class BabelNodeWithStatement extends BabelNode {
-  type: "WithStatement";
-  object: BabelNodeExpression;
-  body: BabelNodeStatement;
-}
-
-declare class BabelNodeAssignmentPattern extends BabelNode {
-  type: "AssignmentPattern";
-  left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern | BabelNodeMemberExpression;
-  right: BabelNodeExpression;
-  decorators?: Array<BabelNodeDecorator>;
-  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-}
-
-declare class BabelNodeArrayPattern extends BabelNode {
-  type: "ArrayPattern";
-  elements: Array<null | BabelNodePatternLike>;
-  decorators?: Array<BabelNodeDecorator>;
-  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-}
-
-declare class BabelNodeArrowFunctionExpression extends BabelNode {
-  type: "ArrowFunctionExpression";
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  body: BabelNodeBlockStatement | BabelNodeExpression;
-  async?: boolean;
-  expression: boolean;
-  generator?: boolean;
-  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeClassBody extends BabelNode {
-  type: "ClassBody";
-  body: Array<BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature>;
-}
-
-declare class BabelNodeClassExpression extends BabelNode {
-  type: "ClassExpression";
-  id?: BabelNodeIdentifier;
-  superClass?: BabelNodeExpression;
-  body: BabelNodeClassBody;
-  decorators?: Array<BabelNodeDecorator>;
-  mixins?: BabelNodeInterfaceExtends;
-  superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeClassDeclaration extends BabelNode {
-  type: "ClassDeclaration";
-  id: BabelNodeIdentifier;
-  superClass?: BabelNodeExpression;
-  body: BabelNodeClassBody;
-  decorators?: Array<BabelNodeDecorator>;
-  abstract?: boolean;
-  declare?: boolean;
-  mixins?: BabelNodeInterfaceExtends;
-  superTypeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeExportAllDeclaration extends BabelNode {
-  type: "ExportAllDeclaration";
-  source: BabelNodeStringLiteral;
-  assertions?: BabelNodeImportAttribute;
-  exportKind?: "type" | "value";
-}
-
-declare class BabelNodeExportDefaultDeclaration extends BabelNode {
-  type: "ExportDefaultDeclaration";
-  declaration: BabelNodeFunctionDeclaration | BabelNodeTSDeclareFunction | BabelNodeClassDeclaration | BabelNodeExpression;
-}
-
-declare class BabelNodeExportNamedDeclaration extends BabelNode {
-  type: "ExportNamedDeclaration";
-  declaration?: BabelNodeDeclaration;
-  specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier>;
-  source?: BabelNodeStringLiteral;
-  assertions?: BabelNodeImportAttribute;
-  exportKind?: "type" | "value";
-}
-
-declare class BabelNodeExportSpecifier extends BabelNode {
-  type: "ExportSpecifier";
-  local: BabelNodeIdentifier;
-  exported: BabelNodeIdentifier | BabelNodeStringLiteral;
-}
-
-declare class BabelNodeForOfStatement extends BabelNode {
-  type: "ForOfStatement";
-  left: BabelNodeVariableDeclaration | BabelNodeLVal;
-  right: BabelNodeExpression;
-  body: BabelNodeStatement;
-}
-
-declare class BabelNodeImportDeclaration extends BabelNode {
-  type: "ImportDeclaration";
-  specifiers: Array<BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier>;
-  source: BabelNodeStringLiteral;
-  assertions?: BabelNodeImportAttribute;
-  importKind?: "type" | "typeof" | "value";
-}
-
-declare class BabelNodeImportDefaultSpecifier extends BabelNode {
-  type: "ImportDefaultSpecifier";
-  local: BabelNodeIdentifier;
-}
-
-declare class BabelNodeImportNamespaceSpecifier extends BabelNode {
-  type: "ImportNamespaceSpecifier";
-  local: BabelNodeIdentifier;
-}
-
-declare class BabelNodeImportSpecifier extends BabelNode {
-  type: "ImportSpecifier";
-  local: BabelNodeIdentifier;
-  imported: BabelNodeIdentifier | BabelNodeStringLiteral;
-  importKind?: "type" | "typeof";
-}
-
-declare class BabelNodeMetaProperty extends BabelNode {
-  type: "MetaProperty";
-  meta: BabelNodeIdentifier;
-  property: BabelNodeIdentifier;
-}
-
-declare class BabelNodeClassMethod extends BabelNode {
-  type: "ClassMethod";
-  kind?: "get" | "set" | "method" | "constructor";
-  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  body: BabelNodeBlockStatement;
-  computed?: boolean;
-  generator?: boolean;
-  async?: boolean;
-  abstract?: boolean;
-  access?: "public" | "private" | "protected";
-  accessibility?: "public" | "private" | "protected";
-  decorators?: Array<BabelNodeDecorator>;
-  optional?: boolean;
-  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeObjectPattern extends BabelNode {
-  type: "ObjectPattern";
-  properties: Array<BabelNodeRestElement | BabelNodeObjectProperty>;
-  decorators?: Array<BabelNodeDecorator>;
-  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-}
-
-declare class BabelNodeSpreadElement extends BabelNode {
-  type: "SpreadElement";
-  argument: BabelNodeExpression;
-}
-
-declare class BabelNodeSuper extends BabelNode {
-  type: "Super";
-}
-
-declare class BabelNodeTaggedTemplateExpression extends BabelNode {
-  type: "TaggedTemplateExpression";
-  tag: BabelNodeExpression;
-  quasi: BabelNodeTemplateLiteral;
-  typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeTemplateElement extends BabelNode {
-  type: "TemplateElement";
-  value: { raw: string, cooked?: string };
-  tail?: boolean;
-}
-
-declare class BabelNodeTemplateLiteral extends BabelNode {
-  type: "TemplateLiteral";
-  quasis: Array<BabelNodeTemplateElement>;
-  expressions: Array<BabelNodeExpression | BabelNodeTSType>;
-}
-
-declare class BabelNodeYieldExpression extends BabelNode {
-  type: "YieldExpression";
-  argument?: BabelNodeExpression;
-  delegate?: boolean;
-}
-
-declare class BabelNodeAwaitExpression extends BabelNode {
-  type: "AwaitExpression";
-  argument: BabelNodeExpression;
-}
-
-declare class BabelNodeImport extends BabelNode {
-  type: "Import";
-}
-
-declare class BabelNodeBigIntLiteral extends BabelNode {
-  type: "BigIntLiteral";
-  value: string;
-}
-
-declare class BabelNodeExportNamespaceSpecifier extends BabelNode {
-  type: "ExportNamespaceSpecifier";
-  exported: BabelNodeIdentifier;
-}
-
-declare class BabelNodeOptionalMemberExpression extends BabelNode {
-  type: "OptionalMemberExpression";
-  object: BabelNodeExpression;
-  property: BabelNodeExpression | BabelNodeIdentifier;
-  computed?: boolean;
-  optional: boolean;
-}
-
-declare class BabelNodeOptionalCallExpression extends BabelNode {
-  type: "OptionalCallExpression";
-  callee: BabelNodeExpression;
-  arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>;
-  optional: boolean;
-  typeArguments?: BabelNodeTypeParameterInstantiation;
-  typeParameters?: BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeAnyTypeAnnotation extends BabelNode {
-  type: "AnyTypeAnnotation";
-}
-
-declare class BabelNodeArrayTypeAnnotation extends BabelNode {
-  type: "ArrayTypeAnnotation";
-  elementType: BabelNodeFlowType;
-}
-
-declare class BabelNodeBooleanTypeAnnotation extends BabelNode {
-  type: "BooleanTypeAnnotation";
-}
-
-declare class BabelNodeBooleanLiteralTypeAnnotation extends BabelNode {
-  type: "BooleanLiteralTypeAnnotation";
-  value: boolean;
-}
-
-declare class BabelNodeNullLiteralTypeAnnotation extends BabelNode {
-  type: "NullLiteralTypeAnnotation";
-}
-
-declare class BabelNodeClassImplements extends BabelNode {
-  type: "ClassImplements";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterInstantiation;
-}
-
-declare class BabelNodeDeclareClass extends BabelNode {
-  type: "DeclareClass";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  body: BabelNodeObjectTypeAnnotation;
-  mixins?: Array<BabelNodeInterfaceExtends>;
-}
-
-declare class BabelNodeDeclareFunction extends BabelNode {
-  type: "DeclareFunction";
-  id: BabelNodeIdentifier;
-  predicate?: BabelNodeDeclaredPredicate;
-}
-
-declare class BabelNodeDeclareInterface extends BabelNode {
-  type: "DeclareInterface";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  body: BabelNodeObjectTypeAnnotation;
-  mixins?: Array<BabelNodeInterfaceExtends>;
-}
-
-declare class BabelNodeDeclareModule extends BabelNode {
-  type: "DeclareModule";
-  id: BabelNodeIdentifier | BabelNodeStringLiteral;
-  body: BabelNodeBlockStatement;
-  kind?: "CommonJS" | "ES";
-}
-
-declare class BabelNodeDeclareModuleExports extends BabelNode {
-  type: "DeclareModuleExports";
-  typeAnnotation: BabelNodeTypeAnnotation;
-}
-
-declare class BabelNodeDeclareTypeAlias extends BabelNode {
-  type: "DeclareTypeAlias";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  right: BabelNodeFlowType;
-}
-
-declare class BabelNodeDeclareOpaqueType extends BabelNode {
-  type: "DeclareOpaqueType";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  supertype?: BabelNodeFlowType;
-}
-
-declare class BabelNodeDeclareVariable extends BabelNode {
-  type: "DeclareVariable";
-  id: BabelNodeIdentifier;
-}
-
-declare class BabelNodeDeclareExportDeclaration extends BabelNode {
-  type: "DeclareExportDeclaration";
-  declaration?: BabelNodeFlow;
-  specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier>;
-  source?: BabelNodeStringLiteral;
-}
-
-declare class BabelNodeDeclareExportAllDeclaration extends BabelNode {
-  type: "DeclareExportAllDeclaration";
-  source: BabelNodeStringLiteral;
-  exportKind?: "type" | "value";
-}
-
-declare class BabelNodeDeclaredPredicate extends BabelNode {
-  type: "DeclaredPredicate";
-  value: BabelNodeFlow;
-}
-
-declare class BabelNodeExistsTypeAnnotation extends BabelNode {
-  type: "ExistsTypeAnnotation";
-}
-
-declare class BabelNodeFunctionTypeAnnotation extends BabelNode {
-  type: "FunctionTypeAnnotation";
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  params: Array<BabelNodeFunctionTypeParam>;
-  rest?: BabelNodeFunctionTypeParam;
-  returnType: BabelNodeFlowType;
-}
-
-declare class BabelNodeFunctionTypeParam extends BabelNode {
-  type: "FunctionTypeParam";
-  name?: BabelNodeIdentifier;
-  typeAnnotation: BabelNodeFlowType;
-  optional?: boolean;
-}
-
-declare class BabelNodeGenericTypeAnnotation extends BabelNode {
-  type: "GenericTypeAnnotation";
-  id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier;
-  typeParameters?: BabelNodeTypeParameterInstantiation;
-}
-
-declare class BabelNodeInferredPredicate extends BabelNode {
-  type: "InferredPredicate";
-}
-
-declare class BabelNodeInterfaceExtends extends BabelNode {
-  type: "InterfaceExtends";
-  id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier;
-  typeParameters?: BabelNodeTypeParameterInstantiation;
-}
-
-declare class BabelNodeInterfaceDeclaration extends BabelNode {
-  type: "InterfaceDeclaration";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  body: BabelNodeObjectTypeAnnotation;
-  mixins?: Array<BabelNodeInterfaceExtends>;
-}
-
-declare class BabelNodeInterfaceTypeAnnotation extends BabelNode {
-  type: "InterfaceTypeAnnotation";
-  body: BabelNodeObjectTypeAnnotation;
-}
-
-declare class BabelNodeIntersectionTypeAnnotation extends BabelNode {
-  type: "IntersectionTypeAnnotation";
-  types: Array<BabelNodeFlowType>;
-}
-
-declare class BabelNodeMixedTypeAnnotation extends BabelNode {
-  type: "MixedTypeAnnotation";
-}
-
-declare class BabelNodeEmptyTypeAnnotation extends BabelNode {
-  type: "EmptyTypeAnnotation";
-}
-
-declare class BabelNodeNullableTypeAnnotation extends BabelNode {
-  type: "NullableTypeAnnotation";
-  typeAnnotation: BabelNodeFlowType;
-}
-
-declare class BabelNodeNumberLiteralTypeAnnotation extends BabelNode {
-  type: "NumberLiteralTypeAnnotation";
-  value: number;
-}
-
-declare class BabelNodeNumberTypeAnnotation extends BabelNode {
-  type: "NumberTypeAnnotation";
-}
-
-declare class BabelNodeObjectTypeAnnotation extends BabelNode {
-  type: "ObjectTypeAnnotation";
-  properties: Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty>;
-  indexers?: Array<BabelNodeObjectTypeIndexer>;
-  callProperties?: Array<BabelNodeObjectTypeCallProperty>;
-  internalSlots?: Array<BabelNodeObjectTypeInternalSlot>;
-  exact?: boolean;
-  inexact?: boolean;
-}
-
-declare class BabelNodeObjectTypeInternalSlot extends BabelNode {
-  type: "ObjectTypeInternalSlot";
-  id: BabelNodeIdentifier;
-  value: BabelNodeFlowType;
-  optional: boolean;
-  method: boolean;
-}
-
-declare class BabelNodeObjectTypeCallProperty extends BabelNode {
-  type: "ObjectTypeCallProperty";
-  value: BabelNodeFlowType;
-}
-
-declare class BabelNodeObjectTypeIndexer extends BabelNode {
-  type: "ObjectTypeIndexer";
-  id?: BabelNodeIdentifier;
-  key: BabelNodeFlowType;
-  value: BabelNodeFlowType;
-  variance?: BabelNodeVariance;
-}
-
-declare class BabelNodeObjectTypeProperty extends BabelNode {
-  type: "ObjectTypeProperty";
-  key: BabelNodeIdentifier | BabelNodeStringLiteral;
-  value: BabelNodeFlowType;
-  variance?: BabelNodeVariance;
-  kind: "init" | "get" | "set";
-  method: boolean;
-  optional: boolean;
-  proto: boolean;
-}
-
-declare class BabelNodeObjectTypeSpreadProperty extends BabelNode {
-  type: "ObjectTypeSpreadProperty";
-  argument: BabelNodeFlowType;
-}
-
-declare class BabelNodeOpaqueType extends BabelNode {
-  type: "OpaqueType";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  supertype?: BabelNodeFlowType;
-  impltype: BabelNodeFlowType;
-}
-
-declare class BabelNodeQualifiedTypeIdentifier extends BabelNode {
-  type: "QualifiedTypeIdentifier";
-  id: BabelNodeIdentifier;
-  qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier;
-}
-
-declare class BabelNodeStringLiteralTypeAnnotation extends BabelNode {
-  type: "StringLiteralTypeAnnotation";
-  value: string;
-}
-
-declare class BabelNodeStringTypeAnnotation extends BabelNode {
-  type: "StringTypeAnnotation";
-}
-
-declare class BabelNodeSymbolTypeAnnotation extends BabelNode {
-  type: "SymbolTypeAnnotation";
-}
-
-declare class BabelNodeThisTypeAnnotation extends BabelNode {
-  type: "ThisTypeAnnotation";
-}
-
-declare class BabelNodeTupleTypeAnnotation extends BabelNode {
-  type: "TupleTypeAnnotation";
-  types: Array<BabelNodeFlowType>;
-}
-
-declare class BabelNodeTypeofTypeAnnotation extends BabelNode {
-  type: "TypeofTypeAnnotation";
-  argument: BabelNodeFlowType;
-}
-
-declare class BabelNodeTypeAlias extends BabelNode {
-  type: "TypeAlias";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTypeParameterDeclaration;
-  right: BabelNodeFlowType;
-}
-
-declare class BabelNodeTypeAnnotation extends BabelNode {
-  type: "TypeAnnotation";
-  typeAnnotation: BabelNodeFlowType;
-}
-
-declare class BabelNodeTypeCastExpression extends BabelNode {
-  type: "TypeCastExpression";
-  expression: BabelNodeExpression;
-  typeAnnotation: BabelNodeTypeAnnotation;
-}
-
-declare class BabelNodeTypeParameter extends BabelNode {
-  type: "TypeParameter";
-  bound?: BabelNodeTypeAnnotation;
-  variance?: BabelNodeVariance;
-  name: string;
-}
-
-declare class BabelNodeTypeParameterDeclaration extends BabelNode {
-  type: "TypeParameterDeclaration";
-  params: Array<BabelNodeTypeParameter>;
-}
-
-declare class BabelNodeTypeParameterInstantiation extends BabelNode {
-  type: "TypeParameterInstantiation";
-  params: Array<BabelNodeFlowType>;
-}
-
-declare class BabelNodeUnionTypeAnnotation extends BabelNode {
-  type: "UnionTypeAnnotation";
-  types: Array<BabelNodeFlowType>;
-}
-
-declare class BabelNodeVariance extends BabelNode {
-  type: "Variance";
-  kind: "minus" | "plus";
-}
-
-declare class BabelNodeVoidTypeAnnotation extends BabelNode {
-  type: "VoidTypeAnnotation";
-}
-
-declare class BabelNodeEnumDeclaration extends BabelNode {
-  type: "EnumDeclaration";
-  id: BabelNodeIdentifier;
-  body: BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody;
-}
-
-declare class BabelNodeEnumBooleanBody extends BabelNode {
-  type: "EnumBooleanBody";
-  members: Array<BabelNodeEnumBooleanMember>;
-  explicitType: boolean;
-}
-
-declare class BabelNodeEnumNumberBody extends BabelNode {
-  type: "EnumNumberBody";
-  members: Array<BabelNodeEnumNumberMember>;
-  explicitType: boolean;
-}
-
-declare class BabelNodeEnumStringBody extends BabelNode {
-  type: "EnumStringBody";
-  members: Array<BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember>;
-  explicitType: boolean;
-}
-
-declare class BabelNodeEnumSymbolBody extends BabelNode {
-  type: "EnumSymbolBody";
-  members: Array<BabelNodeEnumDefaultedMember>;
-}
-
-declare class BabelNodeEnumBooleanMember extends BabelNode {
-  type: "EnumBooleanMember";
-  id: BabelNodeIdentifier;
-  init: BabelNodeBooleanLiteral;
-}
-
-declare class BabelNodeEnumNumberMember extends BabelNode {
-  type: "EnumNumberMember";
-  id: BabelNodeIdentifier;
-  init: BabelNodeNumericLiteral;
-}
-
-declare class BabelNodeEnumStringMember extends BabelNode {
-  type: "EnumStringMember";
-  id: BabelNodeIdentifier;
-  init: BabelNodeStringLiteral;
-}
-
-declare class BabelNodeEnumDefaultedMember extends BabelNode {
-  type: "EnumDefaultedMember";
-  id: BabelNodeIdentifier;
-}
-
-declare class BabelNodeJSXAttribute extends BabelNode {
-  type: "JSXAttribute";
-  name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName;
-  value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer;
-}
-
-declare class BabelNodeJSXClosingElement extends BabelNode {
-  type: "JSXClosingElement";
-  name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName;
-}
-
-declare class BabelNodeJSXElement extends BabelNode {
-  type: "JSXElement";
-  openingElement: BabelNodeJSXOpeningElement;
-  closingElement?: BabelNodeJSXClosingElement;
-  children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>;
-  selfClosing?: boolean;
-}
-
-declare class BabelNodeJSXEmptyExpression extends BabelNode {
-  type: "JSXEmptyExpression";
-}
-
-declare class BabelNodeJSXExpressionContainer extends BabelNode {
-  type: "JSXExpressionContainer";
-  expression: BabelNodeExpression | BabelNodeJSXEmptyExpression;
-}
-
-declare class BabelNodeJSXSpreadChild extends BabelNode {
-  type: "JSXSpreadChild";
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodeJSXIdentifier extends BabelNode {
-  type: "JSXIdentifier";
-  name: string;
-}
-
-declare class BabelNodeJSXMemberExpression extends BabelNode {
-  type: "JSXMemberExpression";
-  object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier;
-  property: BabelNodeJSXIdentifier;
-}
-
-declare class BabelNodeJSXNamespacedName extends BabelNode {
-  type: "JSXNamespacedName";
-  namespace: BabelNodeJSXIdentifier;
-  name: BabelNodeJSXIdentifier;
-}
-
-declare class BabelNodeJSXOpeningElement extends BabelNode {
-  type: "JSXOpeningElement";
-  name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName;
-  attributes: Array<BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute>;
-  selfClosing?: boolean;
-  typeParameters?: BabelNodeTypeParameterInstantiation | BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeJSXSpreadAttribute extends BabelNode {
-  type: "JSXSpreadAttribute";
-  argument: BabelNodeExpression;
-}
-
-declare class BabelNodeJSXText extends BabelNode {
-  type: "JSXText";
-  value: string;
-}
-
-declare class BabelNodeJSXFragment extends BabelNode {
-  type: "JSXFragment";
-  openingFragment: BabelNodeJSXOpeningFragment;
-  closingFragment: BabelNodeJSXClosingFragment;
-  children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>;
-}
-
-declare class BabelNodeJSXOpeningFragment extends BabelNode {
-  type: "JSXOpeningFragment";
-}
-
-declare class BabelNodeJSXClosingFragment extends BabelNode {
-  type: "JSXClosingFragment";
-}
-
-declare class BabelNodeNoop extends BabelNode {
-  type: "Noop";
-}
-
-declare class BabelNodePlaceholder extends BabelNode {
-  type: "Placeholder";
-  expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern";
-  name: BabelNodeIdentifier;
-}
-
-declare class BabelNodeV8IntrinsicIdentifier extends BabelNode {
-  type: "V8IntrinsicIdentifier";
-  name: string;
-}
-
-declare class BabelNodeArgumentPlaceholder extends BabelNode {
-  type: "ArgumentPlaceholder";
-}
-
-declare class BabelNodeBindExpression extends BabelNode {
-  type: "BindExpression";
-  object: BabelNodeExpression;
-  callee: BabelNodeExpression;
-}
-
-declare class BabelNodeClassProperty extends BabelNode {
-  type: "ClassProperty";
-  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
-  value?: BabelNodeExpression;
-  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  decorators?: Array<BabelNodeDecorator>;
-  computed?: boolean;
-  abstract?: boolean;
-  accessibility?: "public" | "private" | "protected";
-  declare?: boolean;
-  definite?: boolean;
-  optional?: boolean;
-  readonly?: boolean;
-}
-
-declare class BabelNodePipelineTopicExpression extends BabelNode {
-  type: "PipelineTopicExpression";
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodePipelineBareFunction extends BabelNode {
-  type: "PipelineBareFunction";
-  callee: BabelNodeExpression;
-}
-
-declare class BabelNodePipelinePrimaryTopicReference extends BabelNode {
-  type: "PipelinePrimaryTopicReference";
-}
-
-declare class BabelNodeClassPrivateProperty extends BabelNode {
-  type: "ClassPrivateProperty";
-  key: BabelNodePrivateName;
-  value?: BabelNodeExpression;
-  decorators?: Array<BabelNodeDecorator>;
-  typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-}
-
-declare class BabelNodeClassPrivateMethod extends BabelNode {
-  type: "ClassPrivateMethod";
-  kind?: "get" | "set" | "method" | "constructor";
-  key: BabelNodePrivateName;
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  body: BabelNodeBlockStatement;
-  abstract?: boolean;
-  access?: "public" | "private" | "protected";
-  accessibility?: "public" | "private" | "protected";
-  async?: boolean;
-  computed?: boolean;
-  decorators?: Array<BabelNodeDecorator>;
-  generator?: boolean;
-  optional?: boolean;
-  returnType?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  typeParameters?: BabelNodeTypeParameterDeclaration | BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-}
-
-declare class BabelNodeImportAttribute extends BabelNode {
-  type: "ImportAttribute";
-  key: BabelNodeIdentifier | BabelNodeStringLiteral;
-  value: BabelNodeStringLiteral;
-}
-
-declare class BabelNodeDecorator extends BabelNode {
-  type: "Decorator";
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodeDoExpression extends BabelNode {
-  type: "DoExpression";
-  body: BabelNodeBlockStatement;
-}
-
-declare class BabelNodeExportDefaultSpecifier extends BabelNode {
-  type: "ExportDefaultSpecifier";
-  exported: BabelNodeIdentifier;
-}
-
-declare class BabelNodePrivateName extends BabelNode {
-  type: "PrivateName";
-  id: BabelNodeIdentifier;
-}
-
-declare class BabelNodeRecordExpression extends BabelNode {
-  type: "RecordExpression";
-  properties: Array<BabelNodeObjectProperty | BabelNodeSpreadElement>;
-}
-
-declare class BabelNodeTupleExpression extends BabelNode {
-  type: "TupleExpression";
-  elements?: Array<BabelNodeExpression | BabelNodeSpreadElement>;
-}
-
-declare class BabelNodeDecimalLiteral extends BabelNode {
-  type: "DecimalLiteral";
-  value: string;
-}
-
-declare class BabelNodeStaticBlock extends BabelNode {
-  type: "StaticBlock";
-  body: Array<BabelNodeStatement>;
-}
-
-declare class BabelNodeTSParameterProperty extends BabelNode {
-  type: "TSParameterProperty";
-  parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern;
-  accessibility?: "public" | "private" | "protected";
-  readonly?: boolean;
-}
-
-declare class BabelNodeTSDeclareFunction extends BabelNode {
-  type: "TSDeclareFunction";
-  id?: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  async?: boolean;
-  declare?: boolean;
-  generator?: boolean;
-}
-
-declare class BabelNodeTSDeclareMethod extends BabelNode {
-  type: "TSDeclareMethod";
-  decorators?: Array<BabelNodeDecorator>;
-  key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression;
-  typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop;
-  params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>;
-  returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop;
-  abstract?: boolean;
-  access?: "public" | "private" | "protected";
-  accessibility?: "public" | "private" | "protected";
-  async?: boolean;
-  computed?: boolean;
-  generator?: boolean;
-  kind?: "get" | "set" | "method" | "constructor";
-  optional?: boolean;
-}
-
-declare class BabelNodeTSQualifiedName extends BabelNode {
-  type: "TSQualifiedName";
-  left: BabelNodeTSEntityName;
-  right: BabelNodeIdentifier;
-}
-
-declare class BabelNodeTSCallSignatureDeclaration extends BabelNode {
-  type: "TSCallSignatureDeclaration";
-  typeParameters?: BabelNodeTSTypeParameterDeclaration;
-  parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-}
-
-declare class BabelNodeTSConstructSignatureDeclaration extends BabelNode {
-  type: "TSConstructSignatureDeclaration";
-  typeParameters?: BabelNodeTSTypeParameterDeclaration;
-  parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-}
-
-declare class BabelNodeTSPropertySignature extends BabelNode {
-  type: "TSPropertySignature";
-  key: BabelNodeExpression;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-  initializer?: BabelNodeExpression;
-  computed?: boolean;
-  optional?: boolean;
-  readonly?: boolean;
-}
-
-declare class BabelNodeTSMethodSignature extends BabelNode {
-  type: "TSMethodSignature";
-  key: BabelNodeExpression;
-  typeParameters?: BabelNodeTSTypeParameterDeclaration;
-  parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-  computed?: boolean;
-  optional?: boolean;
-}
-
-declare class BabelNodeTSIndexSignature extends BabelNode {
-  type: "TSIndexSignature";
-  parameters: Array<BabelNodeIdentifier>;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-  readonly?: boolean;
-}
-
-declare class BabelNodeTSAnyKeyword extends BabelNode {
-  type: "TSAnyKeyword";
-}
-
-declare class BabelNodeTSBooleanKeyword extends BabelNode {
-  type: "TSBooleanKeyword";
-}
-
-declare class BabelNodeTSBigIntKeyword extends BabelNode {
-  type: "TSBigIntKeyword";
-}
-
-declare class BabelNodeTSIntrinsicKeyword extends BabelNode {
-  type: "TSIntrinsicKeyword";
-}
-
-declare class BabelNodeTSNeverKeyword extends BabelNode {
-  type: "TSNeverKeyword";
-}
-
-declare class BabelNodeTSNullKeyword extends BabelNode {
-  type: "TSNullKeyword";
-}
-
-declare class BabelNodeTSNumberKeyword extends BabelNode {
-  type: "TSNumberKeyword";
-}
-
-declare class BabelNodeTSObjectKeyword extends BabelNode {
-  type: "TSObjectKeyword";
-}
-
-declare class BabelNodeTSStringKeyword extends BabelNode {
-  type: "TSStringKeyword";
-}
-
-declare class BabelNodeTSSymbolKeyword extends BabelNode {
-  type: "TSSymbolKeyword";
-}
-
-declare class BabelNodeTSUndefinedKeyword extends BabelNode {
-  type: "TSUndefinedKeyword";
-}
-
-declare class BabelNodeTSUnknownKeyword extends BabelNode {
-  type: "TSUnknownKeyword";
-}
-
-declare class BabelNodeTSVoidKeyword extends BabelNode {
-  type: "TSVoidKeyword";
-}
-
-declare class BabelNodeTSThisType extends BabelNode {
-  type: "TSThisType";
-}
-
-declare class BabelNodeTSFunctionType extends BabelNode {
-  type: "TSFunctionType";
-  typeParameters?: BabelNodeTSTypeParameterDeclaration;
-  parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-}
-
-declare class BabelNodeTSConstructorType extends BabelNode {
-  type: "TSConstructorType";
-  typeParameters?: BabelNodeTSTypeParameterDeclaration;
-  parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-}
-
-declare class BabelNodeTSTypeReference extends BabelNode {
-  type: "TSTypeReference";
-  typeName: BabelNodeTSEntityName;
-  typeParameters?: BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeTSTypePredicate extends BabelNode {
-  type: "TSTypePredicate";
-  parameterName: BabelNodeIdentifier | BabelNodeTSThisType;
-  typeAnnotation?: BabelNodeTSTypeAnnotation;
-  asserts?: boolean;
-}
-
-declare class BabelNodeTSTypeQuery extends BabelNode {
-  type: "TSTypeQuery";
-  exprName: BabelNodeTSEntityName | BabelNodeTSImportType;
-}
-
-declare class BabelNodeTSTypeLiteral extends BabelNode {
-  type: "TSTypeLiteral";
-  members: Array<BabelNodeTSTypeElement>;
-}
-
-declare class BabelNodeTSArrayType extends BabelNode {
-  type: "TSArrayType";
-  elementType: BabelNodeTSType;
-}
-
-declare class BabelNodeTSTupleType extends BabelNode {
-  type: "TSTupleType";
-  elementTypes: Array<BabelNodeTSType | BabelNodeTSNamedTupleMember>;
-}
-
-declare class BabelNodeTSOptionalType extends BabelNode {
-  type: "TSOptionalType";
-  typeAnnotation: BabelNodeTSType;
-}
-
-declare class BabelNodeTSRestType extends BabelNode {
-  type: "TSRestType";
-  typeAnnotation: BabelNodeTSType;
-}
-
-declare class BabelNodeTSNamedTupleMember extends BabelNode {
-  type: "TSNamedTupleMember";
-  label: BabelNodeIdentifier;
-  elementType: BabelNodeTSType;
-  optional?: boolean;
-}
-
-declare class BabelNodeTSUnionType extends BabelNode {
-  type: "TSUnionType";
-  types: Array<BabelNodeTSType>;
-}
-
-declare class BabelNodeTSIntersectionType extends BabelNode {
-  type: "TSIntersectionType";
-  types: Array<BabelNodeTSType>;
-}
-
-declare class BabelNodeTSConditionalType extends BabelNode {
-  type: "TSConditionalType";
-  checkType: BabelNodeTSType;
-  extendsType: BabelNodeTSType;
-  trueType: BabelNodeTSType;
-  falseType: BabelNodeTSType;
-}
-
-declare class BabelNodeTSInferType extends BabelNode {
-  type: "TSInferType";
-  typeParameter: BabelNodeTSTypeParameter;
-}
-
-declare class BabelNodeTSParenthesizedType extends BabelNode {
-  type: "TSParenthesizedType";
-  typeAnnotation: BabelNodeTSType;
-}
-
-declare class BabelNodeTSTypeOperator extends BabelNode {
-  type: "TSTypeOperator";
-  typeAnnotation: BabelNodeTSType;
-  operator: string;
-}
-
-declare class BabelNodeTSIndexedAccessType extends BabelNode {
-  type: "TSIndexedAccessType";
-  objectType: BabelNodeTSType;
-  indexType: BabelNodeTSType;
-}
-
-declare class BabelNodeTSMappedType extends BabelNode {
-  type: "TSMappedType";
-  typeParameter: BabelNodeTSTypeParameter;
-  typeAnnotation?: BabelNodeTSType;
-  nameType?: BabelNodeTSType;
-  optional?: boolean;
-  readonly?: boolean;
-}
-
-declare class BabelNodeTSLiteralType extends BabelNode {
-  type: "TSLiteralType";
-  literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral;
-}
-
-declare class BabelNodeTSExpressionWithTypeArguments extends BabelNode {
-  type: "TSExpressionWithTypeArguments";
-  expression: BabelNodeTSEntityName;
-  typeParameters?: BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeTSInterfaceDeclaration extends BabelNode {
-  type: "TSInterfaceDeclaration";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTSTypeParameterDeclaration;
-  body: BabelNodeTSInterfaceBody;
-  declare?: boolean;
-}
-
-declare class BabelNodeTSInterfaceBody extends BabelNode {
-  type: "TSInterfaceBody";
-  body: Array<BabelNodeTSTypeElement>;
-}
-
-declare class BabelNodeTSTypeAliasDeclaration extends BabelNode {
-  type: "TSTypeAliasDeclaration";
-  id: BabelNodeIdentifier;
-  typeParameters?: BabelNodeTSTypeParameterDeclaration;
-  typeAnnotation: BabelNodeTSType;
-  declare?: boolean;
-}
-
-declare class BabelNodeTSAsExpression extends BabelNode {
-  type: "TSAsExpression";
-  expression: BabelNodeExpression;
-  typeAnnotation: BabelNodeTSType;
-}
-
-declare class BabelNodeTSTypeAssertion extends BabelNode {
-  type: "TSTypeAssertion";
-  typeAnnotation: BabelNodeTSType;
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodeTSEnumDeclaration extends BabelNode {
-  type: "TSEnumDeclaration";
-  id: BabelNodeIdentifier;
-  members: Array<BabelNodeTSEnumMember>;
-  declare?: boolean;
-  initializer?: BabelNodeExpression;
-}
-
-declare class BabelNodeTSEnumMember extends BabelNode {
-  type: "TSEnumMember";
-  id: BabelNodeIdentifier | BabelNodeStringLiteral;
-  initializer?: BabelNodeExpression;
-}
-
-declare class BabelNodeTSModuleDeclaration extends BabelNode {
-  type: "TSModuleDeclaration";
-  id: BabelNodeIdentifier | BabelNodeStringLiteral;
-  body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration;
-  declare?: boolean;
-  global?: boolean;
-}
-
-declare class BabelNodeTSModuleBlock extends BabelNode {
-  type: "TSModuleBlock";
-  body: Array<BabelNodeStatement>;
-}
-
-declare class BabelNodeTSImportType extends BabelNode {
-  type: "TSImportType";
-  argument: BabelNodeStringLiteral;
-  qualifier?: BabelNodeTSEntityName;
-  typeParameters?: BabelNodeTSTypeParameterInstantiation;
-}
-
-declare class BabelNodeTSImportEqualsDeclaration extends BabelNode {
-  type: "TSImportEqualsDeclaration";
-  id: BabelNodeIdentifier;
-  moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference;
-  isExport: boolean;
-}
-
-declare class BabelNodeTSExternalModuleReference extends BabelNode {
-  type: "TSExternalModuleReference";
-  expression: BabelNodeStringLiteral;
-}
-
-declare class BabelNodeTSNonNullExpression extends BabelNode {
-  type: "TSNonNullExpression";
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodeTSExportAssignment extends BabelNode {
-  type: "TSExportAssignment";
-  expression: BabelNodeExpression;
-}
-
-declare class BabelNodeTSNamespaceExportDeclaration extends BabelNode {
-  type: "TSNamespaceExportDeclaration";
-  id: BabelNodeIdentifier;
-}
-
-declare class BabelNodeTSTypeAnnotation extends BabelNode {
-  type: "TSTypeAnnotation";
-  typeAnnotation: BabelNodeTSType;
-}
-
-declare class BabelNodeTSTypeParameterInstantiation extends BabelNode {
-  type: "TSTypeParameterInstantiation";
-  params: Array<BabelNodeTSType>;
-}
-
-declare class BabelNodeTSTypeParameterDeclaration extends BabelNode {
-  type: "TSTypeParameterDeclaration";
-  params: Array<BabelNodeTSTypeParameter>;
-}
-
-declare class BabelNodeTSTypeParameter extends BabelNode {
-  type: "TSTypeParameter";
-  constraint?: BabelNodeTSType;
-  name: string;
-}
-
-type BabelNodeExpression = BabelNodeArrayExpression | BabelNodeAssignmentExpression | BabelNodeBinaryExpression | BabelNodeCallExpression | BabelNodeConditionalExpression | BabelNodeFunctionExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeLogicalExpression | BabelNodeMemberExpression | BabelNodeNewExpression | BabelNodeObjectExpression | BabelNodeSequenceExpression | BabelNodeParenthesizedExpression | BabelNodeThisExpression | BabelNodeUnaryExpression | BabelNodeUpdateExpression | BabelNodeArrowFunctionExpression | BabelNodeClassExpression | BabelNodeMetaProperty | BabelNodeSuper | BabelNodeTaggedTemplateExpression | BabelNodeTemplateLiteral | BabelNodeYieldExpression | BabelNodeAwaitExpression | BabelNodeImport | BabelNodeBigIntLiteral | BabelNodeOptionalMemberExpression | BabelNodeOptionalCallExpression | BabelNodeTypeCastExpression | BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeBindExpression | BabelNodePipelinePrimaryTopicReference | BabelNodeDoExpression | BabelNodeRecordExpression | BabelNodeTupleExpression | BabelNodeDecimalLiteral | BabelNodeTSAsExpression | BabelNodeTSTypeAssertion | BabelNodeTSNonNullExpression;
-type BabelNodeBinary = BabelNodeBinaryExpression | BabelNodeLogicalExpression;
-type BabelNodeScopable = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeClassExpression | BabelNodeClassDeclaration | BabelNodeForOfStatement | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock;
-type BabelNodeBlockParent = BabelNodeBlockStatement | BabelNodeCatchClause | BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeProgram | BabelNodeObjectMethod | BabelNodeSwitchStatement | BabelNodeWhileStatement | BabelNodeArrowFunctionExpression | BabelNodeForOfStatement | BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeStaticBlock | BabelNodeTSModuleBlock;
-type BabelNodeBlock = BabelNodeBlockStatement | BabelNodeProgram | BabelNodeTSModuleBlock;
-type BabelNodeStatement = BabelNodeBlockStatement | BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeDebuggerStatement | BabelNodeDoWhileStatement | BabelNodeEmptyStatement | BabelNodeExpressionStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeFunctionDeclaration | BabelNodeIfStatement | BabelNodeLabeledStatement | BabelNodeReturnStatement | BabelNodeSwitchStatement | BabelNodeThrowStatement | BabelNodeTryStatement | BabelNodeVariableDeclaration | BabelNodeWhileStatement | BabelNodeWithStatement | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeForOfStatement | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeEnumDeclaration | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration | BabelNodeTSImportEqualsDeclaration | BabelNodeTSExportAssignment | BabelNodeTSNamespaceExportDeclaration;
-type BabelNodeTerminatorless = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement | BabelNodeYieldExpression | BabelNodeAwaitExpression;
-type BabelNodeCompletionStatement = BabelNodeBreakStatement | BabelNodeContinueStatement | BabelNodeReturnStatement | BabelNodeThrowStatement;
-type BabelNodeConditional = BabelNodeConditionalExpression | BabelNodeIfStatement;
-type BabelNodeLoop = BabelNodeDoWhileStatement | BabelNodeForInStatement | BabelNodeForStatement | BabelNodeWhileStatement | BabelNodeForOfStatement;
-type BabelNodeWhile = BabelNodeDoWhileStatement | BabelNodeWhileStatement;
-type BabelNodeExpressionWrapper = BabelNodeExpressionStatement | BabelNodeParenthesizedExpression | BabelNodeTypeCastExpression;
-type BabelNodeFor = BabelNodeForInStatement | BabelNodeForStatement | BabelNodeForOfStatement;
-type BabelNodeForXStatement = BabelNodeForInStatement | BabelNodeForOfStatement;
-type BabelNodeFunction = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod | BabelNodeClassPrivateMethod;
-type BabelNodeFunctionParent = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeObjectMethod | BabelNodeArrowFunctionExpression | BabelNodeClassMethod | BabelNodeClassPrivateMethod;
-type BabelNodePureish = BabelNodeFunctionDeclaration | BabelNodeFunctionExpression | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeArrowFunctionExpression | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral;
-type BabelNodeDeclaration = BabelNodeFunctionDeclaration | BabelNodeVariableDeclaration | BabelNodeClassDeclaration | BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias | BabelNodeEnumDeclaration | BabelNodeTSDeclareFunction | BabelNodeTSInterfaceDeclaration | BabelNodeTSTypeAliasDeclaration | BabelNodeTSEnumDeclaration | BabelNodeTSModuleDeclaration;
-type BabelNodePatternLike = BabelNodeIdentifier | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern;
-type BabelNodeLVal = BabelNodeIdentifier | BabelNodeMemberExpression | BabelNodeRestElement | BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern | BabelNodeTSParameterProperty;
-type BabelNodeTSEntityName = BabelNodeIdentifier | BabelNodeTSQualifiedName;
-type BabelNodeLiteral = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeRegExpLiteral | BabelNodeTemplateLiteral | BabelNodeBigIntLiteral | BabelNodeDecimalLiteral;
-type BabelNodeImmutable = BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeNullLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral | BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXOpeningElement | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment | BabelNodeDecimalLiteral;
-type BabelNodeUserWhitespacable = BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeObjectTypeInternalSlot | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty;
-type BabelNodeMethod = BabelNodeObjectMethod | BabelNodeClassMethod | BabelNodeClassPrivateMethod;
-type BabelNodeObjectMember = BabelNodeObjectMethod | BabelNodeObjectProperty;
-type BabelNodeProperty = BabelNodeObjectProperty | BabelNodeClassProperty | BabelNodeClassPrivateProperty;
-type BabelNodeUnaryLike = BabelNodeUnaryExpression | BabelNodeSpreadElement;
-type BabelNodePattern = BabelNodeAssignmentPattern | BabelNodeArrayPattern | BabelNodeObjectPattern;
-type BabelNodeClass = BabelNodeClassExpression | BabelNodeClassDeclaration;
-type BabelNodeModuleDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration | BabelNodeImportDeclaration;
-type BabelNodeExportDeclaration = BabelNodeExportAllDeclaration | BabelNodeExportDefaultDeclaration | BabelNodeExportNamedDeclaration;
-type BabelNodeModuleSpecifier = BabelNodeExportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier | BabelNodeImportSpecifier | BabelNodeExportNamespaceSpecifier | BabelNodeExportDefaultSpecifier;
-type BabelNodeFlow = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeClassImplements | BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeDeclaredPredicate | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeFunctionTypeParam | BabelNodeGenericTypeAnnotation | BabelNodeInferredPredicate | BabelNodeInterfaceExtends | BabelNodeInterfaceDeclaration | BabelNodeInterfaceTypeAnnotation | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeObjectTypeInternalSlot | BabelNodeObjectTypeCallProperty | BabelNodeObjectTypeIndexer | BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty | BabelNodeOpaqueType | BabelNodeQualifiedTypeIdentifier | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeTypeAlias | BabelNodeTypeAnnotation | BabelNodeTypeCastExpression | BabelNodeTypeParameter | BabelNodeTypeParameterDeclaration | BabelNodeTypeParameterInstantiation | BabelNodeUnionTypeAnnotation | BabelNodeVariance | BabelNodeVoidTypeAnnotation;
-type BabelNodeFlowType = BabelNodeAnyTypeAnnotation | BabelNodeArrayTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeBooleanLiteralTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeExistsTypeAnnotation | BabelNodeFunctionTypeAnnotation | BabelNodeGenericTypeAnnotation | BabelNodeInterfaceTypeAnnotation | BabelNodeIntersectionTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNullableTypeAnnotation | BabelNodeNumberLiteralTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeObjectTypeAnnotation | BabelNodeStringLiteralTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeTupleTypeAnnotation | BabelNodeTypeofTypeAnnotation | BabelNodeUnionTypeAnnotation | BabelNodeVoidTypeAnnotation;
-type BabelNodeFlowBaseAnnotation = BabelNodeAnyTypeAnnotation | BabelNodeBooleanTypeAnnotation | BabelNodeNullLiteralTypeAnnotation | BabelNodeMixedTypeAnnotation | BabelNodeEmptyTypeAnnotation | BabelNodeNumberTypeAnnotation | BabelNodeStringTypeAnnotation | BabelNodeSymbolTypeAnnotation | BabelNodeThisTypeAnnotation | BabelNodeVoidTypeAnnotation;
-type BabelNodeFlowDeclaration = BabelNodeDeclareClass | BabelNodeDeclareFunction | BabelNodeDeclareInterface | BabelNodeDeclareModule | BabelNodeDeclareModuleExports | BabelNodeDeclareTypeAlias | BabelNodeDeclareOpaqueType | BabelNodeDeclareVariable | BabelNodeDeclareExportDeclaration | BabelNodeDeclareExportAllDeclaration | BabelNodeInterfaceDeclaration | BabelNodeOpaqueType | BabelNodeTypeAlias;
-type BabelNodeFlowPredicate = BabelNodeDeclaredPredicate | BabelNodeInferredPredicate;
-type BabelNodeEnumBody = BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody;
-type BabelNodeEnumMember = BabelNodeEnumBooleanMember | BabelNodeEnumNumberMember | BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember;
-type BabelNodeJSX = BabelNodeJSXAttribute | BabelNodeJSXClosingElement | BabelNodeJSXElement | BabelNodeJSXEmptyExpression | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName | BabelNodeJSXOpeningElement | BabelNodeJSXSpreadAttribute | BabelNodeJSXText | BabelNodeJSXFragment | BabelNodeJSXOpeningFragment | BabelNodeJSXClosingFragment;
-type BabelNodePrivate = BabelNodeClassPrivateProperty | BabelNodeClassPrivateMethod | BabelNodePrivateName;
-type BabelNodeTSTypeElement = BabelNodeTSCallSignatureDeclaration | BabelNodeTSConstructSignatureDeclaration | BabelNodeTSPropertySignature | BabelNodeTSMethodSignature | BabelNodeTSIndexSignature;
-type BabelNodeTSType = BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSFunctionType | BabelNodeTSConstructorType | BabelNodeTSTypeReference | BabelNodeTSTypePredicate | BabelNodeTSTypeQuery | BabelNodeTSTypeLiteral | BabelNodeTSArrayType | BabelNodeTSTupleType | BabelNodeTSOptionalType | BabelNodeTSRestType | BabelNodeTSUnionType | BabelNodeTSIntersectionType | BabelNodeTSConditionalType | BabelNodeTSInferType | BabelNodeTSParenthesizedType | BabelNodeTSTypeOperator | BabelNodeTSIndexedAccessType | BabelNodeTSMappedType | BabelNodeTSLiteralType | BabelNodeTSExpressionWithTypeArguments | BabelNodeTSImportType;
-type BabelNodeTSBaseType = BabelNodeTSAnyKeyword | BabelNodeTSBooleanKeyword | BabelNodeTSBigIntKeyword | BabelNodeTSIntrinsicKeyword | BabelNodeTSNeverKeyword | BabelNodeTSNullKeyword | BabelNodeTSNumberKeyword | BabelNodeTSObjectKeyword | BabelNodeTSStringKeyword | BabelNodeTSSymbolKeyword | BabelNodeTSUndefinedKeyword | BabelNodeTSUnknownKeyword | BabelNodeTSVoidKeyword | BabelNodeTSThisType | BabelNodeTSLiteralType;
-
-declare module "@babel/types" {
-  declare export function arrayExpression(elements?: Array<null | BabelNodeExpression | BabelNodeSpreadElement>): BabelNodeArrayExpression;
-  declare export function assignmentExpression(operator: string, left: BabelNodeLVal, right: BabelNodeExpression): BabelNodeAssignmentExpression;
-  declare export function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=", left: BabelNodeExpression | BabelNodePrivateName, right: BabelNodeExpression): BabelNodeBinaryExpression;
-  declare export function interpreterDirective(value: string): BabelNodeInterpreterDirective;
-  declare export function directive(value: BabelNodeDirectiveLiteral): BabelNodeDirective;
-  declare export function directiveLiteral(value: string): BabelNodeDirectiveLiteral;
-  declare export function blockStatement(body: Array<BabelNodeStatement>, directives?: Array<BabelNodeDirective>): BabelNodeBlockStatement;
-  declare export function breakStatement(label?: BabelNodeIdentifier): BabelNodeBreakStatement;
-  declare export function callExpression(callee: BabelNodeExpression | BabelNodeV8IntrinsicIdentifier, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>): BabelNodeCallExpression;
-  declare export function catchClause(param?: BabelNodeIdentifier | BabelNodeArrayPattern | BabelNodeObjectPattern, body: BabelNodeBlockStatement): BabelNodeCatchClause;
-  declare export function conditionalExpression(test: BabelNodeExpression, consequent: BabelNodeExpression, alternate: BabelNodeExpression): BabelNodeConditionalExpression;
-  declare export function continueStatement(label?: BabelNodeIdentifier): BabelNodeContinueStatement;
-  declare export function debuggerStatement(): BabelNodeDebuggerStatement;
-  declare export function doWhileStatement(test: BabelNodeExpression, body: BabelNodeStatement): BabelNodeDoWhileStatement;
-  declare export function emptyStatement(): BabelNodeEmptyStatement;
-  declare export function expressionStatement(expression: BabelNodeExpression): BabelNodeExpressionStatement;
-  declare export function file(program: BabelNodeProgram, comments?: Array<BabelNodeCommentBlock | BabelNodeCommentLine>, tokens?: Array<any>): BabelNodeFile;
-  declare export function forInStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForInStatement;
-  declare export function forStatement(init?: BabelNodeVariableDeclaration | BabelNodeExpression, test?: BabelNodeExpression, update?: BabelNodeExpression, body: BabelNodeStatement): BabelNodeForStatement;
-  declare export function functionDeclaration(id?: BabelNodeIdentifier, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, generator?: boolean, async?: boolean): BabelNodeFunctionDeclaration;
-  declare export function functionExpression(id?: BabelNodeIdentifier, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, generator?: boolean, async?: boolean): BabelNodeFunctionExpression;
-  declare export function identifier(name: string): BabelNodeIdentifier;
-  declare export function ifStatement(test: BabelNodeExpression, consequent: BabelNodeStatement, alternate?: BabelNodeStatement): BabelNodeIfStatement;
-  declare export function labeledStatement(label: BabelNodeIdentifier, body: BabelNodeStatement): BabelNodeLabeledStatement;
-  declare export function stringLiteral(value: string): BabelNodeStringLiteral;
-  declare export function numericLiteral(value: number): BabelNodeNumericLiteral;
-  declare export function nullLiteral(): BabelNodeNullLiteral;
-  declare export function booleanLiteral(value: boolean): BabelNodeBooleanLiteral;
-  declare export function regExpLiteral(pattern: string, flags?: string): BabelNodeRegExpLiteral;
-  declare export function logicalExpression(operator: "||" | "&&" | "??", left: BabelNodeExpression, right: BabelNodeExpression): BabelNodeLogicalExpression;
-  declare export function memberExpression(object: BabelNodeExpression, property: BabelNodeExpression | BabelNodeIdentifier | BabelNodePrivateName, computed?: boolean, optional?: true | false): BabelNodeMemberExpression;
-  declare export function newExpression(callee: BabelNodeExpression | BabelNodeV8IntrinsicIdentifier, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>): BabelNodeNewExpression;
-  declare export function program(body: Array<BabelNodeStatement>, directives?: Array<BabelNodeDirective>, sourceType?: "script" | "module", interpreter?: BabelNodeInterpreterDirective): BabelNodeProgram;
-  declare export function objectExpression(properties: Array<BabelNodeObjectMethod | BabelNodeObjectProperty | BabelNodeSpreadElement>): BabelNodeObjectExpression;
-  declare export function objectMethod(kind?: "method" | "get" | "set", key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, computed?: boolean, generator?: boolean, async?: boolean): BabelNodeObjectMethod;
-  declare export function objectProperty(key: BabelNodeExpression | BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral, value: BabelNodeExpression | BabelNodePatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<BabelNodeDecorator>): BabelNodeObjectProperty;
-  declare export function restElement(argument: BabelNodeLVal): BabelNodeRestElement;
-  declare export function returnStatement(argument?: BabelNodeExpression): BabelNodeReturnStatement;
-  declare export function sequenceExpression(expressions: Array<BabelNodeExpression>): BabelNodeSequenceExpression;
-  declare export function parenthesizedExpression(expression: BabelNodeExpression): BabelNodeParenthesizedExpression;
-  declare export function switchCase(test?: BabelNodeExpression, consequent: Array<BabelNodeStatement>): BabelNodeSwitchCase;
-  declare export function switchStatement(discriminant: BabelNodeExpression, cases: Array<BabelNodeSwitchCase>): BabelNodeSwitchStatement;
-  declare export function thisExpression(): BabelNodeThisExpression;
-  declare export function throwStatement(argument: BabelNodeExpression): BabelNodeThrowStatement;
-  declare export function tryStatement(block: BabelNodeBlockStatement, handler?: BabelNodeCatchClause, finalizer?: BabelNodeBlockStatement): BabelNodeTryStatement;
-  declare export function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUnaryExpression;
-  declare export function updateExpression(operator: "++" | "--", argument: BabelNodeExpression, prefix?: boolean): BabelNodeUpdateExpression;
-  declare export function variableDeclaration(kind: "var" | "let" | "const", declarations: Array<BabelNodeVariableDeclarator>): BabelNodeVariableDeclaration;
-  declare export function variableDeclarator(id: BabelNodeLVal, init?: BabelNodeExpression): BabelNodeVariableDeclarator;
-  declare export function whileStatement(test: BabelNodeExpression, body: BabelNodeStatement): BabelNodeWhileStatement;
-  declare export function withStatement(object: BabelNodeExpression, body: BabelNodeStatement): BabelNodeWithStatement;
-  declare export function assignmentPattern(left: BabelNodeIdentifier | BabelNodeObjectPattern | BabelNodeArrayPattern | BabelNodeMemberExpression, right: BabelNodeExpression): BabelNodeAssignmentPattern;
-  declare export function arrayPattern(elements: Array<null | BabelNodePatternLike>): BabelNodeArrayPattern;
-  declare export function arrowFunctionExpression(params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement | BabelNodeExpression, async?: boolean): BabelNodeArrowFunctionExpression;
-  declare export function classBody(body: Array<BabelNodeClassMethod | BabelNodeClassPrivateMethod | BabelNodeClassProperty | BabelNodeClassPrivateProperty | BabelNodeTSDeclareMethod | BabelNodeTSIndexSignature>): BabelNodeClassBody;
-  declare export function classExpression(id?: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: Array<BabelNodeDecorator>): BabelNodeClassExpression;
-  declare export function classDeclaration(id: BabelNodeIdentifier, superClass?: BabelNodeExpression, body: BabelNodeClassBody, decorators?: Array<BabelNodeDecorator>): BabelNodeClassDeclaration;
-  declare export function exportAllDeclaration(source: BabelNodeStringLiteral): BabelNodeExportAllDeclaration;
-  declare export function exportDefaultDeclaration(declaration: BabelNodeFunctionDeclaration | BabelNodeTSDeclareFunction | BabelNodeClassDeclaration | BabelNodeExpression): BabelNodeExportDefaultDeclaration;
-  declare export function exportNamedDeclaration(declaration?: BabelNodeDeclaration, specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportDefaultSpecifier | BabelNodeExportNamespaceSpecifier>, source?: BabelNodeStringLiteral): BabelNodeExportNamedDeclaration;
-  declare export function exportSpecifier(local: BabelNodeIdentifier, exported: BabelNodeIdentifier | BabelNodeStringLiteral): BabelNodeExportSpecifier;
-  declare export function forOfStatement(left: BabelNodeVariableDeclaration | BabelNodeLVal, right: BabelNodeExpression, body: BabelNodeStatement, _await?: boolean): BabelNodeForOfStatement;
-  declare export function importDeclaration(specifiers: Array<BabelNodeImportSpecifier | BabelNodeImportDefaultSpecifier | BabelNodeImportNamespaceSpecifier>, source: BabelNodeStringLiteral): BabelNodeImportDeclaration;
-  declare export function importDefaultSpecifier(local: BabelNodeIdentifier): BabelNodeImportDefaultSpecifier;
-  declare export function importNamespaceSpecifier(local: BabelNodeIdentifier): BabelNodeImportNamespaceSpecifier;
-  declare export function importSpecifier(local: BabelNodeIdentifier, imported: BabelNodeIdentifier | BabelNodeStringLiteral): BabelNodeImportSpecifier;
-  declare export function metaProperty(meta: BabelNodeIdentifier, property: BabelNodeIdentifier): BabelNodeMetaProperty;
-  declare export function classMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): BabelNodeClassMethod;
-  declare export function objectPattern(properties: Array<BabelNodeRestElement | BabelNodeObjectProperty>): BabelNodeObjectPattern;
-  declare export function spreadElement(argument: BabelNodeExpression): BabelNodeSpreadElement;
-  declare function _super(): BabelNodeSuper;
-  declare export { _super as super }
-  declare export function taggedTemplateExpression(tag: BabelNodeExpression, quasi: BabelNodeTemplateLiteral): BabelNodeTaggedTemplateExpression;
-  declare export function templateElement(value: { raw: string, cooked?: string }, tail?: boolean): BabelNodeTemplateElement;
-  declare export function templateLiteral(quasis: Array<BabelNodeTemplateElement>, expressions: Array<BabelNodeExpression | BabelNodeTSType>): BabelNodeTemplateLiteral;
-  declare export function yieldExpression(argument?: BabelNodeExpression, delegate?: boolean): BabelNodeYieldExpression;
-  declare export function awaitExpression(argument: BabelNodeExpression): BabelNodeAwaitExpression;
-  declare function _import(): BabelNodeImport;
-  declare export { _import as import }
-  declare export function bigIntLiteral(value: string): BabelNodeBigIntLiteral;
-  declare export function exportNamespaceSpecifier(exported: BabelNodeIdentifier): BabelNodeExportNamespaceSpecifier;
-  declare export function optionalMemberExpression(object: BabelNodeExpression, property: BabelNodeExpression | BabelNodeIdentifier, computed?: boolean, optional: boolean): BabelNodeOptionalMemberExpression;
-  declare export function optionalCallExpression(callee: BabelNodeExpression, _arguments: Array<BabelNodeExpression | BabelNodeSpreadElement | BabelNodeJSXNamespacedName | BabelNodeArgumentPlaceholder>, optional: boolean): BabelNodeOptionalCallExpression;
-  declare export function anyTypeAnnotation(): BabelNodeAnyTypeAnnotation;
-  declare export function arrayTypeAnnotation(elementType: BabelNodeFlowType): BabelNodeArrayTypeAnnotation;
-  declare export function booleanTypeAnnotation(): BabelNodeBooleanTypeAnnotation;
-  declare export function booleanLiteralTypeAnnotation(value: boolean): BabelNodeBooleanLiteralTypeAnnotation;
-  declare export function nullLiteralTypeAnnotation(): BabelNodeNullLiteralTypeAnnotation;
-  declare export function classImplements(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeClassImplements;
-  declare export function declareClass(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeDeclareClass;
-  declare export function declareFunction(id: BabelNodeIdentifier): BabelNodeDeclareFunction;
-  declare export function declareInterface(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeDeclareInterface;
-  declare export function declareModule(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeBlockStatement, kind?: "CommonJS" | "ES"): BabelNodeDeclareModule;
-  declare export function declareModuleExports(typeAnnotation: BabelNodeTypeAnnotation): BabelNodeDeclareModuleExports;
-  declare export function declareTypeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeDeclareTypeAlias;
-  declare export function declareOpaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType): BabelNodeDeclareOpaqueType;
-  declare export function declareVariable(id: BabelNodeIdentifier): BabelNodeDeclareVariable;
-  declare export function declareExportDeclaration(declaration?: BabelNodeFlow, specifiers?: Array<BabelNodeExportSpecifier | BabelNodeExportNamespaceSpecifier>, source?: BabelNodeStringLiteral): BabelNodeDeclareExportDeclaration;
-  declare export function declareExportAllDeclaration(source: BabelNodeStringLiteral): BabelNodeDeclareExportAllDeclaration;
-  declare export function declaredPredicate(value: BabelNodeFlow): BabelNodeDeclaredPredicate;
-  declare export function existsTypeAnnotation(): BabelNodeExistsTypeAnnotation;
-  declare export function functionTypeAnnotation(typeParameters?: BabelNodeTypeParameterDeclaration, params: Array<BabelNodeFunctionTypeParam>, rest?: BabelNodeFunctionTypeParam, returnType: BabelNodeFlowType): BabelNodeFunctionTypeAnnotation;
-  declare export function functionTypeParam(name?: BabelNodeIdentifier, typeAnnotation: BabelNodeFlowType): BabelNodeFunctionTypeParam;
-  declare export function genericTypeAnnotation(id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeGenericTypeAnnotation;
-  declare export function inferredPredicate(): BabelNodeInferredPredicate;
-  declare export function interfaceExtends(id: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier, typeParameters?: BabelNodeTypeParameterInstantiation): BabelNodeInterfaceExtends;
-  declare export function interfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, _extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeInterfaceDeclaration;
-  declare export function interfaceTypeAnnotation(_extends?: Array<BabelNodeInterfaceExtends>, body: BabelNodeObjectTypeAnnotation): BabelNodeInterfaceTypeAnnotation;
-  declare export function intersectionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeIntersectionTypeAnnotation;
-  declare export function mixedTypeAnnotation(): BabelNodeMixedTypeAnnotation;
-  declare export function emptyTypeAnnotation(): BabelNodeEmptyTypeAnnotation;
-  declare export function nullableTypeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeNullableTypeAnnotation;
-  declare export function numberLiteralTypeAnnotation(value: number): BabelNodeNumberLiteralTypeAnnotation;
-  declare export function numberTypeAnnotation(): BabelNodeNumberTypeAnnotation;
-  declare export function objectTypeAnnotation(properties: Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty>, indexers?: Array<BabelNodeObjectTypeIndexer>, callProperties?: Array<BabelNodeObjectTypeCallProperty>, internalSlots?: Array<BabelNodeObjectTypeInternalSlot>, exact?: boolean): BabelNodeObjectTypeAnnotation;
-  declare export function objectTypeInternalSlot(id: BabelNodeIdentifier, value: BabelNodeFlowType, optional: boolean, _static: boolean, method: boolean): BabelNodeObjectTypeInternalSlot;
-  declare export function objectTypeCallProperty(value: BabelNodeFlowType): BabelNodeObjectTypeCallProperty;
-  declare export function objectTypeIndexer(id?: BabelNodeIdentifier, key: BabelNodeFlowType, value: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeObjectTypeIndexer;
-  declare export function objectTypeProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral, value: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeObjectTypeProperty;
-  declare export function objectTypeSpreadProperty(argument: BabelNodeFlowType): BabelNodeObjectTypeSpreadProperty;
-  declare export function opaqueType(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, supertype?: BabelNodeFlowType, impltype: BabelNodeFlowType): BabelNodeOpaqueType;
-  declare export function qualifiedTypeIdentifier(id: BabelNodeIdentifier, qualification: BabelNodeIdentifier | BabelNodeQualifiedTypeIdentifier): BabelNodeQualifiedTypeIdentifier;
-  declare export function stringLiteralTypeAnnotation(value: string): BabelNodeStringLiteralTypeAnnotation;
-  declare export function stringTypeAnnotation(): BabelNodeStringTypeAnnotation;
-  declare export function symbolTypeAnnotation(): BabelNodeSymbolTypeAnnotation;
-  declare export function thisTypeAnnotation(): BabelNodeThisTypeAnnotation;
-  declare export function tupleTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeTupleTypeAnnotation;
-  declare export function typeofTypeAnnotation(argument: BabelNodeFlowType): BabelNodeTypeofTypeAnnotation;
-  declare export function typeAlias(id: BabelNodeIdentifier, typeParameters?: BabelNodeTypeParameterDeclaration, right: BabelNodeFlowType): BabelNodeTypeAlias;
-  declare export function typeAnnotation(typeAnnotation: BabelNodeFlowType): BabelNodeTypeAnnotation;
-  declare export function typeCastExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTypeAnnotation): BabelNodeTypeCastExpression;
-  declare export function typeParameter(bound?: BabelNodeTypeAnnotation, _default?: BabelNodeFlowType, variance?: BabelNodeVariance): BabelNodeTypeParameter;
-  declare export function typeParameterDeclaration(params: Array<BabelNodeTypeParameter>): BabelNodeTypeParameterDeclaration;
-  declare export function typeParameterInstantiation(params: Array<BabelNodeFlowType>): BabelNodeTypeParameterInstantiation;
-  declare export function unionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeUnionTypeAnnotation;
-  declare export function variance(kind: "minus" | "plus"): BabelNodeVariance;
-  declare export function voidTypeAnnotation(): BabelNodeVoidTypeAnnotation;
-  declare export function enumDeclaration(id: BabelNodeIdentifier, body: BabelNodeEnumBooleanBody | BabelNodeEnumNumberBody | BabelNodeEnumStringBody | BabelNodeEnumSymbolBody): BabelNodeEnumDeclaration;
-  declare export function enumBooleanBody(members: Array<BabelNodeEnumBooleanMember>): BabelNodeEnumBooleanBody;
-  declare export function enumNumberBody(members: Array<BabelNodeEnumNumberMember>): BabelNodeEnumNumberBody;
-  declare export function enumStringBody(members: Array<BabelNodeEnumStringMember | BabelNodeEnumDefaultedMember>): BabelNodeEnumStringBody;
-  declare export function enumSymbolBody(members: Array<BabelNodeEnumDefaultedMember>): BabelNodeEnumSymbolBody;
-  declare export function enumBooleanMember(id: BabelNodeIdentifier): BabelNodeEnumBooleanMember;
-  declare export function enumNumberMember(id: BabelNodeIdentifier, init: BabelNodeNumericLiteral): BabelNodeEnumNumberMember;
-  declare export function enumStringMember(id: BabelNodeIdentifier, init: BabelNodeStringLiteral): BabelNodeEnumStringMember;
-  declare export function enumDefaultedMember(id: BabelNodeIdentifier): BabelNodeEnumDefaultedMember;
-  declare export function jsxAttribute(name: BabelNodeJSXIdentifier | BabelNodeJSXNamespacedName, value?: BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeStringLiteral | BabelNodeJSXExpressionContainer): BabelNodeJSXAttribute;
-  declare export function jsxClosingElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName): BabelNodeJSXClosingElement;
-  declare export function jsxElement(openingElement: BabelNodeJSXOpeningElement, closingElement?: BabelNodeJSXClosingElement, children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>, selfClosing?: boolean): BabelNodeJSXElement;
-  declare export function jsxEmptyExpression(): BabelNodeJSXEmptyExpression;
-  declare export function jsxExpressionContainer(expression: BabelNodeExpression | BabelNodeJSXEmptyExpression): BabelNodeJSXExpressionContainer;
-  declare export function jsxSpreadChild(expression: BabelNodeExpression): BabelNodeJSXSpreadChild;
-  declare export function jsxIdentifier(name: string): BabelNodeJSXIdentifier;
-  declare export function jsxMemberExpression(object: BabelNodeJSXMemberExpression | BabelNodeJSXIdentifier, property: BabelNodeJSXIdentifier): BabelNodeJSXMemberExpression;
-  declare export function jsxNamespacedName(namespace: BabelNodeJSXIdentifier, name: BabelNodeJSXIdentifier): BabelNodeJSXNamespacedName;
-  declare export function jsxOpeningElement(name: BabelNodeJSXIdentifier | BabelNodeJSXMemberExpression | BabelNodeJSXNamespacedName, attributes: Array<BabelNodeJSXAttribute | BabelNodeJSXSpreadAttribute>, selfClosing?: boolean): BabelNodeJSXOpeningElement;
-  declare export function jsxSpreadAttribute(argument: BabelNodeExpression): BabelNodeJSXSpreadAttribute;
-  declare export function jsxText(value: string): BabelNodeJSXText;
-  declare export function jsxFragment(openingFragment: BabelNodeJSXOpeningFragment, closingFragment: BabelNodeJSXClosingFragment, children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>): BabelNodeJSXFragment;
-  declare export function jsxOpeningFragment(): BabelNodeJSXOpeningFragment;
-  declare export function jsxClosingFragment(): BabelNodeJSXClosingFragment;
-  declare export function noop(): BabelNodeNoop;
-  declare export function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: BabelNodeIdentifier): BabelNodePlaceholder;
-  declare export function v8IntrinsicIdentifier(name: string): BabelNodeV8IntrinsicIdentifier;
-  declare export function argumentPlaceholder(): BabelNodeArgumentPlaceholder;
-  declare export function bindExpression(object: BabelNodeExpression, callee: BabelNodeExpression): BabelNodeBindExpression;
-  declare export function classProperty(key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, value?: BabelNodeExpression, typeAnnotation?: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | BabelNodeNoop, decorators?: Array<BabelNodeDecorator>, computed?: boolean, _static?: boolean): BabelNodeClassProperty;
-  declare export function pipelineTopicExpression(expression: BabelNodeExpression): BabelNodePipelineTopicExpression;
-  declare export function pipelineBareFunction(callee: BabelNodeExpression): BabelNodePipelineBareFunction;
-  declare export function pipelinePrimaryTopicReference(): BabelNodePipelinePrimaryTopicReference;
-  declare export function classPrivateProperty(key: BabelNodePrivateName, value?: BabelNodeExpression, decorators?: Array<BabelNodeDecorator>, _static: any): BabelNodeClassPrivateProperty;
-  declare export function classPrivateMethod(kind?: "get" | "set" | "method" | "constructor", key: BabelNodePrivateName, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, body: BabelNodeBlockStatement, _static?: boolean): BabelNodeClassPrivateMethod;
-  declare export function importAttribute(key: BabelNodeIdentifier | BabelNodeStringLiteral, value: BabelNodeStringLiteral): BabelNodeImportAttribute;
-  declare export function decorator(expression: BabelNodeExpression): BabelNodeDecorator;
-  declare export function doExpression(body: BabelNodeBlockStatement): BabelNodeDoExpression;
-  declare export function exportDefaultSpecifier(exported: BabelNodeIdentifier): BabelNodeExportDefaultSpecifier;
-  declare export function privateName(id: BabelNodeIdentifier): BabelNodePrivateName;
-  declare export function recordExpression(properties: Array<BabelNodeObjectProperty | BabelNodeSpreadElement>): BabelNodeRecordExpression;
-  declare export function tupleExpression(elements?: Array<BabelNodeExpression | BabelNodeSpreadElement>): BabelNodeTupleExpression;
-  declare export function decimalLiteral(value: string): BabelNodeDecimalLiteral;
-  declare export function staticBlock(body: Array<BabelNodeStatement>): BabelNodeStaticBlock;
-  declare export function tsParameterProperty(parameter: BabelNodeIdentifier | BabelNodeAssignmentPattern): BabelNodeTSParameterProperty;
-  declare export function tsDeclareFunction(id?: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareFunction;
-  declare export function tsDeclareMethod(decorators?: Array<BabelNodeDecorator>, key: BabelNodeIdentifier | BabelNodeStringLiteral | BabelNodeNumericLiteral | BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration | BabelNodeNoop, params: Array<BabelNodeIdentifier | BabelNodePattern | BabelNodeRestElement | BabelNodeTSParameterProperty>, returnType?: BabelNodeTSTypeAnnotation | BabelNodeNoop): BabelNodeTSDeclareMethod;
-  declare export function tsQualifiedName(left: BabelNodeTSEntityName, right: BabelNodeIdentifier): BabelNodeTSQualifiedName;
-  declare export function tsCallSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSCallSignatureDeclaration;
-  declare export function tsConstructSignatureDeclaration(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructSignatureDeclaration;
-  declare export function tsPropertySignature(key: BabelNodeExpression, typeAnnotation?: BabelNodeTSTypeAnnotation, initializer?: BabelNodeExpression): BabelNodeTSPropertySignature;
-  declare export function tsMethodSignature(key: BabelNodeExpression, typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSMethodSignature;
-  declare export function tsIndexSignature(parameters: Array<BabelNodeIdentifier>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSIndexSignature;
-  declare export function tsAnyKeyword(): BabelNodeTSAnyKeyword;
-  declare export function tsBooleanKeyword(): BabelNodeTSBooleanKeyword;
-  declare export function tsBigIntKeyword(): BabelNodeTSBigIntKeyword;
-  declare export function tsIntrinsicKeyword(): BabelNodeTSIntrinsicKeyword;
-  declare export function tsNeverKeyword(): BabelNodeTSNeverKeyword;
-  declare export function tsNullKeyword(): BabelNodeTSNullKeyword;
-  declare export function tsNumberKeyword(): BabelNodeTSNumberKeyword;
-  declare export function tsObjectKeyword(): BabelNodeTSObjectKeyword;
-  declare export function tsStringKeyword(): BabelNodeTSStringKeyword;
-  declare export function tsSymbolKeyword(): BabelNodeTSSymbolKeyword;
-  declare export function tsUndefinedKeyword(): BabelNodeTSUndefinedKeyword;
-  declare export function tsUnknownKeyword(): BabelNodeTSUnknownKeyword;
-  declare export function tsVoidKeyword(): BabelNodeTSVoidKeyword;
-  declare export function tsThisType(): BabelNodeTSThisType;
-  declare export function tsFunctionType(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSFunctionType;
-  declare export function tsConstructorType(typeParameters?: BabelNodeTSTypeParameterDeclaration, parameters: Array<BabelNodeIdentifier | BabelNodeRestElement>, typeAnnotation?: BabelNodeTSTypeAnnotation): BabelNodeTSConstructorType;
-  declare export function tsTypeReference(typeName: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSTypeReference;
-  declare export function tsTypePredicate(parameterName: BabelNodeIdentifier | BabelNodeTSThisType, typeAnnotation?: BabelNodeTSTypeAnnotation, asserts?: boolean): BabelNodeTSTypePredicate;
-  declare export function tsTypeQuery(exprName: BabelNodeTSEntityName | BabelNodeTSImportType): BabelNodeTSTypeQuery;
-  declare export function tsTypeLiteral(members: Array<BabelNodeTSTypeElement>): BabelNodeTSTypeLiteral;
-  declare export function tsArrayType(elementType: BabelNodeTSType): BabelNodeTSArrayType;
-  declare export function tsTupleType(elementTypes: Array<BabelNodeTSType | BabelNodeTSNamedTupleMember>): BabelNodeTSTupleType;
-  declare export function tsOptionalType(typeAnnotation: BabelNodeTSType): BabelNodeTSOptionalType;
-  declare export function tsRestType(typeAnnotation: BabelNodeTSType): BabelNodeTSRestType;
-  declare export function tsNamedTupleMember(label: BabelNodeIdentifier, elementType: BabelNodeTSType, optional?: boolean): BabelNodeTSNamedTupleMember;
-  declare export function tsUnionType(types: Array<BabelNodeTSType>): BabelNodeTSUnionType;
-  declare export function tsIntersectionType(types: Array<BabelNodeTSType>): BabelNodeTSIntersectionType;
-  declare export function tsConditionalType(checkType: BabelNodeTSType, extendsType: BabelNodeTSType, trueType: BabelNodeTSType, falseType: BabelNodeTSType): BabelNodeTSConditionalType;
-  declare export function tsInferType(typeParameter: BabelNodeTSTypeParameter): BabelNodeTSInferType;
-  declare export function tsParenthesizedType(typeAnnotation: BabelNodeTSType): BabelNodeTSParenthesizedType;
-  declare export function tsTypeOperator(typeAnnotation: BabelNodeTSType): BabelNodeTSTypeOperator;
-  declare export function tsIndexedAccessType(objectType: BabelNodeTSType, indexType: BabelNodeTSType): BabelNodeTSIndexedAccessType;
-  declare export function tsMappedType(typeParameter: BabelNodeTSTypeParameter, typeAnnotation?: BabelNodeTSType, nameType?: BabelNodeTSType): BabelNodeTSMappedType;
-  declare export function tsLiteralType(literal: BabelNodeNumericLiteral | BabelNodeStringLiteral | BabelNodeBooleanLiteral | BabelNodeBigIntLiteral): BabelNodeTSLiteralType;
-  declare export function tsExpressionWithTypeArguments(expression: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSExpressionWithTypeArguments;
-  declare export function tsInterfaceDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, _extends?: Array<BabelNodeTSExpressionWithTypeArguments>, body: BabelNodeTSInterfaceBody): BabelNodeTSInterfaceDeclaration;
-  declare export function tsInterfaceBody(body: Array<BabelNodeTSTypeElement>): BabelNodeTSInterfaceBody;
-  declare export function tsTypeAliasDeclaration(id: BabelNodeIdentifier, typeParameters?: BabelNodeTSTypeParameterDeclaration, typeAnnotation: BabelNodeTSType): BabelNodeTSTypeAliasDeclaration;
-  declare export function tsAsExpression(expression: BabelNodeExpression, typeAnnotation: BabelNodeTSType): BabelNodeTSAsExpression;
-  declare export function tsTypeAssertion(typeAnnotation: BabelNodeTSType, expression: BabelNodeExpression): BabelNodeTSTypeAssertion;
-  declare export function tsEnumDeclaration(id: BabelNodeIdentifier, members: Array<BabelNodeTSEnumMember>): BabelNodeTSEnumDeclaration;
-  declare export function tsEnumMember(id: BabelNodeIdentifier | BabelNodeStringLiteral, initializer?: BabelNodeExpression): BabelNodeTSEnumMember;
-  declare export function tsModuleDeclaration(id: BabelNodeIdentifier | BabelNodeStringLiteral, body: BabelNodeTSModuleBlock | BabelNodeTSModuleDeclaration): BabelNodeTSModuleDeclaration;
-  declare export function tsModuleBlock(body: Array<BabelNodeStatement>): BabelNodeTSModuleBlock;
-  declare export function tsImportType(argument: BabelNodeStringLiteral, qualifier?: BabelNodeTSEntityName, typeParameters?: BabelNodeTSTypeParameterInstantiation): BabelNodeTSImportType;
-  declare export function tsImportEqualsDeclaration(id: BabelNodeIdentifier, moduleReference: BabelNodeTSEntityName | BabelNodeTSExternalModuleReference): BabelNodeTSImportEqualsDeclaration;
-  declare export function tsExternalModuleReference(expression: BabelNodeStringLiteral): BabelNodeTSExternalModuleReference;
-  declare export function tsNonNullExpression(expression: BabelNodeExpression): BabelNodeTSNonNullExpression;
-  declare export function tsExportAssignment(expression: BabelNodeExpression): BabelNodeTSExportAssignment;
-  declare export function tsNamespaceExportDeclaration(id: BabelNodeIdentifier): BabelNodeTSNamespaceExportDeclaration;
-  declare export function tsTypeAnnotation(typeAnnotation: BabelNodeTSType): BabelNodeTSTypeAnnotation;
-  declare export function tsTypeParameterInstantiation(params: Array<BabelNodeTSType>): BabelNodeTSTypeParameterInstantiation;
-  declare export function tsTypeParameterDeclaration(params: Array<BabelNodeTSTypeParameter>): BabelNodeTSTypeParameterDeclaration;
-  declare export function tsTypeParameter(constraint?: BabelNodeTSType, _default?: BabelNodeTSType, name: string): BabelNodeTSTypeParameter;
-  declare export function isArrayExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayExpression)
-  declare export function assertArrayExpression(node: ?Object, opts?: ?Object): void
-  declare export function isAssignmentExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentExpression)
-  declare export function assertAssignmentExpression(node: ?Object, opts?: ?Object): void
-  declare export function isBinaryExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBinaryExpression)
-  declare export function assertBinaryExpression(node: ?Object, opts?: ?Object): void
-  declare export function isInterpreterDirective(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterpreterDirective)
-  declare export function assertInterpreterDirective(node: ?Object, opts?: ?Object): void
-  declare export function isDirective(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirective)
-  declare export function assertDirective(node: ?Object, opts?: ?Object): void
-  declare export function isDirectiveLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDirectiveLiteral)
-  declare export function assertDirectiveLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isBlockStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBlockStatement)
-  declare export function assertBlockStatement(node: ?Object, opts?: ?Object): void
-  declare export function isBreakStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBreakStatement)
-  declare export function assertBreakStatement(node: ?Object, opts?: ?Object): void
-  declare export function isCallExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCallExpression)
-  declare export function assertCallExpression(node: ?Object, opts?: ?Object): void
-  declare export function isCatchClause(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeCatchClause)
-  declare export function assertCatchClause(node: ?Object, opts?: ?Object): void
-  declare export function isConditionalExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeConditionalExpression)
-  declare export function assertConditionalExpression(node: ?Object, opts?: ?Object): void
-  declare export function isContinueStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeContinueStatement)
-  declare export function assertContinueStatement(node: ?Object, opts?: ?Object): void
-  declare export function isDebuggerStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDebuggerStatement)
-  declare export function assertDebuggerStatement(node: ?Object, opts?: ?Object): void
-  declare export function isDoWhileStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoWhileStatement)
-  declare export function assertDoWhileStatement(node: ?Object, opts?: ?Object): void
-  declare export function isEmptyStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyStatement)
-  declare export function assertEmptyStatement(node: ?Object, opts?: ?Object): void
-  declare export function isExpressionStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExpressionStatement)
-  declare export function assertExpressionStatement(node: ?Object, opts?: ?Object): void
-  declare export function isFile(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFile)
-  declare export function assertFile(node: ?Object, opts?: ?Object): void
-  declare export function isForInStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForInStatement)
-  declare export function assertForInStatement(node: ?Object, opts?: ?Object): void
-  declare export function isForStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForStatement)
-  declare export function assertForStatement(node: ?Object, opts?: ?Object): void
-  declare export function isFunctionDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionDeclaration)
-  declare export function assertFunctionDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isFunctionExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionExpression)
-  declare export function assertFunctionExpression(node: ?Object, opts?: ?Object): void
-  declare export function isIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIdentifier)
-  declare export function assertIdentifier(node: ?Object, opts?: ?Object): void
-  declare export function isIfStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIfStatement)
-  declare export function assertIfStatement(node: ?Object, opts?: ?Object): void
-  declare export function isLabeledStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLabeledStatement)
-  declare export function assertLabeledStatement(node: ?Object, opts?: ?Object): void
-  declare export function isStringLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteral)
-  declare export function assertStringLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isNumericLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumericLiteral)
-  declare export function assertNumericLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isNullLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteral)
-  declare export function assertNullLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isBooleanLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteral)
-  declare export function assertBooleanLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isRegExpLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRegExpLiteral)
-  declare export function assertRegExpLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isLogicalExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeLogicalExpression)
-  declare export function assertLogicalExpression(node: ?Object, opts?: ?Object): void
-  declare export function isMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMemberExpression)
-  declare export function assertMemberExpression(node: ?Object, opts?: ?Object): void
-  declare export function isNewExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNewExpression)
-  declare export function assertNewExpression(node: ?Object, opts?: ?Object): void
-  declare export function isProgram(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeProgram)
-  declare export function assertProgram(node: ?Object, opts?: ?Object): void
-  declare export function isObjectExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectExpression)
-  declare export function assertObjectExpression(node: ?Object, opts?: ?Object): void
-  declare export function isObjectMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectMethod)
-  declare export function assertObjectMethod(node: ?Object, opts?: ?Object): void
-  declare export function isObjectProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectProperty)
-  declare export function assertObjectProperty(node: ?Object, opts?: ?Object): void
-  declare export function isRestElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRestElement)
-  declare export function assertRestElement(node: ?Object, opts?: ?Object): void
-  declare export function isReturnStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeReturnStatement)
-  declare export function assertReturnStatement(node: ?Object, opts?: ?Object): void
-  declare export function isSequenceExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSequenceExpression)
-  declare export function assertSequenceExpression(node: ?Object, opts?: ?Object): void
-  declare export function isParenthesizedExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeParenthesizedExpression)
-  declare export function assertParenthesizedExpression(node: ?Object, opts?: ?Object): void
-  declare export function isSwitchCase(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchCase)
-  declare export function assertSwitchCase(node: ?Object, opts?: ?Object): void
-  declare export function isSwitchStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSwitchStatement)
-  declare export function assertSwitchStatement(node: ?Object, opts?: ?Object): void
-  declare export function isThisExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisExpression)
-  declare export function assertThisExpression(node: ?Object, opts?: ?Object): void
-  declare export function isThrowStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThrowStatement)
-  declare export function assertThrowStatement(node: ?Object, opts?: ?Object): void
-  declare export function isTryStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTryStatement)
-  declare export function assertTryStatement(node: ?Object, opts?: ?Object): void
-  declare export function isUnaryExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnaryExpression)
-  declare export function assertUnaryExpression(node: ?Object, opts?: ?Object): void
-  declare export function isUpdateExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUpdateExpression)
-  declare export function assertUpdateExpression(node: ?Object, opts?: ?Object): void
-  declare export function isVariableDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclaration)
-  declare export function assertVariableDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isVariableDeclarator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariableDeclarator)
-  declare export function assertVariableDeclarator(node: ?Object, opts?: ?Object): void
-  declare export function isWhileStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWhileStatement)
-  declare export function assertWhileStatement(node: ?Object, opts?: ?Object): void
-  declare export function isWithStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeWithStatement)
-  declare export function assertWithStatement(node: ?Object, opts?: ?Object): void
-  declare export function isAssignmentPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAssignmentPattern)
-  declare export function assertAssignmentPattern(node: ?Object, opts?: ?Object): void
-  declare export function isArrayPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayPattern)
-  declare export function assertArrayPattern(node: ?Object, opts?: ?Object): void
-  declare export function isArrowFunctionExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrowFunctionExpression)
-  declare export function assertArrowFunctionExpression(node: ?Object, opts?: ?Object): void
-  declare export function isClassBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassBody)
-  declare export function assertClassBody(node: ?Object, opts?: ?Object): void
-  declare export function isClassExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassExpression)
-  declare export function assertClassExpression(node: ?Object, opts?: ?Object): void
-  declare export function isClassDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassDeclaration)
-  declare export function assertClassDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isExportAllDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportAllDeclaration)
-  declare export function assertExportAllDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isExportDefaultDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultDeclaration)
-  declare export function assertExportDefaultDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isExportNamedDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamedDeclaration)
-  declare export function assertExportNamedDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isExportSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportSpecifier)
-  declare export function assertExportSpecifier(node: ?Object, opts?: ?Object): void
-  declare export function isForOfStatement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeForOfStatement)
-  declare export function assertForOfStatement(node: ?Object, opts?: ?Object): void
-  declare export function isImportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDeclaration)
-  declare export function assertImportDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isImportDefaultSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportDefaultSpecifier)
-  declare export function assertImportDefaultSpecifier(node: ?Object, opts?: ?Object): void
-  declare export function isImportNamespaceSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportNamespaceSpecifier)
-  declare export function assertImportNamespaceSpecifier(node: ?Object, opts?: ?Object): void
-  declare export function isImportSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportSpecifier)
-  declare export function assertImportSpecifier(node: ?Object, opts?: ?Object): void
-  declare export function isMetaProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMetaProperty)
-  declare export function assertMetaProperty(node: ?Object, opts?: ?Object): void
-  declare export function isClassMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassMethod)
-  declare export function assertClassMethod(node: ?Object, opts?: ?Object): void
-  declare export function isObjectPattern(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectPattern)
-  declare export function assertObjectPattern(node: ?Object, opts?: ?Object): void
-  declare export function isSpreadElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSpreadElement)
-  declare export function assertSpreadElement(node: ?Object, opts?: ?Object): void
-  declare export function isSuper(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSuper)
-  declare export function assertSuper(node: ?Object, opts?: ?Object): void
-  declare export function isTaggedTemplateExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTaggedTemplateExpression)
-  declare export function assertTaggedTemplateExpression(node: ?Object, opts?: ?Object): void
-  declare export function isTemplateElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateElement)
-  declare export function assertTemplateElement(node: ?Object, opts?: ?Object): void
-  declare export function isTemplateLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTemplateLiteral)
-  declare export function assertTemplateLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isYieldExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeYieldExpression)
-  declare export function assertYieldExpression(node: ?Object, opts?: ?Object): void
-  declare export function isAwaitExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAwaitExpression)
-  declare export function assertAwaitExpression(node: ?Object, opts?: ?Object): void
-  declare export function isImport(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImport)
-  declare export function assertImport(node: ?Object, opts?: ?Object): void
-  declare export function isBigIntLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBigIntLiteral)
-  declare export function assertBigIntLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isExportNamespaceSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportNamespaceSpecifier)
-  declare export function assertExportNamespaceSpecifier(node: ?Object, opts?: ?Object): void
-  declare export function isOptionalMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalMemberExpression)
-  declare export function assertOptionalMemberExpression(node: ?Object, opts?: ?Object): void
-  declare export function isOptionalCallExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOptionalCallExpression)
-  declare export function assertOptionalCallExpression(node: ?Object, opts?: ?Object): void
-  declare export function isAnyTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeAnyTypeAnnotation)
-  declare export function assertAnyTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isArrayTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArrayTypeAnnotation)
-  declare export function assertArrayTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isBooleanTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanTypeAnnotation)
-  declare export function assertBooleanTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isBooleanLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBooleanLiteralTypeAnnotation)
-  declare export function assertBooleanLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isNullLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullLiteralTypeAnnotation)
-  declare export function assertNullLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isClassImplements(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassImplements)
-  declare export function assertClassImplements(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareClass(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareClass)
-  declare export function assertDeclareClass(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareFunction)
-  declare export function assertDeclareFunction(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareInterface(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareInterface)
-  declare export function assertDeclareInterface(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareModule(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModule)
-  declare export function assertDeclareModule(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareModuleExports(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareModuleExports)
-  declare export function assertDeclareModuleExports(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareTypeAlias(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareTypeAlias)
-  declare export function assertDeclareTypeAlias(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareOpaqueType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareOpaqueType)
-  declare export function assertDeclareOpaqueType(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareVariable(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareVariable)
-  declare export function assertDeclareVariable(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareExportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportDeclaration)
-  declare export function assertDeclareExportDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isDeclareExportAllDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclareExportAllDeclaration)
-  declare export function assertDeclareExportAllDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isDeclaredPredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDeclaredPredicate)
-  declare export function assertDeclaredPredicate(node: ?Object, opts?: ?Object): void
-  declare export function isExistsTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExistsTypeAnnotation)
-  declare export function assertExistsTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isFunctionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeAnnotation)
-  declare export function assertFunctionTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isFunctionTypeParam(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeFunctionTypeParam)
-  declare export function assertFunctionTypeParam(node: ?Object, opts?: ?Object): void
-  declare export function isGenericTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeGenericTypeAnnotation)
-  declare export function assertGenericTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isInferredPredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInferredPredicate)
-  declare export function assertInferredPredicate(node: ?Object, opts?: ?Object): void
-  declare export function isInterfaceExtends(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceExtends)
-  declare export function assertInterfaceExtends(node: ?Object, opts?: ?Object): void
-  declare export function isInterfaceDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceDeclaration)
-  declare export function assertInterfaceDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isInterfaceTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeInterfaceTypeAnnotation)
-  declare export function assertInterfaceTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isIntersectionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeIntersectionTypeAnnotation)
-  declare export function assertIntersectionTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isMixedTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeMixedTypeAnnotation)
-  declare export function assertMixedTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isEmptyTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEmptyTypeAnnotation)
-  declare export function assertEmptyTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isNullableTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNullableTypeAnnotation)
-  declare export function assertNullableTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isNumberLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberLiteralTypeAnnotation)
-  declare export function assertNumberLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isNumberTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumberTypeAnnotation)
-  declare export function assertNumberTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isObjectTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeAnnotation)
-  declare export function assertObjectTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isObjectTypeInternalSlot(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeInternalSlot)
-  declare export function assertObjectTypeInternalSlot(node: ?Object, opts?: ?Object): void
-  declare export function isObjectTypeCallProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeCallProperty)
-  declare export function assertObjectTypeCallProperty(node: ?Object, opts?: ?Object): void
-  declare export function isObjectTypeIndexer(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeIndexer)
-  declare export function assertObjectTypeIndexer(node: ?Object, opts?: ?Object): void
-  declare export function isObjectTypeProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeProperty)
-  declare export function assertObjectTypeProperty(node: ?Object, opts?: ?Object): void
-  declare export function isObjectTypeSpreadProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeObjectTypeSpreadProperty)
-  declare export function assertObjectTypeSpreadProperty(node: ?Object, opts?: ?Object): void
-  declare export function isOpaqueType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeOpaqueType)
-  declare export function assertOpaqueType(node: ?Object, opts?: ?Object): void
-  declare export function isQualifiedTypeIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeQualifiedTypeIdentifier)
-  declare export function assertQualifiedTypeIdentifier(node: ?Object, opts?: ?Object): void
-  declare export function isStringLiteralTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringLiteralTypeAnnotation)
-  declare export function assertStringLiteralTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isStringTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStringTypeAnnotation)
-  declare export function assertStringTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isSymbolTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSymbolTypeAnnotation)
-  declare export function assertSymbolTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isThisTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeThisTypeAnnotation)
-  declare export function assertThisTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isTupleTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTupleTypeAnnotation)
-  declare export function assertTupleTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isTypeofTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeofTypeAnnotation)
-  declare export function assertTypeofTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isTypeAlias(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAlias)
-  declare export function assertTypeAlias(node: ?Object, opts?: ?Object): void
-  declare export function isTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeAnnotation)
-  declare export function assertTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isTypeCastExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeCastExpression)
-  declare export function assertTypeCastExpression(node: ?Object, opts?: ?Object): void
-  declare export function isTypeParameter(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameter)
-  declare export function assertTypeParameter(node: ?Object, opts?: ?Object): void
-  declare export function isTypeParameterDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterDeclaration)
-  declare export function assertTypeParameterDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTypeParameterInstantiation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTypeParameterInstantiation)
-  declare export function assertTypeParameterInstantiation(node: ?Object, opts?: ?Object): void
-  declare export function isUnionTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeUnionTypeAnnotation)
-  declare export function assertUnionTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isVariance(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVariance)
-  declare export function assertVariance(node: ?Object, opts?: ?Object): void
-  declare export function isVoidTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeVoidTypeAnnotation)
-  declare export function assertVoidTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isEnumDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumDeclaration)
-  declare export function assertEnumDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isEnumBooleanBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumBooleanBody)
-  declare export function assertEnumBooleanBody(node: ?Object, opts?: ?Object): void
-  declare export function isEnumNumberBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumNumberBody)
-  declare export function assertEnumNumberBody(node: ?Object, opts?: ?Object): void
-  declare export function isEnumStringBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumStringBody)
-  declare export function assertEnumStringBody(node: ?Object, opts?: ?Object): void
-  declare export function isEnumSymbolBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumSymbolBody)
-  declare export function assertEnumSymbolBody(node: ?Object, opts?: ?Object): void
-  declare export function isEnumBooleanMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumBooleanMember)
-  declare export function assertEnumBooleanMember(node: ?Object, opts?: ?Object): void
-  declare export function isEnumNumberMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumNumberMember)
-  declare export function assertEnumNumberMember(node: ?Object, opts?: ?Object): void
-  declare export function isEnumStringMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumStringMember)
-  declare export function assertEnumStringMember(node: ?Object, opts?: ?Object): void
-  declare export function isEnumDefaultedMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeEnumDefaultedMember)
-  declare export function assertEnumDefaultedMember(node: ?Object, opts?: ?Object): void
-  declare export function isJSXAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXAttribute)
-  declare export function assertJSXAttribute(node: ?Object, opts?: ?Object): void
-  declare export function isJSXClosingElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingElement)
-  declare export function assertJSXClosingElement(node: ?Object, opts?: ?Object): void
-  declare export function isJSXElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXElement)
-  declare export function assertJSXElement(node: ?Object, opts?: ?Object): void
-  declare export function isJSXEmptyExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXEmptyExpression)
-  declare export function assertJSXEmptyExpression(node: ?Object, opts?: ?Object): void
-  declare export function isJSXExpressionContainer(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXExpressionContainer)
-  declare export function assertJSXExpressionContainer(node: ?Object, opts?: ?Object): void
-  declare export function isJSXSpreadChild(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadChild)
-  declare export function assertJSXSpreadChild(node: ?Object, opts?: ?Object): void
-  declare export function isJSXIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXIdentifier)
-  declare export function assertJSXIdentifier(node: ?Object, opts?: ?Object): void
-  declare export function isJSXMemberExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXMemberExpression)
-  declare export function assertJSXMemberExpression(node: ?Object, opts?: ?Object): void
-  declare export function isJSXNamespacedName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXNamespacedName)
-  declare export function assertJSXNamespacedName(node: ?Object, opts?: ?Object): void
-  declare export function isJSXOpeningElement(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningElement)
-  declare export function assertJSXOpeningElement(node: ?Object, opts?: ?Object): void
-  declare export function isJSXSpreadAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXSpreadAttribute)
-  declare export function assertJSXSpreadAttribute(node: ?Object, opts?: ?Object): void
-  declare export function isJSXText(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXText)
-  declare export function assertJSXText(node: ?Object, opts?: ?Object): void
-  declare export function isJSXFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXFragment)
-  declare export function assertJSXFragment(node: ?Object, opts?: ?Object): void
-  declare export function isJSXOpeningFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXOpeningFragment)
-  declare export function assertJSXOpeningFragment(node: ?Object, opts?: ?Object): void
-  declare export function isJSXClosingFragment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeJSXClosingFragment)
-  declare export function assertJSXClosingFragment(node: ?Object, opts?: ?Object): void
-  declare export function isNoop(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNoop)
-  declare export function assertNoop(node: ?Object, opts?: ?Object): void
-  declare export function isPlaceholder(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePlaceholder)
-  declare export function assertPlaceholder(node: ?Object, opts?: ?Object): void
-  declare export function isV8IntrinsicIdentifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeV8IntrinsicIdentifier)
-  declare export function assertV8IntrinsicIdentifier(node: ?Object, opts?: ?Object): void
-  declare export function isArgumentPlaceholder(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeArgumentPlaceholder)
-  declare export function assertArgumentPlaceholder(node: ?Object, opts?: ?Object): void
-  declare export function isBindExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeBindExpression)
-  declare export function assertBindExpression(node: ?Object, opts?: ?Object): void
-  declare export function isClassProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassProperty)
-  declare export function assertClassProperty(node: ?Object, opts?: ?Object): void
-  declare export function isPipelineTopicExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelineTopicExpression)
-  declare export function assertPipelineTopicExpression(node: ?Object, opts?: ?Object): void
-  declare export function isPipelineBareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelineBareFunction)
-  declare export function assertPipelineBareFunction(node: ?Object, opts?: ?Object): void
-  declare export function isPipelinePrimaryTopicReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePipelinePrimaryTopicReference)
-  declare export function assertPipelinePrimaryTopicReference(node: ?Object, opts?: ?Object): void
-  declare export function isClassPrivateProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassPrivateProperty)
-  declare export function assertClassPrivateProperty(node: ?Object, opts?: ?Object): void
-  declare export function isClassPrivateMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeClassPrivateMethod)
-  declare export function assertClassPrivateMethod(node: ?Object, opts?: ?Object): void
-  declare export function isImportAttribute(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeImportAttribute)
-  declare export function assertImportAttribute(node: ?Object, opts?: ?Object): void
-  declare export function isDecorator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDecorator)
-  declare export function assertDecorator(node: ?Object, opts?: ?Object): void
-  declare export function isDoExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDoExpression)
-  declare export function assertDoExpression(node: ?Object, opts?: ?Object): void
-  declare export function isExportDefaultSpecifier(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeExportDefaultSpecifier)
-  declare export function assertExportDefaultSpecifier(node: ?Object, opts?: ?Object): void
-  declare export function isPrivateName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodePrivateName)
-  declare export function assertPrivateName(node: ?Object, opts?: ?Object): void
-  declare export function isRecordExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRecordExpression)
-  declare export function assertRecordExpression(node: ?Object, opts?: ?Object): void
-  declare export function isTupleExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTupleExpression)
-  declare export function assertTupleExpression(node: ?Object, opts?: ?Object): void
-  declare export function isDecimalLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeDecimalLiteral)
-  declare export function assertDecimalLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isStaticBlock(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeStaticBlock)
-  declare export function assertStaticBlock(node: ?Object, opts?: ?Object): void
-  declare export function isTSParameterProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParameterProperty)
-  declare export function assertTSParameterProperty(node: ?Object, opts?: ?Object): void
-  declare export function isTSDeclareFunction(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareFunction)
-  declare export function assertTSDeclareFunction(node: ?Object, opts?: ?Object): void
-  declare export function isTSDeclareMethod(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSDeclareMethod)
-  declare export function assertTSDeclareMethod(node: ?Object, opts?: ?Object): void
-  declare export function isTSQualifiedName(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSQualifiedName)
-  declare export function assertTSQualifiedName(node: ?Object, opts?: ?Object): void
-  declare export function isTSCallSignatureDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSCallSignatureDeclaration)
-  declare export function assertTSCallSignatureDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSConstructSignatureDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructSignatureDeclaration)
-  declare export function assertTSConstructSignatureDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSPropertySignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSPropertySignature)
-  declare export function assertTSPropertySignature(node: ?Object, opts?: ?Object): void
-  declare export function isTSMethodSignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMethodSignature)
-  declare export function assertTSMethodSignature(node: ?Object, opts?: ?Object): void
-  declare export function isTSIndexSignature(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexSignature)
-  declare export function assertTSIndexSignature(node: ?Object, opts?: ?Object): void
-  declare export function isTSAnyKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAnyKeyword)
-  declare export function assertTSAnyKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSBooleanKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSBooleanKeyword)
-  declare export function assertTSBooleanKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSBigIntKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSBigIntKeyword)
-  declare export function assertTSBigIntKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSIntrinsicKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIntrinsicKeyword)
-  declare export function assertTSIntrinsicKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSNeverKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNeverKeyword)
-  declare export function assertTSNeverKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSNullKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNullKeyword)
-  declare export function assertTSNullKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSNumberKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNumberKeyword)
-  declare export function assertTSNumberKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSObjectKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSObjectKeyword)
-  declare export function assertTSObjectKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSStringKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSStringKeyword)
-  declare export function assertTSStringKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSSymbolKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSSymbolKeyword)
-  declare export function assertTSSymbolKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSUndefinedKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUndefinedKeyword)
-  declare export function assertTSUndefinedKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSUnknownKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUnknownKeyword)
-  declare export function assertTSUnknownKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSVoidKeyword(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSVoidKeyword)
-  declare export function assertTSVoidKeyword(node: ?Object, opts?: ?Object): void
-  declare export function isTSThisType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSThisType)
-  declare export function assertTSThisType(node: ?Object, opts?: ?Object): void
-  declare export function isTSFunctionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSFunctionType)
-  declare export function assertTSFunctionType(node: ?Object, opts?: ?Object): void
-  declare export function isTSConstructorType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConstructorType)
-  declare export function assertTSConstructorType(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeReference)
-  declare export function assertTSTypeReference(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypePredicate(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypePredicate)
-  declare export function assertTSTypePredicate(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeQuery(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeQuery)
-  declare export function assertTSTypeQuery(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeLiteral)
-  declare export function assertTSTypeLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isTSArrayType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSArrayType)
-  declare export function assertTSArrayType(node: ?Object, opts?: ?Object): void
-  declare export function isTSTupleType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTupleType)
-  declare export function assertTSTupleType(node: ?Object, opts?: ?Object): void
-  declare export function isTSOptionalType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSOptionalType)
-  declare export function assertTSOptionalType(node: ?Object, opts?: ?Object): void
-  declare export function isTSRestType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSRestType)
-  declare export function assertTSRestType(node: ?Object, opts?: ?Object): void
-  declare export function isTSNamedTupleMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNamedTupleMember)
-  declare export function assertTSNamedTupleMember(node: ?Object, opts?: ?Object): void
-  declare export function isTSUnionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSUnionType)
-  declare export function assertTSUnionType(node: ?Object, opts?: ?Object): void
-  declare export function isTSIntersectionType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIntersectionType)
-  declare export function assertTSIntersectionType(node: ?Object, opts?: ?Object): void
-  declare export function isTSConditionalType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSConditionalType)
-  declare export function assertTSConditionalType(node: ?Object, opts?: ?Object): void
-  declare export function isTSInferType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInferType)
-  declare export function assertTSInferType(node: ?Object, opts?: ?Object): void
-  declare export function isTSParenthesizedType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSParenthesizedType)
-  declare export function assertTSParenthesizedType(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeOperator(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeOperator)
-  declare export function assertTSTypeOperator(node: ?Object, opts?: ?Object): void
-  declare export function isTSIndexedAccessType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSIndexedAccessType)
-  declare export function assertTSIndexedAccessType(node: ?Object, opts?: ?Object): void
-  declare export function isTSMappedType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSMappedType)
-  declare export function assertTSMappedType(node: ?Object, opts?: ?Object): void
-  declare export function isTSLiteralType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSLiteralType)
-  declare export function assertTSLiteralType(node: ?Object, opts?: ?Object): void
-  declare export function isTSExpressionWithTypeArguments(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExpressionWithTypeArguments)
-  declare export function assertTSExpressionWithTypeArguments(node: ?Object, opts?: ?Object): void
-  declare export function isTSInterfaceDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceDeclaration)
-  declare export function assertTSInterfaceDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSInterfaceBody(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSInterfaceBody)
-  declare export function assertTSInterfaceBody(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeAliasDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAliasDeclaration)
-  declare export function assertTSTypeAliasDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSAsExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSAsExpression)
-  declare export function assertTSAsExpression(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeAssertion(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAssertion)
-  declare export function assertTSTypeAssertion(node: ?Object, opts?: ?Object): void
-  declare export function isTSEnumDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumDeclaration)
-  declare export function assertTSEnumDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSEnumMember(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSEnumMember)
-  declare export function assertTSEnumMember(node: ?Object, opts?: ?Object): void
-  declare export function isTSModuleDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleDeclaration)
-  declare export function assertTSModuleDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSModuleBlock(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSModuleBlock)
-  declare export function assertTSModuleBlock(node: ?Object, opts?: ?Object): void
-  declare export function isTSImportType(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSImportType)
-  declare export function assertTSImportType(node: ?Object, opts?: ?Object): void
-  declare export function isTSImportEqualsDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSImportEqualsDeclaration)
-  declare export function assertTSImportEqualsDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSExternalModuleReference(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExternalModuleReference)
-  declare export function assertTSExternalModuleReference(node: ?Object, opts?: ?Object): void
-  declare export function isTSNonNullExpression(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNonNullExpression)
-  declare export function assertTSNonNullExpression(node: ?Object, opts?: ?Object): void
-  declare export function isTSExportAssignment(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSExportAssignment)
-  declare export function assertTSExportAssignment(node: ?Object, opts?: ?Object): void
-  declare export function isTSNamespaceExportDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSNamespaceExportDeclaration)
-  declare export function assertTSNamespaceExportDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeAnnotation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeAnnotation)
-  declare export function assertTSTypeAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeParameterInstantiation(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterInstantiation)
-  declare export function assertTSTypeParameterInstantiation(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeParameterDeclaration(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameterDeclaration)
-  declare export function assertTSTypeParameterDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeParameter(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeTSTypeParameter)
-  declare export function assertTSTypeParameter(node: ?Object, opts?: ?Object): void
-  declare export function isExpression(node: ?Object, opts?: ?Object): boolean
-  declare export function assertExpression(node: ?Object, opts?: ?Object): void
-  declare export function isBinary(node: ?Object, opts?: ?Object): boolean
-  declare export function assertBinary(node: ?Object, opts?: ?Object): void
-  declare export function isScopable(node: ?Object, opts?: ?Object): boolean
-  declare export function assertScopable(node: ?Object, opts?: ?Object): void
-  declare export function isBlockParent(node: ?Object, opts?: ?Object): boolean
-  declare export function assertBlockParent(node: ?Object, opts?: ?Object): void
-  declare export function isBlock(node: ?Object, opts?: ?Object): boolean
-  declare export function assertBlock(node: ?Object, opts?: ?Object): void
-  declare export function isStatement(node: ?Object, opts?: ?Object): boolean
-  declare export function assertStatement(node: ?Object, opts?: ?Object): void
-  declare export function isTerminatorless(node: ?Object, opts?: ?Object): boolean
-  declare export function assertTerminatorless(node: ?Object, opts?: ?Object): void
-  declare export function isCompletionStatement(node: ?Object, opts?: ?Object): boolean
-  declare export function assertCompletionStatement(node: ?Object, opts?: ?Object): void
-  declare export function isConditional(node: ?Object, opts?: ?Object): boolean
-  declare export function assertConditional(node: ?Object, opts?: ?Object): void
-  declare export function isLoop(node: ?Object, opts?: ?Object): boolean
-  declare export function assertLoop(node: ?Object, opts?: ?Object): void
-  declare export function isWhile(node: ?Object, opts?: ?Object): boolean
-  declare export function assertWhile(node: ?Object, opts?: ?Object): void
-  declare export function isExpressionWrapper(node: ?Object, opts?: ?Object): boolean
-  declare export function assertExpressionWrapper(node: ?Object, opts?: ?Object): void
-  declare export function isFor(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFor(node: ?Object, opts?: ?Object): void
-  declare export function isForXStatement(node: ?Object, opts?: ?Object): boolean
-  declare export function assertForXStatement(node: ?Object, opts?: ?Object): void
-  declare export function isFunction(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFunction(node: ?Object, opts?: ?Object): void
-  declare export function isFunctionParent(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFunctionParent(node: ?Object, opts?: ?Object): void
-  declare export function isPureish(node: ?Object, opts?: ?Object): boolean
-  declare export function assertPureish(node: ?Object, opts?: ?Object): void
-  declare export function isDeclaration(node: ?Object, opts?: ?Object): boolean
-  declare export function assertDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isPatternLike(node: ?Object, opts?: ?Object): boolean
-  declare export function assertPatternLike(node: ?Object, opts?: ?Object): void
-  declare export function isLVal(node: ?Object, opts?: ?Object): boolean
-  declare export function assertLVal(node: ?Object, opts?: ?Object): void
-  declare export function isTSEntityName(node: ?Object, opts?: ?Object): boolean
-  declare export function assertTSEntityName(node: ?Object, opts?: ?Object): void
-  declare export function isLiteral(node: ?Object, opts?: ?Object): boolean
-  declare export function assertLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isImmutable(node: ?Object, opts?: ?Object): boolean
-  declare export function assertImmutable(node: ?Object, opts?: ?Object): void
-  declare export function isUserWhitespacable(node: ?Object, opts?: ?Object): boolean
-  declare export function assertUserWhitespacable(node: ?Object, opts?: ?Object): void
-  declare export function isMethod(node: ?Object, opts?: ?Object): boolean
-  declare export function assertMethod(node: ?Object, opts?: ?Object): void
-  declare export function isObjectMember(node: ?Object, opts?: ?Object): boolean
-  declare export function assertObjectMember(node: ?Object, opts?: ?Object): void
-  declare export function isProperty(node: ?Object, opts?: ?Object): boolean
-  declare export function assertProperty(node: ?Object, opts?: ?Object): void
-  declare export function isUnaryLike(node: ?Object, opts?: ?Object): boolean
-  declare export function assertUnaryLike(node: ?Object, opts?: ?Object): void
-  declare export function isPattern(node: ?Object, opts?: ?Object): boolean
-  declare export function assertPattern(node: ?Object, opts?: ?Object): void
-  declare export function isClass(node: ?Object, opts?: ?Object): boolean
-  declare export function assertClass(node: ?Object, opts?: ?Object): void
-  declare export function isModuleDeclaration(node: ?Object, opts?: ?Object): boolean
-  declare export function assertModuleDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isExportDeclaration(node: ?Object, opts?: ?Object): boolean
-  declare export function assertExportDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isModuleSpecifier(node: ?Object, opts?: ?Object): boolean
-  declare export function assertModuleSpecifier(node: ?Object, opts?: ?Object): void
-  declare export function isFlow(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFlow(node: ?Object, opts?: ?Object): void
-  declare export function isFlowType(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFlowType(node: ?Object, opts?: ?Object): void
-  declare export function isFlowBaseAnnotation(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFlowBaseAnnotation(node: ?Object, opts?: ?Object): void
-  declare export function isFlowDeclaration(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFlowDeclaration(node: ?Object, opts?: ?Object): void
-  declare export function isFlowPredicate(node: ?Object, opts?: ?Object): boolean
-  declare export function assertFlowPredicate(node: ?Object, opts?: ?Object): void
-  declare export function isEnumBody(node: ?Object, opts?: ?Object): boolean
-  declare export function assertEnumBody(node: ?Object, opts?: ?Object): void
-  declare export function isEnumMember(node: ?Object, opts?: ?Object): boolean
-  declare export function assertEnumMember(node: ?Object, opts?: ?Object): void
-  declare export function isJSX(node: ?Object, opts?: ?Object): boolean
-  declare export function assertJSX(node: ?Object, opts?: ?Object): void
-  declare export function isPrivate(node: ?Object, opts?: ?Object): boolean
-  declare export function assertPrivate(node: ?Object, opts?: ?Object): void
-  declare export function isTSTypeElement(node: ?Object, opts?: ?Object): boolean
-  declare export function assertTSTypeElement(node: ?Object, opts?: ?Object): void
-  declare export function isTSType(node: ?Object, opts?: ?Object): boolean
-  declare export function assertTSType(node: ?Object, opts?: ?Object): void
-  declare export function isTSBaseType(node: ?Object, opts?: ?Object): boolean
-  declare export function assertTSBaseType(node: ?Object, opts?: ?Object): void
-  declare export function isNumberLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeNumericLiteral)
-  declare export function assertNumberLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isRegexLiteral(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRegExpLiteral)
-  declare export function assertRegexLiteral(node: ?Object, opts?: ?Object): void
-  declare export function isRestProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeRestElement)
-  declare export function assertRestProperty(node: ?Object, opts?: ?Object): void
-  declare export function isSpreadProperty(node: ?Object, opts?: ?Object): boolean %checks (node instanceof BabelNodeSpreadElement)
-  declare export function assertSpreadProperty(node: ?Object, opts?: ?Object): void
-  declare export var VISITOR_KEYS: { [type: string]: string[] }
-  declare export function assertNode(obj: any): void
-  declare export function createTypeAnnotationBasedOnTypeof(type: 'string' | 'number' | 'undefined' | 'boolean' | 'function' | 'object' | 'symbol'): BabelNodeTypeAnnotation
-  declare export function createUnionTypeAnnotation(types: Array<BabelNodeFlowType>): BabelNodeUnionTypeAnnotation
-  declare export function createFlowUnionType(types: Array<BabelNodeFlowType>): BabelNodeUnionTypeAnnotation
-  declare export function buildChildren(node: { children: Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment | BabelNodeJSXEmptyExpression> }): Array<BabelNodeJSXText | BabelNodeJSXExpressionContainer | BabelNodeJSXSpreadChild | BabelNodeJSXElement | BabelNodeJSXFragment>
-  declare export function clone<T>(n: T): T;
-  declare export function cloneDeep<T>(n: T): T;
-  declare export function cloneDeepWithoutLoc<T>(n: T): T;
-  declare export function cloneNode<T>(n: T, deep?: boolean, withoutLoc?: boolean): T;
-  declare export function cloneWithoutLoc<T>(n: T): T;
-  declare type CommentTypeShorthand = 'leading' | 'inner' | 'trailing'
-  declare export function addComment<T: BabelNode>(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T
-  declare export function addComments<T: BabelNode>(node: T, type: CommentTypeShorthand, comments: Array<Comment>): T
-  declare export function inheritInnerComments(node: BabelNode, parent: BabelNode): void
-  declare export function inheritLeadingComments(node: BabelNode, parent: BabelNode): void
-  declare export function inheritsComments<T: BabelNode>(node: T, parent: BabelNode): void
-  declare export function inheritTrailingComments(node: BabelNode, parent: BabelNode): void
-  declare export function removeComments<T: BabelNode>(node: T): T
-  declare export function ensureBlock(node: BabelNode, key: string): BabelNodeBlockStatement
-  declare export function toBindingIdentifierName(name?: ?string): string
-  declare export function toBlock(node: BabelNodeStatement | BabelNodeExpression, parent?: BabelNodeFunction | null): BabelNodeBlockStatement
-  declare export function toComputedKey(node: BabelNodeMethod | BabelNodeProperty, key?: BabelNodeExpression | BabelNodeIdentifier): BabelNodeExpression
-  declare export function toExpression(node: BabelNodeExpressionStatement | BabelNodeExpression | BabelNodeClass | BabelNodeFunction): BabelNodeExpression
-  declare export function toIdentifier(name?: ?string): string
-  declare export function toKeyAlias(node: BabelNodeMethod | BabelNodeProperty, key?: BabelNode): string
-  declare export function toStatement(node: BabelNodeStatement | BabelNodeClass | BabelNodeFunction | BabelNodeAssignmentExpression, ignore?: boolean): BabelNodeStatement | void
-  declare export function valueToNode(value: any): BabelNodeExpression
-  declare export function removeTypeDuplicates(types: Array<BabelNodeFlowType>): Array<BabelNodeFlowType>
-  declare export function appendToMemberExpression(member: BabelNodeMemberExpression, append: BabelNode, computed?: boolean): BabelNodeMemberExpression
-  declare export function inherits<T: BabelNode>(child: T, parent: BabelNode | null | void): T
-  declare export function prependToMemberExpression(member: BabelNodeMemberExpression, prepend: BabelNodeExpression): BabelNodeMemberExpression
-  declare export function removeProperties<T>(n: T, opts: ?{}): void;
-  declare export function removePropertiesDeep<T>(n: T, opts: ?{}): T;
-  declare export var getBindingIdentifiers: {
-      (node: BabelNode, duplicates?: boolean, outerOnly?: boolean): { [key: string]: BabelNodeIdentifier | Array<BabelNodeIdentifier> },
-      keys: { [type: string]: string[] }
-    }
-  declare export function getOuterBindingIdentifiers(node: BabelNode, duplicates?: boolean): { [key: string]: BabelNodeIdentifier | Array<BabelNodeIdentifier> }
-  declare type TraversalAncestors = Array<{
-    node: BabelNode,
-    key: string,
-    index?: number,
-  }>;
-  declare type TraversalHandler<T> = (BabelNode, TraversalAncestors, T) => void;
-  declare type TraversalHandlers<T> = {
-    enter?: TraversalHandler<T>,
-    exit?: TraversalHandler<T>,
-  };
-  declare export function traverse<T>(n: BabelNode, TraversalHandler<T> | TraversalHandlers<T>, state?: T): void;
-  declare export function traverseFast<T>(n: BabelNode, h: TraversalHandler<T>, state?: T): void;
-  declare export function shallowEqual(actual: Object, expected: Object): boolean
-  declare export function buildMatchMemberExpression(match: string, allowPartial?: boolean): (?BabelNode) => boolean
-  declare export function is(type: string, n: BabelNode, opts: Object): boolean;
-  declare export function isBinding(node: BabelNode, parent: BabelNode, grandparent?: BabelNode): boolean
-  declare export function isBlockScoped(node: BabelNode): boolean
-  declare export function isImmutable(node: BabelNode): boolean
-  declare export function isLet(node: BabelNode): boolean
-  declare export function isNode(node: ?Object): boolean
-  declare export function isNodesEquivalent(a: any, b: any): boolean
-  declare export function isPlaceholderType(placeholderType: string, targetType: string): boolean
-  declare export function isReferenced(node: BabelNode, parent: BabelNode, grandparent?: BabelNode): boolean
-  declare export function isScope(node: BabelNode, parent: BabelNode): boolean
-  declare export function isSpecifierDefault(specifier: BabelNodeModuleSpecifier): boolean
-  declare export function isType(nodetype: ?string, targetType: string): boolean
-  declare export function isValidES3Identifier(name: string): boolean
-  declare export function isValidES3Identifier(name: string): boolean
-  declare export function isValidIdentifier(name: string): boolean
-  declare export function isVar(node: BabelNode): boolean
-  declare export function matchesPattern(node: ?BabelNode, match: string | Array<string>, allowPartial?: boolean): boolean
-  declare export function validate(n: BabelNode, key: string, value: mixed): void;
-}

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

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

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

@@ -1,78 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removeTypeDuplicates;
-
-var _generated = require("../../validators/generated");
-
-function getQualifiedName(node) {
-  return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
-}
-
-function removeTypeDuplicates(nodes) {
-  const generics = {};
-  const bases = {};
-  const typeGroups = [];
-  const types = [];
-
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    if (!node) continue;
-
-    if (types.indexOf(node) >= 0) {
-      continue;
-    }
-
-    if ((0, _generated.isAnyTypeAnnotation)(node)) {
-      return [node];
-    }
-
-    if ((0, _generated.isFlowBaseAnnotation)(node)) {
-      bases[node.type] = node;
-      continue;
-    }
-
-    if ((0, _generated.isUnionTypeAnnotation)(node)) {
-      if (typeGroups.indexOf(node.types) < 0) {
-        nodes = nodes.concat(node.types);
-        typeGroups.push(node.types);
-      }
-
-      continue;
-    }
-
-    if ((0, _generated.isGenericTypeAnnotation)(node)) {
-      const name = getQualifiedName(node.id);
-
-      if (generics[name]) {
-        let existing = generics[name];
-
-        if (existing.typeParameters) {
-          if (node.typeParameters) {
-            existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
-          }
-        } else {
-          existing = node.typeParameters;
-        }
-      } else {
-        generics[name] = node;
-      }
-
-      continue;
-    }
-
-    types.push(node);
-  }
-
-  for (const type of Object.keys(bases)) {
-    types.push(bases[type]);
-  }
-
-  for (const name of Object.keys(generics)) {
-    types.push(generics[name]);
-  }
-
-  return types;
-}

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

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

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

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = prependToMemberExpression;
-
-var _generated = require("../builders/generated");
-
-function prependToMemberExpression(member, prepend) {
-  member.object = (0, _generated.memberExpression)(prepend, member.object);
-  return member;
-}

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

@@ -1,30 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removeProperties;
-
-var _constants = require("../constants");
-
-const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
-
-const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
-
-function removeProperties(node, opts = {}) {
-  const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
-
-  for (const key of map) {
-    if (node[key] != null) node[key] = undefined;
-  }
-
-  for (const key of Object.keys(node)) {
-    if (key[0] === "_" && node[key] != null) node[key] = undefined;
-  }
-
-  const symbols = Object.getOwnPropertySymbols(node);
-
-  for (const sym of symbols) {
-    node[sym] = null;
-  }
-}

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

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removePropertiesDeep;
-
-var _traverseFast = _interopRequireDefault(require("../traverse/traverseFast"));
-
-var _removeProperties = _interopRequireDefault(require("./removeProperties"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function removePropertiesDeep(tree, opts) {
-  (0, _traverseFast.default)(tree, _removeProperties.default, opts);
-  return tree;
-}

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

@@ -1,54 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removeTypeDuplicates;
-
-var _generated = require("../../validators/generated");
-
-function removeTypeDuplicates(nodes) {
-  const generics = {};
-  const bases = {};
-  const typeGroups = [];
-  const types = [];
-
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    if (!node) continue;
-
-    if (types.indexOf(node) >= 0) {
-      continue;
-    }
-
-    if ((0, _generated.isTSAnyKeyword)(node)) {
-      return [node];
-    }
-
-    if ((0, _generated.isTSBaseType)(node)) {
-      bases[node.type] = node;
-      continue;
-    }
-
-    if ((0, _generated.isTSUnionType)(node)) {
-      if (typeGroups.indexOf(node.types) < 0) {
-        nodes = nodes.concat(node.types);
-        typeGroups.push(node.types);
-      }
-
-      continue;
-    }
-
-    types.push(node);
-  }
-
-  for (const type of Object.keys(bases)) {
-    types.push(bases[type]);
-  }
-
-  for (const name of Object.keys(generics)) {
-    types.push(generics[name]);
-  }
-
-  return types;
-}

node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js

@@ -1,103 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getBindingIdentifiers;
-
-var _generated = require("../validators/generated");
-
-function getBindingIdentifiers(node, duplicates, outerOnly) {
-  let search = [].concat(node);
-  const ids = Object.create(null);
-
-  while (search.length) {
-    const id = search.shift();
-    if (!id) continue;
-    const keys = getBindingIdentifiers.keys[id.type];
-
-    if ((0, _generated.isIdentifier)(id)) {
-      if (duplicates) {
-        const _ids = ids[id.name] = ids[id.name] || [];
-
-        _ids.push(id);
-      } else {
-        ids[id.name] = id;
-      }
-
-      continue;
-    }
-
-    if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) {
-      if ((0, _generated.isDeclaration)(id.declaration)) {
-        search.push(id.declaration);
-      }
-
-      continue;
-    }
-
-    if (outerOnly) {
-      if ((0, _generated.isFunctionDeclaration)(id)) {
-        search.push(id.id);
-        continue;
-      }
-
-      if ((0, _generated.isFunctionExpression)(id)) {
-        continue;
-      }
-    }
-
-    if (keys) {
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-
-        if (id[key]) {
-          search = search.concat(id[key]);
-        }
-      }
-    }
-  }
-
-  return ids;
-}
-
-getBindingIdentifiers.keys = {
-  DeclareClass: ["id"],
-  DeclareFunction: ["id"],
-  DeclareModule: ["id"],
-  DeclareVariable: ["id"],
-  DeclareInterface: ["id"],
-  DeclareTypeAlias: ["id"],
-  DeclareOpaqueType: ["id"],
-  InterfaceDeclaration: ["id"],
-  TypeAlias: ["id"],
-  OpaqueType: ["id"],
-  CatchClause: ["param"],
-  LabeledStatement: ["label"],
-  UnaryExpression: ["argument"],
-  AssignmentExpression: ["left"],
-  ImportSpecifier: ["local"],
-  ImportNamespaceSpecifier: ["local"],
-  ImportDefaultSpecifier: ["local"],
-  ImportDeclaration: ["specifiers"],
-  ExportSpecifier: ["exported"],
-  ExportNamespaceSpecifier: ["exported"],
-  ExportDefaultSpecifier: ["exported"],
-  FunctionDeclaration: ["id", "params"],
-  FunctionExpression: ["id", "params"],
-  ArrowFunctionExpression: ["params"],
-  ObjectMethod: ["params"],
-  ClassMethod: ["params"],
-  ForInStatement: ["left"],
-  ForOfStatement: ["left"],
-  ClassDeclaration: ["id"],
-  ClassExpression: ["id"],
-  RestElement: ["argument"],
-  UpdateExpression: ["argument"],
-  ObjectProperty: ["value"],
-  AssignmentPattern: ["left"],
-  ArrayPattern: ["elements"],
-  ObjectPattern: ["properties"],
-  VariableDeclaration: ["declarations"],
-  VariableDeclarator: ["id"]
-};

node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _getBindingIdentifiers = _interopRequireDefault(require("./getBindingIdentifiers"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var _default = getOuterBindingIdentifiers;
-exports.default = _default;
-
-function getOuterBindingIdentifiers(node, duplicates) {
-  return (0, _getBindingIdentifiers.default)(node, duplicates, true);
-}

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

@@ -1,55 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = traverse;
-
-var _definitions = require("../definitions");
-
-function traverse(node, handlers, state) {
-  if (typeof handlers === "function") {
-    handlers = {
-      enter: handlers
-    };
-  }
-
-  const {
-    enter,
-    exit
-  } = handlers;
-  traverseSimpleImpl(node, enter, exit, state, []);
-}
-
-function traverseSimpleImpl(node, enter, exit, state, ancestors) {
-  const keys = _definitions.VISITOR_KEYS[node.type];
-  if (!keys) return;
-  if (enter) enter(node, ancestors, state);
-
-  for (const key of keys) {
-    const subNode = node[key];
-
-    if (Array.isArray(subNode)) {
-      for (let i = 0; i < subNode.length; i++) {
-        const child = subNode[i];
-        if (!child) continue;
-        ancestors.push({
-          node,
-          key,
-          index: i
-        });
-        traverseSimpleImpl(child, enter, exit, state, ancestors);
-        ancestors.pop();
-      }
-    } else if (subNode) {
-      ancestors.push({
-        node,
-        key
-      });
-      traverseSimpleImpl(subNode, enter, exit, state, ancestors);
-      ancestors.pop();
-    }
-  }
-
-  if (exit) exit(node, ancestors, state);
-}

node_modules/@babel/types/lib/traverse/traverseFast.js

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = traverseFast;
-
-var _definitions = require("../definitions");
-
-function traverseFast(node, enter, opts) {
-  if (!node) return;
-  const keys = _definitions.VISITOR_KEYS[node.type];
-  if (!keys) return;
-  opts = opts || {};
-  enter(node, opts);
-
-  for (const key of keys) {
-    const subNode = node[key];
-
-    if (Array.isArray(subNode)) {
-      for (const node of subNode) {
-        traverseFast(node, enter, opts);
-      }
-    } else {
-      traverseFast(subNode, enter, opts);
-    }
-  }
-}

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

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inherit;
-
-function inherit(key, child, parent) {
-  if (child && parent) {
-    child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));
-  }
-}

node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js

@@ -1,47 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = cleanJSXElementLiteralChild;
-
-var _generated = require("../../builders/generated");
-
-function cleanJSXElementLiteralChild(child, args) {
-  const lines = child.value.split(/\r\n|\n|\r/);
-  let lastNonEmptyLine = 0;
-
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].match(/[^ \t]/)) {
-      lastNonEmptyLine = i;
-    }
-  }
-
-  let str = "";
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isFirstLine = i === 0;
-    const isLastLine = i === lines.length - 1;
-    const isLastNonEmptyLine = i === lastNonEmptyLine;
-    let trimmedLine = line.replace(/\t/g, " ");
-
-    if (!isFirstLine) {
-      trimmedLine = trimmedLine.replace(/^[ ]+/, "");
-    }
-
-    if (!isLastLine) {
-      trimmedLine = trimmedLine.replace(/[ ]+$/, "");
-    }
-
-    if (trimmedLine) {
-      if (!isLastNonEmptyLine) {
-        trimmedLine += " ";
-      }
-
-      str += trimmedLine;
-    }
-  }
-
-  if (str) args.push((0, _generated.stringLiteral)(str));
-}

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

@@ -1,18 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = shallowEqual;
-
-function shallowEqual(actual, expected) {
-  const keys = Object.keys(expected);
-
-  for (const key of keys) {
-    if (actual[key] !== expected[key]) {
-      return false;
-    }
-  }
-
-  return true;
-}

node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js

@@ -1,15 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = buildMatchMemberExpression;
-
-var _matchesPattern = _interopRequireDefault(require("./matchesPattern"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function buildMatchMemberExpression(match, allowPartial) {
-  const parts = match.split(".");
-  return member => (0, _matchesPattern.default)(member, parts, allowPartial);
-}

node_modules/@babel/types/lib/validators/is.js

@@ -1,35 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = is;
-
-var _shallowEqual = _interopRequireDefault(require("../utils/shallowEqual"));
-
-var _isType = _interopRequireDefault(require("./isType"));
-
-var _isPlaceholderType = _interopRequireDefault(require("./isPlaceholderType"));
-
-var _definitions = require("../definitions");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function is(type, node, opts) {
-  if (!node) return false;
-  const matches = (0, _isType.default)(node.type, type);
-
-  if (!matches) {
-    if (!opts && node.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) {
-      return (0, _isPlaceholderType.default)(node.expectedNode, type);
-    }
-
-    return false;
-  }
-
-  if (typeof opts === "undefined") {
-    return true;
-  } else {
-    return (0, _shallowEqual.default)(node, opts);
-  }
-}

node_modules/@babel/types/lib/validators/isBinding.js

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = isBinding;
-
-var _getBindingIdentifiers = _interopRequireDefault(require("../retrievers/getBindingIdentifiers"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function isBinding(node, parent, grandparent) {
-  if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") {
-    return false;
-  }
-
-  const keys = _getBindingIdentifiers.default.keys[parent.type];
-
-  if (keys) {
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const val = parent[key];
-
-      if (Array.isArray(val)) {
-        if (val.indexOf(node) >= 0) return true;
-      } else {
-        if (val === node) return true;
-      }
-    }
-  }
-
-  return false;
-}

node_modules/@babel/types/lib/validators/isBlockScoped.js

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = isBlockScoped;
-
-var _generated = require("./generated");
-
-var _isLet = _interopRequireDefault(require("./isLet"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function isBlockScoped(node) {
-  return (0, _generated.isFunctionDeclaration)(node) || (0, _generated.isClassDeclaration)(node) || (0, _isLet.default)(node);
-}

node_modules/@babel/types/lib/validators/isImmutable.js

@@ -1,26 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = isImmutable;
-
-var _isType = _interopRequireDefault(require("./isType"));
-
-var _generated = require("./generated");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function isImmutable(node) {
-  if ((0, _isType.default)(node.type, "Immutable")) return true;
-
-  if ((0, _generated.isIdentifier)(node)) {
-    if (node.name === "undefined") {
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  return false;
-}