Merge branch 'MLAB-667' into 'testing'

Mlab 667

See merge request !151

node_modules/@babel/parser/LICENSE

+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

+# @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

+#!/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

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

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

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

node_modules/@babel/types/LICENSE

+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

+# @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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = assertNode;
+
+var _isNode = require("../validators/isNode");
+
+function assertNode(node) {
+  if (!(0, _isNode.default)(node)) {
+    var _node$type;
+
+    const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
+    throw new TypeError(`Not a valid node of type "${type}"`);
+  }
+}
\ No newline at end of file

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertAccessor = assertAccessor;
+exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
+exports.assertArgumentPlaceholder = assertArgumentPlaceholder;
+exports.assertArrayExpression = assertArrayExpression;
+exports.assertArrayPattern = assertArrayPattern;
+exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
+exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
+exports.assertAssignmentExpression = assertAssignmentExpression;
+exports.assertAssignmentPattern = assertAssignmentPattern;
+exports.assertAwaitExpression = assertAwaitExpression;
+exports.assertBigIntLiteral = assertBigIntLiteral;
+exports.assertBinary = assertBinary;
+exports.assertBinaryExpression = assertBinaryExpression;
+exports.assertBindExpression = assertBindExpression;
+exports.assertBlock = assertBlock;
+exports.assertBlockParent = assertBlockParent;
+exports.assertBlockStatement = assertBlockStatement;
+exports.assertBooleanLiteral = assertBooleanLiteral;
+exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
+exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
+exports.assertBreakStatement = assertBreakStatement;
+exports.assertCallExpression = assertCallExpression;
+exports.assertCatchClause = assertCatchClause;
+exports.assertClass = assertClass;
+exports.assertClassAccessorProperty = assertClassAccessorProperty;
+exports.assertClassBody = assertClassBody;
+exports.assertClassDeclaration = assertClassDeclaration;
+exports.assertClassExpression = assertClassExpression;
+exports.assertClassImplements = assertClassImplements;
+exports.assertClassMethod = assertClassMethod;
+exports.assertClassPrivateMethod = assertClassPrivateMethod;
+exports.assertClassPrivateProperty = assertClassPrivateProperty;
+exports.assertClassProperty = assertClassProperty;
+exports.assertCompletionStatement = assertCompletionStatement;
+exports.assertConditional = assertConditional;
+exports.assertConditionalExpression = assertConditionalExpression;
+exports.assertContinueStatement = assertContinueStatement;
+exports.assertDebuggerStatement = assertDebuggerStatement;
+exports.assertDecimalLiteral = assertDecimalLiteral;
+exports.assertDeclaration = assertDeclaration;
+exports.assertDeclareClass = assertDeclareClass;
+exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
+exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
+exports.assertDeclareFunction = assertDeclareFunction;
+exports.assertDeclareInterface = assertDeclareInterface;
+exports.assertDeclareModule = assertDeclareModule;
+exports.assertDeclareModuleExports = assertDeclareModuleExports;
+exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
+exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
+exports.assertDeclareVariable = assertDeclareVariable;
+exports.assertDeclaredPredicate = assertDeclaredPredicate;
+exports.assertDecorator = assertDecorator;
+exports.assertDirective = assertDirective;
+exports.assertDirectiveLiteral = assertDirectiveLiteral;
+exports.assertDoExpression = assertDoExpression;
+exports.assertDoWhileStatement = assertDoWhileStatement;
+exports.assertEmptyStatement = assertEmptyStatement;
+exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
+exports.assertEnumBody = assertEnumBody;
+exports.assertEnumBooleanBody = assertEnumBooleanBody;
+exports.assertEnumBooleanMember = assertEnumBooleanMember;
+exports.assertEnumDeclaration = assertEnumDeclaration;
+exports.assertEnumDefaultedMember = assertEnumDefaultedMember;
+exports.assertEnumMember = assertEnumMember;
+exports.assertEnumNumberBody = assertEnumNumberBody;
+exports.assertEnumNumberMember = assertEnumNumberMember;
+exports.assertEnumStringBody = assertEnumStringBody;
+exports.assertEnumStringMember = assertEnumStringMember;
+exports.assertEnumSymbolBody = assertEnumSymbolBody;
+exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
+exports.assertExportAllDeclaration = assertExportAllDeclaration;
+exports.assertExportDeclaration = assertExportDeclaration;
+exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
+exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
+exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
+exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
+exports.assertExportSpecifier = assertExportSpecifier;
+exports.assertExpression = assertExpression;
+exports.assertExpressionStatement = assertExpressionStatement;
+exports.assertExpressionWrapper = assertExpressionWrapper;
+exports.assertFile = assertFile;
+exports.assertFlow = assertFlow;
+exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
+exports.assertFlowDeclaration = assertFlowDeclaration;
+exports.assertFlowPredicate = assertFlowPredicate;
+exports.assertFlowType = assertFlowType;
+exports.assertFor = assertFor;
+exports.assertForInStatement = assertForInStatement;
+exports.assertForOfStatement = assertForOfStatement;
+exports.assertForStatement = assertForStatement;
+exports.assertForXStatement = assertForXStatement;
+exports.assertFunction = assertFunction;
+exports.assertFunctionDeclaration = assertFunctionDeclaration;
+exports.assertFunctionExpression = assertFunctionExpression;
+exports.assertFunctionParent = assertFunctionParent;
+exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
+exports.assertFunctionTypeParam = assertFunctionTypeParam;
+exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
+exports.assertIdentifier = assertIdentifier;
+exports.assertIfStatement = assertIfStatement;
+exports.assertImmutable = assertImmutable;
+exports.assertImport = assertImport;
+exports.assertImportAttribute = assertImportAttribute;
+exports.assertImportDeclaration = assertImportDeclaration;
+exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
+exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
+exports.assertImportSpecifier = assertImportSpecifier;
+exports.assertIndexedAccessType = assertIndexedAccessType;
+exports.assertInferredPredicate = assertInferredPredicate;
+exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
+exports.assertInterfaceExtends = assertInterfaceExtends;
+exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
+exports.assertInterpreterDirective = assertInterpreterDirective;
+exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
+exports.assertJSX = assertJSX;
+exports.assertJSXAttribute = assertJSXAttribute;
+exports.assertJSXClosingElement = assertJSXClosingElement;
+exports.assertJSXClosingFragment = assertJSXClosingFragment;
+exports.assertJSXElement = assertJSXElement;
+exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
+exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
+exports.assertJSXFragment = assertJSXFragment;
+exports.assertJSXIdentifier = assertJSXIdentifier;
+exports.assertJSXMemberExpression = assertJSXMemberExpression;
+exports.assertJSXNamespacedName = assertJSXNamespacedName;
+exports.assertJSXOpeningElement = assertJSXOpeningElement;
+exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
+exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
+exports.assertJSXSpreadChild = assertJSXSpreadChild;
+exports.assertJSXText = assertJSXText;
+exports.assertLVal = assertLVal;
+exports.assertLabeledStatement = assertLabeledStatement;
+exports.assertLiteral = assertLiteral;
+exports.assertLogicalExpression = assertLogicalExpression;
+exports.assertLoop = assertLoop;
+exports.assertMemberExpression = assertMemberExpression;
+exports.assertMetaProperty = assertMetaProperty;
+exports.assertMethod = assertMethod;
+exports.assertMiscellaneous = assertMiscellaneous;
+exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
+exports.assertModuleDeclaration = assertModuleDeclaration;
+exports.assertModuleExpression = assertModuleExpression;
+exports.assertModuleSpecifier = assertModuleSpecifier;
+exports.assertNewExpression = assertNewExpression;
+exports.assertNoop = assertNoop;
+exports.assertNullLiteral = assertNullLiteral;
+exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
+exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
+exports.assertNumberLiteral = assertNumberLiteral;
+exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
+exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
+exports.assertNumericLiteral = assertNumericLiteral;
+exports.assertObjectExpression = assertObjectExpression;
+exports.assertObjectMember = assertObjectMember;
+exports.assertObjectMethod = assertObjectMethod;
+exports.assertObjectPattern = assertObjectPattern;
+exports.assertObjectProperty = assertObjectProperty;
+exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
+exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
+exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
+exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
+exports.assertObjectTypeProperty = assertObjectTypeProperty;
+exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
+exports.assertOpaqueType = assertOpaqueType;
+exports.assertOptionalCallExpression = assertOptionalCallExpression;
+exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType;
+exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
+exports.assertParenthesizedExpression = assertParenthesizedExpression;
+exports.assertPattern = assertPattern;
+exports.assertPatternLike = assertPatternLike;
+exports.assertPipelineBareFunction = assertPipelineBareFunction;
+exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
+exports.assertPipelineTopicExpression = assertPipelineTopicExpression;
+exports.assertPlaceholder = assertPlaceholder;
+exports.assertPrivate = assertPrivate;
+exports.assertPrivateName = assertPrivateName;
+exports.assertProgram = assertProgram;
+exports.assertProperty = assertProperty;
+exports.assertPureish = assertPureish;
+exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
+exports.assertRecordExpression = assertRecordExpression;
+exports.assertRegExpLiteral = assertRegExpLiteral;
+exports.assertRegexLiteral = assertRegexLiteral;
+exports.assertRestElement = assertRestElement;
+exports.assertRestProperty = assertRestProperty;
+exports.assertReturnStatement = assertReturnStatement;
+exports.assertScopable = assertScopable;
+exports.assertSequenceExpression = assertSequenceExpression;
+exports.assertSpreadElement = assertSpreadElement;
+exports.assertSpreadProperty = assertSpreadProperty;
+exports.assertStandardized = assertStandardized;
+exports.assertStatement = assertStatement;
+exports.assertStaticBlock = assertStaticBlock;
+exports.assertStringLiteral = assertStringLiteral;
+exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
+exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
+exports.assertSuper = assertSuper;
+exports.assertSwitchCase = assertSwitchCase;
+exports.assertSwitchStatement = assertSwitchStatement;
+exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
+exports.assertTSAnyKeyword = assertTSAnyKeyword;
+exports.assertTSArrayType = assertTSArrayType;
+exports.assertTSAsExpression = assertTSAsExpression;
+exports.assertTSBaseType = assertTSBaseType;
+exports.assertTSBigIntKeyword = assertTSBigIntKeyword;
+exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
+exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
+exports.assertTSConditionalType = assertTSConditionalType;
+exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
+exports.assertTSConstructorType = assertTSConstructorType;
+exports.assertTSDeclareFunction = assertTSDeclareFunction;
+exports.assertTSDeclareMethod = assertTSDeclareMethod;
+exports.assertTSEntityName = assertTSEntityName;
+exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
+exports.assertTSEnumMember = assertTSEnumMember;
+exports.assertTSExportAssignment = assertTSExportAssignment;
+exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
+exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
+exports.assertTSFunctionType = assertTSFunctionType;
+exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
+exports.assertTSImportType = assertTSImportType;
+exports.assertTSIndexSignature = assertTSIndexSignature;
+exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
+exports.assertTSInferType = assertTSInferType;
+exports.assertTSInstantiationExpression = assertTSInstantiationExpression;
+exports.assertTSInterfaceBody = assertTSInterfaceBody;
+exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
+exports.assertTSIntersectionType = assertTSIntersectionType;
+exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;
+exports.assertTSLiteralType = assertTSLiteralType;
+exports.assertTSMappedType = assertTSMappedType;
+exports.assertTSMethodSignature = assertTSMethodSignature;
+exports.assertTSModuleBlock = assertTSModuleBlock;
+exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
+exports.assertTSNamedTupleMember = assertTSNamedTupleMember;
+exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
+exports.assertTSNeverKeyword = assertTSNeverKeyword;
+exports.assertTSNonNullExpression = assertTSNonNullExpression;
+exports.assertTSNullKeyword = assertTSNullKeyword;
+exports.assertTSNumberKeyword = assertTSNumberKeyword;
+exports.assertTSObjectKeyword = assertTSObjectKeyword;
+exports.assertTSOptionalType = assertTSOptionalType;
+exports.assertTSParameterProperty = assertTSParameterProperty;
+exports.assertTSParenthesizedType = assertTSParenthesizedType;
+exports.assertTSPropertySignature = assertTSPropertySignature;
+exports.assertTSQualifiedName = assertTSQualifiedName;
+exports.assertTSRestType = assertTSRestType;
+exports.assertTSStringKeyword = assertTSStringKeyword;
+exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
+exports.assertTSThisType = assertTSThisType;
+exports.assertTSTupleType = assertTSTupleType;
+exports.assertTSType = assertTSType;
+exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
+exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
+exports.assertTSTypeAssertion = assertTSTypeAssertion;
+exports.assertTSTypeElement = assertTSTypeElement;
+exports.assertTSTypeLiteral = assertTSTypeLiteral;
+exports.assertTSTypeOperator = assertTSTypeOperator;
+exports.assertTSTypeParameter = assertTSTypeParameter;
+exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
+exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
+exports.assertTSTypePredicate = assertTSTypePredicate;
+exports.assertTSTypeQuery = assertTSTypeQuery;
+exports.assertTSTypeReference = assertTSTypeReference;
+exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
+exports.assertTSUnionType = assertTSUnionType;
+exports.assertTSUnknownKeyword = assertTSUnknownKeyword;
+exports.assertTSVoidKeyword = assertTSVoidKeyword;
+exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
+exports.assertTemplateElement = assertTemplateElement;
+exports.assertTemplateLiteral = assertTemplateLiteral;
+exports.assertTerminatorless = assertTerminatorless;
+exports.assertThisExpression = assertThisExpression;
+exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
+exports.assertThrowStatement = assertThrowStatement;
+exports.assertTopicReference = assertTopicReference;
+exports.assertTryStatement = assertTryStatement;
+exports.assertTupleExpression = assertTupleExpression;
+exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
+exports.assertTypeAlias = assertTypeAlias;
+exports.assertTypeAnnotation = assertTypeAnnotation;
+exports.assertTypeCastExpression = assertTypeCastExpression;
+exports.assertTypeParameter = assertTypeParameter;
+exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
+exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
+exports.assertTypeScript = assertTypeScript;
+exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
+exports.assertUnaryExpression = assertUnaryExpression;
+exports.assertUnaryLike = assertUnaryLike;
+exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
+exports.assertUpdateExpression = assertUpdateExpression;
+exports.assertUserWhitespacable = assertUserWhitespacable;
+exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;
+exports.assertVariableDeclaration = assertVariableDeclaration;
+exports.assertVariableDeclarator = assertVariableDeclarator;
+exports.assertVariance = assertVariance;
+exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
+exports.assertWhile = assertWhile;
+exports.assertWhileStatement = assertWhileStatement;
+exports.assertWithStatement = assertWithStatement;
+exports.assertYieldExpression = assertYieldExpression;
+
+var _is = require("../../validators/is");
+
+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 assertClassProperty(node, opts) {
+  assert("ClassProperty", node, opts);
+}
+
+function assertClassAccessorProperty(node, opts) {
+  assert("ClassAccessorProperty", node, opts);
+}
+
+function assertClassPrivateProperty(node, opts) {
+  assert("ClassPrivateProperty", node, opts);
+}
+
+function assertClassPrivateMethod(node, opts) {
+  assert("ClassPrivateMethod", node, opts);
+}
+
+function assertPrivateName(node, opts) {
+  assert("PrivateName", node, opts);
+}
+
+function assertStaticBlock(node, opts) {
+  assert("StaticBlock", 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 assertIndexedAccessType(node, opts) {
+  assert("IndexedAccessType", node, opts);
+}
+
+function assertOptionalIndexedAccessType(node, opts) {
+  assert("OptionalIndexedAccessType", 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 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 assertRecordExpression(node, opts) {
+  assert("RecordExpression", node, opts);
+}
+
+function assertTupleExpression(node, opts) {
+  assert("TupleExpression", node, opts);
+}
+
+function assertDecimalLiteral(node, opts) {
+  assert("DecimalLiteral", node, opts);
+}
+
+function assertModuleExpression(node, opts) {
+  assert("ModuleExpression", node, opts);
+}
+
+function assertTopicReference(node, opts) {
+  assert("TopicReference", 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 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 assertTSInstantiationExpression(node, opts) {
+  assert("TSInstantiationExpression", 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 assertStandardized(node, opts) {
+  assert("Standardized", 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 assertAccessor(node, opts) {
+  assert("Accessor", node, opts);
+}
+
+function assertPrivate(node, opts) {
+  assert("Private", 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 assertMiscellaneous(node, opts) {
+  assert("Miscellaneous", node, opts);
+}
+
+function assertTypeScript(node, opts) {
+  assert("TypeScript", 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);
+}
\ No newline at end of file

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createFlowUnionType;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates");
+
+function createFlowUnionType(types) {
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _generated.unionTypeAnnotation)(flattened);
+  }
+}
\ No newline at end of file

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _generated = require("../generated");
+
+var _default = createTypeAnnotationBasedOnTypeof;
+exports.default = _default;
+
+function createTypeAnnotationBasedOnTypeof(type) {
+  switch (type) {
+    case "string":
+      return (0, _generated.stringTypeAnnotation)();
+
+    case "number":
+      return (0, _generated.numberTypeAnnotation)();
+
+    case "undefined":
+      return (0, _generated.voidTypeAnnotation)();
+
+    case "boolean":
+      return (0, _generated.booleanTypeAnnotation)();
+
+    case "function":
+      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
+
+    case "object":
+      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
+
+    case "symbol":
+      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
+
+    case "bigint":
+      return (0, _generated.anyTypeAnnotation)();
+  }
+
+  throw new Error("Invalid typeof value: " + type);
+}
\ No newline at end of file

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

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

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AnyTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.anyTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ArgumentPlaceholder", {
+  enumerable: true,
+  get: function () {
+    return _index.argumentPlaceholder;
+  }
+});
+Object.defineProperty(exports, "ArrayExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayExpression;
+  }
+});
+Object.defineProperty(exports, "ArrayPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayPattern;
+  }
+});
+Object.defineProperty(exports, "ArrayTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.arrayTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ArrowFunctionExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.arrowFunctionExpression;
+  }
+});
+Object.defineProperty(exports, "AssignmentExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.assignmentExpression;
+  }
+});
+Object.defineProperty(exports, "AssignmentPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.assignmentPattern;
+  }
+});
+Object.defineProperty(exports, "AwaitExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.awaitExpression;
+  }
+});
+Object.defineProperty(exports, "BigIntLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.bigIntLiteral;
+  }
+});
+Object.defineProperty(exports, "BinaryExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.binaryExpression;
+  }
+});
+Object.defineProperty(exports, "BindExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.bindExpression;
+  }
+});
+Object.defineProperty(exports, "BlockStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.blockStatement;
+  }
+});
+Object.defineProperty(exports, "BooleanLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanLiteral;
+  }
+});
+Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "BooleanTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.booleanTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "BreakStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.breakStatement;
+  }
+});
+Object.defineProperty(exports, "CallExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.callExpression;
+  }
+});
+Object.defineProperty(exports, "CatchClause", {
+  enumerable: true,
+  get: function () {
+    return _index.catchClause;
+  }
+});
+Object.defineProperty(exports, "ClassAccessorProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classAccessorProperty;
+  }
+});
+Object.defineProperty(exports, "ClassBody", {
+  enumerable: true,
+  get: function () {
+    return _index.classBody;
+  }
+});
+Object.defineProperty(exports, "ClassDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.classDeclaration;
+  }
+});
+Object.defineProperty(exports, "ClassExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.classExpression;
+  }
+});
+Object.defineProperty(exports, "ClassImplements", {
+  enumerable: true,
+  get: function () {
+    return _index.classImplements;
+  }
+});
+Object.defineProperty(exports, "ClassMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.classMethod;
+  }
+});
+Object.defineProperty(exports, "ClassPrivateMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.classPrivateMethod;
+  }
+});
+Object.defineProperty(exports, "ClassPrivateProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classPrivateProperty;
+  }
+});
+Object.defineProperty(exports, "ClassProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.classProperty;
+  }
+});
+Object.defineProperty(exports, "ConditionalExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.conditionalExpression;
+  }
+});
+Object.defineProperty(exports, "ContinueStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.continueStatement;
+  }
+});
+Object.defineProperty(exports, "DebuggerStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.debuggerStatement;
+  }
+});
+Object.defineProperty(exports, "DecimalLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.decimalLiteral;
+  }
+});
+Object.defineProperty(exports, "DeclareClass", {
+  enumerable: true,
+  get: function () {
+    return _index.declareClass;
+  }
+});
+Object.defineProperty(exports, "DeclareExportAllDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.declareExportAllDeclaration;
+  }
+});
+Object.defineProperty(exports, "DeclareExportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.declareExportDeclaration;
+  }
+});
+Object.defineProperty(exports, "DeclareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.declareFunction;
+  }
+});
+Object.defineProperty(exports, "DeclareInterface", {
+  enumerable: true,
+  get: function () {
+    return _index.declareInterface;
+  }
+});
+Object.defineProperty(exports, "DeclareModule", {
+  enumerable: true,
+  get: function () {
+    return _index.declareModule;
+  }
+});
+Object.defineProperty(exports, "DeclareModuleExports", {
+  enumerable: true,
+  get: function () {
+    return _index.declareModuleExports;
+  }
+});
+Object.defineProperty(exports, "DeclareOpaqueType", {
+  enumerable: true,
+  get: function () {
+    return _index.declareOpaqueType;
+  }
+});
+Object.defineProperty(exports, "DeclareTypeAlias", {
+  enumerable: true,
+  get: function () {
+    return _index.declareTypeAlias;
+  }
+});
+Object.defineProperty(exports, "DeclareVariable", {
+  enumerable: true,
+  get: function () {
+    return _index.declareVariable;
+  }
+});
+Object.defineProperty(exports, "DeclaredPredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.declaredPredicate;
+  }
+});
+Object.defineProperty(exports, "Decorator", {
+  enumerable: true,
+  get: function () {
+    return _index.decorator;
+  }
+});
+Object.defineProperty(exports, "Directive", {
+  enumerable: true,
+  get: function () {
+    return _index.directive;
+  }
+});
+Object.defineProperty(exports, "DirectiveLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.directiveLiteral;
+  }
+});
+Object.defineProperty(exports, "DoExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.doExpression;
+  }
+});
+Object.defineProperty(exports, "DoWhileStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.doWhileStatement;
+  }
+});
+Object.defineProperty(exports, "EmptyStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.emptyStatement;
+  }
+});
+Object.defineProperty(exports, "EmptyTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.emptyTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "EnumBooleanBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumBooleanBody;
+  }
+});
+Object.defineProperty(exports, "EnumBooleanMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumBooleanMember;
+  }
+});
+Object.defineProperty(exports, "EnumDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.enumDeclaration;
+  }
+});
+Object.defineProperty(exports, "EnumDefaultedMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumDefaultedMember;
+  }
+});
+Object.defineProperty(exports, "EnumNumberBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumNumberBody;
+  }
+});
+Object.defineProperty(exports, "EnumNumberMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumNumberMember;
+  }
+});
+Object.defineProperty(exports, "EnumStringBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumStringBody;
+  }
+});
+Object.defineProperty(exports, "EnumStringMember", {
+  enumerable: true,
+  get: function () {
+    return _index.enumStringMember;
+  }
+});
+Object.defineProperty(exports, "EnumSymbolBody", {
+  enumerable: true,
+  get: function () {
+    return _index.enumSymbolBody;
+  }
+});
+Object.defineProperty(exports, "ExistsTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.existsTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ExportAllDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportAllDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportDefaultDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportDefaultDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportDefaultSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportDefaultSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExportNamedDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.exportNamedDeclaration;
+  }
+});
+Object.defineProperty(exports, "ExportNamespaceSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportNamespaceSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExportSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.exportSpecifier;
+  }
+});
+Object.defineProperty(exports, "ExpressionStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.expressionStatement;
+  }
+});
+Object.defineProperty(exports, "File", {
+  enumerable: true,
+  get: function () {
+    return _index.file;
+  }
+});
+Object.defineProperty(exports, "ForInStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forInStatement;
+  }
+});
+Object.defineProperty(exports, "ForOfStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forOfStatement;
+  }
+});
+Object.defineProperty(exports, "ForStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.forStatement;
+  }
+});
+Object.defineProperty(exports, "FunctionDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.functionDeclaration;
+  }
+});
+Object.defineProperty(exports, "FunctionExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.functionExpression;
+  }
+});
+Object.defineProperty(exports, "FunctionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.functionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "FunctionTypeParam", {
+  enumerable: true,
+  get: function () {
+    return _index.functionTypeParam;
+  }
+});
+Object.defineProperty(exports, "GenericTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.genericTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "Identifier", {
+  enumerable: true,
+  get: function () {
+    return _index.identifier;
+  }
+});
+Object.defineProperty(exports, "IfStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.ifStatement;
+  }
+});
+Object.defineProperty(exports, "Import", {
+  enumerable: true,
+  get: function () {
+    return _index.import;
+  }
+});
+Object.defineProperty(exports, "ImportAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.importAttribute;
+  }
+});
+Object.defineProperty(exports, "ImportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.importDeclaration;
+  }
+});
+Object.defineProperty(exports, "ImportDefaultSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importDefaultSpecifier;
+  }
+});
+Object.defineProperty(exports, "ImportNamespaceSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importNamespaceSpecifier;
+  }
+});
+Object.defineProperty(exports, "ImportSpecifier", {
+  enumerable: true,
+  get: function () {
+    return _index.importSpecifier;
+  }
+});
+Object.defineProperty(exports, "IndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.indexedAccessType;
+  }
+});
+Object.defineProperty(exports, "InferredPredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.inferredPredicate;
+  }
+});
+Object.defineProperty(exports, "InterfaceDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceDeclaration;
+  }
+});
+Object.defineProperty(exports, "InterfaceExtends", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceExtends;
+  }
+});
+Object.defineProperty(exports, "InterfaceTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.interfaceTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "InterpreterDirective", {
+  enumerable: true,
+  get: function () {
+    return _index.interpreterDirective;
+  }
+});
+Object.defineProperty(exports, "IntersectionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.intersectionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "JSXAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxAttribute;
+  }
+});
+Object.defineProperty(exports, "JSXClosingElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxClosingElement;
+  }
+});
+Object.defineProperty(exports, "JSXClosingFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxClosingFragment;
+  }
+});
+Object.defineProperty(exports, "JSXElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxElement;
+  }
+});
+Object.defineProperty(exports, "JSXEmptyExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxEmptyExpression;
+  }
+});
+Object.defineProperty(exports, "JSXExpressionContainer", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxExpressionContainer;
+  }
+});
+Object.defineProperty(exports, "JSXFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxFragment;
+  }
+});
+Object.defineProperty(exports, "JSXIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxIdentifier;
+  }
+});
+Object.defineProperty(exports, "JSXMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxMemberExpression;
+  }
+});
+Object.defineProperty(exports, "JSXNamespacedName", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxNamespacedName;
+  }
+});
+Object.defineProperty(exports, "JSXOpeningElement", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxOpeningElement;
+  }
+});
+Object.defineProperty(exports, "JSXOpeningFragment", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxOpeningFragment;
+  }
+});
+Object.defineProperty(exports, "JSXSpreadAttribute", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxSpreadAttribute;
+  }
+});
+Object.defineProperty(exports, "JSXSpreadChild", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxSpreadChild;
+  }
+});
+Object.defineProperty(exports, "JSXText", {
+  enumerable: true,
+  get: function () {
+    return _index.jsxText;
+  }
+});
+Object.defineProperty(exports, "LabeledStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.labeledStatement;
+  }
+});
+Object.defineProperty(exports, "LogicalExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.logicalExpression;
+  }
+});
+Object.defineProperty(exports, "MemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.memberExpression;
+  }
+});
+Object.defineProperty(exports, "MetaProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.metaProperty;
+  }
+});
+Object.defineProperty(exports, "MixedTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.mixedTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ModuleExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.moduleExpression;
+  }
+});
+Object.defineProperty(exports, "NewExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.newExpression;
+  }
+});
+Object.defineProperty(exports, "Noop", {
+  enumerable: true,
+  get: function () {
+    return _index.noop;
+  }
+});
+Object.defineProperty(exports, "NullLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.nullLiteral;
+  }
+});
+Object.defineProperty(exports, "NullLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.nullLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NullableTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.nullableTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumberLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.numberLiteral;
+  }
+});
+Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.numberLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumberTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.numberTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "NumericLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.numericLiteral;
+  }
+});
+Object.defineProperty(exports, "ObjectExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.objectExpression;
+  }
+});
+Object.defineProperty(exports, "ObjectMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.objectMethod;
+  }
+});
+Object.defineProperty(exports, "ObjectPattern", {
+  enumerable: true,
+  get: function () {
+    return _index.objectPattern;
+  }
+});
+Object.defineProperty(exports, "ObjectProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeCallProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeCallProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeIndexer", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeIndexer;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeInternalSlot", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeInternalSlot;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeProperty;
+  }
+});
+Object.defineProperty(exports, "ObjectTypeSpreadProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.objectTypeSpreadProperty;
+  }
+});
+Object.defineProperty(exports, "OpaqueType", {
+  enumerable: true,
+  get: function () {
+    return _index.opaqueType;
+  }
+});
+Object.defineProperty(exports, "OptionalCallExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalCallExpression;
+  }
+});
+Object.defineProperty(exports, "OptionalIndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalIndexedAccessType;
+  }
+});
+Object.defineProperty(exports, "OptionalMemberExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.optionalMemberExpression;
+  }
+});
+Object.defineProperty(exports, "ParenthesizedExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.parenthesizedExpression;
+  }
+});
+Object.defineProperty(exports, "PipelineBareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelineBareFunction;
+  }
+});
+Object.defineProperty(exports, "PipelinePrimaryTopicReference", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelinePrimaryTopicReference;
+  }
+});
+Object.defineProperty(exports, "PipelineTopicExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.pipelineTopicExpression;
+  }
+});
+Object.defineProperty(exports, "Placeholder", {
+  enumerable: true,
+  get: function () {
+    return _index.placeholder;
+  }
+});
+Object.defineProperty(exports, "PrivateName", {
+  enumerable: true,
+  get: function () {
+    return _index.privateName;
+  }
+});
+Object.defineProperty(exports, "Program", {
+  enumerable: true,
+  get: function () {
+    return _index.program;
+  }
+});
+Object.defineProperty(exports, "QualifiedTypeIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.qualifiedTypeIdentifier;
+  }
+});
+Object.defineProperty(exports, "RecordExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.recordExpression;
+  }
+});
+Object.defineProperty(exports, "RegExpLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.regExpLiteral;
+  }
+});
+Object.defineProperty(exports, "RegexLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.regexLiteral;
+  }
+});
+Object.defineProperty(exports, "RestElement", {
+  enumerable: true,
+  get: function () {
+    return _index.restElement;
+  }
+});
+Object.defineProperty(exports, "RestProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.restProperty;
+  }
+});
+Object.defineProperty(exports, "ReturnStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.returnStatement;
+  }
+});
+Object.defineProperty(exports, "SequenceExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.sequenceExpression;
+  }
+});
+Object.defineProperty(exports, "SpreadElement", {
+  enumerable: true,
+  get: function () {
+    return _index.spreadElement;
+  }
+});
+Object.defineProperty(exports, "SpreadProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.spreadProperty;
+  }
+});
+Object.defineProperty(exports, "StaticBlock", {
+  enumerable: true,
+  get: function () {
+    return _index.staticBlock;
+  }
+});
+Object.defineProperty(exports, "StringLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.stringLiteral;
+  }
+});
+Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.stringLiteralTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "StringTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.stringTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "Super", {
+  enumerable: true,
+  get: function () {
+    return _index.super;
+  }
+});
+Object.defineProperty(exports, "SwitchCase", {
+  enumerable: true,
+  get: function () {
+    return _index.switchCase;
+  }
+});
+Object.defineProperty(exports, "SwitchStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.switchStatement;
+  }
+});
+Object.defineProperty(exports, "SymbolTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.symbolTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TSAnyKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsAnyKeyword;
+  }
+});
+Object.defineProperty(exports, "TSArrayType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsArrayType;
+  }
+});
+Object.defineProperty(exports, "TSAsExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsAsExpression;
+  }
+});
+Object.defineProperty(exports, "TSBigIntKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsBigIntKeyword;
+  }
+});
+Object.defineProperty(exports, "TSBooleanKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsBooleanKeyword;
+  }
+});
+Object.defineProperty(exports, "TSCallSignatureDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsCallSignatureDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSConditionalType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConditionalType;
+  }
+});
+Object.defineProperty(exports, "TSConstructSignatureDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConstructSignatureDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSConstructorType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsConstructorType;
+  }
+});
+Object.defineProperty(exports, "TSDeclareFunction", {
+  enumerable: true,
+  get: function () {
+    return _index.tsDeclareFunction;
+  }
+});
+Object.defineProperty(exports, "TSDeclareMethod", {
+  enumerable: true,
+  get: function () {
+    return _index.tsDeclareMethod;
+  }
+});
+Object.defineProperty(exports, "TSEnumDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsEnumDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSEnumMember", {
+  enumerable: true,
+  get: function () {
+    return _index.tsEnumMember;
+  }
+});
+Object.defineProperty(exports, "TSExportAssignment", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExportAssignment;
+  }
+});
+Object.defineProperty(exports, "TSExpressionWithTypeArguments", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExpressionWithTypeArguments;
+  }
+});
+Object.defineProperty(exports, "TSExternalModuleReference", {
+  enumerable: true,
+  get: function () {
+    return _index.tsExternalModuleReference;
+  }
+});
+Object.defineProperty(exports, "TSFunctionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsFunctionType;
+  }
+});
+Object.defineProperty(exports, "TSImportEqualsDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsImportEqualsDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSImportType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsImportType;
+  }
+});
+Object.defineProperty(exports, "TSIndexSignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIndexSignature;
+  }
+});
+Object.defineProperty(exports, "TSIndexedAccessType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIndexedAccessType;
+  }
+});
+Object.defineProperty(exports, "TSInferType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInferType;
+  }
+});
+Object.defineProperty(exports, "TSInstantiationExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInstantiationExpression;
+  }
+});
+Object.defineProperty(exports, "TSInterfaceBody", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInterfaceBody;
+  }
+});
+Object.defineProperty(exports, "TSInterfaceDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsInterfaceDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSIntersectionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIntersectionType;
+  }
+});
+Object.defineProperty(exports, "TSIntrinsicKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsIntrinsicKeyword;
+  }
+});
+Object.defineProperty(exports, "TSLiteralType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsLiteralType;
+  }
+});
+Object.defineProperty(exports, "TSMappedType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsMappedType;
+  }
+});
+Object.defineProperty(exports, "TSMethodSignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsMethodSignature;
+  }
+});
+Object.defineProperty(exports, "TSModuleBlock", {
+  enumerable: true,
+  get: function () {
+    return _index.tsModuleBlock;
+  }
+});
+Object.defineProperty(exports, "TSModuleDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsModuleDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSNamedTupleMember", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNamedTupleMember;
+  }
+});
+Object.defineProperty(exports, "TSNamespaceExportDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNamespaceExportDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSNeverKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNeverKeyword;
+  }
+});
+Object.defineProperty(exports, "TSNonNullExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNonNullExpression;
+  }
+});
+Object.defineProperty(exports, "TSNullKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNullKeyword;
+  }
+});
+Object.defineProperty(exports, "TSNumberKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsNumberKeyword;
+  }
+});
+Object.defineProperty(exports, "TSObjectKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsObjectKeyword;
+  }
+});
+Object.defineProperty(exports, "TSOptionalType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsOptionalType;
+  }
+});
+Object.defineProperty(exports, "TSParameterProperty", {
+  enumerable: true,
+  get: function () {
+    return _index.tsParameterProperty;
+  }
+});
+Object.defineProperty(exports, "TSParenthesizedType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsParenthesizedType;
+  }
+});
+Object.defineProperty(exports, "TSPropertySignature", {
+  enumerable: true,
+  get: function () {
+    return _index.tsPropertySignature;
+  }
+});
+Object.defineProperty(exports, "TSQualifiedName", {
+  enumerable: true,
+  get: function () {
+    return _index.tsQualifiedName;
+  }
+});
+Object.defineProperty(exports, "TSRestType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsRestType;
+  }
+});
+Object.defineProperty(exports, "TSStringKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsStringKeyword;
+  }
+});
+Object.defineProperty(exports, "TSSymbolKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsSymbolKeyword;
+  }
+});
+Object.defineProperty(exports, "TSThisType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsThisType;
+  }
+});
+Object.defineProperty(exports, "TSTupleType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTupleType;
+  }
+});
+Object.defineProperty(exports, "TSTypeAliasDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeAliasDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TSTypeAssertion", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeAssertion;
+  }
+});
+Object.defineProperty(exports, "TSTypeLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeLiteral;
+  }
+});
+Object.defineProperty(exports, "TSTypeOperator", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeOperator;
+  }
+});
+Object.defineProperty(exports, "TSTypeParameter", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeParameter;
+  }
+});
+Object.defineProperty(exports, "TSTypeParameterDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeParameterDeclaration;
+  }
+});
+Object.defineProperty(exports, "TSTypeParameterInstantiation", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeParameterInstantiation;
+  }
+});
+Object.defineProperty(exports, "TSTypePredicate", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypePredicate;
+  }
+});
+Object.defineProperty(exports, "TSTypeQuery", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeQuery;
+  }
+});
+Object.defineProperty(exports, "TSTypeReference", {
+  enumerable: true,
+  get: function () {
+    return _index.tsTypeReference;
+  }
+});
+Object.defineProperty(exports, "TSUndefinedKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsUndefinedKeyword;
+  }
+});
+Object.defineProperty(exports, "TSUnionType", {
+  enumerable: true,
+  get: function () {
+    return _index.tsUnionType;
+  }
+});
+Object.defineProperty(exports, "TSUnknownKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsUnknownKeyword;
+  }
+});
+Object.defineProperty(exports, "TSVoidKeyword", {
+  enumerable: true,
+  get: function () {
+    return _index.tsVoidKeyword;
+  }
+});
+Object.defineProperty(exports, "TaggedTemplateExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.taggedTemplateExpression;
+  }
+});
+Object.defineProperty(exports, "TemplateElement", {
+  enumerable: true,
+  get: function () {
+    return _index.templateElement;
+  }
+});
+Object.defineProperty(exports, "TemplateLiteral", {
+  enumerable: true,
+  get: function () {
+    return _index.templateLiteral;
+  }
+});
+Object.defineProperty(exports, "ThisExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.thisExpression;
+  }
+});
+Object.defineProperty(exports, "ThisTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.thisTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "ThrowStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.throwStatement;
+  }
+});
+Object.defineProperty(exports, "TopicReference", {
+  enumerable: true,
+  get: function () {
+    return _index.topicReference;
+  }
+});
+Object.defineProperty(exports, "TryStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.tryStatement;
+  }
+});
+Object.defineProperty(exports, "TupleExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.tupleExpression;
+  }
+});
+Object.defineProperty(exports, "TupleTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.tupleTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TypeAlias", {
+  enumerable: true,
+  get: function () {
+    return _index.typeAlias;
+  }
+});
+Object.defineProperty(exports, "TypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.typeAnnotation;
+  }
+});
+Object.defineProperty(exports, "TypeCastExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.typeCastExpression;
+  }
+});
+Object.defineProperty(exports, "TypeParameter", {
+  enumerable: true,
+  get: function () {
+    return _index.typeParameter;
+  }
+});
+Object.defineProperty(exports, "TypeParameterDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.typeParameterDeclaration;
+  }
+});
+Object.defineProperty(exports, "TypeParameterInstantiation", {
+  enumerable: true,
+  get: function () {
+    return _index.typeParameterInstantiation;
+  }
+});
+Object.defineProperty(exports, "TypeofTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.typeofTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "UnaryExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.unaryExpression;
+  }
+});
+Object.defineProperty(exports, "UnionTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.unionTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "UpdateExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.updateExpression;
+  }
+});
+Object.defineProperty(exports, "V8IntrinsicIdentifier", {
+  enumerable: true,
+  get: function () {
+    return _index.v8IntrinsicIdentifier;
+  }
+});
+Object.defineProperty(exports, "VariableDeclaration", {
+  enumerable: true,
+  get: function () {
+    return _index.variableDeclaration;
+  }
+});
+Object.defineProperty(exports, "VariableDeclarator", {
+  enumerable: true,
+  get: function () {
+    return _index.variableDeclarator;
+  }
+});
+Object.defineProperty(exports, "Variance", {
+  enumerable: true,
+  get: function () {
+    return _index.variance;
+  }
+});
+Object.defineProperty(exports, "VoidTypeAnnotation", {
+  enumerable: true,
+  get: function () {
+    return _index.voidTypeAnnotation;
+  }
+});
+Object.defineProperty(exports, "WhileStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.whileStatement;
+  }
+});
+Object.defineProperty(exports, "WithStatement", {
+  enumerable: true,
+  get: function () {
+    return _index.withStatement;
+  }
+});
+Object.defineProperty(exports, "YieldExpression", {
+  enumerable: true,
+  get: function () {
+    return _index.yieldExpression;
+  }
+});
+
+var _index = require("./index");
\ No newline at end of file

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = buildChildren;
+
+var _generated = require("../../validators/generated");
+
+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
+
+function buildChildren(node) {
+  const elements = [];
+
+  for (let i = 0; i < node.children.length; i++) {
+    let child = node.children[i];
+
+    if ((0, _generated.isJSXText)(child)) {
+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
+      continue;
+    }
+
+    if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
+    if ((0, _generated.isJSXEmptyExpression)(child)) continue;
+    elements.push(child);
+  }
+
+  return elements;
+}
\ No newline at end of file

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTSUnionType;
+
+var _generated = require("../generated");
+
+var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
+
+function createTSUnionType(typeAnnotations) {
+  const types = typeAnnotations.map(type => type.typeAnnotation);
+  const flattened = (0, _removeTypeDuplicates.default)(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return (0, _generated.tsUnionType)(flattened);
+  }
+}
\ No newline at end of file

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validateNode;
+
+var _validate = require("../validators/validate");
+
+var _ = require("..");
+
+function validateNode(node) {
+  const keys = _.BUILDER_KEYS[node.type];
+
+  for (const key of keys) {
+    (0, _validate.default)(node, key, node[key]);
+  }
+
+  return node;
+}
\ No newline at end of file

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = clone;
+
+var _cloneNode = require("./cloneNode");
+
+function clone(node) {
+  return (0, _cloneNode.default)(node, false);
+}
\ No newline at end of file