// ==UserScript==
// @name         AST SDK Bundle
// @namespace    local-jsvmp-learning
// @version      0.1.0
// @description  Inject Babel AST SDK into page window for local JSVMP AST learning.
// @match        *://*/*
// @run-at       document-start
// @grant        unsafeWindow
// @license WTF
// ==/UserScript==

var AstSdkBundle = (() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __commonJS = (cb, mod) => function __require() {
    try {
      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
    } catch (e) {
      throw mod = 0, e;
    }
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));
  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

  // node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
  var require_resolve_uri_umd = __commonJS({
    "node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(exports, module) {
      (function(global, factory) {
        typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.resolveURI = factory());
      })(exports, (function() {
        "use strict";
        const schemeRegex = /^[\w+.-]+:\/\//;
        const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
        const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
        function isAbsoluteUrl(input) {
          return schemeRegex.test(input);
        }
        function isSchemeRelativeUrl(input) {
          return input.startsWith("//");
        }
        function isAbsolutePath(input) {
          return input.startsWith("/");
        }
        function isFileUrl(input) {
          return input.startsWith("file:");
        }
        function isRelative(input) {
          return /^[.?#]/.test(input);
        }
        function parseAbsoluteUrl(input) {
          const match = urlRegex.exec(input);
          return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
        }
        function parseFileUrl(input) {
          const match = fileRegex.exec(input);
          const path = match[2];
          return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
        }
        function makeUrl(scheme, user, host, port, path, query, hash) {
          return {
            scheme,
            user,
            host,
            port,
            path,
            query,
            hash,
            type: 7
          };
        }
        function parseUrl(input) {
          if (isSchemeRelativeUrl(input)) {
            const url2 = parseAbsoluteUrl("http:" + input);
            url2.scheme = "";
            url2.type = 6;
            return url2;
          }
          if (isAbsolutePath(input)) {
            const url2 = parseAbsoluteUrl("http://foo.com" + input);
            url2.scheme = "";
            url2.host = "";
            url2.type = 5;
            return url2;
          }
          if (isFileUrl(input))
            return parseFileUrl(input);
          if (isAbsoluteUrl(input))
            return parseAbsoluteUrl(input);
          const url = parseAbsoluteUrl("http://foo.com/" + input);
          url.scheme = "";
          url.host = "";
          url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
          return url;
        }
        function stripPathFilename(path) {
          if (path.endsWith("/.."))
            return path;
          const index2 = path.lastIndexOf("/");
          return path.slice(0, index2 + 1);
        }
        function mergePaths(url, base) {
          normalizePath(base, base.type);
          if (url.path === "/") {
            url.path = base.path;
          } else {
            url.path = stripPathFilename(base.path) + url.path;
          }
        }
        function normalizePath(url, type) {
          const rel = type <= 4;
          const pieces = url.path.split("/");
          let pointer = 1;
          let positive = 0;
          let addTrailingSlash = false;
          for (let i = 1; i < pieces.length; i++) {
            const piece = pieces[i];
            if (!piece) {
              addTrailingSlash = true;
              continue;
            }
            addTrailingSlash = false;
            if (piece === ".")
              continue;
            if (piece === "..") {
              if (positive) {
                addTrailingSlash = true;
                positive--;
                pointer--;
              } else if (rel) {
                pieces[pointer++] = piece;
              }
              continue;
            }
            pieces[pointer++] = piece;
            positive++;
          }
          let path = "";
          for (let i = 1; i < pointer; i++) {
            path += "/" + pieces[i];
          }
          if (!path || addTrailingSlash && !path.endsWith("/..")) {
            path += "/";
          }
          url.path = path;
        }
        function resolve(input, base) {
          if (!input && !base)
            return "";
          const url = parseUrl(input);
          let inputType = url.type;
          if (base && inputType !== 7) {
            const baseUrl = parseUrl(base);
            const baseType = baseUrl.type;
            switch (inputType) {
              case 1:
                url.hash = baseUrl.hash;
              // fall through
              case 2:
                url.query = baseUrl.query;
              // fall through
              case 3:
              case 4:
                mergePaths(url, baseUrl);
              // fall through
              case 5:
                url.user = baseUrl.user;
                url.host = baseUrl.host;
                url.port = baseUrl.port;
              // fall through
              case 6:
                url.scheme = baseUrl.scheme;
            }
            if (baseType > inputType)
              inputType = baseType;
          }
          normalizePath(url, inputType);
          const queryHash = url.query + url.hash;
          switch (inputType) {
            // This is impossible, because of the empty checks at the start of the function.
            // case UrlType.Empty:
            case 2:
            case 3:
              return queryHash;
            case 4: {
              const path = url.path.slice(1);
              if (!path)
                return queryHash || ".";
              if (isRelative(base || input) && !isRelative(path)) {
                return "./" + path + queryHash;
              }
              return path + queryHash;
            }
            case 5:
              return url.path + queryHash;
            default:
              return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
          }
        }
        return resolve;
      }));
    }
  });

  // node_modules/jsesc/jsesc.js
  var require_jsesc = __commonJS({
    "node_modules/jsesc/jsesc.js"(exports, module) {
      "use strict";
      var object = {};
      var hasOwnProperty = object.hasOwnProperty;
      var forOwn = (object2, callback) => {
        for (const key in object2) {
          if (hasOwnProperty.call(object2, key)) {
            callback(key, object2[key]);
          }
        }
      };
      var extend = (destination, source) => {
        if (!source) {
          return destination;
        }
        forOwn(source, (key, value) => {
          destination[key] = value;
        });
        return destination;
      };
      var forEach = (array, callback) => {
        const length = array.length;
        let index2 = -1;
        while (++index2 < length) {
          callback(array[index2]);
        }
      };
      var fourHexEscape = (hex) => {
        return "\\u" + ("0000" + hex).slice(-4);
      };
      var hexadecimal = (code, lowercase) => {
        let hexadecimal2 = code.toString(16);
        if (lowercase) return hexadecimal2;
        return hexadecimal2.toUpperCase();
      };
      var toString = object.toString;
      var isArray = Array.isArray;
      var isBuffer = (value) => {
        return typeof Buffer === "function" && Buffer.isBuffer(value);
      };
      var isObject = (value) => {
        return toString.call(value) == "[object Object]";
      };
      var isString = (value) => {
        return typeof value == "string" || toString.call(value) == "[object String]";
      };
      var isNumber = (value) => {
        return typeof value == "number" || toString.call(value) == "[object Number]";
      };
      var isBigInt = (value) => {
        return typeof value == "bigint";
      };
      var isFunction3 = (value) => {
        return typeof value == "function";
      };
      var isMap = (value) => {
        return toString.call(value) == "[object Map]";
      };
      var isSet = (value) => {
        return toString.call(value) == "[object Set]";
      };
      var singleEscapes = {
        "\\": "\\\\",
        "\b": "\\b",
        "\f": "\\f",
        "\n": "\\n",
        "\r": "\\r",
        "	": "\\t"
        // `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'.
        // '\v': '\\x0B'
      };
      var regexSingleEscape = /[\\\b\f\n\r\t]/;
      var regexDigit = /[0-9]/;
      var regexWhitespace = /[\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
      var escapeEverythingRegex = /([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^]/g;
      var escapeNonAsciiRegex = /([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^ !#-&\(-\[\]-_a-~]/g;
      var jsesc2 = (argument, options) => {
        const increaseIndentation = () => {
          oldIndent = indent;
          ++options.indentLevel;
          indent = options.indent.repeat(options.indentLevel);
        };
        const defaults = {
          "escapeEverything": false,
          "minimal": false,
          "isScriptContext": false,
          "quotes": "single",
          "wrap": false,
          "es6": false,
          "json": false,
          "compact": true,
          "lowercaseHex": false,
          "numbers": "decimal",
          "indent": "	",
          "indentLevel": 0,
          "__inline1__": false,
          "__inline2__": false
        };
        const json = options && options.json;
        if (json) {
          defaults.quotes = "double";
          defaults.wrap = true;
        }
        options = extend(defaults, options);
        if (options.quotes != "single" && options.quotes != "double" && options.quotes != "backtick") {
          options.quotes = "single";
        }
        const quote = options.quotes == "double" ? '"' : options.quotes == "backtick" ? "`" : "'";
        const compact = options.compact;
        const lowercaseHex = options.lowercaseHex;
        let indent = options.indent.repeat(options.indentLevel);
        let oldIndent = "";
        const inline1 = options.__inline1__;
        const inline2 = options.__inline2__;
        const newLine = compact ? "" : "\n";
        let result;
        let isEmpty = true;
        const useBinNumbers = options.numbers == "binary";
        const useOctNumbers = options.numbers == "octal";
        const useDecNumbers = options.numbers == "decimal";
        const useHexNumbers = options.numbers == "hexadecimal";
        if (json && argument && isFunction3(argument.toJSON)) {
          argument = argument.toJSON();
        }
        if (!isString(argument)) {
          if (isMap(argument)) {
            if (argument.size == 0) {
              return "new Map()";
            }
            if (!compact) {
              options.__inline1__ = true;
              options.__inline2__ = false;
            }
            return "new Map(" + jsesc2(Array.from(argument), options) + ")";
          }
          if (isSet(argument)) {
            if (argument.size == 0) {
              return "new Set()";
            }
            return "new Set(" + jsesc2(Array.from(argument), options) + ")";
          }
          if (isBuffer(argument)) {
            if (argument.length == 0) {
              return "Buffer.from([])";
            }
            return "Buffer.from(" + jsesc2(Array.from(argument), options) + ")";
          }
          if (isArray(argument)) {
            result = [];
            options.wrap = true;
            if (inline1) {
              options.__inline1__ = false;
              options.__inline2__ = true;
            }
            if (!inline2) {
              increaseIndentation();
            }
            forEach(argument, (value) => {
              isEmpty = false;
              if (inline2) {
                options.__inline2__ = false;
              }
              result.push(
                (compact || inline2 ? "" : indent) + jsesc2(value, options)
              );
            });
            if (isEmpty) {
              return "[]";
            }
            if (inline2) {
              return "[" + result.join(", ") + "]";
            }
            return "[" + newLine + result.join("," + newLine) + newLine + (compact ? "" : oldIndent) + "]";
          } else if (isNumber(argument) || isBigInt(argument)) {
            if (json) {
              return JSON.stringify(Number(argument));
            }
            let result2;
            if (useDecNumbers) {
              result2 = String(argument);
            } else if (useHexNumbers) {
              let hexadecimal2 = argument.toString(16);
              if (!lowercaseHex) {
                hexadecimal2 = hexadecimal2.toUpperCase();
              }
              result2 = "0x" + hexadecimal2;
            } else if (useBinNumbers) {
              result2 = "0b" + argument.toString(2);
            } else if (useOctNumbers) {
              result2 = "0o" + argument.toString(8);
            }
            if (isBigInt(argument)) {
              return result2 + "n";
            }
            return result2;
          } else if (isBigInt(argument)) {
            if (json) {
              return JSON.stringify(Number(argument));
            }
            return argument + "n";
          } else if (!isObject(argument)) {
            if (json) {
              return JSON.stringify(argument) || "null";
            }
            return String(argument);
          } else {
            result = [];
            options.wrap = true;
            increaseIndentation();
            forOwn(argument, (key, value) => {
              isEmpty = false;
              result.push(
                (compact ? "" : indent) + jsesc2(key, options) + ":" + (compact ? "" : " ") + jsesc2(value, options)
              );
            });
            if (isEmpty) {
              return "{}";
            }
            return "{" + newLine + result.join("," + newLine) + newLine + (compact ? "" : oldIndent) + "}";
          }
        }
        const regex = options.escapeEverything ? escapeEverythingRegex : escapeNonAsciiRegex;
        result = argument.replace(regex, (char, pair, lone, quoteChar, index2, string) => {
          if (pair) {
            if (options.minimal) return pair;
            const first = pair.charCodeAt(0);
            const second = pair.charCodeAt(1);
            if (options.es6) {
              const codePoint = (first - 55296) * 1024 + second - 56320 + 65536;
              const hex2 = hexadecimal(codePoint, lowercaseHex);
              return "\\u{" + hex2 + "}";
            }
            return fourHexEscape(hexadecimal(first, lowercaseHex)) + fourHexEscape(hexadecimal(second, lowercaseHex));
          }
          if (lone) {
            return fourHexEscape(hexadecimal(lone.charCodeAt(0), lowercaseHex));
          }
          if (char == "\0" && !json && !regexDigit.test(string.charAt(index2 + 1))) {
            return "\\0";
          }
          if (quoteChar) {
            if (quoteChar == quote || options.escapeEverything) {
              return "\\" + quoteChar;
            }
            return quoteChar;
          }
          if (regexSingleEscape.test(char)) {
            return singleEscapes[char];
          }
          if (options.minimal && !regexWhitespace.test(char)) {
            return char;
          }
          const hex = hexadecimal(char.charCodeAt(0), lowercaseHex);
          if (json || hex.length > 2) {
            return fourHexEscape(hex);
          }
          return "\\x" + ("00" + hex).slice(-2);
        });
        if (quote == "`") {
          result = result.replace(/\$\{/g, "\\${");
        }
        if (options.isScriptContext) {
          result = result.replace(/<\/(script|style)/gi, "<\\/$1").replace(/<!--/g, json ? "\\u003C!--" : "\\x3C!--");
        }
        if (options.wrap) {
          result = quote + result + quote;
        }
        return result;
      };
      jsesc2.version = "3.0.2";
      module.exports = jsesc2;
    }
  });

  // node_modules/@babel/types/lib/index.js
  var lib_exports = {};
  __export(lib_exports, {
    ACCESSOR_TYPES: () => ACCESSOR_TYPES,
    ALIAS_KEYS: () => ALIAS_KEYS,
    ASSIGNMENT_OPERATORS: () => ASSIGNMENT_OPERATORS,
    AnyTypeAnnotation: () => AnyTypeAnnotation,
    ArgumentPlaceholder: () => ArgumentPlaceholder,
    ArrayExpression: () => ArrayExpression,
    ArrayPattern: () => ArrayPattern,
    ArrayTypeAnnotation: () => ArrayTypeAnnotation,
    ArrowFunctionExpression: () => ArrowFunctionExpression,
    AssignmentExpression: () => AssignmentExpression,
    AssignmentPattern: () => AssignmentPattern,
    AwaitExpression: () => AwaitExpression,
    BINARY_OPERATORS: () => BINARY_OPERATORS,
    BINARY_TYPES: () => BINARY_TYPES,
    BLOCKPARENT_TYPES: () => BLOCKPARENT_TYPES,
    BLOCK_TYPES: () => BLOCK_TYPES,
    BOOLEAN_BINARY_OPERATORS: () => BOOLEAN_BINARY_OPERATORS,
    BOOLEAN_NUMBER_BINARY_OPERATORS: () => BOOLEAN_NUMBER_BINARY_OPERATORS,
    BOOLEAN_UNARY_OPERATORS: () => BOOLEAN_UNARY_OPERATORS,
    BUILDER_KEYS: () => BUILDER_KEYS,
    BigIntLiteral: () => BigIntLiteral,
    BigIntLiteralTypeAnnotation: () => BigIntLiteralTypeAnnotation,
    BinaryExpression: () => BinaryExpression,
    BindExpression: () => BindExpression,
    BlockStatement: () => BlockStatement,
    BooleanLiteral: () => BooleanLiteral,
    BooleanLiteralTypeAnnotation: () => BooleanLiteralTypeAnnotation,
    BooleanTypeAnnotation: () => BooleanTypeAnnotation,
    BreakStatement: () => BreakStatement,
    CLASS_TYPES: () => CLASS_TYPES,
    COMMENT_KEYS: () => COMMENT_KEYS,
    COMPARISON_BINARY_OPERATORS: () => COMPARISON_BINARY_OPERATORS,
    COMPLETIONSTATEMENT_TYPES: () => COMPLETIONSTATEMENT_TYPES,
    CONDITIONAL_TYPES: () => CONDITIONAL_TYPES,
    CallExpression: () => CallExpression,
    CatchClause: () => CatchClause,
    ClassAccessorProperty: () => ClassAccessorProperty,
    ClassBody: () => ClassBody,
    ClassDeclaration: () => ClassDeclaration,
    ClassExpression: () => ClassExpression,
    ClassImplements: () => ClassImplements,
    ClassMethod: () => ClassMethod,
    ClassPrivateMethod: () => ClassPrivateMethod,
    ClassPrivateProperty: () => ClassPrivateProperty,
    ClassProperty: () => ClassProperty,
    ConditionalExpression: () => ConditionalExpression,
    ContinueStatement: () => ContinueStatement,
    DECLARATION_TYPES: () => DECLARATION_TYPES,
    DEPRECATED_ALIASES: () => DEPRECATED_ALIASES,
    DEPRECATED_KEYS: () => DEPRECATED_KEYS,
    DebuggerStatement: () => DebuggerStatement,
    DeclareClass: () => DeclareClass,
    DeclareExportAllDeclaration: () => DeclareExportAllDeclaration,
    DeclareExportDeclaration: () => DeclareExportDeclaration,
    DeclareFunction: () => DeclareFunction,
    DeclareInterface: () => DeclareInterface,
    DeclareModule: () => DeclareModule,
    DeclareModuleExports: () => DeclareModuleExports,
    DeclareOpaqueType: () => DeclareOpaqueType,
    DeclareTypeAlias: () => DeclareTypeAlias,
    DeclareVariable: () => DeclareVariable,
    DeclaredPredicate: () => DeclaredPredicate,
    Decorator: () => Decorator,
    Directive: () => Directive,
    DirectiveLiteral: () => DirectiveLiteral,
    DoExpression: () => DoExpression,
    DoWhileStatement: () => DoWhileStatement,
    ENUMBODY_TYPES: () => ENUMBODY_TYPES,
    ENUMMEMBER_TYPES: () => ENUMMEMBER_TYPES,
    EQUALITY_BINARY_OPERATORS: () => EQUALITY_BINARY_OPERATORS,
    EXPORTDECLARATION_TYPES: () => EXPORTDECLARATION_TYPES,
    EXPRESSIONWRAPPER_TYPES: () => EXPRESSIONWRAPPER_TYPES,
    EXPRESSION_TYPES: () => EXPRESSION_TYPES,
    EmptyStatement: () => EmptyStatement,
    EmptyTypeAnnotation: () => EmptyTypeAnnotation,
    EnumBooleanBody: () => EnumBooleanBody,
    EnumBooleanMember: () => EnumBooleanMember,
    EnumDeclaration: () => EnumDeclaration,
    EnumDefaultedMember: () => EnumDefaultedMember,
    EnumNumberBody: () => EnumNumberBody,
    EnumNumberMember: () => EnumNumberMember,
    EnumStringBody: () => EnumStringBody,
    EnumStringMember: () => EnumStringMember,
    EnumSymbolBody: () => EnumSymbolBody,
    ExistsTypeAnnotation: () => ExistsTypeAnnotation,
    ExportAllDeclaration: () => ExportAllDeclaration,
    ExportDefaultDeclaration: () => ExportDefaultDeclaration,
    ExportDefaultSpecifier: () => ExportDefaultSpecifier,
    ExportNamedDeclaration: () => ExportNamedDeclaration,
    ExportNamespaceSpecifier: () => ExportNamespaceSpecifier,
    ExportSpecifier: () => ExportSpecifier,
    ExpressionStatement: () => ExpressionStatement,
    FLATTENABLE_KEYS: () => FLATTENABLE_KEYS,
    FLIPPED_ALIAS_KEYS: () => FLIPPED_ALIAS_KEYS,
    FLOWBASEANNOTATION_TYPES: () => FLOWBASEANNOTATION_TYPES,
    FLOWDECLARATION_TYPES: () => FLOWDECLARATION_TYPES,
    FLOWPREDICATE_TYPES: () => FLOWPREDICATE_TYPES,
    FLOWTYPE_TYPES: () => FLOWTYPE_TYPES,
    FLOW_TYPES: () => FLOW_TYPES,
    FORXSTATEMENT_TYPES: () => FORXSTATEMENT_TYPES,
    FOR_INIT_KEYS: () => FOR_INIT_KEYS,
    FOR_TYPES: () => FOR_TYPES,
    FUNCTIONPARAMETER_TYPES: () => FUNCTIONPARAMETER_TYPES,
    FUNCTIONPARENT_TYPES: () => FUNCTIONPARENT_TYPES,
    FUNCTION_TYPES: () => FUNCTION_TYPES,
    File: () => File,
    ForInStatement: () => ForInStatement,
    ForOfStatement: () => ForOfStatement,
    ForStatement: () => ForStatement,
    FunctionDeclaration: () => FunctionDeclaration,
    FunctionExpression: () => FunctionExpression,
    FunctionTypeAnnotation: () => FunctionTypeAnnotation,
    FunctionTypeParam: () => FunctionTypeParam,
    GenericTypeAnnotation: () => GenericTypeAnnotation,
    IMMUTABLE_TYPES: () => IMMUTABLE_TYPES,
    IMPORTOREXPORTDECLARATION_TYPES: () => IMPORTOREXPORTDECLARATION_TYPES,
    INHERIT_KEYS: () => INHERIT_KEYS,
    Identifier: () => Identifier,
    IfStatement: () => IfStatement,
    Import: () => Import,
    ImportAttribute: () => ImportAttribute,
    ImportDeclaration: () => ImportDeclaration,
    ImportDefaultSpecifier: () => ImportDefaultSpecifier,
    ImportExpression: () => ImportExpression,
    ImportNamespaceSpecifier: () => ImportNamespaceSpecifier,
    ImportSpecifier: () => ImportSpecifier,
    IndexedAccessType: () => IndexedAccessType,
    InferredPredicate: () => InferredPredicate,
    InterfaceDeclaration: () => InterfaceDeclaration,
    InterfaceExtends: () => InterfaceExtends,
    InterfaceTypeAnnotation: () => InterfaceTypeAnnotation,
    InterpreterDirective: () => InterpreterDirective,
    IntersectionTypeAnnotation: () => IntersectionTypeAnnotation,
    JSXAttribute: () => JSXAttribute,
    JSXClosingElement: () => JSXClosingElement,
    JSXClosingFragment: () => JSXClosingFragment,
    JSXElement: () => JSXElement,
    JSXEmptyExpression: () => JSXEmptyExpression,
    JSXExpressionContainer: () => JSXExpressionContainer,
    JSXFragment: () => JSXFragment,
    JSXIdentifier: () => JSXIdentifier,
    JSXMemberExpression: () => JSXMemberExpression,
    JSXNamespacedName: () => JSXNamespacedName,
    JSXOpeningElement: () => JSXOpeningElement,
    JSXOpeningFragment: () => JSXOpeningFragment,
    JSXSpreadAttribute: () => JSXSpreadAttribute,
    JSXSpreadChild: () => JSXSpreadChild,
    JSXText: () => JSXText,
    JSX_TYPES: () => JSX_TYPES,
    LITERAL_TYPES: () => LITERAL_TYPES,
    LOGICAL_OPERATORS: () => LOGICAL_OPERATORS,
    LOOP_TYPES: () => LOOP_TYPES,
    LVAL_TYPES: () => LVAL_TYPES,
    LabeledStatement: () => LabeledStatement,
    LogicalExpression: () => LogicalExpression,
    METHOD_TYPES: () => METHOD_TYPES,
    MISCELLANEOUS_TYPES: () => MISCELLANEOUS_TYPES,
    MODULEDECLARATION_TYPES: () => MODULEDECLARATION_TYPES,
    MODULESPECIFIER_TYPES: () => MODULESPECIFIER_TYPES,
    MemberExpression: () => MemberExpression,
    MetaProperty: () => MetaProperty,
    MixedTypeAnnotation: () => MixedTypeAnnotation,
    ModuleExpression: () => ModuleExpression,
    NODE_FIELDS: () => NODE_FIELDS$1,
    NODE_PARENT_VALIDATIONS: () => NODE_PARENT_VALIDATIONS,
    NODE_UNION_SHAPES__PRIVATE: () => NODE_UNION_SHAPES__PRIVATE,
    NUMBER_BINARY_OPERATORS: () => NUMBER_BINARY_OPERATORS,
    NUMBER_UNARY_OPERATORS: () => NUMBER_UNARY_OPERATORS,
    NewExpression: () => NewExpression,
    NullLiteral: () => NullLiteral,
    NullLiteralTypeAnnotation: () => NullLiteralTypeAnnotation,
    NullableTypeAnnotation: () => NullableTypeAnnotation,
    NumberLiteralTypeAnnotation: () => NumberLiteralTypeAnnotation,
    NumberTypeAnnotation: () => NumberTypeAnnotation,
    NumericLiteral: () => NumericLiteral,
    OBJECTMEMBER_TYPES: () => OBJECTMEMBER_TYPES,
    ObjectExpression: () => ObjectExpression,
    ObjectMethod: () => ObjectMethod,
    ObjectPattern: () => ObjectPattern,
    ObjectProperty: () => ObjectProperty,
    ObjectTypeAnnotation: () => ObjectTypeAnnotation,
    ObjectTypeCallProperty: () => ObjectTypeCallProperty,
    ObjectTypeIndexer: () => ObjectTypeIndexer,
    ObjectTypeInternalSlot: () => ObjectTypeInternalSlot,
    ObjectTypeProperty: () => ObjectTypeProperty,
    ObjectTypeSpreadProperty: () => ObjectTypeSpreadProperty,
    OpaqueType: () => OpaqueType,
    OptionalCallExpression: () => OptionalCallExpression,
    OptionalIndexedAccessType: () => OptionalIndexedAccessType,
    OptionalMemberExpression: () => OptionalMemberExpression,
    PATTERNLIKE_TYPES: () => PATTERNLIKE_TYPES,
    PATTERN_TYPES: () => PATTERN_TYPES,
    PLACEHOLDERS: () => PLACEHOLDERS,
    PLACEHOLDERS_ALIAS: () => PLACEHOLDERS_ALIAS,
    PLACEHOLDERS_FLIPPED_ALIAS: () => PLACEHOLDERS_FLIPPED_ALIAS,
    PRIVATE_TYPES: () => PRIVATE_TYPES,
    PROPERTY_TYPES: () => PROPERTY_TYPES,
    PUREISH_TYPES: () => PUREISH_TYPES,
    ParenthesizedExpression: () => ParenthesizedExpression,
    Placeholder: () => Placeholder,
    PrivateName: () => PrivateName,
    Program: () => Program,
    QualifiedTypeIdentifier: () => QualifiedTypeIdentifier,
    RegExpLiteral: () => RegExpLiteral,
    RestElement: () => RestElement,
    ReturnStatement: () => ReturnStatement,
    SCOPABLE_TYPES: () => SCOPABLE_TYPES,
    STANDARDIZED_TYPES: () => STANDARDIZED_TYPES,
    STATEMENT_OR_BLOCK_KEYS: () => STATEMENT_OR_BLOCK_KEYS,
    STATEMENT_TYPES: () => STATEMENT_TYPES,
    STRING_UNARY_OPERATORS: () => STRING_UNARY_OPERATORS,
    SequenceExpression: () => SequenceExpression,
    SpreadElement: () => SpreadElement,
    StaticBlock: () => StaticBlock,
    StringLiteral: () => StringLiteral,
    StringLiteralTypeAnnotation: () => StringLiteralTypeAnnotation,
    StringTypeAnnotation: () => StringTypeAnnotation,
    Super: () => Super,
    SwitchCase: () => SwitchCase,
    SwitchStatement: () => SwitchStatement,
    SymbolTypeAnnotation: () => SymbolTypeAnnotation,
    TERMINATORLESS_TYPES: () => TERMINATORLESS_TYPES,
    TSAnyKeyword: () => TSAnyKeyword,
    TSArrayType: () => TSArrayType,
    TSAsExpression: () => TSAsExpression,
    TSBASETYPE_TYPES: () => TSBASETYPE_TYPES,
    TSBigIntKeyword: () => TSBigIntKeyword,
    TSBooleanKeyword: () => TSBooleanKeyword,
    TSCallSignatureDeclaration: () => TSCallSignatureDeclaration,
    TSClassImplements: () => TSClassImplements,
    TSConditionalType: () => TSConditionalType,
    TSConstructSignatureDeclaration: () => TSConstructSignatureDeclaration,
    TSConstructorType: () => TSConstructorType,
    TSDeclareFunction: () => TSDeclareFunction,
    TSDeclareMethod: () => TSDeclareMethod,
    TSENTITYNAME_TYPES: () => TSENTITYNAME_TYPES,
    TSEnumBody: () => TSEnumBody,
    TSEnumDeclaration: () => TSEnumDeclaration,
    TSEnumMember: () => TSEnumMember,
    TSExportAssignment: () => TSExportAssignment,
    TSExternalModuleReference: () => TSExternalModuleReference,
    TSFunctionType: () => TSFunctionType,
    TSImportEqualsDeclaration: () => TSImportEqualsDeclaration,
    TSImportType: () => TSImportType,
    TSIndexSignature: () => TSIndexSignature,
    TSIndexedAccessType: () => TSIndexedAccessType,
    TSInferType: () => TSInferType,
    TSInstantiationExpression: () => TSInstantiationExpression,
    TSInterfaceBody: () => TSInterfaceBody,
    TSInterfaceDeclaration: () => TSInterfaceDeclaration,
    TSInterfaceHeritage: () => TSInterfaceHeritage,
    TSIntersectionType: () => TSIntersectionType,
    TSIntrinsicKeyword: () => TSIntrinsicKeyword,
    TSLiteralType: () => TSLiteralType,
    TSMappedType: () => TSMappedType,
    TSMethodSignature: () => TSMethodSignature,
    TSModuleBlock: () => TSModuleBlock,
    TSModuleDeclaration: () => TSModuleDeclaration,
    TSNamedTupleMember: () => TSNamedTupleMember,
    TSNamespaceExportDeclaration: () => TSNamespaceExportDeclaration,
    TSNeverKeyword: () => TSNeverKeyword,
    TSNonNullExpression: () => TSNonNullExpression,
    TSNullKeyword: () => TSNullKeyword,
    TSNumberKeyword: () => TSNumberKeyword,
    TSObjectKeyword: () => TSObjectKeyword,
    TSOptionalType: () => TSOptionalType,
    TSParameterProperty: () => TSParameterProperty,
    TSParenthesizedType: () => TSParenthesizedType,
    TSPropertySignature: () => TSPropertySignature,
    TSQualifiedName: () => TSQualifiedName,
    TSRestType: () => TSRestType,
    TSSatisfiesExpression: () => TSSatisfiesExpression,
    TSStringKeyword: () => TSStringKeyword,
    TSSymbolKeyword: () => TSSymbolKeyword,
    TSTYPEELEMENT_TYPES: () => TSTYPEELEMENT_TYPES,
    TSTYPE_TYPES: () => TSTYPE_TYPES,
    TSTemplateLiteralType: () => TSTemplateLiteralType,
    TSThisType: () => TSThisType,
    TSTupleType: () => TSTupleType,
    TSTypeAliasDeclaration: () => TSTypeAliasDeclaration,
    TSTypeAnnotation: () => TSTypeAnnotation,
    TSTypeAssertion: () => TSTypeAssertion,
    TSTypeLiteral: () => TSTypeLiteral,
    TSTypeOperator: () => TSTypeOperator,
    TSTypeParameter: () => TSTypeParameter,
    TSTypeParameterDeclaration: () => TSTypeParameterDeclaration,
    TSTypeParameterInstantiation: () => TSTypeParameterInstantiation,
    TSTypePredicate: () => TSTypePredicate,
    TSTypeQuery: () => TSTypeQuery,
    TSTypeReference: () => TSTypeReference,
    TSUndefinedKeyword: () => TSUndefinedKeyword,
    TSUnionType: () => TSUnionType,
    TSUnknownKeyword: () => TSUnknownKeyword,
    TSVoidKeyword: () => TSVoidKeyword,
    TYPES: () => TYPES,
    TYPESCRIPT_TYPES: () => TYPESCRIPT_TYPES,
    TaggedTemplateExpression: () => TaggedTemplateExpression,
    TemplateElement: () => TemplateElement,
    TemplateLiteral: () => TemplateLiteral,
    ThisExpression: () => ThisExpression,
    ThisTypeAnnotation: () => ThisTypeAnnotation,
    ThrowStatement: () => ThrowStatement,
    TopicReference: () => TopicReference,
    TryStatement: () => TryStatement,
    TupleTypeAnnotation: () => TupleTypeAnnotation,
    TypeAlias: () => TypeAlias,
    TypeAnnotation: () => TypeAnnotation,
    TypeCastExpression: () => TypeCastExpression,
    TypeParameter: () => TypeParameter,
    TypeParameterDeclaration: () => TypeParameterDeclaration,
    TypeParameterInstantiation: () => TypeParameterInstantiation,
    TypeofTypeAnnotation: () => TypeofTypeAnnotation,
    UNARYLIKE_TYPES: () => UNARYLIKE_TYPES,
    UNARY_OPERATORS: () => UNARY_OPERATORS,
    UPDATE_OPERATORS: () => UPDATE_OPERATORS,
    USERWHITESPACABLE_TYPES: () => USERWHITESPACABLE_TYPES,
    UnaryExpression: () => UnaryExpression,
    UnionTypeAnnotation: () => UnionTypeAnnotation,
    UpdateExpression: () => UpdateExpression,
    V8IntrinsicIdentifier: () => V8IntrinsicIdentifier,
    VISITOR_KEYS: () => VISITOR_KEYS,
    VariableDeclaration: () => VariableDeclaration,
    VariableDeclarator: () => VariableDeclarator,
    Variance: () => Variance,
    VoidPattern: () => VoidPattern,
    VoidTypeAnnotation: () => VoidTypeAnnotation,
    WHILE_TYPES: () => WHILE_TYPES,
    WhileStatement: () => WhileStatement,
    WithStatement: () => WithStatement,
    YieldExpression: () => YieldExpression,
    __internal__deprecationWarning: () => deprecationWarning,
    addComment: () => addComment,
    addComments: () => addComments,
    anyTypeAnnotation: () => anyTypeAnnotation,
    appendToMemberExpression: () => appendToMemberExpression,
    argumentPlaceholder: () => argumentPlaceholder,
    arrayExpression: () => arrayExpression,
    arrayPattern: () => arrayPattern,
    arrayTypeAnnotation: () => arrayTypeAnnotation,
    arrowFunctionExpression: () => arrowFunctionExpression,
    assertAccessor: () => assertAccessor,
    assertAnyTypeAnnotation: () => assertAnyTypeAnnotation,
    assertArgumentPlaceholder: () => assertArgumentPlaceholder,
    assertArrayExpression: () => assertArrayExpression,
    assertArrayPattern: () => assertArrayPattern,
    assertArrayTypeAnnotation: () => assertArrayTypeAnnotation,
    assertArrowFunctionExpression: () => assertArrowFunctionExpression,
    assertAssignmentExpression: () => assertAssignmentExpression,
    assertAssignmentPattern: () => assertAssignmentPattern,
    assertAwaitExpression: () => assertAwaitExpression,
    assertBigIntLiteral: () => assertBigIntLiteral,
    assertBigIntLiteralTypeAnnotation: () => assertBigIntLiteralTypeAnnotation,
    assertBinary: () => assertBinary,
    assertBinaryExpression: () => assertBinaryExpression,
    assertBindExpression: () => assertBindExpression,
    assertBlock: () => assertBlock,
    assertBlockParent: () => assertBlockParent,
    assertBlockStatement: () => assertBlockStatement,
    assertBooleanLiteral: () => assertBooleanLiteral,
    assertBooleanLiteralTypeAnnotation: () => assertBooleanLiteralTypeAnnotation,
    assertBooleanTypeAnnotation: () => assertBooleanTypeAnnotation,
    assertBreakStatement: () => assertBreakStatement,
    assertCallExpression: () => assertCallExpression,
    assertCatchClause: () => assertCatchClause,
    assertClass: () => assertClass,
    assertClassAccessorProperty: () => assertClassAccessorProperty,
    assertClassBody: () => assertClassBody,
    assertClassDeclaration: () => assertClassDeclaration,
    assertClassExpression: () => assertClassExpression,
    assertClassImplements: () => assertClassImplements,
    assertClassMethod: () => assertClassMethod,
    assertClassPrivateMethod: () => assertClassPrivateMethod,
    assertClassPrivateProperty: () => assertClassPrivateProperty,
    assertClassProperty: () => assertClassProperty,
    assertCompletionStatement: () => assertCompletionStatement,
    assertConditional: () => assertConditional,
    assertConditionalExpression: () => assertConditionalExpression,
    assertContinueStatement: () => assertContinueStatement,
    assertDebuggerStatement: () => assertDebuggerStatement,
    assertDeclaration: () => assertDeclaration,
    assertDeclareClass: () => assertDeclareClass,
    assertDeclareExportAllDeclaration: () => assertDeclareExportAllDeclaration,
    assertDeclareExportDeclaration: () => assertDeclareExportDeclaration,
    assertDeclareFunction: () => assertDeclareFunction,
    assertDeclareInterface: () => assertDeclareInterface,
    assertDeclareModule: () => assertDeclareModule,
    assertDeclareModuleExports: () => assertDeclareModuleExports,
    assertDeclareOpaqueType: () => assertDeclareOpaqueType,
    assertDeclareTypeAlias: () => assertDeclareTypeAlias,
    assertDeclareVariable: () => assertDeclareVariable,
    assertDeclaredPredicate: () => assertDeclaredPredicate,
    assertDecorator: () => assertDecorator,
    assertDirective: () => assertDirective,
    assertDirectiveLiteral: () => assertDirectiveLiteral,
    assertDoExpression: () => assertDoExpression,
    assertDoWhileStatement: () => assertDoWhileStatement,
    assertEmptyStatement: () => assertEmptyStatement,
    assertEmptyTypeAnnotation: () => assertEmptyTypeAnnotation,
    assertEnumBody: () => assertEnumBody,
    assertEnumBooleanBody: () => assertEnumBooleanBody,
    assertEnumBooleanMember: () => assertEnumBooleanMember,
    assertEnumDeclaration: () => assertEnumDeclaration,
    assertEnumDefaultedMember: () => assertEnumDefaultedMember,
    assertEnumMember: () => assertEnumMember,
    assertEnumNumberBody: () => assertEnumNumberBody,
    assertEnumNumberMember: () => assertEnumNumberMember,
    assertEnumStringBody: () => assertEnumStringBody,
    assertEnumStringMember: () => assertEnumStringMember,
    assertEnumSymbolBody: () => assertEnumSymbolBody,
    assertExistsTypeAnnotation: () => assertExistsTypeAnnotation,
    assertExportAllDeclaration: () => assertExportAllDeclaration,
    assertExportDeclaration: () => assertExportDeclaration,
    assertExportDefaultDeclaration: () => assertExportDefaultDeclaration,
    assertExportDefaultSpecifier: () => assertExportDefaultSpecifier,
    assertExportNamedDeclaration: () => assertExportNamedDeclaration,
    assertExportNamespaceSpecifier: () => assertExportNamespaceSpecifier,
    assertExportSpecifier: () => assertExportSpecifier,
    assertExpression: () => assertExpression,
    assertExpressionStatement: () => assertExpressionStatement,
    assertExpressionWrapper: () => assertExpressionWrapper,
    assertFile: () => assertFile,
    assertFlow: () => assertFlow,
    assertFlowBaseAnnotation: () => assertFlowBaseAnnotation,
    assertFlowDeclaration: () => assertFlowDeclaration,
    assertFlowPredicate: () => assertFlowPredicate,
    assertFlowType: () => assertFlowType,
    assertFor: () => assertFor,
    assertForInStatement: () => assertForInStatement,
    assertForOfStatement: () => assertForOfStatement,
    assertForStatement: () => assertForStatement,
    assertForXStatement: () => assertForXStatement,
    assertFunction: () => assertFunction,
    assertFunctionDeclaration: () => assertFunctionDeclaration,
    assertFunctionExpression: () => assertFunctionExpression,
    assertFunctionParameter: () => assertFunctionParameter,
    assertFunctionParent: () => assertFunctionParent,
    assertFunctionTypeAnnotation: () => assertFunctionTypeAnnotation,
    assertFunctionTypeParam: () => assertFunctionTypeParam,
    assertGenericTypeAnnotation: () => assertGenericTypeAnnotation,
    assertIdentifier: () => assertIdentifier,
    assertIfStatement: () => assertIfStatement,
    assertImmutable: () => assertImmutable,
    assertImport: () => assertImport,
    assertImportAttribute: () => assertImportAttribute,
    assertImportDeclaration: () => assertImportDeclaration,
    assertImportDefaultSpecifier: () => assertImportDefaultSpecifier,
    assertImportExpression: () => assertImportExpression,
    assertImportNamespaceSpecifier: () => assertImportNamespaceSpecifier,
    assertImportOrExportDeclaration: () => assertImportOrExportDeclaration,
    assertImportSpecifier: () => assertImportSpecifier,
    assertIndexedAccessType: () => assertIndexedAccessType,
    assertInferredPredicate: () => assertInferredPredicate,
    assertInterfaceDeclaration: () => assertInterfaceDeclaration,
    assertInterfaceExtends: () => assertInterfaceExtends,
    assertInterfaceTypeAnnotation: () => assertInterfaceTypeAnnotation,
    assertInterpreterDirective: () => assertInterpreterDirective,
    assertIntersectionTypeAnnotation: () => assertIntersectionTypeAnnotation,
    assertJSX: () => assertJSX,
    assertJSXAttribute: () => assertJSXAttribute,
    assertJSXClosingElement: () => assertJSXClosingElement,
    assertJSXClosingFragment: () => assertJSXClosingFragment,
    assertJSXElement: () => assertJSXElement,
    assertJSXEmptyExpression: () => assertJSXEmptyExpression,
    assertJSXExpressionContainer: () => assertJSXExpressionContainer,
    assertJSXFragment: () => assertJSXFragment,
    assertJSXIdentifier: () => assertJSXIdentifier,
    assertJSXMemberExpression: () => assertJSXMemberExpression,
    assertJSXNamespacedName: () => assertJSXNamespacedName,
    assertJSXOpeningElement: () => assertJSXOpeningElement,
    assertJSXOpeningFragment: () => assertJSXOpeningFragment,
    assertJSXSpreadAttribute: () => assertJSXSpreadAttribute,
    assertJSXSpreadChild: () => assertJSXSpreadChild,
    assertJSXText: () => assertJSXText,
    assertLVal: () => assertLVal,
    assertLabeledStatement: () => assertLabeledStatement,
    assertLiteral: () => assertLiteral,
    assertLogicalExpression: () => assertLogicalExpression,
    assertLoop: () => assertLoop,
    assertMemberExpression: () => assertMemberExpression,
    assertMetaProperty: () => assertMetaProperty,
    assertMethod: () => assertMethod,
    assertMiscellaneous: () => assertMiscellaneous,
    assertMixedTypeAnnotation: () => assertMixedTypeAnnotation,
    assertModuleDeclaration: () => assertModuleDeclaration,
    assertModuleExpression: () => assertModuleExpression,
    assertModuleSpecifier: () => assertModuleSpecifier,
    assertNewExpression: () => assertNewExpression,
    assertNode: () => assertNode,
    assertNullLiteral: () => assertNullLiteral,
    assertNullLiteralTypeAnnotation: () => assertNullLiteralTypeAnnotation,
    assertNullableTypeAnnotation: () => assertNullableTypeAnnotation,
    assertNumberLiteral: () => assertNumberLiteral,
    assertNumberLiteralTypeAnnotation: () => assertNumberLiteralTypeAnnotation,
    assertNumberTypeAnnotation: () => assertNumberTypeAnnotation,
    assertNumericLiteral: () => assertNumericLiteral,
    assertObjectExpression: () => assertObjectExpression,
    assertObjectMember: () => assertObjectMember,
    assertObjectMethod: () => assertObjectMethod,
    assertObjectPattern: () => assertObjectPattern,
    assertObjectProperty: () => assertObjectProperty,
    assertObjectTypeAnnotation: () => assertObjectTypeAnnotation,
    assertObjectTypeCallProperty: () => assertObjectTypeCallProperty,
    assertObjectTypeIndexer: () => assertObjectTypeIndexer,
    assertObjectTypeInternalSlot: () => assertObjectTypeInternalSlot,
    assertObjectTypeProperty: () => assertObjectTypeProperty,
    assertObjectTypeSpreadProperty: () => assertObjectTypeSpreadProperty,
    assertOpaqueType: () => assertOpaqueType,
    assertOptionalCallExpression: () => assertOptionalCallExpression,
    assertOptionalIndexedAccessType: () => assertOptionalIndexedAccessType,
    assertOptionalMemberExpression: () => assertOptionalMemberExpression,
    assertParenthesizedExpression: () => assertParenthesizedExpression,
    assertPattern: () => assertPattern,
    assertPatternLike: () => assertPatternLike,
    assertPlaceholder: () => assertPlaceholder,
    assertPrivate: () => assertPrivate,
    assertPrivateName: () => assertPrivateName,
    assertProgram: () => assertProgram,
    assertProperty: () => assertProperty,
    assertPureish: () => assertPureish,
    assertQualifiedTypeIdentifier: () => assertQualifiedTypeIdentifier,
    assertRegExpLiteral: () => assertRegExpLiteral,
    assertRegexLiteral: () => assertRegexLiteral,
    assertRestElement: () => assertRestElement,
    assertRestProperty: () => assertRestProperty,
    assertReturnStatement: () => assertReturnStatement,
    assertScopable: () => assertScopable,
    assertSequenceExpression: () => assertSequenceExpression,
    assertSpreadElement: () => assertSpreadElement,
    assertSpreadProperty: () => assertSpreadProperty,
    assertStandardized: () => assertStandardized,
    assertStatement: () => assertStatement,
    assertStaticBlock: () => assertStaticBlock,
    assertStringLiteral: () => assertStringLiteral,
    assertStringLiteralTypeAnnotation: () => assertStringLiteralTypeAnnotation,
    assertStringTypeAnnotation: () => assertStringTypeAnnotation,
    assertSuper: () => assertSuper,
    assertSwitchCase: () => assertSwitchCase,
    assertSwitchStatement: () => assertSwitchStatement,
    assertSymbolTypeAnnotation: () => assertSymbolTypeAnnotation,
    assertTSAnyKeyword: () => assertTSAnyKeyword,
    assertTSArrayType: () => assertTSArrayType,
    assertTSAsExpression: () => assertTSAsExpression,
    assertTSBaseType: () => assertTSBaseType,
    assertTSBigIntKeyword: () => assertTSBigIntKeyword,
    assertTSBooleanKeyword: () => assertTSBooleanKeyword,
    assertTSCallSignatureDeclaration: () => assertTSCallSignatureDeclaration,
    assertTSClassImplements: () => assertTSClassImplements,
    assertTSConditionalType: () => assertTSConditionalType,
    assertTSConstructSignatureDeclaration: () => assertTSConstructSignatureDeclaration,
    assertTSConstructorType: () => assertTSConstructorType,
    assertTSDeclareFunction: () => assertTSDeclareFunction,
    assertTSDeclareMethod: () => assertTSDeclareMethod,
    assertTSEntityName: () => assertTSEntityName,
    assertTSEnumBody: () => assertTSEnumBody,
    assertTSEnumDeclaration: () => assertTSEnumDeclaration,
    assertTSEnumMember: () => assertTSEnumMember,
    assertTSExportAssignment: () => assertTSExportAssignment,
    assertTSExternalModuleReference: () => assertTSExternalModuleReference,
    assertTSFunctionType: () => assertTSFunctionType,
    assertTSImportEqualsDeclaration: () => assertTSImportEqualsDeclaration,
    assertTSImportType: () => assertTSImportType,
    assertTSIndexSignature: () => assertTSIndexSignature,
    assertTSIndexedAccessType: () => assertTSIndexedAccessType,
    assertTSInferType: () => assertTSInferType,
    assertTSInstantiationExpression: () => assertTSInstantiationExpression,
    assertTSInterfaceBody: () => assertTSInterfaceBody,
    assertTSInterfaceDeclaration: () => assertTSInterfaceDeclaration,
    assertTSInterfaceHeritage: () => assertTSInterfaceHeritage,
    assertTSIntersectionType: () => assertTSIntersectionType,
    assertTSIntrinsicKeyword: () => assertTSIntrinsicKeyword,
    assertTSLiteralType: () => assertTSLiteralType,
    assertTSMappedType: () => assertTSMappedType,
    assertTSMethodSignature: () => assertTSMethodSignature,
    assertTSModuleBlock: () => assertTSModuleBlock,
    assertTSModuleDeclaration: () => assertTSModuleDeclaration,
    assertTSNamedTupleMember: () => assertTSNamedTupleMember,
    assertTSNamespaceExportDeclaration: () => assertTSNamespaceExportDeclaration,
    assertTSNeverKeyword: () => assertTSNeverKeyword,
    assertTSNonNullExpression: () => assertTSNonNullExpression,
    assertTSNullKeyword: () => assertTSNullKeyword,
    assertTSNumberKeyword: () => assertTSNumberKeyword,
    assertTSObjectKeyword: () => assertTSObjectKeyword,
    assertTSOptionalType: () => assertTSOptionalType,
    assertTSParameterProperty: () => assertTSParameterProperty,
    assertTSParenthesizedType: () => assertTSParenthesizedType,
    assertTSPropertySignature: () => assertTSPropertySignature,
    assertTSQualifiedName: () => assertTSQualifiedName,
    assertTSRestType: () => assertTSRestType,
    assertTSSatisfiesExpression: () => assertTSSatisfiesExpression,
    assertTSStringKeyword: () => assertTSStringKeyword,
    assertTSSymbolKeyword: () => assertTSSymbolKeyword,
    assertTSTemplateLiteralType: () => assertTSTemplateLiteralType,
    assertTSThisType: () => assertTSThisType,
    assertTSTupleType: () => assertTSTupleType,
    assertTSType: () => assertTSType,
    assertTSTypeAliasDeclaration: () => assertTSTypeAliasDeclaration,
    assertTSTypeAnnotation: () => assertTSTypeAnnotation,
    assertTSTypeAssertion: () => assertTSTypeAssertion,
    assertTSTypeElement: () => assertTSTypeElement,
    assertTSTypeLiteral: () => assertTSTypeLiteral,
    assertTSTypeOperator: () => assertTSTypeOperator,
    assertTSTypeParameter: () => assertTSTypeParameter,
    assertTSTypeParameterDeclaration: () => assertTSTypeParameterDeclaration,
    assertTSTypeParameterInstantiation: () => assertTSTypeParameterInstantiation,
    assertTSTypePredicate: () => assertTSTypePredicate,
    assertTSTypeQuery: () => assertTSTypeQuery,
    assertTSTypeReference: () => assertTSTypeReference,
    assertTSUndefinedKeyword: () => assertTSUndefinedKeyword,
    assertTSUnionType: () => assertTSUnionType,
    assertTSUnknownKeyword: () => assertTSUnknownKeyword,
    assertTSVoidKeyword: () => assertTSVoidKeyword,
    assertTaggedTemplateExpression: () => assertTaggedTemplateExpression,
    assertTemplateElement: () => assertTemplateElement,
    assertTemplateLiteral: () => assertTemplateLiteral,
    assertTerminatorless: () => assertTerminatorless,
    assertThisExpression: () => assertThisExpression,
    assertThisTypeAnnotation: () => assertThisTypeAnnotation,
    assertThrowStatement: () => assertThrowStatement,
    assertTopicReference: () => assertTopicReference,
    assertTryStatement: () => assertTryStatement,
    assertTupleTypeAnnotation: () => assertTupleTypeAnnotation,
    assertTypeAlias: () => assertTypeAlias,
    assertTypeAnnotation: () => assertTypeAnnotation,
    assertTypeCastExpression: () => assertTypeCastExpression,
    assertTypeParameter: () => assertTypeParameter,
    assertTypeParameterDeclaration: () => assertTypeParameterDeclaration,
    assertTypeParameterInstantiation: () => assertTypeParameterInstantiation,
    assertTypeScript: () => assertTypeScript,
    assertTypeofTypeAnnotation: () => assertTypeofTypeAnnotation,
    assertUnaryExpression: () => assertUnaryExpression,
    assertUnaryLike: () => assertUnaryLike,
    assertUnionTypeAnnotation: () => assertUnionTypeAnnotation,
    assertUpdateExpression: () => assertUpdateExpression,
    assertUserWhitespacable: () => assertUserWhitespacable,
    assertV8IntrinsicIdentifier: () => assertV8IntrinsicIdentifier,
    assertVariableDeclaration: () => assertVariableDeclaration,
    assertVariableDeclarator: () => assertVariableDeclarator,
    assertVariance: () => assertVariance,
    assertVoidPattern: () => assertVoidPattern,
    assertVoidTypeAnnotation: () => assertVoidTypeAnnotation,
    assertWhile: () => assertWhile,
    assertWhileStatement: () => assertWhileStatement,
    assertWithStatement: () => assertWithStatement,
    assertYieldExpression: () => assertYieldExpression,
    assignmentExpression: () => assignmentExpression,
    assignmentPattern: () => assignmentPattern,
    awaitExpression: () => awaitExpression,
    bigIntLiteral: () => bigIntLiteral,
    bigIntLiteralTypeAnnotation: () => bigIntLiteralTypeAnnotation,
    binaryExpression: () => binaryExpression,
    bindExpression: () => bindExpression,
    blockStatement: () => blockStatement,
    booleanLiteral: () => booleanLiteral,
    booleanLiteralTypeAnnotation: () => booleanLiteralTypeAnnotation,
    booleanTypeAnnotation: () => booleanTypeAnnotation,
    breakStatement: () => breakStatement,
    buildMatchMemberExpression: () => buildMatchMemberExpression,
    buildUndefinedNode: () => buildUndefinedNode,
    callExpression: () => callExpression,
    catchClause: () => catchClause,
    classAccessorProperty: () => classAccessorProperty,
    classBody: () => classBody,
    classDeclaration: () => classDeclaration,
    classExpression: () => classExpression,
    classImplements: () => classImplements,
    classMethod: () => classMethod,
    classPrivateMethod: () => classPrivateMethod,
    classPrivateProperty: () => classPrivateProperty,
    classProperty: () => classProperty,
    clone: () => clone,
    cloneDeep: () => cloneDeep,
    cloneDeepWithoutLoc: () => cloneDeepWithoutLoc,
    cloneNode: () => cloneNode,
    cloneWithoutLoc: () => cloneWithoutLoc,
    conditionalExpression: () => conditionalExpression,
    continueStatement: () => continueStatement,
    createFlowUnionType: () => createFlowUnionType,
    createTSUnionType: () => createTSUnionType,
    createTypeAnnotationBasedOnTypeof: () => createTypeAnnotationBasedOnTypeof,
    createUnionTypeAnnotation: () => createFlowUnionType,
    debuggerStatement: () => debuggerStatement,
    declareClass: () => declareClass,
    declareExportAllDeclaration: () => declareExportAllDeclaration,
    declareExportDeclaration: () => declareExportDeclaration,
    declareFunction: () => declareFunction,
    declareInterface: () => declareInterface,
    declareModule: () => declareModule,
    declareModuleExports: () => declareModuleExports,
    declareOpaqueType: () => declareOpaqueType,
    declareTypeAlias: () => declareTypeAlias,
    declareVariable: () => declareVariable,
    declaredPredicate: () => declaredPredicate,
    decorator: () => decorator,
    directive: () => directive,
    directiveLiteral: () => directiveLiteral,
    doExpression: () => doExpression,
    doWhileStatement: () => doWhileStatement,
    emptyStatement: () => emptyStatement,
    emptyTypeAnnotation: () => emptyTypeAnnotation,
    ensureBlock: () => ensureBlock,
    enumBooleanBody: () => enumBooleanBody,
    enumBooleanMember: () => enumBooleanMember,
    enumDeclaration: () => enumDeclaration,
    enumDefaultedMember: () => enumDefaultedMember,
    enumNumberBody: () => enumNumberBody,
    enumNumberMember: () => enumNumberMember,
    enumStringBody: () => enumStringBody,
    enumStringMember: () => enumStringMember,
    enumSymbolBody: () => enumSymbolBody,
    existsTypeAnnotation: () => existsTypeAnnotation,
    exportAllDeclaration: () => exportAllDeclaration,
    exportDefaultDeclaration: () => exportDefaultDeclaration,
    exportDefaultSpecifier: () => exportDefaultSpecifier,
    exportNamedDeclaration: () => exportNamedDeclaration,
    exportNamespaceSpecifier: () => exportNamespaceSpecifier,
    exportSpecifier: () => exportSpecifier,
    expressionStatement: () => expressionStatement,
    file: () => file,
    forInStatement: () => forInStatement,
    forOfStatement: () => forOfStatement,
    forStatement: () => forStatement,
    functionDeclaration: () => functionDeclaration,
    functionExpression: () => functionExpression,
    functionTypeAnnotation: () => functionTypeAnnotation,
    functionTypeParam: () => functionTypeParam,
    genericTypeAnnotation: () => genericTypeAnnotation,
    getAssignmentIdentifiers: () => getAssignmentIdentifiers,
    getBindingIdentifiers: () => getBindingIdentifiers,
    getFunctionName: () => getFunctionName,
    getOuterBindingIdentifiers: () => getOuterBindingIdentifiers,
    identifier: () => identifier,
    ifStatement: () => ifStatement,
    import: () => _import,
    importAttribute: () => importAttribute,
    importDeclaration: () => importDeclaration,
    importDefaultSpecifier: () => importDefaultSpecifier,
    importExpression: () => importExpression,
    importNamespaceSpecifier: () => importNamespaceSpecifier,
    importSpecifier: () => importSpecifier,
    indexedAccessType: () => indexedAccessType,
    inferredPredicate: () => inferredPredicate,
    inheritInnerComments: () => inheritInnerComments,
    inheritLeadingComments: () => inheritLeadingComments,
    inheritTrailingComments: () => inheritTrailingComments,
    inherits: () => inherits,
    inheritsComments: () => inheritsComments,
    interfaceDeclaration: () => interfaceDeclaration,
    interfaceExtends: () => interfaceExtends,
    interfaceTypeAnnotation: () => interfaceTypeAnnotation,
    interpreterDirective: () => interpreterDirective,
    intersectionTypeAnnotation: () => intersectionTypeAnnotation,
    is: () => is,
    isAccessor: () => isAccessor,
    isAnyTypeAnnotation: () => isAnyTypeAnnotation,
    isArgumentPlaceholder: () => isArgumentPlaceholder,
    isArrayExpression: () => isArrayExpression,
    isArrayPattern: () => isArrayPattern,
    isArrayTypeAnnotation: () => isArrayTypeAnnotation,
    isArrowFunctionExpression: () => isArrowFunctionExpression,
    isAssignmentExpression: () => isAssignmentExpression,
    isAssignmentPattern: () => isAssignmentPattern,
    isAwaitExpression: () => isAwaitExpression,
    isBigIntLiteral: () => isBigIntLiteral,
    isBigIntLiteralTypeAnnotation: () => isBigIntLiteralTypeAnnotation,
    isBinary: () => isBinary,
    isBinaryExpression: () => isBinaryExpression,
    isBindExpression: () => isBindExpression,
    isBinding: () => isBinding,
    isBlock: () => isBlock,
    isBlockParent: () => isBlockParent,
    isBlockScoped: () => isBlockScoped,
    isBlockStatement: () => isBlockStatement,
    isBooleanLiteral: () => isBooleanLiteral,
    isBooleanLiteralTypeAnnotation: () => isBooleanLiteralTypeAnnotation,
    isBooleanTypeAnnotation: () => isBooleanTypeAnnotation,
    isBreakStatement: () => isBreakStatement,
    isCallExpression: () => isCallExpression,
    isCatchClause: () => isCatchClause,
    isClass: () => isClass,
    isClassAccessorProperty: () => isClassAccessorProperty,
    isClassBody: () => isClassBody,
    isClassDeclaration: () => isClassDeclaration,
    isClassExpression: () => isClassExpression,
    isClassImplements: () => isClassImplements,
    isClassMethod: () => isClassMethod,
    isClassPrivateMethod: () => isClassPrivateMethod,
    isClassPrivateProperty: () => isClassPrivateProperty,
    isClassProperty: () => isClassProperty,
    isCompletionStatement: () => isCompletionStatement,
    isConditional: () => isConditional,
    isConditionalExpression: () => isConditionalExpression,
    isContinueStatement: () => isContinueStatement,
    isDebuggerStatement: () => isDebuggerStatement,
    isDeclaration: () => isDeclaration,
    isDeclareClass: () => isDeclareClass,
    isDeclareExportAllDeclaration: () => isDeclareExportAllDeclaration,
    isDeclareExportDeclaration: () => isDeclareExportDeclaration,
    isDeclareFunction: () => isDeclareFunction,
    isDeclareInterface: () => isDeclareInterface,
    isDeclareModule: () => isDeclareModule,
    isDeclareModuleExports: () => isDeclareModuleExports,
    isDeclareOpaqueType: () => isDeclareOpaqueType,
    isDeclareTypeAlias: () => isDeclareTypeAlias,
    isDeclareVariable: () => isDeclareVariable,
    isDeclaredPredicate: () => isDeclaredPredicate,
    isDecorator: () => isDecorator,
    isDirective: () => isDirective,
    isDirectiveLiteral: () => isDirectiveLiteral,
    isDoExpression: () => isDoExpression,
    isDoWhileStatement: () => isDoWhileStatement,
    isEmptyStatement: () => isEmptyStatement,
    isEmptyTypeAnnotation: () => isEmptyTypeAnnotation,
    isEnumBody: () => isEnumBody,
    isEnumBooleanBody: () => isEnumBooleanBody,
    isEnumBooleanMember: () => isEnumBooleanMember,
    isEnumDeclaration: () => isEnumDeclaration,
    isEnumDefaultedMember: () => isEnumDefaultedMember,
    isEnumMember: () => isEnumMember,
    isEnumNumberBody: () => isEnumNumberBody,
    isEnumNumberMember: () => isEnumNumberMember,
    isEnumStringBody: () => isEnumStringBody,
    isEnumStringMember: () => isEnumStringMember,
    isEnumSymbolBody: () => isEnumSymbolBody,
    isExistsTypeAnnotation: () => isExistsTypeAnnotation,
    isExportAllDeclaration: () => isExportAllDeclaration,
    isExportDeclaration: () => isExportDeclaration,
    isExportDefaultDeclaration: () => isExportDefaultDeclaration,
    isExportDefaultSpecifier: () => isExportDefaultSpecifier,
    isExportNamedDeclaration: () => isExportNamedDeclaration,
    isExportNamespaceSpecifier: () => isExportNamespaceSpecifier,
    isExportSpecifier: () => isExportSpecifier,
    isExpression: () => isExpression,
    isExpressionStatement: () => isExpressionStatement,
    isExpressionWrapper: () => isExpressionWrapper,
    isFile: () => isFile,
    isFlow: () => isFlow,
    isFlowBaseAnnotation: () => isFlowBaseAnnotation,
    isFlowDeclaration: () => isFlowDeclaration,
    isFlowPredicate: () => isFlowPredicate,
    isFlowType: () => isFlowType,
    isFor: () => isFor,
    isForInStatement: () => isForInStatement,
    isForOfStatement: () => isForOfStatement,
    isForStatement: () => isForStatement,
    isForXStatement: () => isForXStatement,
    isFunction: () => isFunction,
    isFunctionDeclaration: () => isFunctionDeclaration,
    isFunctionExpression: () => isFunctionExpression,
    isFunctionParameter: () => isFunctionParameter,
    isFunctionParent: () => isFunctionParent,
    isFunctionTypeAnnotation: () => isFunctionTypeAnnotation,
    isFunctionTypeParam: () => isFunctionTypeParam,
    isGenericTypeAnnotation: () => isGenericTypeAnnotation,
    isIdentifier: () => isIdentifier,
    isIfStatement: () => isIfStatement,
    isImmutable: () => isImmutable,
    isImport: () => isImport,
    isImportAttribute: () => isImportAttribute,
    isImportDeclaration: () => isImportDeclaration,
    isImportDefaultSpecifier: () => isImportDefaultSpecifier,
    isImportExpression: () => isImportExpression,
    isImportNamespaceSpecifier: () => isImportNamespaceSpecifier,
    isImportOrExportDeclaration: () => isImportOrExportDeclaration,
    isImportSpecifier: () => isImportSpecifier,
    isIndexedAccessType: () => isIndexedAccessType,
    isInferredPredicate: () => isInferredPredicate,
    isInterfaceDeclaration: () => isInterfaceDeclaration,
    isInterfaceExtends: () => isInterfaceExtends,
    isInterfaceTypeAnnotation: () => isInterfaceTypeAnnotation,
    isInterpreterDirective: () => isInterpreterDirective,
    isIntersectionTypeAnnotation: () => isIntersectionTypeAnnotation,
    isJSX: () => isJSX,
    isJSXAttribute: () => isJSXAttribute,
    isJSXClosingElement: () => isJSXClosingElement,
    isJSXClosingFragment: () => isJSXClosingFragment,
    isJSXElement: () => isJSXElement,
    isJSXEmptyExpression: () => isJSXEmptyExpression,
    isJSXExpressionContainer: () => isJSXExpressionContainer,
    isJSXFragment: () => isJSXFragment,
    isJSXIdentifier: () => isJSXIdentifier,
    isJSXMemberExpression: () => isJSXMemberExpression,
    isJSXNamespacedName: () => isJSXNamespacedName,
    isJSXOpeningElement: () => isJSXOpeningElement,
    isJSXOpeningFragment: () => isJSXOpeningFragment,
    isJSXSpreadAttribute: () => isJSXSpreadAttribute,
    isJSXSpreadChild: () => isJSXSpreadChild,
    isJSXText: () => isJSXText,
    isLVal: () => isLVal,
    isLabeledStatement: () => isLabeledStatement,
    isLet: () => isLet,
    isLiteral: () => isLiteral,
    isLogicalExpression: () => isLogicalExpression,
    isLoop: () => isLoop,
    isMemberExpression: () => isMemberExpression,
    isMetaProperty: () => isMetaProperty,
    isMethod: () => isMethod,
    isMiscellaneous: () => isMiscellaneous,
    isMixedTypeAnnotation: () => isMixedTypeAnnotation,
    isModuleDeclaration: () => isModuleDeclaration,
    isModuleExpression: () => isModuleExpression,
    isModuleSpecifier: () => isModuleSpecifier,
    isNewExpression: () => isNewExpression,
    isNode: () => isNode,
    isNodesEquivalent: () => isNodesEquivalent,
    isNullLiteral: () => isNullLiteral,
    isNullLiteralTypeAnnotation: () => isNullLiteralTypeAnnotation,
    isNullableTypeAnnotation: () => isNullableTypeAnnotation,
    isNumberLiteral: () => isNumberLiteral,
    isNumberLiteralTypeAnnotation: () => isNumberLiteralTypeAnnotation,
    isNumberTypeAnnotation: () => isNumberTypeAnnotation,
    isNumericLiteral: () => isNumericLiteral,
    isObjectExpression: () => isObjectExpression,
    isObjectMember: () => isObjectMember,
    isObjectMethod: () => isObjectMethod,
    isObjectPattern: () => isObjectPattern,
    isObjectProperty: () => isObjectProperty,
    isObjectTypeAnnotation: () => isObjectTypeAnnotation,
    isObjectTypeCallProperty: () => isObjectTypeCallProperty,
    isObjectTypeIndexer: () => isObjectTypeIndexer,
    isObjectTypeInternalSlot: () => isObjectTypeInternalSlot,
    isObjectTypeProperty: () => isObjectTypeProperty,
    isObjectTypeSpreadProperty: () => isObjectTypeSpreadProperty,
    isOpaqueType: () => isOpaqueType,
    isOptionalCallExpression: () => isOptionalCallExpression,
    isOptionalIndexedAccessType: () => isOptionalIndexedAccessType,
    isOptionalMemberExpression: () => isOptionalMemberExpression,
    isParenthesizedExpression: () => isParenthesizedExpression,
    isPattern: () => isPattern,
    isPatternLike: () => isPatternLike,
    isPlaceholder: () => isPlaceholder,
    isPlaceholderType: () => isPlaceholderType,
    isPrivate: () => isPrivate,
    isPrivateName: () => isPrivateName,
    isProgram: () => isProgram,
    isProperty: () => isProperty,
    isPureish: () => isPureish,
    isQualifiedTypeIdentifier: () => isQualifiedTypeIdentifier,
    isReferenced: () => isReferenced,
    isRegExpLiteral: () => isRegExpLiteral,
    isRegexLiteral: () => isRegexLiteral,
    isRestElement: () => isRestElement,
    isRestProperty: () => isRestProperty,
    isReturnStatement: () => isReturnStatement,
    isScopable: () => isScopable,
    isScope: () => isScope,
    isSequenceExpression: () => isSequenceExpression,
    isSpecifierDefault: () => isSpecifierDefault,
    isSpreadElement: () => isSpreadElement,
    isSpreadProperty: () => isSpreadProperty,
    isStandardized: () => isStandardized,
    isStatement: () => isStatement,
    isStaticBlock: () => isStaticBlock,
    isStringLiteral: () => isStringLiteral,
    isStringLiteralTypeAnnotation: () => isStringLiteralTypeAnnotation,
    isStringTypeAnnotation: () => isStringTypeAnnotation,
    isSuper: () => isSuper,
    isSwitchCase: () => isSwitchCase,
    isSwitchStatement: () => isSwitchStatement,
    isSymbolTypeAnnotation: () => isSymbolTypeAnnotation,
    isTSAnyKeyword: () => isTSAnyKeyword,
    isTSArrayType: () => isTSArrayType,
    isTSAsExpression: () => isTSAsExpression,
    isTSBaseType: () => isTSBaseType,
    isTSBigIntKeyword: () => isTSBigIntKeyword,
    isTSBooleanKeyword: () => isTSBooleanKeyword,
    isTSCallSignatureDeclaration: () => isTSCallSignatureDeclaration,
    isTSClassImplements: () => isTSClassImplements,
    isTSConditionalType: () => isTSConditionalType,
    isTSConstructSignatureDeclaration: () => isTSConstructSignatureDeclaration,
    isTSConstructorType: () => isTSConstructorType,
    isTSDeclareFunction: () => isTSDeclareFunction,
    isTSDeclareMethod: () => isTSDeclareMethod,
    isTSEntityName: () => isTSEntityName,
    isTSEnumBody: () => isTSEnumBody,
    isTSEnumDeclaration: () => isTSEnumDeclaration,
    isTSEnumMember: () => isTSEnumMember,
    isTSExportAssignment: () => isTSExportAssignment,
    isTSExternalModuleReference: () => isTSExternalModuleReference,
    isTSFunctionType: () => isTSFunctionType,
    isTSImportEqualsDeclaration: () => isTSImportEqualsDeclaration,
    isTSImportType: () => isTSImportType,
    isTSIndexSignature: () => isTSIndexSignature,
    isTSIndexedAccessType: () => isTSIndexedAccessType,
    isTSInferType: () => isTSInferType,
    isTSInstantiationExpression: () => isTSInstantiationExpression,
    isTSInterfaceBody: () => isTSInterfaceBody,
    isTSInterfaceDeclaration: () => isTSInterfaceDeclaration,
    isTSInterfaceHeritage: () => isTSInterfaceHeritage,
    isTSIntersectionType: () => isTSIntersectionType,
    isTSIntrinsicKeyword: () => isTSIntrinsicKeyword,
    isTSLiteralType: () => isTSLiteralType,
    isTSMappedType: () => isTSMappedType,
    isTSMethodSignature: () => isTSMethodSignature,
    isTSModuleBlock: () => isTSModuleBlock,
    isTSModuleDeclaration: () => isTSModuleDeclaration,
    isTSNamedTupleMember: () => isTSNamedTupleMember,
    isTSNamespaceExportDeclaration: () => isTSNamespaceExportDeclaration,
    isTSNeverKeyword: () => isTSNeverKeyword,
    isTSNonNullExpression: () => isTSNonNullExpression,
    isTSNullKeyword: () => isTSNullKeyword,
    isTSNumberKeyword: () => isTSNumberKeyword,
    isTSObjectKeyword: () => isTSObjectKeyword,
    isTSOptionalType: () => isTSOptionalType,
    isTSParameterProperty: () => isTSParameterProperty,
    isTSParenthesizedType: () => isTSParenthesizedType,
    isTSPropertySignature: () => isTSPropertySignature,
    isTSQualifiedName: () => isTSQualifiedName,
    isTSRestType: () => isTSRestType,
    isTSSatisfiesExpression: () => isTSSatisfiesExpression,
    isTSStringKeyword: () => isTSStringKeyword,
    isTSSymbolKeyword: () => isTSSymbolKeyword,
    isTSTemplateLiteralType: () => isTSTemplateLiteralType,
    isTSThisType: () => isTSThisType,
    isTSTupleType: () => isTSTupleType,
    isTSType: () => isTSType,
    isTSTypeAliasDeclaration: () => isTSTypeAliasDeclaration,
    isTSTypeAnnotation: () => isTSTypeAnnotation,
    isTSTypeAssertion: () => isTSTypeAssertion,
    isTSTypeElement: () => isTSTypeElement,
    isTSTypeLiteral: () => isTSTypeLiteral,
    isTSTypeOperator: () => isTSTypeOperator,
    isTSTypeParameter: () => isTSTypeParameter,
    isTSTypeParameterDeclaration: () => isTSTypeParameterDeclaration,
    isTSTypeParameterInstantiation: () => isTSTypeParameterInstantiation,
    isTSTypePredicate: () => isTSTypePredicate,
    isTSTypeQuery: () => isTSTypeQuery,
    isTSTypeReference: () => isTSTypeReference,
    isTSUndefinedKeyword: () => isTSUndefinedKeyword,
    isTSUnionType: () => isTSUnionType,
    isTSUnknownKeyword: () => isTSUnknownKeyword,
    isTSVoidKeyword: () => isTSVoidKeyword,
    isTaggedTemplateExpression: () => isTaggedTemplateExpression,
    isTemplateElement: () => isTemplateElement,
    isTemplateLiteral: () => isTemplateLiteral,
    isTerminatorless: () => isTerminatorless,
    isThisExpression: () => isThisExpression,
    isThisTypeAnnotation: () => isThisTypeAnnotation,
    isThrowStatement: () => isThrowStatement,
    isTopicReference: () => isTopicReference,
    isTryStatement: () => isTryStatement,
    isTupleTypeAnnotation: () => isTupleTypeAnnotation,
    isType: () => isType,
    isTypeAlias: () => isTypeAlias,
    isTypeAnnotation: () => isTypeAnnotation,
    isTypeCastExpression: () => isTypeCastExpression,
    isTypeParameter: () => isTypeParameter,
    isTypeParameterDeclaration: () => isTypeParameterDeclaration,
    isTypeParameterInstantiation: () => isTypeParameterInstantiation,
    isTypeScript: () => isTypeScript,
    isTypeofTypeAnnotation: () => isTypeofTypeAnnotation,
    isUnaryExpression: () => isUnaryExpression,
    isUnaryLike: () => isUnaryLike,
    isUnionTypeAnnotation: () => isUnionTypeAnnotation,
    isUpdateExpression: () => isUpdateExpression,
    isUserWhitespacable: () => isUserWhitespacable,
    isV8IntrinsicIdentifier: () => isV8IntrinsicIdentifier,
    isValidES3Identifier: () => isValidES3Identifier,
    isValidIdentifier: () => isValidIdentifier,
    isVar: () => isVar,
    isVariableDeclaration: () => isVariableDeclaration,
    isVariableDeclarator: () => isVariableDeclarator,
    isVariance: () => isVariance,
    isVoidPattern: () => isVoidPattern,
    isVoidTypeAnnotation: () => isVoidTypeAnnotation,
    isWhile: () => isWhile,
    isWhileStatement: () => isWhileStatement,
    isWithStatement: () => isWithStatement,
    isYieldExpression: () => isYieldExpression,
    jsxAttribute: () => jsxAttribute,
    jsxClosingElement: () => jsxClosingElement,
    jsxClosingFragment: () => jsxClosingFragment,
    jsxElement: () => jsxElement,
    jsxEmptyExpression: () => jsxEmptyExpression,
    jsxExpressionContainer: () => jsxExpressionContainer,
    jsxFragment: () => jsxFragment,
    jsxIdentifier: () => jsxIdentifier,
    jsxMemberExpression: () => jsxMemberExpression,
    jsxNamespacedName: () => jsxNamespacedName,
    jsxOpeningElement: () => jsxOpeningElement,
    jsxOpeningFragment: () => jsxOpeningFragment,
    jsxSpreadAttribute: () => jsxSpreadAttribute,
    jsxSpreadChild: () => jsxSpreadChild,
    jsxText: () => jsxText,
    labeledStatement: () => labeledStatement,
    logicalExpression: () => logicalExpression,
    matchesPattern: () => matchesPattern,
    memberExpression: () => memberExpression,
    metaProperty: () => metaProperty,
    mixedTypeAnnotation: () => mixedTypeAnnotation,
    moduleExpression: () => moduleExpression,
    newExpression: () => newExpression,
    nullLiteral: () => nullLiteral,
    nullLiteralTypeAnnotation: () => nullLiteralTypeAnnotation,
    nullableTypeAnnotation: () => nullableTypeAnnotation,
    numberLiteral: () => NumberLiteral,
    numberLiteralTypeAnnotation: () => numberLiteralTypeAnnotation,
    numberTypeAnnotation: () => numberTypeAnnotation,
    numericLiteral: () => numericLiteral,
    objectExpression: () => objectExpression,
    objectMethod: () => objectMethod,
    objectPattern: () => objectPattern,
    objectProperty: () => objectProperty,
    objectTypeAnnotation: () => objectTypeAnnotation,
    objectTypeCallProperty: () => objectTypeCallProperty,
    objectTypeIndexer: () => objectTypeIndexer,
    objectTypeInternalSlot: () => objectTypeInternalSlot,
    objectTypeProperty: () => objectTypeProperty,
    objectTypeSpreadProperty: () => objectTypeSpreadProperty,
    opaqueType: () => opaqueType,
    optionalCallExpression: () => optionalCallExpression,
    optionalIndexedAccessType: () => optionalIndexedAccessType,
    optionalMemberExpression: () => optionalMemberExpression,
    parenthesizedExpression: () => parenthesizedExpression,
    placeholder: () => placeholder,
    prependToMemberExpression: () => prependToMemberExpression,
    privateName: () => privateName,
    program: () => program,
    qualifiedTypeIdentifier: () => qualifiedTypeIdentifier,
    react: () => react,
    regExpLiteral: () => regExpLiteral,
    regexLiteral: () => RegexLiteral,
    removeComments: () => removeComments,
    removeProperties: () => removeProperties,
    removePropertiesDeep: () => removePropertiesDeep,
    removeTypeDuplicates: () => removeTypeDuplicates$1,
    restElement: () => restElement,
    restProperty: () => RestProperty,
    returnStatement: () => returnStatement,
    sequenceExpression: () => sequenceExpression,
    shallowEqual: () => shallowEqual,
    spreadElement: () => spreadElement,
    spreadProperty: () => SpreadProperty,
    staticBlock: () => staticBlock,
    stringLiteral: () => stringLiteral,
    stringLiteralTypeAnnotation: () => stringLiteralTypeAnnotation,
    stringTypeAnnotation: () => stringTypeAnnotation,
    super: () => _super,
    switchCase: () => switchCase,
    switchStatement: () => switchStatement,
    symbolTypeAnnotation: () => symbolTypeAnnotation,
    taggedTemplateExpression: () => taggedTemplateExpression,
    templateElement: () => templateElement,
    templateLiteral: () => templateLiteral,
    thisExpression: () => thisExpression,
    thisTypeAnnotation: () => thisTypeAnnotation,
    throwStatement: () => throwStatement,
    toBindingIdentifierName: () => toBindingIdentifierName,
    toBlock: () => toBlock,
    toComputedKey: () => toComputedKey,
    toExpression: () => toExpression,
    toIdentifier: () => toIdentifier,
    toKeyAlias: () => toKeyAlias,
    toStatement: () => toStatement,
    topicReference: () => topicReference,
    traverse: () => traverse,
    traverseFast: () => traverseFast,
    tryStatement: () => tryStatement,
    tsAnyKeyword: () => tsAnyKeyword,
    tsArrayType: () => tsArrayType,
    tsAsExpression: () => tsAsExpression,
    tsBigIntKeyword: () => tsBigIntKeyword,
    tsBooleanKeyword: () => tsBooleanKeyword,
    tsCallSignatureDeclaration: () => tsCallSignatureDeclaration,
    tsClassImplements: () => tsClassImplements,
    tsConditionalType: () => tsConditionalType,
    tsConstructSignatureDeclaration: () => tsConstructSignatureDeclaration,
    tsConstructorType: () => tsConstructorType,
    tsDeclareFunction: () => tsDeclareFunction,
    tsDeclareMethod: () => tsDeclareMethod,
    tsEnumBody: () => tsEnumBody,
    tsEnumDeclaration: () => tsEnumDeclaration,
    tsEnumMember: () => tsEnumMember,
    tsExportAssignment: () => tsExportAssignment,
    tsExternalModuleReference: () => tsExternalModuleReference,
    tsFunctionType: () => tsFunctionType,
    tsImportEqualsDeclaration: () => tsImportEqualsDeclaration,
    tsImportType: () => tsImportType,
    tsIndexSignature: () => tsIndexSignature,
    tsIndexedAccessType: () => tsIndexedAccessType,
    tsInferType: () => tsInferType,
    tsInstantiationExpression: () => tsInstantiationExpression,
    tsInterfaceBody: () => tsInterfaceBody,
    tsInterfaceDeclaration: () => tsInterfaceDeclaration,
    tsInterfaceHeritage: () => tsInterfaceHeritage,
    tsIntersectionType: () => tsIntersectionType,
    tsIntrinsicKeyword: () => tsIntrinsicKeyword,
    tsLiteralType: () => tsLiteralType,
    tsMappedType: () => tsMappedType,
    tsMethodSignature: () => tsMethodSignature,
    tsModuleBlock: () => tsModuleBlock,
    tsModuleDeclaration: () => tsModuleDeclaration,
    tsNamedTupleMember: () => tsNamedTupleMember,
    tsNamespaceExportDeclaration: () => tsNamespaceExportDeclaration,
    tsNeverKeyword: () => tsNeverKeyword,
    tsNonNullExpression: () => tsNonNullExpression,
    tsNullKeyword: () => tsNullKeyword,
    tsNumberKeyword: () => tsNumberKeyword,
    tsObjectKeyword: () => tsObjectKeyword,
    tsOptionalType: () => tsOptionalType,
    tsParameterProperty: () => tsParameterProperty,
    tsParenthesizedType: () => tsParenthesizedType,
    tsPropertySignature: () => tsPropertySignature,
    tsQualifiedName: () => tsQualifiedName,
    tsRestType: () => tsRestType,
    tsSatisfiesExpression: () => tsSatisfiesExpression,
    tsStringKeyword: () => tsStringKeyword,
    tsSymbolKeyword: () => tsSymbolKeyword,
    tsTemplateLiteralType: () => tsTemplateLiteralType,
    tsThisType: () => tsThisType,
    tsTupleType: () => tsTupleType,
    tsTypeAliasDeclaration: () => tsTypeAliasDeclaration,
    tsTypeAnnotation: () => tsTypeAnnotation,
    tsTypeAssertion: () => tsTypeAssertion,
    tsTypeLiteral: () => tsTypeLiteral,
    tsTypeOperator: () => tsTypeOperator,
    tsTypeParameter: () => tsTypeParameter,
    tsTypeParameterDeclaration: () => tsTypeParameterDeclaration,
    tsTypeParameterInstantiation: () => tsTypeParameterInstantiation,
    tsTypePredicate: () => tsTypePredicate,
    tsTypeQuery: () => tsTypeQuery,
    tsTypeReference: () => tsTypeReference,
    tsUndefinedKeyword: () => tsUndefinedKeyword,
    tsUnionType: () => tsUnionType,
    tsUnknownKeyword: () => tsUnknownKeyword,
    tsVoidKeyword: () => tsVoidKeyword,
    tupleTypeAnnotation: () => tupleTypeAnnotation,
    typeAlias: () => typeAlias,
    typeAnnotation: () => typeAnnotation,
    typeCastExpression: () => typeCastExpression,
    typeParameter: () => typeParameter,
    typeParameterDeclaration: () => typeParameterDeclaration,
    typeParameterInstantiation: () => typeParameterInstantiation,
    typeofTypeAnnotation: () => typeofTypeAnnotation,
    unaryExpression: () => unaryExpression,
    unionTypeAnnotation: () => unionTypeAnnotation,
    updateExpression: () => updateExpression,
    v8IntrinsicIdentifier: () => v8IntrinsicIdentifier,
    validate: () => validate$1,
    valueToNode: () => valueToNode,
    variableDeclaration: () => variableDeclaration,
    variableDeclarator: () => variableDeclarator,
    variance: () => variance,
    voidPattern: () => voidPattern,
    voidTypeAnnotation: () => voidTypeAnnotation,
    whileStatement: () => whileStatement,
    withStatement: () => withStatement,
    yieldExpression: () => yieldExpression
  });

  // node_modules/@babel/helper-validator-identifier/lib/identifier-browser.js
  var bmpIdentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088F\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5C\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDC-\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7DC\uA7F1-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
  var bmpIdentifierChars = "\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ADD\u1AE0-\u1AEB\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\u30FB\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F\uFF65";
  var bmpIdentifierStart = new RegExp("[" + bmpIdentifierStartChars + "]");
  var bmpIdentifier = new RegExp("[" + bmpIdentifierStartChars + bmpIdentifierChars + "]");
  var supplementaryIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489];
  var supplementaryIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
  function isInSupplementarySet(code, set) {
    let pos = 65536;
    for (let i = 0, length = set.length; i < length; i += 2) {
      pos += set[i];
      if (pos > code) return false;
      pos += set[i + 1];
      if (pos >= code) return true;
    }
    return false;
  }
  function isIdentifierStart(code) {
    if (code < 65) return code === 36;
    if (code <= 90) return true;
    if (code < 97) return code === 95;
    if (code <= 122) return true;
    if (code <= 65535) {
      return code >= 170 && bmpIdentifierStart.test(String.fromCharCode(code));
    }
    return isInSupplementarySet(code, supplementaryIdentifierStartCodes);
  }
  function isIdentifierChar(code) {
    if (code < 48) return code === 36;
    if (code < 58) return true;
    if (code < 65) return false;
    if (code <= 90) return true;
    if (code < 97) return code === 95;
    if (code <= 122) return true;
    if (code <= 65535) {
      return code >= 170 && bmpIdentifier.test(String.fromCharCode(code));
    }
    return isInSupplementarySet(code, supplementaryIdentifierStartCodes) || isInSupplementarySet(code, supplementaryIdentifierCodes);
  }
  function isIdentifierName(name) {
    let isFirst = true;
    for (let i = 0; i < name.length; i++) {
      let cp = name.charCodeAt(i);
      if ((cp & 64512) === 55296 && i + 1 < name.length) {
        const trail = name.charCodeAt(++i);
        if ((trail & 64512) === 56320) {
          cp = 65536 + ((cp & 1023) << 10) + (trail & 1023);
        }
      }
      if (isFirst) {
        isFirst = false;
        if (!isIdentifierStart(cp)) {
          return false;
        }
      } else if (!isIdentifierChar(cp)) {
        return false;
      }
    }
    return !isFirst;
  }

  // node_modules/@babel/helper-validator-identifier/lib/index.js
  var reservedWords = {
    keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
    strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
    strictBind: ["eval", "arguments"]
  };
  var keywords = new Set(reservedWords.keyword);
  var reservedWordsStrictSet = new Set(reservedWords.strict);
  var reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
  function isReservedWord(word, inModule) {
    return inModule && word === "await" || word === "enum";
  }
  function isStrictReservedWord(word, inModule) {
    return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
  }
  function isKeyword(word) {
    return keywords.has(word);
  }

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

  // node_modules/@babel/types/lib/index.js
  function shallowEqual(actual, expected) {
    const keys2 = Object.keys(expected);
    for (const key of keys2) {
      if (actual[key] !== expected[key]) {
        return false;
      }
    }
    return true;
  }
  var warnings = /* @__PURE__ */ new Set();
  function deprecationWarning(oldName, newName, prefix = "", cacheKey = oldName) {
    if (warnings.has(cacheKey)) return;
    warnings.add(cacheKey);
    const {
      internal,
      trace
    } = captureShortStackTrace(1, 2);
    if (internal) {
      return;
    }
    console.warn(`${prefix}\`${oldName}\` has been deprecated, please migrate to \`${newName}\`
${trace}`);
  }
  function captureShortStackTrace(skip, length) {
    const {
      stackTraceLimit,
      prepareStackTrace
    } = Error;
    let stackTrace;
    Error.stackTraceLimit = 1 + skip + length;
    Error.prepareStackTrace = function(err, stack) {
      stackTrace = stack;
    };
    new Error().stack;
    Error.stackTraceLimit = stackTraceLimit;
    Error.prepareStackTrace = prepareStackTrace;
    if (!stackTrace) return {
      internal: false,
      trace: ""
    };
    const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);
    return {
      internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()),
      trace: shortStackTrace.map((frame) => `    at ${frame}`).join("\n")
    };
  }
  function isArrayExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ArrayExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isAssignmentExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "AssignmentExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBinaryExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "BinaryExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isInterpreterDirective(node, opts) {
    if (!node) return false;
    if (node.type !== "InterpreterDirective") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDirective(node, opts) {
    if (!node) return false;
    if (node.type !== "Directive") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDirectiveLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "DirectiveLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBlockStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "BlockStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBreakStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "BreakStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isCallExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "CallExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isCatchClause(node, opts) {
    if (!node) return false;
    if (node.type !== "CatchClause") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isConditionalExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ConditionalExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isContinueStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "ContinueStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDebuggerStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "DebuggerStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDoWhileStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "DoWhileStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEmptyStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "EmptyStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExpressionStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "ExpressionStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isFile(node, opts) {
    if (!node) return false;
    if (node.type !== "File") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isForInStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "ForInStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isForStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "ForStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isFunctionDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "FunctionDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isFunctionExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "FunctionExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isIdentifier(node, opts) {
    if (!node) return false;
    if (node.type !== "Identifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isIfStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "IfStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isLabeledStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "LabeledStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isStringLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "StringLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isNumericLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "NumericLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isNullLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "NullLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBooleanLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "BooleanLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isRegExpLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "RegExpLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isLogicalExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "LogicalExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isMemberExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "MemberExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isNewExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "NewExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isProgram(node, opts) {
    if (!node) return false;
    if (node.type !== "Program") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectMethod(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectMethod") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isRestElement(node, opts) {
    if (!node) return false;
    if (node.type !== "RestElement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isReturnStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "ReturnStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isSequenceExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "SequenceExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isParenthesizedExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ParenthesizedExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isSwitchCase(node, opts) {
    if (!node) return false;
    if (node.type !== "SwitchCase") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isSwitchStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "SwitchStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isThisExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ThisExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isThrowStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "ThrowStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTryStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "TryStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isUnaryExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "UnaryExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isUpdateExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "UpdateExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isVariableDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "VariableDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isVariableDeclarator(node, opts) {
    if (!node) return false;
    if (node.type !== "VariableDeclarator") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isWhileStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "WhileStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isWithStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "WithStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isAssignmentPattern(node, opts) {
    if (!node) return false;
    if (node.type !== "AssignmentPattern") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isArrayPattern(node, opts) {
    if (!node) return false;
    if (node.type !== "ArrayPattern") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isArrowFunctionExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ArrowFunctionExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassBody(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassBody") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExportAllDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "ExportAllDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExportDefaultDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "ExportDefaultDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExportNamedDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "ExportNamedDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExportSpecifier(node, opts) {
    if (!node) return false;
    if (node.type !== "ExportSpecifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isForOfStatement(node, opts) {
    if (!node) return false;
    if (node.type !== "ForOfStatement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isImportDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "ImportDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isImportDefaultSpecifier(node, opts) {
    if (!node) return false;
    if (node.type !== "ImportDefaultSpecifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isImportNamespaceSpecifier(node, opts) {
    if (!node) return false;
    if (node.type !== "ImportNamespaceSpecifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isImportSpecifier(node, opts) {
    if (!node) return false;
    if (node.type !== "ImportSpecifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isMetaProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "MetaProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassMethod(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassMethod") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectPattern(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectPattern") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isSpreadElement(node, opts) {
    if (!node) return false;
    if (node.type !== "SpreadElement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isSuper(node, opts) {
    if (!node) return false;
    if (node.type !== "Super") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTaggedTemplateExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "TaggedTemplateExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTemplateElement(node, opts) {
    if (!node) return false;
    if (node.type !== "TemplateElement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTemplateLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "TemplateLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isYieldExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "YieldExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isAwaitExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "AwaitExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isImportExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ImportExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isImport(node, opts) {
    if (!node) return false;
    if (node.type !== "Import") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBigIntLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "BigIntLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExportNamespaceSpecifier(node, opts) {
    if (!node) return false;
    if (node.type !== "ExportNamespaceSpecifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isOptionalMemberExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "OptionalMemberExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isOptionalCallExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "OptionalCallExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassPrivateProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassPrivateProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassPrivateMethod(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassPrivateMethod") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isPrivateName(node, opts) {
    if (!node) return false;
    if (node.type !== "PrivateName") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isStaticBlock(node, opts) {
    if (!node) return false;
    if (node.type !== "StaticBlock") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isImportAttribute(node, opts) {
    if (!node) return false;
    if (node.type !== "ImportAttribute") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isAnyTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "AnyTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isArrayTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "ArrayTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBooleanTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "BooleanTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBooleanLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "BooleanLiteralTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isNullLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "NullLiteralTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassImplements(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassImplements") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareClass(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareClass") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareFunction(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareFunction") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareInterface(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareInterface") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareModule(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareModule") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareModuleExports(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareModuleExports") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareTypeAlias(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareTypeAlias") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareOpaqueType(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareOpaqueType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareVariable(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareVariable") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareExportDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareExportDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclareExportAllDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclareExportAllDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclaredPredicate(node, opts) {
    if (!node) return false;
    if (node.type !== "DeclaredPredicate") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExistsTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "ExistsTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isFunctionTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "FunctionTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isFunctionTypeParam(node, opts) {
    if (!node) return false;
    if (node.type !== "FunctionTypeParam") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isGenericTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "GenericTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isInferredPredicate(node, opts) {
    if (!node) return false;
    if (node.type !== "InferredPredicate") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isInterfaceExtends(node, opts) {
    if (!node) return false;
    if (node.type !== "InterfaceExtends") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isInterfaceDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "InterfaceDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isInterfaceTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "InterfaceTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isIntersectionTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "IntersectionTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isMixedTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "MixedTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEmptyTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "EmptyTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isNullableTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "NullableTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isNumberLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "NumberLiteralTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBigIntLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "BigIntLiteralTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isNumberTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "NumberTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectTypeInternalSlot(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectTypeInternalSlot") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectTypeCallProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectTypeCallProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectTypeIndexer(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectTypeIndexer") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectTypeProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectTypeProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectTypeSpreadProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "ObjectTypeSpreadProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isOpaqueType(node, opts) {
    if (!node) return false;
    if (node.type !== "OpaqueType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isQualifiedTypeIdentifier(node, opts) {
    if (!node) return false;
    if (node.type !== "QualifiedTypeIdentifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isStringLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "StringLiteralTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isStringTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "StringTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isSymbolTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "SymbolTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isThisTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "ThisTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTupleTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "TupleTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeofTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "TypeofTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeAlias(node, opts) {
    if (!node) return false;
    if (node.type !== "TypeAlias") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "TypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeCastExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "TypeCastExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeParameter(node, opts) {
    if (!node) return false;
    if (node.type !== "TypeParameter") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeParameterDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TypeParameterDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeParameterInstantiation(node, opts) {
    if (!node) return false;
    if (node.type !== "TypeParameterInstantiation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isUnionTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "UnionTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isVariance(node, opts) {
    if (!node) return false;
    if (node.type !== "Variance") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isVoidTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "VoidTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumBooleanBody(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumBooleanBody") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumNumberBody(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumNumberBody") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumStringBody(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumStringBody") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumSymbolBody(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumSymbolBody") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumBooleanMember(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumBooleanMember") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumNumberMember(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumNumberMember") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumStringMember(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumStringMember") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumDefaultedMember(node, opts) {
    if (!node) return false;
    if (node.type !== "EnumDefaultedMember") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isIndexedAccessType(node, opts) {
    if (!node) return false;
    if (node.type !== "IndexedAccessType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isOptionalIndexedAccessType(node, opts) {
    if (!node) return false;
    if (node.type !== "OptionalIndexedAccessType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXAttribute(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXAttribute") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXClosingElement(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXClosingElement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXElement(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXElement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXEmptyExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXEmptyExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXExpressionContainer(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXExpressionContainer") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXSpreadChild(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXSpreadChild") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXIdentifier(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXIdentifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXMemberExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXMemberExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXNamespacedName(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXNamespacedName") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXOpeningElement(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXOpeningElement") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXSpreadAttribute(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXSpreadAttribute") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXText(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXText") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXFragment(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXFragment") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXOpeningFragment(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXOpeningFragment") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isJSXClosingFragment(node, opts) {
    if (!node) return false;
    if (node.type !== "JSXClosingFragment") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isPlaceholder(node, opts) {
    if (!node) return false;
    if (node.type !== "Placeholder") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isV8IntrinsicIdentifier(node, opts) {
    if (!node) return false;
    if (node.type !== "V8IntrinsicIdentifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isArgumentPlaceholder(node, opts) {
    if (!node) return false;
    if (node.type !== "ArgumentPlaceholder") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isBindExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "BindExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isClassAccessorProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "ClassAccessorProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDecorator(node, opts) {
    if (!node) return false;
    if (node.type !== "Decorator") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isDoExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "DoExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isExportDefaultSpecifier(node, opts) {
    if (!node) return false;
    if (node.type !== "ExportDefaultSpecifier") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isModuleExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "ModuleExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTopicReference(node, opts) {
    if (!node) return false;
    if (node.type !== "TopicReference") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isVoidPattern(node, opts) {
    if (!node) return false;
    if (node.type !== "VoidPattern") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSParameterProperty(node, opts) {
    if (!node) return false;
    if (node.type !== "TSParameterProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSDeclareFunction(node, opts) {
    if (!node) return false;
    if (node.type !== "TSDeclareFunction") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSDeclareMethod(node, opts) {
    if (!node) return false;
    if (node.type !== "TSDeclareMethod") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSQualifiedName(node, opts) {
    if (!node) return false;
    if (node.type !== "TSQualifiedName") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSCallSignatureDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSCallSignatureDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSConstructSignatureDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSConstructSignatureDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSPropertySignature(node, opts) {
    if (!node) return false;
    if (node.type !== "TSPropertySignature") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSMethodSignature(node, opts) {
    if (!node) return false;
    if (node.type !== "TSMethodSignature") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSIndexSignature(node, opts) {
    if (!node) return false;
    if (node.type !== "TSIndexSignature") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSAnyKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSAnyKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSBooleanKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSBooleanKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSBigIntKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSBigIntKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSIntrinsicKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSIntrinsicKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSNeverKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSNeverKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSNullKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSNullKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSNumberKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSNumberKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSObjectKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSObjectKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSStringKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSStringKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSSymbolKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSSymbolKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSUndefinedKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSUndefinedKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSUnknownKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSUnknownKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSVoidKeyword(node, opts) {
    if (!node) return false;
    if (node.type !== "TSVoidKeyword") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSThisType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSThisType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSFunctionType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSFunctionType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSConstructorType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSConstructorType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeReference(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeReference") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypePredicate(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypePredicate") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeQuery(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeQuery") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeLiteral(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSArrayType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSArrayType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTupleType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTupleType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSOptionalType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSOptionalType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSRestType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSRestType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSNamedTupleMember(node, opts) {
    if (!node) return false;
    if (node.type !== "TSNamedTupleMember") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSUnionType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSUnionType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSIntersectionType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSIntersectionType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSConditionalType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSConditionalType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSInferType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSInferType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSParenthesizedType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSParenthesizedType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeOperator(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeOperator") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSIndexedAccessType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSIndexedAccessType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSMappedType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSMappedType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTemplateLiteralType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTemplateLiteralType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSLiteralType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSLiteralType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSClassImplements(node, opts) {
    if (!node) return false;
    if (node.type !== "TSClassImplements") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSInterfaceHeritage(node, opts) {
    if (!node) return false;
    if (node.type !== "TSInterfaceHeritage") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSInterfaceDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSInterfaceDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSInterfaceBody(node, opts) {
    if (!node) return false;
    if (node.type !== "TSInterfaceBody") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeAliasDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeAliasDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSInstantiationExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "TSInstantiationExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSAsExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "TSAsExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSSatisfiesExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "TSSatisfiesExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeAssertion(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeAssertion") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSEnumBody(node, opts) {
    if (!node) return false;
    if (node.type !== "TSEnumBody") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSEnumDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSEnumDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSEnumMember(node, opts) {
    if (!node) return false;
    if (node.type !== "TSEnumMember") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSModuleDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSModuleDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSModuleBlock(node, opts) {
    if (!node) return false;
    if (node.type !== "TSModuleBlock") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSImportType(node, opts) {
    if (!node) return false;
    if (node.type !== "TSImportType") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSImportEqualsDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSImportEqualsDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSExternalModuleReference(node, opts) {
    if (!node) return false;
    if (node.type !== "TSExternalModuleReference") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSNonNullExpression(node, opts) {
    if (!node) return false;
    if (node.type !== "TSNonNullExpression") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSExportAssignment(node, opts) {
    if (!node) return false;
    if (node.type !== "TSExportAssignment") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSNamespaceExportDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSNamespaceExportDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeAnnotation(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeAnnotation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeParameterInstantiation(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeParameterInstantiation") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeParameterDeclaration(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeParameterDeclaration") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeParameter(node, opts) {
    if (!node) return false;
    if (node.type !== "TSTypeParameter") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isStandardized(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ArrayExpression":
      case "AssignmentExpression":
      case "BinaryExpression":
      case "InterpreterDirective":
      case "Directive":
      case "DirectiveLiteral":
      case "BlockStatement":
      case "BreakStatement":
      case "CallExpression":
      case "CatchClause":
      case "ConditionalExpression":
      case "ContinueStatement":
      case "DebuggerStatement":
      case "DoWhileStatement":
      case "EmptyStatement":
      case "ExpressionStatement":
      case "File":
      case "ForInStatement":
      case "ForStatement":
      case "FunctionDeclaration":
      case "FunctionExpression":
      case "Identifier":
      case "IfStatement":
      case "LabeledStatement":
      case "StringLiteral":
      case "NumericLiteral":
      case "NullLiteral":
      case "BooleanLiteral":
      case "RegExpLiteral":
      case "LogicalExpression":
      case "MemberExpression":
      case "NewExpression":
      case "Program":
      case "ObjectExpression":
      case "ObjectMethod":
      case "ObjectProperty":
      case "RestElement":
      case "ReturnStatement":
      case "SequenceExpression":
      case "ParenthesizedExpression":
      case "SwitchCase":
      case "SwitchStatement":
      case "ThisExpression":
      case "ThrowStatement":
      case "TryStatement":
      case "UnaryExpression":
      case "UpdateExpression":
      case "VariableDeclaration":
      case "VariableDeclarator":
      case "WhileStatement":
      case "WithStatement":
      case "AssignmentPattern":
      case "ArrayPattern":
      case "ArrowFunctionExpression":
      case "ClassBody":
      case "ClassExpression":
      case "ClassDeclaration":
      case "ExportAllDeclaration":
      case "ExportDefaultDeclaration":
      case "ExportNamedDeclaration":
      case "ExportSpecifier":
      case "ForOfStatement":
      case "ImportDeclaration":
      case "ImportDefaultSpecifier":
      case "ImportNamespaceSpecifier":
      case "ImportSpecifier":
      case "MetaProperty":
      case "ClassMethod":
      case "ObjectPattern":
      case "SpreadElement":
      case "Super":
      case "TaggedTemplateExpression":
      case "TemplateElement":
      case "TemplateLiteral":
      case "YieldExpression":
      case "AwaitExpression":
      case "ImportExpression":
      case "Import":
      case "BigIntLiteral":
      case "ExportNamespaceSpecifier":
      case "OptionalMemberExpression":
      case "OptionalCallExpression":
      case "ClassProperty":
      case "ClassPrivateProperty":
      case "ClassPrivateMethod":
      case "PrivateName":
      case "StaticBlock":
      case "ImportAttribute":
        break;
      case "Placeholder":
        switch (node.expectedNode) {
          case "Identifier":
          case "StringLiteral":
          case "BlockStatement":
          case "ClassBody":
            break;
          default:
            return false;
        }
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isExpression(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ArrayExpression":
      case "AssignmentExpression":
      case "BinaryExpression":
      case "CallExpression":
      case "ConditionalExpression":
      case "FunctionExpression":
      case "Identifier":
      case "StringLiteral":
      case "NumericLiteral":
      case "NullLiteral":
      case "BooleanLiteral":
      case "RegExpLiteral":
      case "LogicalExpression":
      case "MemberExpression":
      case "NewExpression":
      case "ObjectExpression":
      case "SequenceExpression":
      case "ParenthesizedExpression":
      case "ThisExpression":
      case "UnaryExpression":
      case "UpdateExpression":
      case "ArrowFunctionExpression":
      case "ClassExpression":
      case "MetaProperty":
      case "TaggedTemplateExpression":
      case "TemplateLiteral":
      case "YieldExpression":
      case "AwaitExpression":
      case "ImportExpression":
      case "BigIntLiteral":
      case "OptionalMemberExpression":
      case "OptionalCallExpression":
      case "TypeCastExpression":
      case "JSXElement":
      case "JSXFragment":
      case "BindExpression":
      case "DoExpression":
      case "ModuleExpression":
      case "TopicReference":
      case "TSInstantiationExpression":
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSTypeAssertion":
      case "TSNonNullExpression":
        break;
      case "Placeholder":
        switch (node.expectedNode) {
          case "Expression":
          case "Identifier":
          case "StringLiteral":
            break;
          default:
            return false;
        }
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isBinary(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "BinaryExpression":
      case "LogicalExpression":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isScopable(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "BlockStatement":
      case "CatchClause":
      case "DoWhileStatement":
      case "ForInStatement":
      case "ForStatement":
      case "FunctionDeclaration":
      case "FunctionExpression":
      case "Program":
      case "ObjectMethod":
      case "SwitchStatement":
      case "WhileStatement":
      case "ArrowFunctionExpression":
      case "ClassExpression":
      case "ClassDeclaration":
      case "ForOfStatement":
      case "ClassMethod":
      case "ClassPrivateMethod":
      case "StaticBlock":
      case "TSModuleBlock":
        break;
      case "Placeholder":
        if (node.expectedNode === "BlockStatement") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isBlockParent(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "BlockStatement":
      case "CatchClause":
      case "DoWhileStatement":
      case "ForInStatement":
      case "ForStatement":
      case "FunctionDeclaration":
      case "FunctionExpression":
      case "Program":
      case "ObjectMethod":
      case "SwitchStatement":
      case "WhileStatement":
      case "ArrowFunctionExpression":
      case "ForOfStatement":
      case "ClassMethod":
      case "ClassPrivateMethod":
      case "StaticBlock":
      case "TSModuleBlock":
        break;
      case "Placeholder":
        if (node.expectedNode === "BlockStatement") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isBlock(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "BlockStatement":
      case "Program":
      case "TSModuleBlock":
        break;
      case "Placeholder":
        if (node.expectedNode === "BlockStatement") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isStatement(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "BlockStatement":
      case "BreakStatement":
      case "ContinueStatement":
      case "DebuggerStatement":
      case "DoWhileStatement":
      case "EmptyStatement":
      case "ExpressionStatement":
      case "ForInStatement":
      case "ForStatement":
      case "FunctionDeclaration":
      case "IfStatement":
      case "LabeledStatement":
      case "ReturnStatement":
      case "SwitchStatement":
      case "ThrowStatement":
      case "TryStatement":
      case "VariableDeclaration":
      case "WhileStatement":
      case "WithStatement":
      case "ClassDeclaration":
      case "ExportAllDeclaration":
      case "ExportDefaultDeclaration":
      case "ExportNamedDeclaration":
      case "ForOfStatement":
      case "ImportDeclaration":
      case "DeclareClass":
      case "DeclareFunction":
      case "DeclareInterface":
      case "DeclareModule":
      case "DeclareModuleExports":
      case "DeclareTypeAlias":
      case "DeclareOpaqueType":
      case "DeclareVariable":
      case "DeclareExportDeclaration":
      case "DeclareExportAllDeclaration":
      case "InterfaceDeclaration":
      case "OpaqueType":
      case "TypeAlias":
      case "EnumDeclaration":
      case "TSDeclareFunction":
      case "TSInterfaceDeclaration":
      case "TSTypeAliasDeclaration":
      case "TSEnumDeclaration":
      case "TSModuleDeclaration":
      case "TSImportEqualsDeclaration":
      case "TSExportAssignment":
      case "TSNamespaceExportDeclaration":
        break;
      case "Placeholder":
        switch (node.expectedNode) {
          case "Statement":
          case "Declaration":
          case "BlockStatement":
            break;
          default:
            return false;
        }
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isTerminatorless(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "BreakStatement":
      case "ContinueStatement":
      case "ReturnStatement":
      case "ThrowStatement":
      case "YieldExpression":
      case "AwaitExpression":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isCompletionStatement(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "BreakStatement":
      case "ContinueStatement":
      case "ReturnStatement":
      case "ThrowStatement":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isConditional(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ConditionalExpression":
      case "IfStatement":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isLoop(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "DoWhileStatement":
      case "ForInStatement":
      case "ForStatement":
      case "WhileStatement":
      case "ForOfStatement":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isWhile(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "DoWhileStatement":
      case "WhileStatement":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isExpressionWrapper(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ExpressionStatement":
      case "ParenthesizedExpression":
      case "TypeCastExpression":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFor(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ForInStatement":
      case "ForStatement":
      case "ForOfStatement":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isForXStatement(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ForInStatement":
      case "ForOfStatement":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFunction(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "FunctionDeclaration":
      case "FunctionExpression":
      case "ObjectMethod":
      case "ArrowFunctionExpression":
      case "ClassMethod":
      case "ClassPrivateMethod":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFunctionParent(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "FunctionDeclaration":
      case "FunctionExpression":
      case "ObjectMethod":
      case "ArrowFunctionExpression":
      case "ClassMethod":
      case "ClassPrivateMethod":
      case "StaticBlock":
      case "TSModuleBlock":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isPureish(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "FunctionDeclaration":
      case "FunctionExpression":
      case "StringLiteral":
      case "NumericLiteral":
      case "NullLiteral":
      case "BooleanLiteral":
      case "RegExpLiteral":
      case "ArrowFunctionExpression":
      case "BigIntLiteral":
        break;
      case "Placeholder":
        if (node.expectedNode === "StringLiteral") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isDeclaration(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "FunctionDeclaration":
      case "VariableDeclaration":
      case "ClassDeclaration":
      case "ExportAllDeclaration":
      case "ExportDefaultDeclaration":
      case "ExportNamedDeclaration":
      case "ImportDeclaration":
      case "DeclareClass":
      case "DeclareFunction":
      case "DeclareInterface":
      case "DeclareModule":
      case "DeclareModuleExports":
      case "DeclareTypeAlias":
      case "DeclareOpaqueType":
      case "DeclareVariable":
      case "DeclareExportDeclaration":
      case "DeclareExportAllDeclaration":
      case "InterfaceDeclaration":
      case "OpaqueType":
      case "TypeAlias":
      case "EnumDeclaration":
      case "TSDeclareFunction":
      case "TSInterfaceDeclaration":
      case "TSTypeAliasDeclaration":
      case "TSEnumDeclaration":
      case "TSModuleDeclaration":
      case "TSImportEqualsDeclaration":
        break;
      case "Placeholder":
        if (node.expectedNode === "Declaration") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFunctionParameter(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "Identifier":
      case "RestElement":
      case "AssignmentPattern":
      case "ArrayPattern":
      case "ObjectPattern":
      case "VoidPattern":
        break;
      case "Placeholder":
        if (node.expectedNode === "Identifier") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isPatternLike(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "Identifier":
      case "MemberExpression":
      case "RestElement":
      case "AssignmentPattern":
      case "ArrayPattern":
      case "ObjectPattern":
      case "VoidPattern":
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSTypeAssertion":
      case "TSNonNullExpression":
        break;
      case "Placeholder":
        switch (node.expectedNode) {
          case "Pattern":
          case "Identifier":
            break;
          default:
            return false;
        }
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isLVal(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "Identifier":
      case "MemberExpression":
      case "ArrayPattern":
      case "ObjectPattern":
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSTypeAssertion":
      case "TSNonNullExpression":
        break;
      case "Placeholder":
        switch (node.expectedNode) {
          case "Pattern":
          case "Identifier":
            break;
          default:
            return false;
        }
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isTSEntityName(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "Identifier":
      case "ThisExpression":
      case "TSQualifiedName":
        break;
      case "Placeholder":
        if (node.expectedNode === "Identifier") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isLiteral(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "StringLiteral":
      case "NumericLiteral":
      case "NullLiteral":
      case "BooleanLiteral":
      case "RegExpLiteral":
      case "TemplateLiteral":
      case "BigIntLiteral":
        break;
      case "Placeholder":
        if (node.expectedNode === "StringLiteral") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isUserWhitespacable(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ObjectMethod":
      case "ObjectProperty":
      case "ObjectTypeInternalSlot":
      case "ObjectTypeCallProperty":
      case "ObjectTypeIndexer":
      case "ObjectTypeProperty":
      case "ObjectTypeSpreadProperty":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isMethod(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ObjectMethod":
      case "ClassMethod":
      case "ClassPrivateMethod":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isObjectMember(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ObjectMethod":
      case "ObjectProperty":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isProperty(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ObjectProperty":
      case "ClassProperty":
      case "ClassPrivateProperty":
      case "ClassAccessorProperty":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isUnaryLike(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "UnaryExpression":
      case "SpreadElement":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isPattern(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "AssignmentPattern":
      case "ArrayPattern":
      case "ObjectPattern":
      case "VoidPattern":
        break;
      case "Placeholder":
        if (node.expectedNode === "Pattern") break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isClass(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ClassExpression":
      case "ClassDeclaration":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isImportOrExportDeclaration(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ExportAllDeclaration":
      case "ExportDefaultDeclaration":
      case "ExportNamedDeclaration":
      case "ImportDeclaration":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isExportDeclaration(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ExportAllDeclaration":
      case "ExportDefaultDeclaration":
      case "ExportNamedDeclaration":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isModuleSpecifier(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ExportSpecifier":
      case "ImportDefaultSpecifier":
      case "ImportNamespaceSpecifier":
      case "ImportSpecifier":
      case "ExportNamespaceSpecifier":
      case "ExportDefaultSpecifier":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isPrivate(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ClassPrivateProperty":
      case "ClassPrivateMethod":
      case "PrivateName":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFlow(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "AnyTypeAnnotation":
      case "ArrayTypeAnnotation":
      case "BooleanTypeAnnotation":
      case "BooleanLiteralTypeAnnotation":
      case "NullLiteralTypeAnnotation":
      case "ClassImplements":
      case "DeclareClass":
      case "DeclareFunction":
      case "DeclareInterface":
      case "DeclareModule":
      case "DeclareModuleExports":
      case "DeclareTypeAlias":
      case "DeclareOpaqueType":
      case "DeclareVariable":
      case "DeclareExportDeclaration":
      case "DeclareExportAllDeclaration":
      case "DeclaredPredicate":
      case "ExistsTypeAnnotation":
      case "FunctionTypeAnnotation":
      case "FunctionTypeParam":
      case "GenericTypeAnnotation":
      case "InferredPredicate":
      case "InterfaceExtends":
      case "InterfaceDeclaration":
      case "InterfaceTypeAnnotation":
      case "IntersectionTypeAnnotation":
      case "MixedTypeAnnotation":
      case "EmptyTypeAnnotation":
      case "NullableTypeAnnotation":
      case "NumberLiteralTypeAnnotation":
      case "BigIntLiteralTypeAnnotation":
      case "NumberTypeAnnotation":
      case "ObjectTypeAnnotation":
      case "ObjectTypeInternalSlot":
      case "ObjectTypeCallProperty":
      case "ObjectTypeIndexer":
      case "ObjectTypeProperty":
      case "ObjectTypeSpreadProperty":
      case "OpaqueType":
      case "QualifiedTypeIdentifier":
      case "StringLiteralTypeAnnotation":
      case "StringTypeAnnotation":
      case "SymbolTypeAnnotation":
      case "ThisTypeAnnotation":
      case "TupleTypeAnnotation":
      case "TypeofTypeAnnotation":
      case "TypeAlias":
      case "TypeAnnotation":
      case "TypeCastExpression":
      case "TypeParameter":
      case "TypeParameterDeclaration":
      case "TypeParameterInstantiation":
      case "UnionTypeAnnotation":
      case "Variance":
      case "VoidTypeAnnotation":
      case "EnumDeclaration":
      case "EnumBooleanBody":
      case "EnumNumberBody":
      case "EnumStringBody":
      case "EnumSymbolBody":
      case "EnumBooleanMember":
      case "EnumNumberMember":
      case "EnumStringMember":
      case "EnumDefaultedMember":
      case "IndexedAccessType":
      case "OptionalIndexedAccessType":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFlowType(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "AnyTypeAnnotation":
      case "ArrayTypeAnnotation":
      case "BooleanTypeAnnotation":
      case "BooleanLiteralTypeAnnotation":
      case "NullLiteralTypeAnnotation":
      case "ExistsTypeAnnotation":
      case "FunctionTypeAnnotation":
      case "GenericTypeAnnotation":
      case "InterfaceTypeAnnotation":
      case "IntersectionTypeAnnotation":
      case "MixedTypeAnnotation":
      case "EmptyTypeAnnotation":
      case "NullableTypeAnnotation":
      case "NumberLiteralTypeAnnotation":
      case "BigIntLiteralTypeAnnotation":
      case "NumberTypeAnnotation":
      case "ObjectTypeAnnotation":
      case "StringLiteralTypeAnnotation":
      case "StringTypeAnnotation":
      case "SymbolTypeAnnotation":
      case "ThisTypeAnnotation":
      case "TupleTypeAnnotation":
      case "TypeofTypeAnnotation":
      case "UnionTypeAnnotation":
      case "VoidTypeAnnotation":
      case "IndexedAccessType":
      case "OptionalIndexedAccessType":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFlowBaseAnnotation(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "AnyTypeAnnotation":
      case "BooleanTypeAnnotation":
      case "NullLiteralTypeAnnotation":
      case "MixedTypeAnnotation":
      case "EmptyTypeAnnotation":
      case "NumberTypeAnnotation":
      case "StringTypeAnnotation":
      case "SymbolTypeAnnotation":
      case "ThisTypeAnnotation":
      case "VoidTypeAnnotation":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFlowDeclaration(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "DeclareClass":
      case "DeclareFunction":
      case "DeclareInterface":
      case "DeclareModule":
      case "DeclareModuleExports":
      case "DeclareTypeAlias":
      case "DeclareOpaqueType":
      case "DeclareVariable":
      case "DeclareExportDeclaration":
      case "DeclareExportAllDeclaration":
      case "InterfaceDeclaration":
      case "OpaqueType":
      case "TypeAlias":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isFlowPredicate(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "DeclaredPredicate":
      case "InferredPredicate":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumBody(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "EnumBooleanBody":
      case "EnumNumberBody":
      case "EnumStringBody":
      case "EnumSymbolBody":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isEnumMember(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "EnumBooleanMember":
      case "EnumNumberMember":
      case "EnumStringMember":
      case "EnumDefaultedMember":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isJSX(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "JSXAttribute":
      case "JSXClosingElement":
      case "JSXElement":
      case "JSXEmptyExpression":
      case "JSXExpressionContainer":
      case "JSXSpreadChild":
      case "JSXIdentifier":
      case "JSXMemberExpression":
      case "JSXNamespacedName":
      case "JSXOpeningElement":
      case "JSXSpreadAttribute":
      case "JSXText":
      case "JSXFragment":
      case "JSXOpeningFragment":
      case "JSXClosingFragment":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isMiscellaneous(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "Placeholder":
      case "V8IntrinsicIdentifier":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isAccessor(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "ClassAccessorProperty":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isTypeScript(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "TSParameterProperty":
      case "TSDeclareFunction":
      case "TSDeclareMethod":
      case "TSQualifiedName":
      case "TSCallSignatureDeclaration":
      case "TSConstructSignatureDeclaration":
      case "TSPropertySignature":
      case "TSMethodSignature":
      case "TSIndexSignature":
      case "TSAnyKeyword":
      case "TSBooleanKeyword":
      case "TSBigIntKeyword":
      case "TSIntrinsicKeyword":
      case "TSNeverKeyword":
      case "TSNullKeyword":
      case "TSNumberKeyword":
      case "TSObjectKeyword":
      case "TSStringKeyword":
      case "TSSymbolKeyword":
      case "TSUndefinedKeyword":
      case "TSUnknownKeyword":
      case "TSVoidKeyword":
      case "TSThisType":
      case "TSFunctionType":
      case "TSConstructorType":
      case "TSTypeReference":
      case "TSTypePredicate":
      case "TSTypeQuery":
      case "TSTypeLiteral":
      case "TSArrayType":
      case "TSTupleType":
      case "TSOptionalType":
      case "TSRestType":
      case "TSNamedTupleMember":
      case "TSUnionType":
      case "TSIntersectionType":
      case "TSConditionalType":
      case "TSInferType":
      case "TSParenthesizedType":
      case "TSTypeOperator":
      case "TSIndexedAccessType":
      case "TSMappedType":
      case "TSTemplateLiteralType":
      case "TSLiteralType":
      case "TSClassImplements":
      case "TSInterfaceHeritage":
      case "TSInterfaceDeclaration":
      case "TSInterfaceBody":
      case "TSTypeAliasDeclaration":
      case "TSInstantiationExpression":
      case "TSAsExpression":
      case "TSSatisfiesExpression":
      case "TSTypeAssertion":
      case "TSEnumBody":
      case "TSEnumDeclaration":
      case "TSEnumMember":
      case "TSModuleDeclaration":
      case "TSModuleBlock":
      case "TSImportType":
      case "TSImportEqualsDeclaration":
      case "TSExternalModuleReference":
      case "TSNonNullExpression":
      case "TSExportAssignment":
      case "TSNamespaceExportDeclaration":
      case "TSTypeAnnotation":
      case "TSTypeParameterInstantiation":
      case "TSTypeParameterDeclaration":
      case "TSTypeParameter":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isTSTypeElement(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "TSCallSignatureDeclaration":
      case "TSConstructSignatureDeclaration":
      case "TSPropertySignature":
      case "TSMethodSignature":
      case "TSIndexSignature":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isTSType(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "TSAnyKeyword":
      case "TSBooleanKeyword":
      case "TSBigIntKeyword":
      case "TSIntrinsicKeyword":
      case "TSNeverKeyword":
      case "TSNullKeyword":
      case "TSNumberKeyword":
      case "TSObjectKeyword":
      case "TSStringKeyword":
      case "TSSymbolKeyword":
      case "TSUndefinedKeyword":
      case "TSUnknownKeyword":
      case "TSVoidKeyword":
      case "TSThisType":
      case "TSFunctionType":
      case "TSConstructorType":
      case "TSTypeReference":
      case "TSTypePredicate":
      case "TSTypeQuery":
      case "TSTypeLiteral":
      case "TSArrayType":
      case "TSTupleType":
      case "TSOptionalType":
      case "TSRestType":
      case "TSUnionType":
      case "TSIntersectionType":
      case "TSConditionalType":
      case "TSInferType":
      case "TSParenthesizedType":
      case "TSTypeOperator":
      case "TSIndexedAccessType":
      case "TSMappedType":
      case "TSTemplateLiteralType":
      case "TSLiteralType":
      case "TSClassImplements":
      case "TSInterfaceHeritage":
      case "TSImportType":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isTSBaseType(node, opts) {
    if (!node) return false;
    switch (node.type) {
      case "TSAnyKeyword":
      case "TSBooleanKeyword":
      case "TSBigIntKeyword":
      case "TSIntrinsicKeyword":
      case "TSNeverKeyword":
      case "TSNullKeyword":
      case "TSNumberKeyword":
      case "TSObjectKeyword":
      case "TSStringKeyword":
      case "TSSymbolKeyword":
      case "TSUndefinedKeyword":
      case "TSUnknownKeyword":
      case "TSVoidKeyword":
      case "TSThisType":
      case "TSTemplateLiteralType":
      case "TSLiteralType":
        break;
      default:
        return false;
    }
    return opts == null || shallowEqual(node, opts);
  }
  function isNumberLiteral(node, opts) {
    deprecationWarning("isNumberLiteral", "isNumericLiteral");
    if (!node) return false;
    if (node.type !== "NumberLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isRegexLiteral(node, opts) {
    deprecationWarning("isRegexLiteral", "isRegExpLiteral");
    if (!node) return false;
    if (node.type !== "RegexLiteral") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isRestProperty(node, opts) {
    deprecationWarning("isRestProperty", "isRestElement");
    if (!node) return false;
    if (node.type !== "RestProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isSpreadProperty(node, opts) {
    deprecationWarning("isSpreadProperty", "isSpreadElement");
    if (!node) return false;
    if (node.type !== "SpreadProperty") return false;
    return opts == null || shallowEqual(node, opts);
  }
  function isModuleDeclaration(node, opts) {
    deprecationWarning("isModuleDeclaration", "isImportOrExportDeclaration");
    return isImportOrExportDeclaration(node, opts);
  }
  function isMemberExpressionLike(node) {
    return isMemberExpression(node) || isMetaProperty(node);
  }
  function matchesPattern(member, match, allowPartial) {
    var _a;
    if (!isMemberExpressionLike(member)) return false;
    const parts = Array.isArray(match) ? match : match.split(".");
    const nodes = [];
    let node;
    for (node = member; isMemberExpressionLike(node); node = (_a = node.object) != null ? _a : node.meta) {
      nodes.push(node.property);
    }
    nodes.push(node);
    if (nodes.length < parts.length) return false;
    if (!allowPartial && nodes.length > parts.length) return false;
    for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
      const node2 = nodes[j];
      let value;
      if (isIdentifier(node2)) {
        value = node2.name;
      } else if (isStringLiteral(node2)) {
        value = node2.value;
      } else if (isThisExpression(node2)) {
        value = "this";
      } else if (isSuper(node2)) {
        value = "super";
      } else if (isPrivateName(node2)) {
        value = "#" + node2.id.name;
      } else {
        return false;
      }
      if (parts[i] !== value) return false;
    }
    return true;
  }
  function buildMatchMemberExpression(match, allowPartial) {
    const parts = match.split(".");
    return (member) => matchesPattern(member, parts, allowPartial);
  }
  var isReactComponent = buildMatchMemberExpression("React.Component");
  function isCompatTag(tagName) {
    return !!tagName && /^[a-z]/.test(tagName);
  }
  function isType(nodeType, targetType) {
    if (nodeType === targetType) return true;
    if (nodeType == null) return false;
    if (ALIAS_KEYS[targetType]) return false;
    const aliases = FLIPPED_ALIAS_KEYS[targetType];
    if (aliases == null ? void 0 : aliases.includes(nodeType)) return true;
    return false;
  }
  function isPlaceholderType(placeholderType, targetType) {
    if (placeholderType === targetType) return true;
    const aliases = PLACEHOLDERS_ALIAS[placeholderType];
    if (aliases == null ? void 0 : aliases.includes(targetType)) return true;
    return false;
  }
  function is(type, node, opts) {
    if (!node) return false;
    const matches = isType(node.type, type);
    if (!matches) {
      if (!opts && node.type === "Placeholder" && type in FLIPPED_ALIAS_KEYS) {
        return isPlaceholderType(node.expectedNode, type);
      }
      return false;
    }
    if (opts === void 0) {
      return true;
    } else {
      return shallowEqual(node, opts);
    }
  }
  function isValidIdentifier(name, reserved = true) {
    if (typeof name !== "string") return false;
    if (reserved) {
      if (isKeyword(name) || isStrictReservedWord(name, true)) {
        return false;
      }
    }
    return isIdentifierName(name);
  }
  var STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
  var FLATTENABLE_KEYS = ["body", "expressions"];
  var FOR_INIT_KEYS = ["left", "init"];
  var COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
  var LOGICAL_OPERATORS = ["||", "&&", "??"];
  var UPDATE_OPERATORS = ["++", "--"];
  var BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
  var EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
  var COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
  var BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
  var NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
  var BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
  var ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map((op) => op + "="), ...LOGICAL_OPERATORS.map((op) => op + "=")];
  var BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
  var NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
  var STRING_UNARY_OPERATORS = ["typeof"];
  var UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
  var INHERIT_KEYS = {
    optional: ["typeAnnotation", "typeParameters", "returnType"],
    force: ["start", "loc", "end"]
  };
  var VISITOR_KEYS = {};
  var ALIAS_KEYS = {};
  var FLIPPED_ALIAS_KEYS = {};
  var NODE_FIELDS$1 = {};
  var BUILDER_KEYS = {};
  var DEPRECATED_KEYS = {};
  var NODE_PARENT_VALIDATIONS = {};
  var NODE_UNION_SHAPES__PRIVATE = {};
  function getType(val) {
    if (Array.isArray(val)) {
      return "array";
    } else if (val === null) {
      return "null";
    } else {
      return typeof val;
    }
  }
  function combine(fn, ...validators) {
    return Object.assign(fn, ...validators);
  }
  function validate$2(validate2) {
    return {
      validate: validate2
    };
  }
  function validateType(...typeNames) {
    return validate$2(assertNodeType(...typeNames));
  }
  function validateOptional(validate2) {
    return {
      validate: validate2,
      optional: true
    };
  }
  function validateDefault(validate2, defaultValue) {
    return {
      validate: validate2,
      default: defaultValue,
      optional: false
    };
  }
  function validateOptionalType(...typeNames) {
    return {
      validate: assertNodeType(...typeNames),
      optional: true
    };
  }
  function arrayOf(elementType) {
    return chain(assertValueType("array"), assertEach(elementType));
  }
  function arrayOfType(...typeNames) {
    return arrayOf(assertNodeType(...typeNames));
  }
  function validateArrayOfType(...typeNames) {
    return validate$2(arrayOfType(...typeNames));
  }
  function assertEach(callback) {
    const childValidator = validateChild;
    function validator(node, key, val) {
      if (!Array.isArray(val)) return;
      let i = 0;
      const subKey = {
        toString() {
          return `${key}[${i}]`;
        }
      };
      for (; i < val.length; i++) {
        const v = val[i];
        callback(node, subKey, v);
        childValidator(node, subKey, v);
      }
    }
    validator.each = callback;
    return validator;
  }
  function assertOneOf(...values) {
    function validate2(node, key, val) {
      if (!values.includes(val)) {
        throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
      }
    }
    validate2.oneOf = values;
    return validate2;
  }
  var allExpandedTypes = [];
  function assertNodeType(...types) {
    const expandedTypes = /* @__PURE__ */ new Set();
    allExpandedTypes.push({
      types,
      set: expandedTypes
    });
    function validate2(node, key, val) {
      const valType = val == null ? void 0 : val.type;
      if (valType != null) {
        if (expandedTypes.has(valType)) {
          validateChild(node, key, val);
          return;
        }
        if (valType === "Placeholder") {
          for (const type of types) {
            if (is(type, val)) {
              validateChild(node, key, val);
              return;
            }
          }
        }
      }
      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(valType)}`);
    }
    validate2.oneOfNodeTypes = types;
    return validate2;
  }
  function assertNodeOrValueType(...types) {
    function validate2(node, key, val) {
      const primitiveType = getType(val);
      for (const type of types) {
        if (primitiveType === type || is(type, val)) {
          validateChild(node, key, val);
          return;
        }
      }
      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
    }
    validate2.oneOfNodeOrValueTypes = types;
    return validate2;
  }
  function assertValueType(type) {
    function validate2(node, key, val) {
      if (getType(val) === type) {
        return;
      }
      throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
    }
    validate2.type = type;
    return validate2;
  }
  function assertShape(shape) {
    const keys2 = Object.keys(shape);
    function validate2(node, key, val) {
      const errors = [];
      for (const property of keys2) {
        try {
          validateField(node, property, val[property], shape[property]);
        } catch (error) {
          if (error instanceof TypeError) {
            errors.push(error.message);
            continue;
          }
          throw error;
        }
      }
      if (errors.length) {
        throw new TypeError(`Property ${key} of ${node.type} expected to have the following:
${errors.join("\n")}`);
      }
    }
    validate2.shapeOf = shape;
    return validate2;
  }
  function assertOptionalChainStart() {
    function validate2(node) {
      let current = node;
      while (node) {
        const {
          type
        } = current;
        if (type === "OptionalCallExpression") {
          if (current.optional) return;
          current = current.callee;
          continue;
        }
        if (type === "OptionalMemberExpression") {
          if (current.optional) return;
          current = current.object;
          continue;
        }
        break;
      }
      throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${current == null ? void 0 : current.type}`);
    }
    return validate2;
  }
  function chain(...fns) {
    function validate2(...args) {
      for (const fn of fns) {
        fn(...args);
      }
    }
    validate2.chainOf = fns;
    if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
      throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
    }
    return validate2;
  }
  var validTypeOpts = /* @__PURE__ */ new Set(["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate", "unionShape"]);
  var validFieldKeys = /* @__PURE__ */ new Set(["default", "optional", "deprecated", "validate"]);
  var store = {};
  function defineAliasedType(...aliases) {
    return (type, opts = {}) => {
      var _a;
      let defined = opts.aliases;
      if (!defined) {
        if (opts.inherits) defined = (_a = store[opts.inherits].aliases) == null ? void 0 : _a.slice();
        defined != null ? defined : defined = [];
        opts.aliases = defined;
      }
      const additional = aliases.filter((a) => !defined.includes(a));
      defined.unshift(...additional);
      defineType$5(type, opts);
    };
  }
  function defineType$5(type, opts = {}) {
    var _a, _b;
    const inherits2 = opts.inherits && store[opts.inherits] || {};
    const visitor = opts.visitor || inherits2.visitor || [];
    const aliases = opts.aliases || inherits2.aliases || [];
    const builder = opts.builder || inherits2.builder || opts.visitor || [];
    let fields = opts.fields;
    if (!fields) {
      fields = {};
      if (inherits2.fields) {
        const keys2 = Object.getOwnPropertyNames(inherits2.fields);
        for (const key of keys2) {
          const field = inherits2.fields[key];
          const def = field.default;
          if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
            throw new Error("field defaults can only be primitives or empty arrays currently");
          }
          fields[key] = {
            default: Array.isArray(def) ? [] : def,
            optional: field.optional,
            deprecated: field.deprecated,
            validate: field.validate
          };
        }
      }
    }
    for (const k of Object.keys(opts)) {
      if (!validTypeOpts.has(k)) {
        throw new Error(`Unknown type option "${k}" on ${type}`);
      }
    }
    if (opts.deprecatedAlias) {
      DEPRECATED_KEYS[opts.deprecatedAlias] = type;
    }
    for (const key of visitor.concat(builder)) {
      fields[key] = fields[key] || {};
    }
    for (const key of Object.keys(fields)) {
      const field = fields[key];
      if (field.default === null) {
        (_a = field.optional) != null ? _a : field.optional = true;
      }
      if (field.default === void 0) {
        field.default = null;
        (_b = field.optional) != null ? _b : field.optional = false;
      } else if (!field.validate && field.default != null) {
        field.validate = assertValueType(getType(field.default));
      }
      for (const k of Object.keys(field)) {
        if (!validFieldKeys.has(k)) {
          throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
        }
      }
    }
    VISITOR_KEYS[type] = opts.visitor = visitor;
    BUILDER_KEYS[type] = opts.builder = builder;
    NODE_FIELDS$1[type] = opts.fields = fields;
    ALIAS_KEYS[type] = opts.aliases = aliases;
    aliases.forEach((alias2) => {
      FLIPPED_ALIAS_KEYS[alias2] = FLIPPED_ALIAS_KEYS[alias2] || [];
      FLIPPED_ALIAS_KEYS[alias2].push(type);
    });
    if (opts.validate) {
      NODE_PARENT_VALIDATIONS[type] = opts.validate;
    }
    if (opts.unionShape) {
      NODE_UNION_SHAPES__PRIVATE[type] = opts.unionShape;
    }
    store[type] = opts;
  }
  var utils = /* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    ALIAS_KEYS,
    BUILDER_KEYS,
    DEPRECATED_KEYS,
    FLIPPED_ALIAS_KEYS,
    NODE_FIELDS: NODE_FIELDS$1,
    NODE_PARENT_VALIDATIONS,
    NODE_UNION_SHAPES__PRIVATE,
    VISITOR_KEYS,
    allExpandedTypes,
    arrayOf,
    arrayOfType,
    assertEach,
    assertNodeOrValueType,
    assertNodeType,
    assertOneOf,
    assertOptionalChainStart,
    assertShape,
    assertValueType,
    chain,
    combine,
    default: defineType$5,
    defineAliasedType,
    validate: validate$2,
    validateArrayOfType,
    validateDefault,
    validateOptional,
    validateOptionalType,
    validateType
  }, Symbol.toStringTag, { value: "Module" });
  var classMethodOrPropertyUnionShapeCommon = (allowPrivateName = false) => ({
    unionShape: {
      discriminator: "computed",
      shapes: [{
        name: "computed",
        value: [true],
        properties: {
          key: {
            validate: assertNodeType("Expression")
          }
        }
      }, {
        name: "nonComputed",
        value: [false],
        properties: {
          key: {
            validate: allowPrivateName ? assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName") : assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral")
          }
        }
      }]
    }
  });
  var memberExpressionUnionShapeCommon = {
    unionShape: {
      discriminator: "computed",
      shapes: [{
        name: "computed",
        value: [true],
        properties: {
          property: {
            validate: assertNodeType("Expression")
          }
        }
      }, {
        name: "nonComputed",
        value: [false],
        properties: {
          property: {
            validate: assertNodeType("Identifier", "PrivateName")
          }
        }
      }]
    }
  };
  var defineType$4 = defineAliasedType("Standardized");
  defineType$4("ArrayExpression", {
    fields: {
      elements: {
        validate: arrayOf(assertNodeOrValueType("null", "Expression", "SpreadElement")),
        default: void 0
      }
    },
    visitor: ["elements"],
    aliases: ["Expression"]
  });
  defineType$4("AssignmentExpression", {
    fields: {
      operator: {
        validate: combine((function() {
          const identifier2 = assertOneOf(...ASSIGNMENT_OPERATORS);
          const pattern = assertOneOf("=");
          return function(node, key, val) {
            const validator = is("Pattern", node.left) ? pattern : identifier2;
            validator(node, key, val);
          };
        })(), {
          oneOf: ASSIGNMENT_OPERATORS
        })
      },
      left: {
        validate: assertNodeType("Identifier", "MemberExpression", "OptionalMemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
      },
      right: {
        validate: assertNodeType("Expression")
      }
    },
    builder: ["operator", "left", "right"],
    visitor: ["left", "right"],
    aliases: ["Expression"]
  });
  defineType$4("BinaryExpression", {
    builder: ["operator", "left", "right"],
    fields: {
      operator: {
        validate: assertOneOf(...BINARY_OPERATORS)
      },
      left: {
        validate: (function() {
          const expression = assertNodeType("Expression");
          const inOp = assertNodeType("Expression", "PrivateName");
          const validator = combine(function(node, key, val) {
            const validator2 = node.operator === "in" ? inOp : expression;
            validator2(node, key, val);
          }, {
            oneOfNodeTypes: ["Expression", "PrivateName"]
          });
          return validator;
        })()
      },
      right: {
        validate: assertNodeType("Expression")
      }
    },
    unionShape: {
      discriminator: "operator",
      shapes: [{
        name: "in",
        value: ["in"],
        properties: {
          left: {
            validate: assertNodeType("Expression", "PrivateName")
          }
        }
      }, {
        name: "notIn",
        value: BINARY_OPERATORS.filter((op) => op !== "in"),
        properties: {
          left: {
            validate: assertNodeType("Expression")
          }
        }
      }]
    },
    visitor: ["left", "right"],
    aliases: ["Binary", "Expression"]
  });
  defineType$4("InterpreterDirective", {
    builder: ["value"],
    fields: {
      value: {
        validate: assertValueType("string")
      }
    }
  });
  defineType$4("Directive", {
    visitor: ["value"],
    fields: {
      value: {
        validate: assertNodeType("DirectiveLiteral")
      }
    }
  });
  defineType$4("DirectiveLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: assertValueType("string")
      }
    }
  });
  defineType$4("BlockStatement", {
    builder: ["body", "directives"],
    visitor: ["directives", "body"],
    fields: {
      directives: {
        validate: arrayOfType("Directive"),
        default: []
      },
      body: validateArrayOfType("Statement")
    },
    aliases: ["Scopable", "BlockParent", "Block", "Statement"]
  });
  defineType$4("BreakStatement", {
    visitor: ["label"],
    fields: {
      label: {
        validate: assertNodeType("Identifier"),
        optional: true
      }
    },
    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
  });
  defineType$4("CallExpression", {
    visitor: ["callee", "typeArguments", "arguments"],
    builder: ["callee", "arguments"],
    aliases: ["Expression"],
    fields: {
      callee: {
        validate: assertNodeType("Expression", "Super", "Import", "V8IntrinsicIdentifier")
      },
      arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
      typeArguments: {
        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  defineType$4("CatchClause", {
    visitor: ["param", "body"],
    fields: {
      param: {
        validate: assertNodeType("Identifier", "ArrayPattern", "ObjectPattern"),
        optional: true
      },
      body: {
        validate: assertNodeType("BlockStatement")
      }
    },
    aliases: ["Scopable", "BlockParent"]
  });
  defineType$4("ConditionalExpression", {
    visitor: ["test", "consequent", "alternate"],
    fields: {
      test: {
        validate: assertNodeType("Expression")
      },
      consequent: {
        validate: assertNodeType("Expression")
      },
      alternate: {
        validate: assertNodeType("Expression")
      }
    },
    aliases: ["Expression", "Conditional"]
  });
  defineType$4("ContinueStatement", {
    visitor: ["label"],
    fields: {
      label: {
        validate: assertNodeType("Identifier"),
        optional: true
      }
    },
    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
  });
  defineType$4("DebuggerStatement", {
    aliases: ["Statement"]
  });
  defineType$4("DoWhileStatement", {
    builder: ["test", "body"],
    visitor: ["body", "test"],
    fields: {
      test: {
        validate: assertNodeType("Expression")
      },
      body: {
        validate: assertNodeType("Statement")
      }
    },
    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
  });
  defineType$4("EmptyStatement", {
    aliases: ["Statement"]
  });
  defineType$4("ExpressionStatement", {
    visitor: ["expression"],
    fields: {
      expression: {
        validate: assertNodeType("Expression")
      }
    },
    aliases: ["Statement", "ExpressionWrapper"]
  });
  defineType$4("File", {
    builder: ["program", "comments", "tokens"],
    visitor: ["program"],
    fields: {
      program: {
        validate: assertNodeType("Program")
      },
      comments: {
        validate: assertEach(assertNodeType("CommentBlock", "CommentLine")),
        optional: true
      },
      tokens: {
        validate: assertEach(Object.assign(() => {
        }, {
          type: "any"
        })),
        optional: true
      }
    }
  });
  defineType$4("ForInStatement", {
    visitor: ["left", "right", "body"],
    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
    fields: {
      left: {
        validate: assertNodeType("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
      },
      right: {
        validate: assertNodeType("Expression")
      },
      body: {
        validate: assertNodeType("Statement")
      }
    }
  });
  defineType$4("ForStatement", {
    visitor: ["init", "test", "update", "body"],
    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
    fields: {
      init: {
        validate: assertNodeType("VariableDeclaration", "Expression"),
        optional: true
      },
      test: {
        validate: assertNodeType("Expression"),
        optional: true
      },
      update: {
        validate: assertNodeType("Expression"),
        optional: true
      },
      body: {
        validate: assertNodeType("Statement")
      }
    }
  });
  var functionCommon = () => ({
    params: validateArrayOfType("FunctionParameter"),
    generator: {
      default: false
    },
    async: {
      default: false
    }
  });
  var functionTypeAnnotationCommon = () => ({
    returnType: {
      validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation"),
      optional: true
    },
    typeParameters: {
      validate: assertNodeType("TypeParameterDeclaration", "TSTypeParameterDeclaration"),
      optional: true
    }
  });
  var functionDeclarationCommon = () => ({
    ...functionCommon(),
    declare: {
      validate: assertValueType("boolean"),
      optional: true
    },
    id: {
      validate: assertNodeType("Identifier"),
      optional: true
    }
  });
  defineType$4("FunctionDeclaration", {
    builder: ["id", "params", "body", "generator", "async"],
    visitor: ["id", "typeParameters", "params", "predicate", "returnType", "body"],
    fields: {
      ...functionDeclarationCommon(),
      ...functionTypeAnnotationCommon(),
      body: {
        validate: assertNodeType("BlockStatement")
      },
      predicate: {
        validate: assertNodeType("FlowPredicate"),
        optional: true
      }
    },
    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
    validate: (function() {
      const identifier2 = assertNodeType("Identifier");
      return function(parent, key, node) {
        if (!is("ExportDefaultDeclaration", parent)) {
          identifier2(node, "id", node.id);
        }
      };
    })()
  });
  defineType$4("FunctionExpression", {
    inherits: "FunctionDeclaration",
    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
    fields: {
      ...functionCommon(),
      ...functionTypeAnnotationCommon(),
      id: {
        validate: assertNodeType("Identifier"),
        optional: true
      },
      body: {
        validate: assertNodeType("BlockStatement")
      },
      predicate: {
        validate: assertNodeType("FlowPredicate"),
        optional: true
      }
    }
  });
  var patternLikeCommon = () => ({
    typeAnnotation: {
      validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation"),
      optional: true
    },
    optional: {
      validate: assertValueType("boolean"),
      optional: true
    },
    decorators: {
      validate: arrayOfType("Decorator"),
      optional: true
    }
  });
  defineType$4("Identifier", {
    builder: ["name"],
    visitor: ["typeAnnotation", "decorators"],
    aliases: ["Expression", "FunctionParameter", "PatternLike", "LVal", "TSEntityName"],
    fields: {
      ...patternLikeCommon(),
      name: {
        validate: chain(assertValueType("string"), combine(function(node, key, val) {
          if (!isValidIdentifier(val, false)) {
            throw new TypeError(`"${val}" is not a valid identifier name`);
          }
        }, {
          type: "string"
        }))
      }
    },
    validate: function(parent, key, node) {
      const match = /\.(\w+)$/.exec(key.toString());
      if (!match) return;
      const [, parentKey] = match;
      const nonComp = {
        computed: false
      };
      if (parentKey === "property") {
        if (is("MemberExpression", parent, nonComp)) return;
        if (is("OptionalMemberExpression", parent, nonComp)) return;
      } else if (parentKey === "key") {
        if (is("Property", parent, nonComp)) return;
        if (is("Method", parent, nonComp)) return;
      } else if (parentKey === "exported") {
        if (is("ExportSpecifier", parent)) return;
      } else if (parentKey === "imported") {
        if (is("ImportSpecifier", parent, {
          imported: node
        })) return;
      } else if (parentKey === "meta") {
        if (is("MetaProperty", parent, {
          meta: node
        })) return;
      }
      if ((isKeyword(node.name) || isReservedWord(node.name, false)) && node.name !== "this") {
        throw new TypeError(`"${node.name}" is not a valid identifier`);
      }
    }
  });
  defineType$4("IfStatement", {
    visitor: ["test", "consequent", "alternate"],
    aliases: ["Statement", "Conditional"],
    fields: {
      test: {
        validate: assertNodeType("Expression")
      },
      consequent: {
        validate: assertNodeType("Statement")
      },
      alternate: {
        optional: true,
        validate: assertNodeType("Statement")
      }
    }
  });
  defineType$4("LabeledStatement", {
    visitor: ["label", "body"],
    aliases: ["Statement"],
    fields: {
      label: {
        validate: assertNodeType("Identifier")
      },
      body: {
        validate: assertNodeType("Statement")
      }
    }
  });
  defineType$4("StringLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: assertValueType("string")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  defineType$4("NumericLiteral", {
    builder: ["value"],
    deprecatedAlias: "NumberLiteral",
    fields: {
      value: {
        validate: chain(assertValueType("number"), combine(function(node, key, val) {
          if (1 / val < 0 || !Number.isFinite(val)) {
            const error = new Error(`NumericLiterals must be non-negative finite numbers. You can use t.valueToNode(${val}) instead.`);
            if (!new Error().stack.includes("regenerator")) {
              throw error;
            }
          }
        }, {
          type: "number"
        }))
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  defineType$4("NullLiteral", {
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  defineType$4("BooleanLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: assertValueType("boolean")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  defineType$4("RegExpLiteral", {
    builder: ["pattern", "flags"],
    deprecatedAlias: "RegexLiteral",
    aliases: ["Expression", "Pureish", "Literal"],
    fields: {
      pattern: {
        validate: assertValueType("string")
      },
      flags: {
        validate: chain(assertValueType("string"), combine(function(node, key, val) {
          const invalid = /[^dgimsuvy]/.exec(val);
          if (invalid) {
            throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
          }
        }, {
          type: "string"
        })),
        default: ""
      }
    }
  });
  defineType$4("LogicalExpression", {
    builder: ["operator", "left", "right"],
    visitor: ["left", "right"],
    aliases: ["Binary", "Expression"],
    fields: {
      operator: {
        validate: assertOneOf(...LOGICAL_OPERATORS)
      },
      left: {
        validate: assertNodeType("Expression")
      },
      right: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$4("MemberExpression", {
    builder: ["object", "property", "computed"],
    visitor: ["object", "property"],
    aliases: ["Expression", "LVal", "PatternLike"],
    ...memberExpressionUnionShapeCommon,
    fields: {
      object: {
        validate: assertNodeType("Expression", "Super")
      },
      property: {
        validate: (function() {
          const normal = assertNodeType("Identifier", "PrivateName");
          const computed = assertNodeType("Expression");
          const validator = combine(function(node, key, val) {
            const validator2 = node.computed ? computed : normal;
            validator2(node, key, val);
          }, {
            oneOfNodeTypes: ["Expression", "Identifier", "PrivateName"]
          });
          return validator;
        })()
      },
      computed: {
        default: false
      }
    }
  });
  defineType$4("NewExpression", {
    inherits: "CallExpression",
    fields: {
      callee: {
        validate: assertNodeType("Expression")
      },
      arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
      typeArguments: {
        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  defineType$4("Program", {
    visitor: ["directives", "body"],
    builder: ["body", "directives", "sourceType", "interpreter"],
    fields: {
      sourceType: {
        validate: assertOneOf("script", "module"),
        default: "script"
      },
      interpreter: {
        validate: assertNodeType("InterpreterDirective"),
        default: null,
        optional: true
      },
      directives: {
        validate: arrayOfType("Directive"),
        default: []
      },
      body: validateArrayOfType("Statement")
    },
    aliases: ["Scopable", "BlockParent", "Block"]
  });
  defineType$4("ObjectExpression", {
    visitor: ["properties"],
    aliases: ["Expression"],
    fields: {
      properties: validateArrayOfType("ObjectMethod", "ObjectProperty", "SpreadElement")
    }
  });
  defineType$4("ObjectMethod", {
    builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
    visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"],
    ...classMethodOrPropertyUnionShapeCommon(),
    fields: {
      ...functionCommon(),
      ...functionTypeAnnotationCommon(),
      kind: {
        validate: assertOneOf("method", "get", "set")
      },
      computed: {
        default: false
      },
      key: {
        validate: (function() {
          const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
          const computed = assertNodeType("Expression");
          const validator = combine(function(node, key, val) {
            const validator2 = node.computed ? computed : normal;
            validator2(node, key, val);
          }, {
            oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"]
          });
          return validator;
        })()
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      },
      body: {
        validate: assertNodeType("BlockStatement")
      }
    },
    aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
  });
  defineType$4("ObjectProperty", {
    builder: ["key", "value", "computed", "shorthand"],
    ...classMethodOrPropertyUnionShapeCommon(true),
    fields: {
      computed: {
        default: false
      },
      key: {
        validate: (function() {
          const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
          const computed = assertNodeType("Expression");
          const validator = combine(function(node, key, val) {
            const validator2 = node.computed ? computed : normal;
            validator2(node, key, val);
          }, {
            oneOfNodeTypes: ["Expression", "Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName"]
          });
          return validator;
        })()
      },
      value: {
        validate: assertNodeType("Expression", "PatternLike")
      },
      shorthand: {
        validate: chain(assertValueType("boolean"), combine(function(node, key, shorthand) {
          if (!shorthand) return;
          if (node.computed) {
            throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
          }
          if (!is("Identifier", node.key)) {
            throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
          }
        }, {
          type: "boolean"
        })),
        default: false
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      }
    },
    visitor: ["decorators", "key", "value"],
    aliases: ["UserWhitespacable", "Property", "ObjectMember"],
    validate: (function() {
      const pattern = assertNodeType("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion");
      const expression = assertNodeType("Expression");
      return function(parent, key, node) {
        const validator = is("ObjectPattern", parent) ? pattern : expression;
        validator(node, "value", node.value);
      };
    })()
  });
  defineType$4("RestElement", {
    visitor: ["argument", "typeAnnotation"],
    builder: ["argument"],
    aliases: ["FunctionParameter", "PatternLike"],
    deprecatedAlias: "RestProperty",
    fields: {
      ...patternLikeCommon(),
      argument: {
        validate: assertNodeType("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
      }
    },
    validate: function(parent, key) {
      const match = /(\w+)\[(\d+)\]/.exec(key.toString());
      if (!match) throw new Error("Internal Babel error: malformed key.");
      const [, listKey, index2] = match;
      if (parent[listKey].length > +index2 + 1) {
        throw new TypeError(`RestElement must be last element of ${listKey}`);
      }
    }
  });
  defineType$4("ReturnStatement", {
    visitor: ["argument"],
    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
    fields: {
      argument: {
        validate: assertNodeType("Expression"),
        optional: true
      }
    }
  });
  defineType$4("SequenceExpression", {
    visitor: ["expressions"],
    fields: {
      expressions: validateArrayOfType("Expression")
    },
    aliases: ["Expression"]
  });
  defineType$4("ParenthesizedExpression", {
    visitor: ["expression"],
    aliases: ["Expression", "ExpressionWrapper"],
    fields: {
      expression: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$4("SwitchCase", {
    visitor: ["test", "consequent"],
    fields: {
      test: {
        validate: assertNodeType("Expression"),
        optional: true
      },
      consequent: validateArrayOfType("Statement")
    }
  });
  defineType$4("SwitchStatement", {
    visitor: ["discriminant", "cases"],
    aliases: ["Statement", "BlockParent", "Scopable"],
    fields: {
      discriminant: {
        validate: assertNodeType("Expression")
      },
      cases: validateArrayOfType("SwitchCase")
    }
  });
  defineType$4("ThisExpression", {
    aliases: ["Expression", "TSEntityName"]
  });
  defineType$4("ThrowStatement", {
    visitor: ["argument"],
    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
    fields: {
      argument: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$4("TryStatement", {
    visitor: ["block", "handler", "finalizer"],
    aliases: ["Statement"],
    fields: {
      block: {
        validate: chain(assertNodeType("BlockStatement"), combine(function(node) {
          if (!node.handler && !node.finalizer) {
            throw new TypeError("TryStatement expects either a handler or finalizer, or both");
          }
        }, {
          oneOfNodeTypes: ["BlockStatement"]
        }))
      },
      handler: {
        optional: true,
        validate: assertNodeType("CatchClause")
      },
      finalizer: {
        optional: true,
        validate: assertNodeType("BlockStatement")
      }
    }
  });
  defineType$4("UnaryExpression", {
    builder: ["operator", "argument", "prefix"],
    fields: {
      prefix: {
        default: true
      },
      argument: {
        validate: assertNodeType("Expression")
      },
      operator: {
        validate: assertOneOf(...UNARY_OPERATORS)
      }
    },
    visitor: ["argument"],
    aliases: ["UnaryLike", "Expression"]
  });
  defineType$4("UpdateExpression", {
    builder: ["operator", "argument", "prefix"],
    fields: {
      prefix: {
        default: false
      },
      argument: {
        validate: assertNodeType("Identifier", "MemberExpression")
      },
      operator: {
        validate: assertOneOf(...UPDATE_OPERATORS)
      }
    },
    visitor: ["argument"],
    aliases: ["Expression"]
  });
  defineType$4("VariableDeclaration", {
    builder: ["kind", "declarations"],
    visitor: ["declarations"],
    aliases: ["Statement", "Declaration"],
    fields: {
      declare: {
        validate: assertValueType("boolean"),
        optional: true
      },
      kind: {
        validate: assertOneOf("var", "let", "const", "using", "await using")
      },
      declarations: validateArrayOfType("VariableDeclarator")
    },
    validate: (() => {
      const withoutInit = assertNodeType("Identifier", "Placeholder");
      const constOrLetOrVar = assertNodeType("Identifier", "ArrayPattern", "ObjectPattern", "Placeholder");
      const usingOrAwaitUsing = assertNodeType("Identifier", "VoidPattern", "Placeholder");
      return function(parent, key, node) {
        const {
          kind,
          declarations
        } = node;
        const parentIsForX = is("ForXStatement", parent, {
          left: node
        });
        if (parentIsForX) {
          if (declarations.length !== 1) {
            throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
          }
        }
        for (const decl of declarations) {
          if (kind === "const" || kind === "let" || kind === "var") {
            if (!parentIsForX && !decl.init) {
              withoutInit(decl, "id", decl.id);
            } else {
              constOrLetOrVar(decl, "id", decl.id);
            }
          } else {
            usingOrAwaitUsing(decl, "id", decl.id);
          }
        }
      };
    })()
  });
  defineType$4("VariableDeclarator", {
    visitor: ["id", "init"],
    fields: {
      id: {
        validate: assertNodeType("Identifier", "ArrayPattern", "ObjectPattern", "VoidPattern")
      },
      definite: {
        optional: true,
        validate: assertValueType("boolean")
      },
      init: {
        optional: true,
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$4("WhileStatement", {
    visitor: ["test", "body"],
    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
    fields: {
      test: {
        validate: assertNodeType("Expression")
      },
      body: {
        validate: assertNodeType("Statement")
      }
    }
  });
  defineType$4("WithStatement", {
    visitor: ["object", "body"],
    aliases: ["Statement"],
    fields: {
      object: {
        validate: assertNodeType("Expression")
      },
      body: {
        validate: assertNodeType("Statement")
      }
    }
  });
  defineType$4("AssignmentPattern", {
    visitor: ["left", "right", "decorators"],
    builder: ["left", "right"],
    aliases: ["FunctionParameter", "Pattern", "PatternLike"],
    fields: {
      ...patternLikeCommon(),
      left: {
        validate: assertNodeType("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression")
      },
      right: {
        validate: assertNodeType("Expression")
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      }
    }
  });
  defineType$4("ArrayPattern", {
    visitor: ["elements", "typeAnnotation"],
    builder: ["elements"],
    aliases: ["FunctionParameter", "Pattern", "PatternLike", "LVal"],
    fields: {
      ...patternLikeCommon(),
      elements: {
        validate: chain(assertValueType("array"), assertEach(assertNodeOrValueType("null", "PatternLike")))
      }
    }
  });
  defineType$4("ArrowFunctionExpression", {
    builder: ["params", "body", "async"],
    visitor: ["typeParameters", "params", "predicate", "returnType", "body"],
    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
    fields: {
      ...functionCommon(),
      generator: {
        default: null,
        optional: true,
        validate: combine((node, key, val) => {
          if (val) {
            throw new TypeError("ArrowFunctionExpression cannot be a generator");
          }
        }, {
          type: "boolean"
        })
      },
      ...functionTypeAnnotationCommon(),
      expression: {
        optional: true,
        validate: assertValueType("boolean")
      },
      body: {
        validate: assertNodeType("BlockStatement", "Expression")
      },
      predicate: {
        validate: assertNodeType("FlowPredicate"),
        optional: true
      }
    }
  });
  defineType$4("ClassBody", {
    visitor: ["body"],
    fields: {
      body: validateArrayOfType("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock")
    }
  });
  defineType$4("ClassExpression", {
    builder: ["id", "superClass", "body", "decorators"],
    visitor: ["decorators", "id", "typeParameters", "superClass", "superTypeArguments", "mixins", "implements", "body"],
    aliases: ["Scopable", "Class", "Expression"],
    fields: {
      id: {
        validate: assertNodeType("Identifier"),
        optional: true
      },
      typeParameters: {
        validate: assertNodeType("TypeParameterDeclaration", "TSTypeParameterDeclaration"),
        optional: true
      },
      body: {
        validate: assertNodeType("ClassBody")
      },
      superClass: {
        optional: true,
        validate: assertNodeType("Expression")
      },
      ["superTypeArguments"]: {
        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      },
      implements: {
        validate: arrayOfType("TSClassImplements", "ClassImplements"),
        optional: true
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      },
      mixins: {
        validate: assertNodeType("InterfaceExtends"),
        optional: true
      }
    }
  });
  defineType$4("ClassDeclaration", {
    inherits: "ClassExpression",
    aliases: ["Scopable", "Class", "Statement", "Declaration"],
    fields: {
      id: {
        validate: assertNodeType("Identifier"),
        optional: true
      },
      typeParameters: {
        validate: assertNodeType("TypeParameterDeclaration", "TSTypeParameterDeclaration"),
        optional: true
      },
      body: {
        validate: assertNodeType("ClassBody")
      },
      superClass: {
        optional: true,
        validate: assertNodeType("Expression")
      },
      ["superTypeArguments"]: {
        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      },
      implements: {
        validate: arrayOfType("TSClassImplements", "ClassImplements"),
        optional: true
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      },
      mixins: {
        validate: assertNodeType("InterfaceExtends"),
        optional: true
      },
      declare: {
        validate: assertValueType("boolean"),
        optional: true
      },
      abstract: {
        validate: assertValueType("boolean"),
        optional: true
      }
    },
    validate: (function() {
      const identifier2 = assertNodeType("Identifier");
      return function(parent, key, node) {
        if (!is("ExportDefaultDeclaration", parent)) {
          identifier2(node, "id", node.id);
        }
      };
    })()
  });
  var importAttributes = {
    attributes: {
      optional: true,
      validate: arrayOfType("ImportAttribute")
    }
  };
  defineType$4("ExportAllDeclaration", {
    visitor: ["source", "attributes"],
    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
    fields: {
      source: {
        validate: assertNodeType("StringLiteral")
      },
      exportKind: validateOptional(assertOneOf("type", "value")),
      ...importAttributes
    }
  });
  defineType$4("ExportDefaultDeclaration", {
    visitor: ["declaration"],
    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
    fields: {
      declaration: validateType("FunctionDeclaration", "ClassDeclaration", "Expression", "TSDeclareFunction", "TSInterfaceDeclaration", "EnumDeclaration"),
      exportKind: validateOptional(assertOneOf("value"))
    }
  });
  defineType$4("ExportNamedDeclaration", {
    builder: ["declaration", "specifiers", "source", "attributes"],
    visitor: ["declaration", "specifiers", "source", "attributes"],
    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration", "ExportDeclaration"],
    fields: {
      declaration: {
        optional: true,
        validate: chain(assertNodeType("Declaration"), combine(function(node, key, val) {
          if (val && node.specifiers.length) {
            throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
          }
          if (val && node.source) {
            throw new TypeError("Cannot export a declaration from a source");
          }
        }, {
          oneOfNodeTypes: ["VariableDeclaration", "FunctionDeclaration", "ClassDeclaration", "TSDeclareFunction", "TSEnumDeclaration", "TSImportEqualsDeclaration", "TSInterfaceDeclaration", "TSModuleDeclaration", "TSTypeAliasDeclaration", "EnumDeclaration", "InterfaceDeclaration", "OpaqueType", "TypeAlias"]
        }))
      },
      ...importAttributes,
      specifiers: {
        default: [],
        validate: arrayOf((function() {
          const sourced = assertNodeType("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
          const sourceless = assertNodeType("ExportSpecifier");
          return combine(function(node, key, val) {
            const validator = node.source ? sourced : sourceless;
            validator(node, key, val);
          }, {
            oneOfNodeTypes: ["ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"]
          });
        })())
      },
      source: {
        validate: assertNodeType("StringLiteral"),
        optional: true
      },
      exportKind: validateOptional(assertOneOf("type", "value"))
    }
  });
  defineType$4("ExportSpecifier", {
    visitor: ["local", "exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: assertNodeType("Identifier")
      },
      exported: {
        validate: assertNodeType("Identifier", "StringLiteral")
      },
      exportKind: {
        validate: assertOneOf("type", "value"),
        optional: true
      }
    }
  });
  defineType$4("ForOfStatement", {
    visitor: ["left", "right", "body"],
    builder: ["left", "right", "body", "await"],
    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
    fields: {
      left: {
        validate: (function() {
          const declaration = assertNodeType("VariableDeclaration");
          const lval = assertNodeType("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression");
          return combine(function(node, key, val) {
            if (is("VariableDeclaration", val)) {
              declaration(node, key, val);
            } else {
              lval(node, key, val);
            }
          }, {
            oneOfNodeTypes: ["VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression"]
          });
        })()
      },
      right: {
        validate: assertNodeType("Expression")
      },
      body: {
        validate: assertNodeType("Statement")
      },
      await: {
        default: false
      }
    }
  });
  defineType$4("ImportDeclaration", {
    builder: ["specifiers", "source", "attributes"],
    visitor: ["specifiers", "source", "attributes"],
    aliases: ["Statement", "Declaration", "ImportOrExportDeclaration"],
    fields: {
      ...importAttributes,
      module: {
        optional: true,
        validate: assertValueType("boolean")
      },
      phase: {
        default: null,
        validate: assertOneOf("source", "defer")
      },
      specifiers: validateArrayOfType("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"),
      source: {
        validate: assertNodeType("StringLiteral")
      },
      importKind: {
        validate: assertOneOf("type", "typeof", "value"),
        optional: true
      }
    }
  });
  defineType$4("ImportDefaultSpecifier", {
    visitor: ["local"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: assertNodeType("Identifier")
      }
    }
  });
  defineType$4("ImportNamespaceSpecifier", {
    visitor: ["local"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: assertNodeType("Identifier")
      }
    }
  });
  defineType$4("ImportSpecifier", {
    visitor: ["imported", "local"],
    builder: ["local", "imported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: assertNodeType("Identifier")
      },
      imported: {
        validate: assertNodeType("Identifier", "StringLiteral")
      },
      importKind: {
        validate: assertOneOf("type", "typeof", "value"),
        optional: true
      }
    }
  });
  defineType$4("MetaProperty", {
    visitor: ["meta", "property"],
    aliases: ["Expression"],
    fields: {
      meta: {
        validate: chain(assertNodeType("Identifier"), combine(function(node, key, val) {
          let property;
          switch (val.name) {
            case "function":
              property = "sent";
              break;
            case "new":
              property = "target";
              break;
            case "import":
              property = "meta";
              break;
          }
          if (!is("Identifier", node.property, {
            name: property
          })) {
            throw new TypeError("Unrecognised MetaProperty");
          }
        }, {
          oneOfNodeTypes: ["Identifier"]
        }))
      },
      property: {
        validate: assertNodeType("Identifier")
      }
    }
  });
  var classMethodOrPropertyCommon = () => ({
    abstract: {
      validate: assertValueType("boolean"),
      default: false,
      optional: true
    },
    accessibility: {
      validate: assertOneOf("public", "private", "protected"),
      optional: true
    },
    static: {
      default: false
    },
    override: {
      optional: true,
      validate: assertValueType("boolean"),
      default: false
    },
    computed: {
      default: false
    },
    optional: {
      validate: assertValueType("boolean"),
      optional: true
    },
    key: {
      validate: chain((function() {
        const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
        const computed = assertNodeType("Expression");
        return function(node, key, val) {
          const validator = node.computed ? computed : normal;
          validator(node, key, val);
        };
      })(), assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression"))
    }
  });
  var classMethodOrDeclareMethodCommon = (allowDecorators = true) => ({
    ...functionCommon(),
    ...classMethodOrPropertyCommon(),
    params: validateArrayOfType("FunctionParameter", "TSParameterProperty"),
    kind: {
      validate: assertOneOf("get", "set", "method", "constructor"),
      default: "method"
    },
    access: {
      validate: chain(assertValueType("string"), assertOneOf("public", "private", "protected")),
      optional: true
    },
    ...allowDecorators ? {
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      }
    } : {}
  });
  defineType$4("ClassMethod", {
    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
    builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
    visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"],
    ...classMethodOrPropertyUnionShapeCommon(),
    fields: {
      ...classMethodOrDeclareMethodCommon(),
      ...functionTypeAnnotationCommon(),
      body: {
        validate: assertNodeType("BlockStatement")
      }
    }
  });
  defineType$4("ObjectPattern", {
    visitor: ["decorators", "properties", "typeAnnotation"],
    builder: ["properties"],
    aliases: ["FunctionParameter", "Pattern", "PatternLike", "LVal"],
    fields: {
      ...patternLikeCommon(),
      properties: validateArrayOfType("RestElement", "ObjectProperty")
    }
  });
  defineType$4("SpreadElement", {
    visitor: ["argument"],
    aliases: ["UnaryLike"],
    deprecatedAlias: "SpreadProperty",
    fields: {
      argument: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$4("Super");
  defineType$4("TaggedTemplateExpression", {
    visitor: ["tag", "typeArguments", "quasi"],
    builder: ["tag", "quasi"],
    aliases: ["Expression"],
    fields: {
      tag: {
        validate: assertNodeType("Expression")
      },
      quasi: {
        validate: assertNodeType("TemplateLiteral")
      },
      ["typeArguments"]: {
        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  defineType$4("TemplateElement", {
    builder: ["value", "tail"],
    fields: {
      value: {
        validate: chain(assertShape({
          raw: {
            validate: assertValueType("string")
          },
          cooked: {
            validate: assertValueType("string"),
            optional: true
          }
        }), function templateElementCookedValidator(node) {
          const raw = node.value.raw;
          let unterminatedCalled = false;
          const error = () => {
            throw new Error("Internal @babel/types error.");
          };
          const {
            str,
            firstInvalidLoc
          } = readStringContents("template", raw, 0, 0, 0, {
            unterminated() {
              unterminatedCalled = true;
            },
            strictNumericEscape: error,
            invalidEscapeSequence: error,
            numericSeparatorInEscapeSequence: error,
            unexpectedNumericSeparator: error,
            invalidDigit: error,
            invalidCodePoint: error
          });
          if (!unterminatedCalled) throw new Error("Invalid raw");
          node.value.cooked = firstInvalidLoc ? null : str;
        })
      },
      tail: {
        default: false
      }
    }
  });
  defineType$4("TemplateLiteral", {
    visitor: ["quasis", "expressions"],
    aliases: ["Expression", "Literal"],
    fields: {
      quasis: validateArrayOfType("TemplateElement"),
      expressions: {
        validate: chain(assertValueType("array"), assertEach(assertNodeType("Expression", "TSType")), function(node, key, val) {
          if (node.quasis.length !== val.length + 1) {
            throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.
Expected ${val.length + 1} quasis but got ${node.quasis.length}`);
          }
        })
      }
    }
  });
  defineType$4("YieldExpression", {
    builder: ["argument", "delegate"],
    visitor: ["argument"],
    aliases: ["Expression", "Terminatorless"],
    fields: {
      delegate: {
        validate: chain(assertValueType("boolean"), combine(function(node, key, val) {
          if (val && !node.argument) {
            throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
          }
        }, {
          type: "boolean"
        })),
        default: false
      },
      argument: {
        optional: true,
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$4("AwaitExpression", {
    builder: ["argument"],
    visitor: ["argument"],
    aliases: ["Expression", "Terminatorless"],
    fields: {
      argument: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$4("ImportExpression", {
    visitor: ["source", "options"],
    aliases: ["Expression"],
    fields: {
      phase: {
        default: null,
        validate: assertOneOf("source", "defer")
      },
      source: {
        validate: assertNodeType("Expression")
      },
      options: {
        validate: assertNodeType("Expression"),
        optional: true
      }
    }
  });
  defineType$4("Import");
  defineType$4("BigIntLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: assertValueType("bigint")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  defineType$4("ExportNamespaceSpecifier", {
    visitor: ["exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      exported: {
        validate: assertNodeType("Identifier", "StringLiteral")
      }
    }
  });
  defineType$4("OptionalMemberExpression", {
    builder: ["object", "property", "computed", "optional"],
    visitor: ["object", "property"],
    aliases: ["Expression"],
    ...memberExpressionUnionShapeCommon,
    fields: {
      object: {
        validate: assertNodeType("Expression")
      },
      property: {
        validate: (function() {
          const normal = assertNodeType("Identifier", "PrivateName");
          const computed = assertNodeType("Expression");
          return combine(function(node, key, val) {
            const validator = node.computed ? computed : normal;
            validator(node, key, val);
          }, {
            oneOfNodeTypes: ["Expression", "PrivateName"]
          });
        })()
      },
      computed: {
        default: false
      },
      optional: {
        validate: chain(assertValueType("boolean"), assertOptionalChainStart())
      }
    }
  });
  defineType$4("OptionalCallExpression", {
    visitor: ["callee", "typeArguments", "arguments"],
    builder: ["callee", "arguments", "optional"],
    aliases: ["Expression"],
    fields: {
      callee: {
        validate: assertNodeType("Expression")
      },
      arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
      optional: {
        validate: chain(assertValueType("boolean"), assertOptionalChainStart())
      },
      typeArguments: {
        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  defineType$4("ClassProperty", {
    visitor: ["decorators", "variance", "key", "typeAnnotation", "value"],
    builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
    aliases: ["Property"],
    ...classMethodOrPropertyUnionShapeCommon(),
    fields: {
      ...classMethodOrPropertyCommon(),
      value: {
        validate: assertNodeType("Expression"),
        optional: true
      },
      definite: {
        validate: assertValueType("boolean"),
        optional: true
      },
      typeAnnotation: {
        validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation"),
        optional: true
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      },
      readonly: {
        validate: assertValueType("boolean"),
        optional: true
      },
      declare: {
        validate: assertValueType("boolean"),
        optional: true
      },
      variance: {
        validate: assertNodeType("Variance"),
        optional: true
      }
    }
  });
  defineType$4("ClassPrivateProperty", {
    visitor: ["decorators", "variance", "key", "typeAnnotation", "value"],
    builder: ["key", "value", "decorators", "static"],
    aliases: ["Property", "Private"],
    fields: {
      key: {
        validate: assertNodeType("PrivateName")
      },
      value: {
        validate: assertNodeType("Expression"),
        optional: true
      },
      typeAnnotation: {
        validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation"),
        optional: true
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      },
      static: {
        validate: assertValueType("boolean"),
        default: false
      },
      readonly: {
        validate: assertValueType("boolean"),
        optional: true
      },
      optional: {
        validate: assertValueType("boolean"),
        optional: true
      },
      definite: {
        validate: assertValueType("boolean"),
        optional: true
      },
      variance: {
        validate: assertNodeType("Variance"),
        optional: true
      }
    }
  });
  defineType$4("ClassPrivateMethod", {
    builder: ["kind", "key", "params", "body", "static"],
    visitor: ["decorators", "key", "typeParameters", "params", "returnType", "body"],
    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
    fields: {
      ...classMethodOrDeclareMethodCommon(),
      ...functionTypeAnnotationCommon(),
      kind: {
        validate: assertOneOf("get", "set", "method"),
        default: "method"
      },
      key: {
        validate: assertNodeType("PrivateName")
      },
      body: {
        validate: assertNodeType("BlockStatement")
      }
    }
  });
  defineType$4("PrivateName", {
    visitor: ["id"],
    aliases: ["Private"],
    fields: {
      id: {
        validate: assertNodeType("Identifier")
      }
    }
  });
  defineType$4("StaticBlock", {
    visitor: ["body"],
    fields: {
      body: validateArrayOfType("Statement")
    },
    aliases: ["Scopable", "BlockParent", "FunctionParent"]
  });
  defineType$4("ImportAttribute", {
    visitor: ["key", "value"],
    fields: {
      key: {
        validate: assertNodeType("Identifier", "StringLiteral")
      },
      value: {
        validate: assertNodeType("StringLiteral")
      }
    }
  });
  var defineType$3 = defineAliasedType("Flow");
  var defineInterfaceishType = (name) => {
    const isDeclareClass2 = name === "DeclareClass";
    defineType$3(name, {
      builder: ["id", "typeParameters", "extends", "body"],
      visitor: ["id", "typeParameters", "extends", ...isDeclareClass2 ? ["mixins", "implements"] : [], "body"],
      aliases: ["FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: validateType("Identifier"),
        typeParameters: validateOptionalType("TypeParameterDeclaration"),
        extends: validateOptional(arrayOfType("InterfaceExtends")),
        ...isDeclareClass2 ? {
          mixins: validateOptional(arrayOfType("InterfaceExtends")),
          implements: validateOptional(arrayOfType("ClassImplements"))
        } : {},
        body: validateType("ObjectTypeAnnotation")
      }
    });
  };
  defineType$3("AnyTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("ArrayTypeAnnotation", {
    visitor: ["elementType"],
    aliases: ["FlowType"],
    fields: {
      elementType: validateType("FlowType")
    }
  });
  defineType$3("BooleanTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("BooleanLiteralTypeAnnotation", {
    builder: ["value"],
    aliases: ["FlowType"],
    fields: {
      value: validate$2(assertValueType("boolean"))
    }
  });
  defineType$3("NullLiteralTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("ClassImplements", {
    visitor: ["id", "typeParameters"],
    fields: {
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TypeParameterInstantiation")
    }
  });
  defineInterfaceishType("DeclareClass");
  defineType$3("DeclareFunction", {
    builder: ["id"],
    visitor: ["id", "predicate"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: validateType("Identifier"),
      predicate: validateOptionalType("FlowPredicate")
    }
  });
  defineInterfaceishType("DeclareInterface");
  defineType$3("DeclareModule", {
    builder: ["id", "body", "kind"],
    visitor: ["id", "body"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: validateType("Identifier", "StringLiteral"),
      body: validateType("BlockStatement"),
      kind: validateOptional(assertOneOf("CommonJS", "ES"))
    }
  });
  defineType$3("DeclareModuleExports", {
    visitor: ["typeAnnotation"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      typeAnnotation: validateType("TypeAnnotation")
    }
  });
  defineType$3("DeclareTypeAlias", {
    visitor: ["id", "typeParameters", "right"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TypeParameterDeclaration"),
      right: validateType("FlowType")
    }
  });
  defineType$3("DeclareOpaqueType", {
    visitor: ["id", "typeParameters", "supertype"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TypeParameterDeclaration"),
      supertype: validateOptionalType("FlowType"),
      impltype: validateOptionalType("FlowType")
    }
  });
  defineType$3("DeclareVariable", {
    visitor: ["id"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: validateType("Identifier")
    }
  });
  defineType$3("DeclareExportDeclaration", {
    visitor: ["declaration", "specifiers", "source", "attributes"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      declaration: validateOptionalType("Flow"),
      specifiers: validateOptional(arrayOfType("ExportSpecifier", "ExportNamespaceSpecifier")),
      source: validateOptionalType("StringLiteral"),
      default: validateOptional(assertValueType("boolean")),
      ...importAttributes
    }
  });
  defineType$3("DeclareExportAllDeclaration", {
    visitor: ["source", "attributes"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      source: validateType("StringLiteral"),
      exportKind: validateOptional(assertOneOf("type", "value")),
      ...importAttributes
    }
  });
  defineType$3("DeclaredPredicate", {
    visitor: ["value"],
    aliases: ["FlowPredicate"],
    fields: {
      value: validateType("Expression")
    }
  });
  defineType$3("ExistsTypeAnnotation", {
    aliases: ["FlowType"]
  });
  defineType$3("FunctionTypeAnnotation", {
    builder: ["typeParameters", "params", "rest", "returnType"],
    visitor: ["typeParameters", "this", "params", "rest", "returnType"],
    aliases: ["FlowType"],
    fields: {
      typeParameters: validateOptionalType("TypeParameterDeclaration"),
      params: validateArrayOfType("FunctionTypeParam"),
      rest: validateOptionalType("FunctionTypeParam"),
      this: validateOptionalType("FunctionTypeParam"),
      returnType: validateType("FlowType")
    }
  });
  defineType$3("FunctionTypeParam", {
    visitor: ["name", "typeAnnotation"],
    fields: {
      name: validateOptionalType("Identifier"),
      typeAnnotation: validateType("FlowType"),
      optional: validateOptional(assertValueType("boolean"))
    }
  });
  defineType$3("GenericTypeAnnotation", {
    visitor: ["id", "typeParameters"],
    aliases: ["FlowType"],
    fields: {
      id: validateType("Identifier", "QualifiedTypeIdentifier"),
      typeParameters: validateOptionalType("TypeParameterInstantiation")
    }
  });
  defineType$3("InferredPredicate", {
    aliases: ["FlowPredicate"]
  });
  defineType$3("InterfaceExtends", {
    visitor: ["id", "typeParameters"],
    fields: {
      id: validateType("Identifier", "QualifiedTypeIdentifier"),
      typeParameters: validateOptionalType("TypeParameterInstantiation")
    }
  });
  defineInterfaceishType("InterfaceDeclaration");
  defineType$3("InterfaceTypeAnnotation", {
    visitor: ["extends", "body"],
    aliases: ["FlowType"],
    fields: {
      extends: validateOptional(arrayOfType("InterfaceExtends")),
      body: validateType("ObjectTypeAnnotation")
    }
  });
  defineType$3("IntersectionTypeAnnotation", {
    visitor: ["types"],
    aliases: ["FlowType"],
    fields: {
      types: validate$2(arrayOfType("FlowType"))
    }
  });
  defineType$3("MixedTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("EmptyTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("NullableTypeAnnotation", {
    visitor: ["typeAnnotation"],
    aliases: ["FlowType"],
    fields: {
      typeAnnotation: validateType("FlowType")
    }
  });
  defineType$3("NumberLiteralTypeAnnotation", {
    builder: ["value"],
    aliases: ["FlowType"],
    fields: {
      value: validate$2(assertValueType("number"))
    }
  });
  defineType$3("BigIntLiteralTypeAnnotation", {
    builder: ["value"],
    aliases: ["FlowType"],
    fields: {
      value: validate$2(assertValueType("bigint"))
    }
  });
  defineType$3("NumberTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("ObjectTypeAnnotation", {
    visitor: ["properties", "indexers", "callProperties", "internalSlots"],
    aliases: ["FlowType"],
    builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
    fields: {
      properties: validate$2(arrayOfType("ObjectTypeProperty", "ObjectTypeSpreadProperty")),
      indexers: {
        validate: arrayOfType("ObjectTypeIndexer"),
        optional: false,
        default: []
      },
      callProperties: {
        validate: arrayOfType("ObjectTypeCallProperty"),
        optional: false,
        default: []
      },
      internalSlots: {
        validate: arrayOfType("ObjectTypeInternalSlot"),
        optional: false,
        default: []
      },
      exact: {
        validate: assertValueType("boolean"),
        default: false
      },
      inexact: validateOptional(assertValueType("boolean"))
    }
  });
  defineType$3("ObjectTypeInternalSlot", {
    visitor: ["id", "value"],
    builder: ["id", "value", "optional", "static", "method"],
    aliases: ["UserWhitespacable"],
    fields: {
      id: validateType("Identifier"),
      value: validateType("FlowType"),
      optional: validate$2(assertValueType("boolean")),
      static: validate$2(assertValueType("boolean")),
      method: validate$2(assertValueType("boolean"))
    }
  });
  defineType$3("ObjectTypeCallProperty", {
    visitor: ["value"],
    aliases: ["UserWhitespacable"],
    fields: {
      value: validateType("FlowType"),
      static: validateDefault(assertValueType("boolean"), false)
    }
  });
  defineType$3("ObjectTypeIndexer", {
    visitor: ["variance", "id", "key", "value"],
    builder: ["id", "key", "value", "variance"],
    aliases: ["UserWhitespacable"],
    fields: {
      id: validateOptionalType("Identifier"),
      key: validateType("FlowType"),
      value: validateType("FlowType"),
      static: validateDefault(assertValueType("boolean"), false),
      variance: validateOptionalType("Variance")
    }
  });
  defineType$3("ObjectTypeProperty", {
    visitor: ["key", "value", "variance"],
    aliases: ["UserWhitespacable"],
    fields: {
      key: validateType("Identifier", "StringLiteral", "NumericLiteral"),
      value: validateType("FlowType"),
      kind: {
        validate: assertOneOf("init", "get", "set"),
        default: "init",
        optional: false
      },
      static: validateDefault(assertValueType("boolean"), false),
      proto: validateDefault(assertValueType("boolean"), false),
      optional: validateDefault(assertValueType("boolean"), false),
      variance: validateOptionalType("Variance"),
      method: validateDefault(assertValueType("boolean"), false)
    }
  });
  defineType$3("ObjectTypeSpreadProperty", {
    visitor: ["argument"],
    aliases: ["UserWhitespacable"],
    fields: {
      argument: validateType("FlowType")
    }
  });
  defineType$3("OpaqueType", {
    visitor: ["id", "typeParameters", "supertype", "impltype"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TypeParameterDeclaration"),
      supertype: validateOptionalType("FlowType"),
      impltype: validateType("FlowType")
    }
  });
  defineType$3("QualifiedTypeIdentifier", {
    visitor: ["qualification", "id"],
    builder: ["id", "qualification"],
    fields: {
      id: validateType("Identifier"),
      qualification: validateType("Identifier", "QualifiedTypeIdentifier")
    }
  });
  defineType$3("StringLiteralTypeAnnotation", {
    builder: ["value"],
    aliases: ["FlowType"],
    fields: {
      value: validate$2(assertValueType("string"))
    }
  });
  defineType$3("StringTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("SymbolTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("ThisTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("TupleTypeAnnotation", {
    visitor: ["types"],
    aliases: ["FlowType"],
    fields: {
      types: validate$2(arrayOfType("FlowType"))
    }
  });
  defineType$3("TypeofTypeAnnotation", {
    visitor: ["argument"],
    aliases: ["FlowType"],
    fields: {
      argument: validateType("FlowType")
    }
  });
  defineType$3("TypeAlias", {
    visitor: ["id", "typeParameters", "right"],
    aliases: ["FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TypeParameterDeclaration"),
      right: validateType("FlowType")
    }
  });
  defineType$3("TypeAnnotation", {
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: validateType("FlowType")
    }
  });
  defineType$3("TypeCastExpression", {
    visitor: ["expression", "typeAnnotation"],
    aliases: ["ExpressionWrapper", "Expression"],
    fields: {
      expression: validateType("Expression"),
      typeAnnotation: validateType("TypeAnnotation")
    }
  });
  defineType$3("TypeParameter", {
    builder: ["name", "bound", "default", "variance"],
    visitor: ["bound", "default", "variance"],
    fields: {
      name: validate$2(assertValueType("string")),
      bound: validateOptionalType("TypeAnnotation"),
      default: validateOptionalType("FlowType"),
      variance: validateOptionalType("Variance")
    }
  });
  defineType$3("TypeParameterDeclaration", {
    visitor: ["params"],
    fields: {
      params: validate$2(arrayOfType("TypeParameter"))
    }
  });
  defineType$3("TypeParameterInstantiation", {
    visitor: ["params"],
    fields: {
      params: validate$2(arrayOfType("FlowType"))
    }
  });
  defineType$3("UnionTypeAnnotation", {
    visitor: ["types"],
    aliases: ["FlowType"],
    fields: {
      types: validate$2(arrayOfType("FlowType"))
    }
  });
  defineType$3("Variance", {
    builder: ["kind"],
    fields: {
      kind: validate$2(assertOneOf("minus", "plus"))
    }
  });
  defineType$3("VoidTypeAnnotation", {
    aliases: ["FlowType", "FlowBaseAnnotation"]
  });
  defineType$3("EnumDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "body"],
    fields: {
      id: validateType("Identifier"),
      body: validateType("EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody")
    }
  });
  var enumBodyBase = {
    explicitType: validateDefault(assertValueType("boolean"), false),
    hasUnknownMembers: validateDefault(assertValueType("boolean"), false)
  };
  defineType$3("EnumBooleanBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      ...enumBodyBase,
      members: validateArrayOfType("EnumBooleanMember")
    }
  });
  defineType$3("EnumNumberBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      ...enumBodyBase,
      members: validateArrayOfType("EnumNumberMember")
    }
  });
  defineType$3("EnumStringBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      ...enumBodyBase,
      members: validateArrayOfType("EnumStringMember", "EnumDefaultedMember")
    }
  });
  defineType$3("EnumSymbolBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      members: validateArrayOfType("EnumDefaultedMember"),
      hasUnknownMembers: validateDefault(assertValueType("boolean"), false)
    }
  });
  defineType$3("EnumBooleanMember", {
    aliases: ["EnumMember"],
    visitor: ["id", "init"],
    fields: {
      id: validateType("Identifier"),
      init: validateType("BooleanLiteral")
    }
  });
  defineType$3("EnumNumberMember", {
    aliases: ["EnumMember"],
    visitor: ["id", "init"],
    fields: {
      id: validateType("Identifier"),
      init: validateType("NumericLiteral")
    }
  });
  defineType$3("EnumStringMember", {
    aliases: ["EnumMember"],
    visitor: ["id", "init"],
    fields: {
      id: validateType("Identifier"),
      init: validateType("StringLiteral")
    }
  });
  defineType$3("EnumDefaultedMember", {
    aliases: ["EnumMember"],
    visitor: ["id"],
    fields: {
      id: validateType("Identifier")
    }
  });
  defineType$3("IndexedAccessType", {
    visitor: ["objectType", "indexType"],
    aliases: ["FlowType"],
    fields: {
      objectType: validateType("FlowType"),
      indexType: validateType("FlowType")
    }
  });
  defineType$3("OptionalIndexedAccessType", {
    visitor: ["objectType", "indexType"],
    aliases: ["FlowType"],
    fields: {
      objectType: validateType("FlowType"),
      indexType: validateType("FlowType"),
      optional: validateDefault(assertValueType("boolean"), false)
    }
  });
  var defineType$2 = defineAliasedType("JSX");
  defineType$2("JSXAttribute", {
    visitor: ["name", "value"],
    aliases: ["Immutable"],
    fields: {
      name: {
        validate: assertNodeType("JSXIdentifier", "JSXNamespacedName")
      },
      value: {
        optional: true,
        validate: assertNodeType("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
      }
    }
  });
  defineType$2("JSXClosingElement", {
    visitor: ["name"],
    aliases: ["Immutable"],
    fields: {
      name: {
        validate: assertNodeType("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
      }
    }
  });
  defineType$2("JSXElement", {
    builder: ["openingElement", "closingElement", "children"],
    visitor: ["openingElement", "children", "closingElement"],
    aliases: ["Immutable", "Expression"],
    fields: {
      openingElement: {
        validate: assertNodeType("JSXOpeningElement")
      },
      closingElement: {
        optional: true,
        validate: assertNodeType("JSXClosingElement")
      },
      children: validateArrayOfType("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")
    }
  });
  defineType$2("JSXEmptyExpression", {});
  defineType$2("JSXExpressionContainer", {
    visitor: ["expression"],
    aliases: ["Immutable"],
    fields: {
      expression: {
        validate: assertNodeType("Expression", "JSXEmptyExpression")
      }
    }
  });
  defineType$2("JSXSpreadChild", {
    visitor: ["expression"],
    aliases: ["Immutable"],
    fields: {
      expression: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$2("JSXIdentifier", {
    builder: ["name"],
    fields: {
      name: {
        validate: assertValueType("string")
      }
    }
  });
  defineType$2("JSXMemberExpression", {
    visitor: ["object", "property"],
    fields: {
      object: {
        validate: assertNodeType("JSXMemberExpression", "JSXIdentifier")
      },
      property: {
        validate: assertNodeType("JSXIdentifier")
      }
    }
  });
  defineType$2("JSXNamespacedName", {
    visitor: ["namespace", "name"],
    fields: {
      namespace: {
        validate: assertNodeType("JSXIdentifier")
      },
      name: {
        validate: assertNodeType("JSXIdentifier")
      }
    }
  });
  defineType$2("JSXOpeningElement", {
    builder: ["name", "attributes", "selfClosing"],
    visitor: ["name", "typeArguments", "attributes"],
    aliases: ["Immutable"],
    fields: {
      name: {
        validate: assertNodeType("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
      },
      selfClosing: {
        default: false
      },
      attributes: validateArrayOfType("JSXAttribute", "JSXSpreadAttribute"),
      typeArguments: {
        validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  defineType$2("JSXSpreadAttribute", {
    visitor: ["argument"],
    fields: {
      argument: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$2("JSXText", {
    aliases: ["Immutable"],
    builder: ["value"],
    fields: {
      value: {
        validate: assertValueType("string")
      }
    }
  });
  defineType$2("JSXFragment", {
    builder: ["openingFragment", "closingFragment", "children"],
    visitor: ["openingFragment", "children", "closingFragment"],
    aliases: ["Immutable", "Expression"],
    fields: {
      openingFragment: {
        validate: assertNodeType("JSXOpeningFragment")
      },
      closingFragment: {
        validate: assertNodeType("JSXClosingFragment")
      },
      children: validateArrayOfType("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")
    }
  });
  defineType$2("JSXOpeningFragment", {
    aliases: ["Immutable"]
  });
  defineType$2("JSXClosingFragment", {
    aliases: ["Immutable"]
  });
  var PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
  var PLACEHOLDERS_ALIAS = {
    Declaration: ["Statement"],
    Pattern: ["PatternLike", "LVal"]
  };
  for (const type of PLACEHOLDERS) {
    const alias2 = ALIAS_KEYS[type];
    if (alias2 == null ? void 0 : alias2.length) PLACEHOLDERS_ALIAS[type] = alias2;
  }
  var PLACEHOLDERS_FLIPPED_ALIAS = {};
  Object.keys(PLACEHOLDERS_ALIAS).forEach((type) => {
    PLACEHOLDERS_ALIAS[type].forEach((alias2) => {
      if (!Object.hasOwn(PLACEHOLDERS_FLIPPED_ALIAS, alias2)) {
        PLACEHOLDERS_FLIPPED_ALIAS[alias2] = [];
      }
      PLACEHOLDERS_FLIPPED_ALIAS[alias2].push(type);
    });
  });
  var defineType$1 = defineAliasedType("Miscellaneous");
  defineType$1("Placeholder", {
    visitor: [],
    builder: ["expectedNode", "name"],
    fields: {
      name: {
        validate: assertNodeType("Identifier")
      },
      expectedNode: {
        validate: assertOneOf(...PLACEHOLDERS)
      },
      ...patternLikeCommon()
    }
  });
  defineType$1("V8IntrinsicIdentifier", {
    builder: ["name"],
    fields: {
      name: {
        validate: assertValueType("string")
      }
    }
  });
  defineType$5("ArgumentPlaceholder", {});
  defineType$5("BindExpression", {
    visitor: ["object", "callee"],
    aliases: ["Expression"],
    fields: {
      object: {
        validate: assertNodeOrValueType("null", "Expression")
      },
      callee: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$5("ClassAccessorProperty", {
    visitor: ["decorators", "key", "typeAnnotation", "value"],
    builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
    aliases: ["Property", "Accessor"],
    ...classMethodOrPropertyUnionShapeCommon(true),
    fields: {
      ...classMethodOrPropertyCommon(),
      key: {
        validate: chain((function() {
          const normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
          const computed = assertNodeType("Expression");
          return function(node, key, val) {
            const validator = node.computed ? computed : normal;
            validator(node, key, val);
          };
        })(), assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName"))
      },
      value: {
        validate: assertNodeType("Expression"),
        optional: true
      },
      definite: {
        validate: assertValueType("boolean"),
        optional: true
      },
      typeAnnotation: {
        validate: assertNodeType("TypeAnnotation", "TSTypeAnnotation"),
        optional: true
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      },
      readonly: {
        validate: assertValueType("boolean"),
        optional: true
      },
      declare: {
        validate: assertValueType("boolean"),
        optional: true
      },
      variance: {
        validate: assertNodeType("Variance"),
        optional: true
      }
    }
  });
  defineType$5("Decorator", {
    visitor: ["expression"],
    fields: {
      expression: {
        validate: assertNodeType("Expression")
      }
    }
  });
  defineType$5("DoExpression", {
    visitor: ["body"],
    builder: ["body", "async"],
    aliases: ["Expression"],
    fields: {
      body: {
        validate: assertNodeType("BlockStatement")
      },
      async: {
        validate: assertValueType("boolean"),
        default: false
      }
    }
  });
  defineType$5("ExportDefaultSpecifier", {
    visitor: ["exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      exported: {
        validate: assertNodeType("Identifier")
      }
    }
  });
  defineType$5("ModuleExpression", {
    visitor: ["body"],
    fields: {
      body: {
        validate: assertNodeType("Program")
      }
    },
    aliases: ["Expression"]
  });
  defineType$5("TopicReference", {
    aliases: ["Expression"]
  });
  defineType$5("VoidPattern", {
    aliases: ["Pattern", "PatternLike", "FunctionParameter"]
  });
  var defineType = defineAliasedType("TypeScript");
  var bool = assertValueType("boolean");
  var tSFunctionTypeAnnotationCommon = () => ({
    returnType: {
      validate: assertNodeType("TSTypeAnnotation"),
      optional: true
    },
    typeParameters: {
      validate: assertNodeType("TSTypeParameterDeclaration"),
      optional: true
    }
  });
  defineType("TSParameterProperty", {
    aliases: [],
    visitor: ["parameter"],
    fields: {
      accessibility: {
        validate: assertOneOf("public", "private", "protected"),
        optional: true
      },
      readonly: {
        validate: assertValueType("boolean"),
        optional: true
      },
      parameter: {
        validate: assertNodeType("Identifier", "AssignmentPattern")
      },
      override: {
        validate: assertValueType("boolean"),
        optional: true
      },
      decorators: {
        validate: arrayOfType("Decorator"),
        optional: true
      }
    }
  });
  defineType("TSDeclareFunction", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "params", "returnType"],
    fields: {
      ...functionDeclarationCommon(),
      ...tSFunctionTypeAnnotationCommon()
    }
  });
  defineType("TSDeclareMethod", {
    visitor: ["key", "typeParameters", "params", "returnType"],
    ...classMethodOrPropertyUnionShapeCommon(),
    fields: {
      ...classMethodOrDeclareMethodCommon(false),
      ...tSFunctionTypeAnnotationCommon()
    }
  });
  defineType("TSQualifiedName", {
    aliases: ["TSEntityName"],
    visitor: ["left", "right"],
    fields: {
      left: validateType("TSEntityName"),
      right: validateType("Identifier")
    }
  });
  var signatureDeclarationCommon = () => ({
    typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
    ["params"]: validateArrayOfType("ArrayPattern", "Identifier", "ObjectPattern", "RestElement"),
    ["returnType"]: validateOptionalType("TSTypeAnnotation")
  });
  var callConstructSignatureDeclaration = {
    aliases: ["TSTypeElement"],
    visitor: ["typeParameters", "params", "returnType"],
    fields: signatureDeclarationCommon()
  };
  defineType("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
  defineType("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
  var namedTypeElementCommon = () => ({
    key: validateType("Expression"),
    computed: {
      default: false
    },
    optional: validateOptional(bool)
  });
  defineType("TSPropertySignature", {
    aliases: ["TSTypeElement"],
    visitor: ["key", "typeAnnotation"],
    fields: {
      ...namedTypeElementCommon(),
      readonly: validateOptional(bool),
      typeAnnotation: validateOptionalType("TSTypeAnnotation"),
      kind: {
        optional: true,
        validate: assertOneOf("get", "set")
      }
    }
  });
  defineType("TSMethodSignature", {
    aliases: ["TSTypeElement"],
    visitor: ["key", "typeParameters", "params", "returnType"],
    fields: {
      ...signatureDeclarationCommon(),
      ...namedTypeElementCommon(),
      kind: {
        validate: assertOneOf("method", "get", "set"),
        default: "method"
      }
    }
  });
  defineType("TSIndexSignature", {
    aliases: ["TSTypeElement"],
    visitor: ["parameters", "typeAnnotation"],
    fields: {
      readonly: validateOptional(bool),
      static: validateOptional(bool),
      parameters: validateArrayOfType("Identifier"),
      typeAnnotation: validateOptionalType("TSTypeAnnotation")
    }
  });
  var tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
  for (const type of tsKeywordTypes) {
    defineType(type, {
      aliases: ["TSType", "TSBaseType"],
      visitor: [],
      fields: {}
    });
  }
  defineType("TSThisType", {
    aliases: ["TSType", "TSBaseType"],
    visitor: [],
    fields: {}
  });
  var fnOrCtrBase = {
    aliases: ["TSType"],
    visitor: ["typeParameters", "params", "returnType"]
  };
  defineType("TSFunctionType", {
    ...fnOrCtrBase,
    fields: signatureDeclarationCommon()
  });
  defineType("TSConstructorType", {
    ...fnOrCtrBase,
    fields: {
      ...signatureDeclarationCommon(),
      abstract: validateOptional(bool)
    }
  });
  defineType("TSTypeReference", {
    aliases: ["TSType"],
    visitor: ["typeName", "typeArguments"],
    fields: {
      typeName: validateType("TSEntityName"),
      ["typeArguments"]: validateOptionalType("TSTypeParameterInstantiation")
    }
  });
  defineType("TSTypePredicate", {
    aliases: ["TSType"],
    visitor: ["parameterName", "typeAnnotation"],
    builder: ["parameterName", "typeAnnotation", "asserts"],
    fields: {
      parameterName: validateType("Identifier", "TSThisType"),
      typeAnnotation: validateOptionalType("TSTypeAnnotation"),
      asserts: validateOptional(bool)
    }
  });
  defineType("TSTypeQuery", {
    aliases: ["TSType"],
    visitor: ["exprName", "typeArguments"],
    fields: {
      exprName: validateType("TSEntityName", "TSImportType"),
      ["typeArguments"]: validateOptionalType("TSTypeParameterInstantiation")
    }
  });
  defineType("TSTypeLiteral", {
    aliases: ["TSType"],
    visitor: ["members"],
    fields: {
      members: validateArrayOfType("TSTypeElement")
    }
  });
  defineType("TSArrayType", {
    aliases: ["TSType"],
    visitor: ["elementType"],
    fields: {
      elementType: validateType("TSType")
    }
  });
  defineType("TSTupleType", {
    aliases: ["TSType"],
    visitor: ["elementTypes"],
    fields: {
      elementTypes: validateArrayOfType("TSType", "TSNamedTupleMember")
    }
  });
  defineType("TSOptionalType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSRestType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSNamedTupleMember", {
    visitor: ["label", "elementType"],
    builder: ["label", "elementType", "optional"],
    fields: {
      label: validateType("Identifier"),
      optional: {
        validate: bool,
        default: false
      },
      elementType: validateType("TSType")
    }
  });
  var unionOrIntersection = {
    aliases: ["TSType"],
    visitor: ["types"],
    fields: {
      types: validateArrayOfType("TSType")
    }
  };
  defineType("TSUnionType", unionOrIntersection);
  defineType("TSIntersectionType", unionOrIntersection);
  defineType("TSConditionalType", {
    aliases: ["TSType"],
    visitor: ["checkType", "extendsType", "trueType", "falseType"],
    fields: {
      checkType: validateType("TSType"),
      extendsType: validateType("TSType"),
      trueType: validateType("TSType"),
      falseType: validateType("TSType")
    }
  });
  defineType("TSInferType", {
    aliases: ["TSType"],
    visitor: ["typeParameter"],
    fields: {
      typeParameter: validateType("TSTypeParameter")
    }
  });
  defineType("TSParenthesizedType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSTypeOperator", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    builder: ["typeAnnotation", "operator"],
    fields: {
      operator: {
        validate: assertOneOf("keyof", "readonly", "unique"),
        default: void 0
      },
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSIndexedAccessType", {
    aliases: ["TSType"],
    visitor: ["objectType", "indexType"],
    fields: {
      objectType: validateType("TSType"),
      indexType: validateType("TSType")
    }
  });
  defineType("TSMappedType", {
    aliases: ["TSType"],
    visitor: ["key", "constraint", "nameType", "typeAnnotation"],
    builder: ["key", "constraint", "nameType", "typeAnnotation"],
    fields: {
      key: validateType("Identifier"),
      constraint: validateType("TSType"),
      readonly: validateOptional(assertOneOf(true, false, "+", "-")),
      optional: validateOptional(assertOneOf(true, false, "+", "-")),
      typeAnnotation: validateOptionalType("TSType"),
      nameType: validateOptionalType("TSType")
    }
  });
  defineType("TSTemplateLiteralType", {
    aliases: ["TSType", "TSBaseType"],
    visitor: ["quasis", "types"],
    fields: {
      quasis: validateArrayOfType("TemplateElement"),
      types: {
        validate: chain(assertValueType("array"), assertEach(assertNodeType("TSType")), function(node, key, val) {
          if (node.quasis.length !== val.length + 1) {
            throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of types.
Expected ${val.length + 1} quasis but got ${node.quasis.length}`);
          }
        })
      }
    }
  });
  defineType("TSLiteralType", {
    aliases: ["TSType", "TSBaseType"],
    visitor: ["literal"],
    fields: {
      literal: {
        validate: (function() {
          const unaryExpression2 = assertNodeType("NumericLiteral", "BigIntLiteral");
          const unaryOperator = assertOneOf("-");
          const literal = assertNodeType("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
          const validator = combine(function validator2(parent, key, node) {
            if (is("UnaryExpression", node)) {
              unaryOperator(node, "operator", node.operator);
              unaryExpression2(node, "argument", node.argument);
            } else {
              literal(parent, key, node);
            }
          }, {
            oneOfNodeTypes: ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"]
          });
          return validator;
        })()
      }
    }
  });
  defineType("TSClassImplements", {
    aliases: ["TSType"],
    visitor: ["expression", "typeArguments"],
    fields: {
      expression: validateType("Expression"),
      typeArguments: validateOptionalType("TSTypeParameterInstantiation")
    }
  });
  defineType("TSInterfaceHeritage", {
    aliases: ["TSType"],
    visitor: ["expression", "typeArguments"],
    fields: {
      expression: validateType("Expression"),
      typeArguments: validateOptionalType("TSTypeParameterInstantiation")
    }
  });
  defineType("TSInterfaceDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "extends", "body"],
    fields: {
      declare: validateOptional(bool),
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
      extends: validateOptional(arrayOfType("TSInterfaceHeritage")),
      body: validateType("TSInterfaceBody")
    }
  });
  defineType("TSInterfaceBody", {
    visitor: ["body"],
    fields: {
      body: validateArrayOfType("TSTypeElement")
    }
  });
  defineType("TSTypeAliasDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "typeAnnotation"],
    fields: {
      declare: validateOptional(bool),
      id: validateType("Identifier"),
      typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
      typeAnnotation: validateType("TSType")
    }
  });
  defineType("TSInstantiationExpression", {
    aliases: ["Expression"],
    visitor: ["expression", "typeArguments"],
    fields: {
      expression: validateType("Expression"),
      ["typeArguments"]: validateOptionalType("TSTypeParameterInstantiation")
    }
  });
  var TSTypeExpression = {
    aliases: ["Expression", "LVal", "PatternLike"],
    visitor: ["expression", "typeAnnotation"],
    fields: {
      expression: validateType("Expression"),
      typeAnnotation: validateType("TSType")
    }
  };
  defineType("TSAsExpression", TSTypeExpression);
  defineType("TSSatisfiesExpression", TSTypeExpression);
  defineType("TSTypeAssertion", {
    aliases: ["Expression", "LVal", "PatternLike"],
    visitor: ["typeAnnotation", "expression"],
    fields: {
      typeAnnotation: validateType("TSType"),
      expression: validateType("Expression")
    }
  });
  defineType("TSEnumBody", {
    visitor: ["members"],
    fields: {
      members: validateArrayOfType("TSEnumMember")
    }
  });
  defineType("TSEnumDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "body"],
    fields: {
      declare: validateOptional(bool),
      const: validateOptional(bool),
      id: validateType("Identifier"),
      body: validateType("TSEnumBody")
    }
  });
  defineType("TSEnumMember", {
    visitor: ["id", "initializer"],
    fields: {
      id: validateType("Identifier", "StringLiteral"),
      initializer: validateOptionalType("Expression")
    }
  });
  defineType("TSModuleDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "body"],
    fields: {
      kind: {
        validate: assertOneOf("global", "namespace", "module"),
        default: "namespace"
      },
      declare: validateOptional(bool),
      id: {
        validate: chain(assertNodeType("TSEntityName", "StringLiteral"), combine(function(node, key, val) {
          if (node.kind === "namespace" && is("StringLiteral", val)) {
            throw new TypeError(`TSModuleDeclaration of kind 'namespace' cannot have a StringLiteral id.`);
          }
        }, {
          oneOfNodeTypes: ["TSEntityName", "StringLiteral"]
        }))
      },
      body: validateType("TSModuleBlock")
    }
  });
  defineType("TSModuleBlock", {
    aliases: ["Scopable", "Block", "BlockParent", "FunctionParent"],
    visitor: ["body"],
    fields: {
      body: validateArrayOfType("Statement")
    }
  });
  defineType("TSImportType", {
    aliases: ["TSType"],
    builder: ["source", "qualifier", "typeArguments"],
    visitor: ["source", "options", "qualifier", "typeArguments"],
    fields: {
      source: validateType("StringLiteral"),
      qualifier: validateOptionalType("TSEntityName"),
      typeArguments: validateOptionalType("TSTypeParameterInstantiation"),
      options: {
        validate: assertNodeType("ObjectExpression"),
        optional: true
      }
    }
  });
  defineType("TSImportEqualsDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "moduleReference"],
    fields: {
      id: validateType("Identifier"),
      moduleReference: validateType("TSEntityName", "TSExternalModuleReference"),
      importKind: {
        validate: assertOneOf("type", "value"),
        optional: true
      }
    }
  });
  defineType("TSExternalModuleReference", {
    visitor: ["expression"],
    fields: {
      expression: validateType("StringLiteral")
    }
  });
  defineType("TSNonNullExpression", {
    aliases: ["Expression", "LVal", "PatternLike"],
    visitor: ["expression"],
    fields: {
      expression: validateType("Expression")
    }
  });
  defineType("TSExportAssignment", {
    aliases: ["Statement"],
    visitor: ["expression"],
    fields: {
      expression: validateType("Expression")
    }
  });
  defineType("TSNamespaceExportDeclaration", {
    aliases: ["Statement"],
    visitor: ["id"],
    fields: {
      id: validateType("Identifier")
    }
  });
  defineType("TSTypeAnnotation", {
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: {
        validate: assertNodeType("TSType")
      }
    }
  });
  defineType("TSTypeParameterInstantiation", {
    visitor: ["params"],
    fields: {
      params: validateArrayOfType("TSType")
    }
  });
  defineType("TSTypeParameterDeclaration", {
    visitor: ["params"],
    fields: {
      params: validateArrayOfType("TSTypeParameter")
    }
  });
  defineType("TSTypeParameter", {
    builder: ["constraint", "default", "name"],
    visitor: ["name", "constraint", "default"],
    fields: {
      name: {
        validate: assertNodeType("Identifier")
      },
      in: {
        validate: assertValueType("boolean"),
        optional: true
      },
      out: {
        validate: assertValueType("boolean"),
        optional: true
      },
      const: {
        validate: assertValueType("boolean"),
        optional: true
      },
      constraint: {
        validate: assertNodeType("TSType"),
        optional: true
      },
      default: {
        validate: assertNodeType("TSType"),
        optional: true
      }
    }
  });
  var DEPRECATED_ALIASES = {
    ModuleDeclaration: "ImportOrExportDeclaration"
  };
  Object.keys(DEPRECATED_ALIASES).forEach((deprecatedAlias) => {
    FLIPPED_ALIAS_KEYS[deprecatedAlias] = FLIPPED_ALIAS_KEYS[DEPRECATED_ALIASES[deprecatedAlias]];
  });
  for (const {
    types,
    set
  } of allExpandedTypes) {
    for (const type of types) {
      const aliases = FLIPPED_ALIAS_KEYS[type];
      if (aliases) {
        aliases.forEach(set.add, set);
      } else {
        set.add(type);
      }
    }
  }
  var TYPES = [].concat(Object.keys(VISITOR_KEYS), Object.keys(FLIPPED_ALIAS_KEYS), Object.keys(DEPRECATED_KEYS));
  function validate$1(node, key, val) {
    if (!node) return;
    const fields = NODE_FIELDS$1[node.type];
    if (!fields) return;
    const field = fields[key];
    validateField(node, key, val, field);
    validateChild(node, key, val);
  }
  function validateInternal(field, node, key, val, maybeNode) {
    var _a;
    if (!(field == null ? void 0 : field.validate)) return;
    if (field.optional && val == null) return;
    field.validate(node, key, val);
    if (maybeNode) {
      const type = val.type;
      if (type == null) return;
      (_a = NODE_PARENT_VALIDATIONS[type]) == null ? void 0 : _a.call(NODE_PARENT_VALIDATIONS, node, key, val);
    }
  }
  function validateField(node, key, val, field) {
    if (!(field == null ? void 0 : field.validate)) return;
    if (field.optional && val == null) return;
    field.validate(node, key, val);
  }
  function validateChild(node, key, val) {
    var _a;
    const type = val == null ? void 0 : val.type;
    if (type == null) return;
    (_a = NODE_PARENT_VALIDATIONS[type]) == null ? void 0 : _a.call(NODE_PARENT_VALIDATIONS, node, key, val);
  }
  var _validate = /* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    default: validate$1,
    validateChild,
    validateField,
    validateInternal
  }, Symbol.toStringTag, { value: "Module" });
  var {
    validateInternal: validate
  } = _validate;
  var {
    NODE_FIELDS
  } = utils;
  function arrayExpression(elements) {
    const node = {
      type: "ArrayExpression",
      elements
    };
    const defs = NODE_FIELDS.ArrayExpression;
    validate(defs.elements, node, "elements", elements, 1);
    return node;
  }
  function assignmentExpression(operator, left, right) {
    const node = {
      type: "AssignmentExpression",
      operator,
      left,
      right
    };
    const defs = NODE_FIELDS.AssignmentExpression;
    validate(defs.operator, node, "operator", operator);
    validate(defs.left, node, "left", left, 1);
    validate(defs.right, node, "right", right, 1);
    return node;
  }
  function binaryExpression(operator, left, right) {
    const node = {
      type: "BinaryExpression",
      operator,
      left,
      right
    };
    const defs = NODE_FIELDS.BinaryExpression;
    validate(defs.operator, node, "operator", operator);
    validate(defs.left, node, "left", left, 1);
    validate(defs.right, node, "right", right, 1);
    return node;
  }
  function interpreterDirective(value) {
    const node = {
      type: "InterpreterDirective",
      value
    };
    const defs = NODE_FIELDS.InterpreterDirective;
    validate(defs.value, node, "value", value);
    return node;
  }
  function directive(value) {
    const node = {
      type: "Directive",
      value
    };
    const defs = NODE_FIELDS.Directive;
    validate(defs.value, node, "value", value, 1);
    return node;
  }
  function directiveLiteral(value) {
    const node = {
      type: "DirectiveLiteral",
      value
    };
    const defs = NODE_FIELDS.DirectiveLiteral;
    validate(defs.value, node, "value", value);
    return node;
  }
  function blockStatement(body, directives = []) {
    const node = {
      type: "BlockStatement",
      body,
      directives
    };
    const defs = NODE_FIELDS.BlockStatement;
    validate(defs.body, node, "body", body, 1);
    validate(defs.directives, node, "directives", directives, 1);
    return node;
  }
  function breakStatement(label = null) {
    const node = {
      type: "BreakStatement",
      label
    };
    const defs = NODE_FIELDS.BreakStatement;
    validate(defs.label, node, "label", label, 1);
    return node;
  }
  function callExpression(callee, _arguments) {
    const node = {
      type: "CallExpression",
      callee,
      arguments: _arguments
    };
    const defs = NODE_FIELDS.CallExpression;
    validate(defs.callee, node, "callee", callee, 1);
    validate(defs.arguments, node, "arguments", _arguments, 1);
    return node;
  }
  function catchClause(param = null, body) {
    const node = {
      type: "CatchClause",
      param,
      body
    };
    const defs = NODE_FIELDS.CatchClause;
    validate(defs.param, node, "param", param, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function conditionalExpression(test, consequent, alternate) {
    const node = {
      type: "ConditionalExpression",
      test,
      consequent,
      alternate
    };
    const defs = NODE_FIELDS.ConditionalExpression;
    validate(defs.test, node, "test", test, 1);
    validate(defs.consequent, node, "consequent", consequent, 1);
    validate(defs.alternate, node, "alternate", alternate, 1);
    return node;
  }
  function continueStatement(label = null) {
    const node = {
      type: "ContinueStatement",
      label
    };
    const defs = NODE_FIELDS.ContinueStatement;
    validate(defs.label, node, "label", label, 1);
    return node;
  }
  function debuggerStatement() {
    return {
      type: "DebuggerStatement"
    };
  }
  function doWhileStatement(test, body) {
    const node = {
      type: "DoWhileStatement",
      test,
      body
    };
    const defs = NODE_FIELDS.DoWhileStatement;
    validate(defs.test, node, "test", test, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function emptyStatement() {
    return {
      type: "EmptyStatement"
    };
  }
  function expressionStatement(expression) {
    const node = {
      type: "ExpressionStatement",
      expression
    };
    const defs = NODE_FIELDS.ExpressionStatement;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function file(program2, comments = null, tokens = null) {
    const node = {
      type: "File",
      program: program2,
      comments,
      tokens
    };
    const defs = NODE_FIELDS.File;
    validate(defs.program, node, "program", program2, 1);
    validate(defs.comments, node, "comments", comments, 1);
    validate(defs.tokens, node, "tokens", tokens);
    return node;
  }
  function forInStatement(left, right, body) {
    const node = {
      type: "ForInStatement",
      left,
      right,
      body
    };
    const defs = NODE_FIELDS.ForInStatement;
    validate(defs.left, node, "left", left, 1);
    validate(defs.right, node, "right", right, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function forStatement(init = null, test = null, update = null, body) {
    const node = {
      type: "ForStatement",
      init,
      test,
      update,
      body
    };
    const defs = NODE_FIELDS.ForStatement;
    validate(defs.init, node, "init", init, 1);
    validate(defs.test, node, "test", test, 1);
    validate(defs.update, node, "update", update, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function functionDeclaration(id = null, params, body, generator2 = false, async = false) {
    const node = {
      type: "FunctionDeclaration",
      id,
      params,
      body,
      generator: generator2,
      async
    };
    const defs = NODE_FIELDS.FunctionDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.generator, node, "generator", generator2);
    validate(defs.async, node, "async", async);
    return node;
  }
  function functionExpression(id = null, params, body, generator2 = false, async = false) {
    const node = {
      type: "FunctionExpression",
      id,
      params,
      body,
      generator: generator2,
      async
    };
    const defs = NODE_FIELDS.FunctionExpression;
    validate(defs.id, node, "id", id, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.generator, node, "generator", generator2);
    validate(defs.async, node, "async", async);
    return node;
  }
  function identifier(name) {
    const node = {
      type: "Identifier",
      name
    };
    const defs = NODE_FIELDS.Identifier;
    validate(defs.name, node, "name", name);
    return node;
  }
  function ifStatement(test, consequent, alternate = null) {
    const node = {
      type: "IfStatement",
      test,
      consequent,
      alternate
    };
    const defs = NODE_FIELDS.IfStatement;
    validate(defs.test, node, "test", test, 1);
    validate(defs.consequent, node, "consequent", consequent, 1);
    validate(defs.alternate, node, "alternate", alternate, 1);
    return node;
  }
  function labeledStatement(label, body) {
    const node = {
      type: "LabeledStatement",
      label,
      body
    };
    const defs = NODE_FIELDS.LabeledStatement;
    validate(defs.label, node, "label", label, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function stringLiteral(value) {
    const node = {
      type: "StringLiteral",
      value
    };
    const defs = NODE_FIELDS.StringLiteral;
    validate(defs.value, node, "value", value);
    return node;
  }
  function numericLiteral(value) {
    const node = {
      type: "NumericLiteral",
      value
    };
    const defs = NODE_FIELDS.NumericLiteral;
    validate(defs.value, node, "value", value);
    return node;
  }
  function nullLiteral() {
    return {
      type: "NullLiteral"
    };
  }
  function booleanLiteral(value) {
    const node = {
      type: "BooleanLiteral",
      value
    };
    const defs = NODE_FIELDS.BooleanLiteral;
    validate(defs.value, node, "value", value);
    return node;
  }
  function regExpLiteral(pattern, flags = "") {
    const node = {
      type: "RegExpLiteral",
      pattern,
      flags
    };
    const defs = NODE_FIELDS.RegExpLiteral;
    validate(defs.pattern, node, "pattern", pattern);
    validate(defs.flags, node, "flags", flags);
    return node;
  }
  function logicalExpression(operator, left, right) {
    const node = {
      type: "LogicalExpression",
      operator,
      left,
      right
    };
    const defs = NODE_FIELDS.LogicalExpression;
    validate(defs.operator, node, "operator", operator);
    validate(defs.left, node, "left", left, 1);
    validate(defs.right, node, "right", right, 1);
    return node;
  }
  function memberExpression(object, property, computed = false) {
    const node = {
      type: "MemberExpression",
      object,
      property,
      computed
    };
    const defs = NODE_FIELDS.MemberExpression;
    validate(defs.object, node, "object", object, 1);
    validate(defs.property, node, "property", property, 1);
    validate(defs.computed, node, "computed", computed);
    return node;
  }
  function newExpression(callee, _arguments) {
    const node = {
      type: "NewExpression",
      callee,
      arguments: _arguments
    };
    const defs = NODE_FIELDS.NewExpression;
    validate(defs.callee, node, "callee", callee, 1);
    validate(defs.arguments, node, "arguments", _arguments, 1);
    return node;
  }
  function program(body, directives = [], sourceType = "script", interpreter = null) {
    const node = {
      type: "Program",
      body,
      directives,
      sourceType,
      interpreter
    };
    const defs = NODE_FIELDS.Program;
    validate(defs.body, node, "body", body, 1);
    validate(defs.directives, node, "directives", directives, 1);
    validate(defs.sourceType, node, "sourceType", sourceType);
    validate(defs.interpreter, node, "interpreter", interpreter, 1);
    return node;
  }
  function objectExpression(properties) {
    const node = {
      type: "ObjectExpression",
      properties
    };
    const defs = NODE_FIELDS.ObjectExpression;
    validate(defs.properties, node, "properties", properties, 1);
    return node;
  }
  function objectMethod(kind, key, params, body, computed = false, generator2 = false, async = false) {
    const node = {
      type: "ObjectMethod",
      kind,
      key,
      params,
      body,
      computed,
      generator: generator2,
      async
    };
    const defs = NODE_FIELDS.ObjectMethod;
    validate(defs.kind, node, "kind", kind);
    validate(defs.key, node, "key", key, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.computed, node, "computed", computed);
    validate(defs.generator, node, "generator", generator2);
    validate(defs.async, node, "async", async);
    return node;
  }
  function objectProperty(key, value, computed = false, shorthand = false) {
    const node = {
      type: "ObjectProperty",
      key,
      value,
      computed,
      shorthand
    };
    const defs = NODE_FIELDS.ObjectProperty;
    validate(defs.key, node, "key", key, 1);
    validate(defs.value, node, "value", value, 1);
    validate(defs.computed, node, "computed", computed);
    validate(defs.shorthand, node, "shorthand", shorthand);
    return node;
  }
  function restElement(argument) {
    const node = {
      type: "RestElement",
      argument
    };
    const defs = NODE_FIELDS.RestElement;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function returnStatement(argument = null) {
    const node = {
      type: "ReturnStatement",
      argument
    };
    const defs = NODE_FIELDS.ReturnStatement;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function sequenceExpression(expressions) {
    const node = {
      type: "SequenceExpression",
      expressions
    };
    const defs = NODE_FIELDS.SequenceExpression;
    validate(defs.expressions, node, "expressions", expressions, 1);
    return node;
  }
  function parenthesizedExpression(expression) {
    const node = {
      type: "ParenthesizedExpression",
      expression
    };
    const defs = NODE_FIELDS.ParenthesizedExpression;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function switchCase(test = null, consequent) {
    const node = {
      type: "SwitchCase",
      test,
      consequent
    };
    const defs = NODE_FIELDS.SwitchCase;
    validate(defs.test, node, "test", test, 1);
    validate(defs.consequent, node, "consequent", consequent, 1);
    return node;
  }
  function switchStatement(discriminant, cases) {
    const node = {
      type: "SwitchStatement",
      discriminant,
      cases
    };
    const defs = NODE_FIELDS.SwitchStatement;
    validate(defs.discriminant, node, "discriminant", discriminant, 1);
    validate(defs.cases, node, "cases", cases, 1);
    return node;
  }
  function thisExpression() {
    return {
      type: "ThisExpression"
    };
  }
  function throwStatement(argument) {
    const node = {
      type: "ThrowStatement",
      argument
    };
    const defs = NODE_FIELDS.ThrowStatement;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function tryStatement(block, handler = null, finalizer = null) {
    const node = {
      type: "TryStatement",
      block,
      handler,
      finalizer
    };
    const defs = NODE_FIELDS.TryStatement;
    validate(defs.block, node, "block", block, 1);
    validate(defs.handler, node, "handler", handler, 1);
    validate(defs.finalizer, node, "finalizer", finalizer, 1);
    return node;
  }
  function unaryExpression(operator, argument, prefix = true) {
    const node = {
      type: "UnaryExpression",
      operator,
      argument,
      prefix
    };
    const defs = NODE_FIELDS.UnaryExpression;
    validate(defs.operator, node, "operator", operator);
    validate(defs.argument, node, "argument", argument, 1);
    validate(defs.prefix, node, "prefix", prefix);
    return node;
  }
  function updateExpression(operator, argument, prefix = false) {
    const node = {
      type: "UpdateExpression",
      operator,
      argument,
      prefix
    };
    const defs = NODE_FIELDS.UpdateExpression;
    validate(defs.operator, node, "operator", operator);
    validate(defs.argument, node, "argument", argument, 1);
    validate(defs.prefix, node, "prefix", prefix);
    return node;
  }
  function variableDeclaration(kind, declarations) {
    const node = {
      type: "VariableDeclaration",
      kind,
      declarations
    };
    const defs = NODE_FIELDS.VariableDeclaration;
    validate(defs.kind, node, "kind", kind);
    validate(defs.declarations, node, "declarations", declarations, 1);
    return node;
  }
  function variableDeclarator(id, init = null) {
    const node = {
      type: "VariableDeclarator",
      id,
      init
    };
    const defs = NODE_FIELDS.VariableDeclarator;
    validate(defs.id, node, "id", id, 1);
    validate(defs.init, node, "init", init, 1);
    return node;
  }
  function whileStatement(test, body) {
    const node = {
      type: "WhileStatement",
      test,
      body
    };
    const defs = NODE_FIELDS.WhileStatement;
    validate(defs.test, node, "test", test, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function withStatement(object, body) {
    const node = {
      type: "WithStatement",
      object,
      body
    };
    const defs = NODE_FIELDS.WithStatement;
    validate(defs.object, node, "object", object, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function assignmentPattern(left, right) {
    const node = {
      type: "AssignmentPattern",
      left,
      right
    };
    const defs = NODE_FIELDS.AssignmentPattern;
    validate(defs.left, node, "left", left, 1);
    validate(defs.right, node, "right", right, 1);
    return node;
  }
  function arrayPattern(elements) {
    const node = {
      type: "ArrayPattern",
      elements
    };
    const defs = NODE_FIELDS.ArrayPattern;
    validate(defs.elements, node, "elements", elements, 1);
    return node;
  }
  function arrowFunctionExpression(params, body, async = false) {
    const node = {
      type: "ArrowFunctionExpression",
      params,
      body,
      async
    };
    const defs = NODE_FIELDS.ArrowFunctionExpression;
    validate(defs.params, node, "params", params, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.async, node, "async", async);
    return node;
  }
  function classBody(body) {
    const node = {
      type: "ClassBody",
      body
    };
    const defs = NODE_FIELDS.ClassBody;
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function classExpression(id = null, superClass = null, body, decorators = null) {
    const node = {
      type: "ClassExpression",
      id,
      superClass,
      body,
      decorators
    };
    const defs = NODE_FIELDS.ClassExpression;
    validate(defs.id, node, "id", id, 1);
    validate(defs.superClass, node, "superClass", superClass, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.decorators, node, "decorators", decorators, 1);
    return node;
  }
  function classDeclaration(id = null, superClass = null, body, decorators = null) {
    const node = {
      type: "ClassDeclaration",
      id,
      superClass,
      body,
      decorators
    };
    const defs = NODE_FIELDS.ClassDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.superClass, node, "superClass", superClass, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.decorators, node, "decorators", decorators, 1);
    return node;
  }
  function exportAllDeclaration(source, attributes = null) {
    const node = {
      type: "ExportAllDeclaration",
      source,
      attributes
    };
    const defs = NODE_FIELDS.ExportAllDeclaration;
    validate(defs.source, node, "source", source, 1);
    validate(defs.attributes, node, "attributes", attributes, 1);
    return node;
  }
  function exportDefaultDeclaration(declaration) {
    const node = {
      type: "ExportDefaultDeclaration",
      declaration
    };
    const defs = NODE_FIELDS.ExportDefaultDeclaration;
    validate(defs.declaration, node, "declaration", declaration, 1);
    return node;
  }
  function exportNamedDeclaration(declaration = null, specifiers = [], source = null, attributes = null) {
    const node = {
      type: "ExportNamedDeclaration",
      declaration,
      specifiers,
      source,
      attributes
    };
    const defs = NODE_FIELDS.ExportNamedDeclaration;
    validate(defs.declaration, node, "declaration", declaration, 1);
    validate(defs.specifiers, node, "specifiers", specifiers, 1);
    validate(defs.source, node, "source", source, 1);
    validate(defs.attributes, node, "attributes", attributes, 1);
    return node;
  }
  function exportSpecifier(local, exported) {
    const node = {
      type: "ExportSpecifier",
      local,
      exported
    };
    const defs = NODE_FIELDS.ExportSpecifier;
    validate(defs.local, node, "local", local, 1);
    validate(defs.exported, node, "exported", exported, 1);
    return node;
  }
  function forOfStatement(left, right, body, _await = false) {
    const node = {
      type: "ForOfStatement",
      left,
      right,
      body,
      await: _await
    };
    const defs = NODE_FIELDS.ForOfStatement;
    validate(defs.left, node, "left", left, 1);
    validate(defs.right, node, "right", right, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.await, node, "await", _await);
    return node;
  }
  function importDeclaration(specifiers, source, attributes = null) {
    const node = {
      type: "ImportDeclaration",
      specifiers,
      source,
      attributes
    };
    const defs = NODE_FIELDS.ImportDeclaration;
    validate(defs.specifiers, node, "specifiers", specifiers, 1);
    validate(defs.source, node, "source", source, 1);
    validate(defs.attributes, node, "attributes", attributes, 1);
    return node;
  }
  function importDefaultSpecifier(local) {
    const node = {
      type: "ImportDefaultSpecifier",
      local
    };
    const defs = NODE_FIELDS.ImportDefaultSpecifier;
    validate(defs.local, node, "local", local, 1);
    return node;
  }
  function importNamespaceSpecifier(local) {
    const node = {
      type: "ImportNamespaceSpecifier",
      local
    };
    const defs = NODE_FIELDS.ImportNamespaceSpecifier;
    validate(defs.local, node, "local", local, 1);
    return node;
  }
  function importSpecifier(local, imported) {
    const node = {
      type: "ImportSpecifier",
      local,
      imported
    };
    const defs = NODE_FIELDS.ImportSpecifier;
    validate(defs.local, node, "local", local, 1);
    validate(defs.imported, node, "imported", imported, 1);
    return node;
  }
  function metaProperty(meta, property) {
    const node = {
      type: "MetaProperty",
      meta,
      property
    };
    const defs = NODE_FIELDS.MetaProperty;
    validate(defs.meta, node, "meta", meta, 1);
    validate(defs.property, node, "property", property, 1);
    return node;
  }
  function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator2 = false, async = false) {
    const node = {
      type: "ClassMethod",
      kind,
      key,
      params,
      body,
      computed,
      static: _static,
      generator: generator2,
      async
    };
    const defs = NODE_FIELDS.ClassMethod;
    validate(defs.kind, node, "kind", kind);
    validate(defs.key, node, "key", key, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.computed, node, "computed", computed);
    validate(defs.static, node, "static", _static);
    validate(defs.generator, node, "generator", generator2);
    validate(defs.async, node, "async", async);
    return node;
  }
  function objectPattern(properties) {
    const node = {
      type: "ObjectPattern",
      properties
    };
    const defs = NODE_FIELDS.ObjectPattern;
    validate(defs.properties, node, "properties", properties, 1);
    return node;
  }
  function spreadElement(argument) {
    const node = {
      type: "SpreadElement",
      argument
    };
    const defs = NODE_FIELDS.SpreadElement;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function _super() {
    return {
      type: "Super"
    };
  }
  function taggedTemplateExpression(tag, quasi) {
    const node = {
      type: "TaggedTemplateExpression",
      tag,
      quasi
    };
    const defs = NODE_FIELDS.TaggedTemplateExpression;
    validate(defs.tag, node, "tag", tag, 1);
    validate(defs.quasi, node, "quasi", quasi, 1);
    return node;
  }
  function templateElement(value, tail = false) {
    const node = {
      type: "TemplateElement",
      value,
      tail
    };
    const defs = NODE_FIELDS.TemplateElement;
    validate(defs.value, node, "value", value);
    validate(defs.tail, node, "tail", tail);
    return node;
  }
  function templateLiteral(quasis, expressions) {
    const node = {
      type: "TemplateLiteral",
      quasis,
      expressions
    };
    const defs = NODE_FIELDS.TemplateLiteral;
    validate(defs.quasis, node, "quasis", quasis, 1);
    validate(defs.expressions, node, "expressions", expressions, 1);
    return node;
  }
  function yieldExpression(argument = null, delegate = false) {
    const node = {
      type: "YieldExpression",
      argument,
      delegate
    };
    const defs = NODE_FIELDS.YieldExpression;
    validate(defs.argument, node, "argument", argument, 1);
    validate(defs.delegate, node, "delegate", delegate);
    return node;
  }
  function awaitExpression(argument) {
    const node = {
      type: "AwaitExpression",
      argument
    };
    const defs = NODE_FIELDS.AwaitExpression;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function importExpression(source, options = null) {
    const node = {
      type: "ImportExpression",
      source,
      options
    };
    const defs = NODE_FIELDS.ImportExpression;
    validate(defs.source, node, "source", source, 1);
    validate(defs.options, node, "options", options, 1);
    return node;
  }
  function _import() {
    return {
      type: "Import"
    };
  }
  function bigIntLiteral(value) {
    const node = {
      type: "BigIntLiteral",
      value
    };
    const defs = NODE_FIELDS.BigIntLiteral;
    validate(defs.value, node, "value", value);
    return node;
  }
  function exportNamespaceSpecifier(exported) {
    const node = {
      type: "ExportNamespaceSpecifier",
      exported
    };
    const defs = NODE_FIELDS.ExportNamespaceSpecifier;
    validate(defs.exported, node, "exported", exported, 1);
    return node;
  }
  function optionalMemberExpression(object, property, computed = false, optional) {
    const node = {
      type: "OptionalMemberExpression",
      object,
      property,
      computed,
      optional
    };
    const defs = NODE_FIELDS.OptionalMemberExpression;
    validate(defs.object, node, "object", object, 1);
    validate(defs.property, node, "property", property, 1);
    validate(defs.computed, node, "computed", computed);
    validate(defs.optional, node, "optional", optional);
    return node;
  }
  function optionalCallExpression(callee, _arguments, optional) {
    const node = {
      type: "OptionalCallExpression",
      callee,
      arguments: _arguments,
      optional
    };
    const defs = NODE_FIELDS.OptionalCallExpression;
    validate(defs.callee, node, "callee", callee, 1);
    validate(defs.arguments, node, "arguments", _arguments, 1);
    validate(defs.optional, node, "optional", optional);
    return node;
  }
  function classProperty(key, value = null, typeAnnotation2 = null, decorators = null, computed = false, _static = false) {
    const node = {
      type: "ClassProperty",
      key,
      value,
      typeAnnotation: typeAnnotation2,
      decorators,
      computed,
      static: _static
    };
    const defs = NODE_FIELDS.ClassProperty;
    validate(defs.key, node, "key", key, 1);
    validate(defs.value, node, "value", value, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    validate(defs.decorators, node, "decorators", decorators, 1);
    validate(defs.computed, node, "computed", computed);
    validate(defs.static, node, "static", _static);
    return node;
  }
  function classPrivateProperty(key, value = null, decorators = null, _static = false) {
    const node = {
      type: "ClassPrivateProperty",
      key,
      value,
      decorators,
      static: _static
    };
    const defs = NODE_FIELDS.ClassPrivateProperty;
    validate(defs.key, node, "key", key, 1);
    validate(defs.value, node, "value", value, 1);
    validate(defs.decorators, node, "decorators", decorators, 1);
    validate(defs.static, node, "static", _static);
    return node;
  }
  function classPrivateMethod(kind = "method", key, params, body, _static = false) {
    const node = {
      type: "ClassPrivateMethod",
      kind,
      key,
      params,
      body,
      static: _static,
      async: false,
      computed: false,
      generator: false
    };
    const defs = NODE_FIELDS.ClassPrivateMethod;
    validate(defs.kind, node, "kind", kind);
    validate(defs.key, node, "key", key, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.static, node, "static", _static);
    return node;
  }
  function privateName(id) {
    const node = {
      type: "PrivateName",
      id
    };
    const defs = NODE_FIELDS.PrivateName;
    validate(defs.id, node, "id", id, 1);
    return node;
  }
  function staticBlock(body) {
    const node = {
      type: "StaticBlock",
      body
    };
    const defs = NODE_FIELDS.StaticBlock;
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function importAttribute(key, value) {
    const node = {
      type: "ImportAttribute",
      key,
      value
    };
    const defs = NODE_FIELDS.ImportAttribute;
    validate(defs.key, node, "key", key, 1);
    validate(defs.value, node, "value", value, 1);
    return node;
  }
  function anyTypeAnnotation() {
    return {
      type: "AnyTypeAnnotation"
    };
  }
  function arrayTypeAnnotation(elementType) {
    const node = {
      type: "ArrayTypeAnnotation",
      elementType
    };
    const defs = NODE_FIELDS.ArrayTypeAnnotation;
    validate(defs.elementType, node, "elementType", elementType, 1);
    return node;
  }
  function booleanTypeAnnotation() {
    return {
      type: "BooleanTypeAnnotation"
    };
  }
  function booleanLiteralTypeAnnotation(value) {
    const node = {
      type: "BooleanLiteralTypeAnnotation",
      value
    };
    const defs = NODE_FIELDS.BooleanLiteralTypeAnnotation;
    validate(defs.value, node, "value", value);
    return node;
  }
  function nullLiteralTypeAnnotation() {
    return {
      type: "NullLiteralTypeAnnotation"
    };
  }
  function classImplements(id, typeParameters = null) {
    const node = {
      type: "ClassImplements",
      id,
      typeParameters
    };
    const defs = NODE_FIELDS.ClassImplements;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    return node;
  }
  function declareClass(id, typeParameters = null, _extends = null, body) {
    const node = {
      type: "DeclareClass",
      id,
      typeParameters,
      extends: _extends,
      body
    };
    const defs = NODE_FIELDS.DeclareClass;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.extends, node, "extends", _extends, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function declareFunction(id) {
    const node = {
      type: "DeclareFunction",
      id
    };
    const defs = NODE_FIELDS.DeclareFunction;
    validate(defs.id, node, "id", id, 1);
    return node;
  }
  function declareInterface(id, typeParameters = null, _extends = null, body) {
    const node = {
      type: "DeclareInterface",
      id,
      typeParameters,
      extends: _extends,
      body
    };
    const defs = NODE_FIELDS.DeclareInterface;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.extends, node, "extends", _extends, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function declareModule(id, body, kind = null) {
    const node = {
      type: "DeclareModule",
      id,
      body,
      kind
    };
    const defs = NODE_FIELDS.DeclareModule;
    validate(defs.id, node, "id", id, 1);
    validate(defs.body, node, "body", body, 1);
    validate(defs.kind, node, "kind", kind);
    return node;
  }
  function declareModuleExports(typeAnnotation2) {
    const node = {
      type: "DeclareModuleExports",
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.DeclareModuleExports;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function declareTypeAlias(id, typeParameters = null, right) {
    const node = {
      type: "DeclareTypeAlias",
      id,
      typeParameters,
      right
    };
    const defs = NODE_FIELDS.DeclareTypeAlias;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.right, node, "right", right, 1);
    return node;
  }
  function declareOpaqueType(id, typeParameters = null, supertype = null) {
    const node = {
      type: "DeclareOpaqueType",
      id,
      typeParameters,
      supertype
    };
    const defs = NODE_FIELDS.DeclareOpaqueType;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.supertype, node, "supertype", supertype, 1);
    return node;
  }
  function declareVariable(id) {
    const node = {
      type: "DeclareVariable",
      id
    };
    const defs = NODE_FIELDS.DeclareVariable;
    validate(defs.id, node, "id", id, 1);
    return node;
  }
  function declareExportDeclaration(declaration = null, specifiers = null, source = null, attributes = null) {
    const node = {
      type: "DeclareExportDeclaration",
      declaration,
      specifiers,
      source,
      attributes
    };
    const defs = NODE_FIELDS.DeclareExportDeclaration;
    validate(defs.declaration, node, "declaration", declaration, 1);
    validate(defs.specifiers, node, "specifiers", specifiers, 1);
    validate(defs.source, node, "source", source, 1);
    validate(defs.attributes, node, "attributes", attributes, 1);
    return node;
  }
  function declareExportAllDeclaration(source, attributes = null) {
    const node = {
      type: "DeclareExportAllDeclaration",
      source,
      attributes
    };
    const defs = NODE_FIELDS.DeclareExportAllDeclaration;
    validate(defs.source, node, "source", source, 1);
    validate(defs.attributes, node, "attributes", attributes, 1);
    return node;
  }
  function declaredPredicate(value) {
    const node = {
      type: "DeclaredPredicate",
      value
    };
    const defs = NODE_FIELDS.DeclaredPredicate;
    validate(defs.value, node, "value", value, 1);
    return node;
  }
  function existsTypeAnnotation() {
    return {
      type: "ExistsTypeAnnotation"
    };
  }
  function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
    const node = {
      type: "FunctionTypeAnnotation",
      typeParameters,
      params,
      rest,
      returnType
    };
    const defs = NODE_FIELDS.FunctionTypeAnnotation;
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.rest, node, "rest", rest, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function functionTypeParam(name = null, typeAnnotation2) {
    const node = {
      type: "FunctionTypeParam",
      name,
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.FunctionTypeParam;
    validate(defs.name, node, "name", name, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function genericTypeAnnotation(id, typeParameters = null) {
    const node = {
      type: "GenericTypeAnnotation",
      id,
      typeParameters
    };
    const defs = NODE_FIELDS.GenericTypeAnnotation;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    return node;
  }
  function inferredPredicate() {
    return {
      type: "InferredPredicate"
    };
  }
  function interfaceExtends(id, typeParameters = null) {
    const node = {
      type: "InterfaceExtends",
      id,
      typeParameters
    };
    const defs = NODE_FIELDS.InterfaceExtends;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    return node;
  }
  function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
    const node = {
      type: "InterfaceDeclaration",
      id,
      typeParameters,
      extends: _extends,
      body
    };
    const defs = NODE_FIELDS.InterfaceDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.extends, node, "extends", _extends, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function interfaceTypeAnnotation(_extends = null, body) {
    const node = {
      type: "InterfaceTypeAnnotation",
      extends: _extends,
      body
    };
    const defs = NODE_FIELDS.InterfaceTypeAnnotation;
    validate(defs.extends, node, "extends", _extends, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function intersectionTypeAnnotation(types) {
    const node = {
      type: "IntersectionTypeAnnotation",
      types
    };
    const defs = NODE_FIELDS.IntersectionTypeAnnotation;
    validate(defs.types, node, "types", types, 1);
    return node;
  }
  function mixedTypeAnnotation() {
    return {
      type: "MixedTypeAnnotation"
    };
  }
  function emptyTypeAnnotation() {
    return {
      type: "EmptyTypeAnnotation"
    };
  }
  function nullableTypeAnnotation(typeAnnotation2) {
    const node = {
      type: "NullableTypeAnnotation",
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.NullableTypeAnnotation;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function numberLiteralTypeAnnotation(value) {
    const node = {
      type: "NumberLiteralTypeAnnotation",
      value
    };
    const defs = NODE_FIELDS.NumberLiteralTypeAnnotation;
    validate(defs.value, node, "value", value);
    return node;
  }
  function bigIntLiteralTypeAnnotation(value) {
    const node = {
      type: "BigIntLiteralTypeAnnotation",
      value
    };
    const defs = NODE_FIELDS.BigIntLiteralTypeAnnotation;
    validate(defs.value, node, "value", value);
    return node;
  }
  function numberTypeAnnotation() {
    return {
      type: "NumberTypeAnnotation"
    };
  }
  function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
    const node = {
      type: "ObjectTypeAnnotation",
      properties,
      indexers,
      callProperties,
      internalSlots,
      exact
    };
    const defs = NODE_FIELDS.ObjectTypeAnnotation;
    validate(defs.properties, node, "properties", properties, 1);
    validate(defs.indexers, node, "indexers", indexers, 1);
    validate(defs.callProperties, node, "callProperties", callProperties, 1);
    validate(defs.internalSlots, node, "internalSlots", internalSlots, 1);
    validate(defs.exact, node, "exact", exact);
    return node;
  }
  function objectTypeInternalSlot(id, value, optional, _static, method) {
    const node = {
      type: "ObjectTypeInternalSlot",
      id,
      value,
      optional,
      static: _static,
      method
    };
    const defs = NODE_FIELDS.ObjectTypeInternalSlot;
    validate(defs.id, node, "id", id, 1);
    validate(defs.value, node, "value", value, 1);
    validate(defs.optional, node, "optional", optional);
    validate(defs.static, node, "static", _static);
    validate(defs.method, node, "method", method);
    return node;
  }
  function objectTypeCallProperty(value) {
    const node = {
      type: "ObjectTypeCallProperty",
      value,
      static: false
    };
    const defs = NODE_FIELDS.ObjectTypeCallProperty;
    validate(defs.value, node, "value", value, 1);
    return node;
  }
  function objectTypeIndexer(id = null, key, value, variance2 = null) {
    const node = {
      type: "ObjectTypeIndexer",
      id,
      key,
      value,
      variance: variance2,
      static: false
    };
    const defs = NODE_FIELDS.ObjectTypeIndexer;
    validate(defs.id, node, "id", id, 1);
    validate(defs.key, node, "key", key, 1);
    validate(defs.value, node, "value", value, 1);
    validate(defs.variance, node, "variance", variance2, 1);
    return node;
  }
  function objectTypeProperty(key, value, variance2 = null) {
    const node = {
      type: "ObjectTypeProperty",
      key,
      value,
      variance: variance2,
      kind: "init",
      method: false,
      optional: false,
      proto: false,
      static: false
    };
    const defs = NODE_FIELDS.ObjectTypeProperty;
    validate(defs.key, node, "key", key, 1);
    validate(defs.value, node, "value", value, 1);
    validate(defs.variance, node, "variance", variance2, 1);
    return node;
  }
  function objectTypeSpreadProperty(argument) {
    const node = {
      type: "ObjectTypeSpreadProperty",
      argument
    };
    const defs = NODE_FIELDS.ObjectTypeSpreadProperty;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function opaqueType(id, typeParameters = null, supertype = null, impltype) {
    const node = {
      type: "OpaqueType",
      id,
      typeParameters,
      supertype,
      impltype
    };
    const defs = NODE_FIELDS.OpaqueType;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.supertype, node, "supertype", supertype, 1);
    validate(defs.impltype, node, "impltype", impltype, 1);
    return node;
  }
  function qualifiedTypeIdentifier(id, qualification) {
    const node = {
      type: "QualifiedTypeIdentifier",
      id,
      qualification
    };
    const defs = NODE_FIELDS.QualifiedTypeIdentifier;
    validate(defs.id, node, "id", id, 1);
    validate(defs.qualification, node, "qualification", qualification, 1);
    return node;
  }
  function stringLiteralTypeAnnotation(value) {
    const node = {
      type: "StringLiteralTypeAnnotation",
      value
    };
    const defs = NODE_FIELDS.StringLiteralTypeAnnotation;
    validate(defs.value, node, "value", value);
    return node;
  }
  function stringTypeAnnotation() {
    return {
      type: "StringTypeAnnotation"
    };
  }
  function symbolTypeAnnotation() {
    return {
      type: "SymbolTypeAnnotation"
    };
  }
  function thisTypeAnnotation() {
    return {
      type: "ThisTypeAnnotation"
    };
  }
  function tupleTypeAnnotation(types) {
    const node = {
      type: "TupleTypeAnnotation",
      types
    };
    const defs = NODE_FIELDS.TupleTypeAnnotation;
    validate(defs.types, node, "types", types, 1);
    return node;
  }
  function typeofTypeAnnotation(argument) {
    const node = {
      type: "TypeofTypeAnnotation",
      argument
    };
    const defs = NODE_FIELDS.TypeofTypeAnnotation;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function typeAlias(id, typeParameters = null, right) {
    const node = {
      type: "TypeAlias",
      id,
      typeParameters,
      right
    };
    const defs = NODE_FIELDS.TypeAlias;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.right, node, "right", right, 1);
    return node;
  }
  function typeAnnotation(typeAnnotation2) {
    const node = {
      type: "TypeAnnotation",
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TypeAnnotation;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function typeCastExpression(expression, typeAnnotation2) {
    const node = {
      type: "TypeCastExpression",
      expression,
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TypeCastExpression;
    validate(defs.expression, node, "expression", expression, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function typeParameter(name, bound = null, _default = null, variance2 = null) {
    const node = {
      type: "TypeParameter",
      name,
      bound,
      default: _default,
      variance: variance2
    };
    const defs = NODE_FIELDS.TypeParameter;
    validate(defs.name, node, "name", name);
    validate(defs.bound, node, "bound", bound, 1);
    validate(defs.default, node, "default", _default, 1);
    validate(defs.variance, node, "variance", variance2, 1);
    return node;
  }
  function typeParameterDeclaration(params) {
    const node = {
      type: "TypeParameterDeclaration",
      params
    };
    const defs = NODE_FIELDS.TypeParameterDeclaration;
    validate(defs.params, node, "params", params, 1);
    return node;
  }
  function typeParameterInstantiation(params) {
    const node = {
      type: "TypeParameterInstantiation",
      params
    };
    const defs = NODE_FIELDS.TypeParameterInstantiation;
    validate(defs.params, node, "params", params, 1);
    return node;
  }
  function unionTypeAnnotation(types) {
    const node = {
      type: "UnionTypeAnnotation",
      types
    };
    const defs = NODE_FIELDS.UnionTypeAnnotation;
    validate(defs.types, node, "types", types, 1);
    return node;
  }
  function variance(kind) {
    const node = {
      type: "Variance",
      kind
    };
    const defs = NODE_FIELDS.Variance;
    validate(defs.kind, node, "kind", kind);
    return node;
  }
  function voidTypeAnnotation() {
    return {
      type: "VoidTypeAnnotation"
    };
  }
  function enumDeclaration(id, body) {
    const node = {
      type: "EnumDeclaration",
      id,
      body
    };
    const defs = NODE_FIELDS.EnumDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function enumBooleanBody(members) {
    const node = {
      type: "EnumBooleanBody",
      members,
      explicitType: false,
      hasUnknownMembers: false
    };
    const defs = NODE_FIELDS.EnumBooleanBody;
    validate(defs.members, node, "members", members, 1);
    return node;
  }
  function enumNumberBody(members) {
    const node = {
      type: "EnumNumberBody",
      members,
      explicitType: false,
      hasUnknownMembers: false
    };
    const defs = NODE_FIELDS.EnumNumberBody;
    validate(defs.members, node, "members", members, 1);
    return node;
  }
  function enumStringBody(members) {
    const node = {
      type: "EnumStringBody",
      members,
      explicitType: false,
      hasUnknownMembers: false
    };
    const defs = NODE_FIELDS.EnumStringBody;
    validate(defs.members, node, "members", members, 1);
    return node;
  }
  function enumSymbolBody(members) {
    const node = {
      type: "EnumSymbolBody",
      members,
      hasUnknownMembers: false
    };
    const defs = NODE_FIELDS.EnumSymbolBody;
    validate(defs.members, node, "members", members, 1);
    return node;
  }
  function enumBooleanMember(id, init) {
    const node = {
      type: "EnumBooleanMember",
      id,
      init
    };
    const defs = NODE_FIELDS.EnumBooleanMember;
    validate(defs.id, node, "id", id, 1);
    validate(defs.init, node, "init", init, 1);
    return node;
  }
  function enumNumberMember(id, init) {
    const node = {
      type: "EnumNumberMember",
      id,
      init
    };
    const defs = NODE_FIELDS.EnumNumberMember;
    validate(defs.id, node, "id", id, 1);
    validate(defs.init, node, "init", init, 1);
    return node;
  }
  function enumStringMember(id, init) {
    const node = {
      type: "EnumStringMember",
      id,
      init
    };
    const defs = NODE_FIELDS.EnumStringMember;
    validate(defs.id, node, "id", id, 1);
    validate(defs.init, node, "init", init, 1);
    return node;
  }
  function enumDefaultedMember(id) {
    const node = {
      type: "EnumDefaultedMember",
      id
    };
    const defs = NODE_FIELDS.EnumDefaultedMember;
    validate(defs.id, node, "id", id, 1);
    return node;
  }
  function indexedAccessType(objectType, indexType) {
    const node = {
      type: "IndexedAccessType",
      objectType,
      indexType
    };
    const defs = NODE_FIELDS.IndexedAccessType;
    validate(defs.objectType, node, "objectType", objectType, 1);
    validate(defs.indexType, node, "indexType", indexType, 1);
    return node;
  }
  function optionalIndexedAccessType(objectType, indexType) {
    const node = {
      type: "OptionalIndexedAccessType",
      objectType,
      indexType,
      optional: false
    };
    const defs = NODE_FIELDS.OptionalIndexedAccessType;
    validate(defs.objectType, node, "objectType", objectType, 1);
    validate(defs.indexType, node, "indexType", indexType, 1);
    return node;
  }
  function jsxAttribute(name, value = null) {
    const node = {
      type: "JSXAttribute",
      name,
      value
    };
    const defs = NODE_FIELDS.JSXAttribute;
    validate(defs.name, node, "name", name, 1);
    validate(defs.value, node, "value", value, 1);
    return node;
  }
  function jsxClosingElement(name) {
    const node = {
      type: "JSXClosingElement",
      name
    };
    const defs = NODE_FIELDS.JSXClosingElement;
    validate(defs.name, node, "name", name, 1);
    return node;
  }
  function jsxElement(openingElement, closingElement = null, children) {
    const node = {
      type: "JSXElement",
      openingElement,
      closingElement,
      children
    };
    const defs = NODE_FIELDS.JSXElement;
    validate(defs.openingElement, node, "openingElement", openingElement, 1);
    validate(defs.closingElement, node, "closingElement", closingElement, 1);
    validate(defs.children, node, "children", children, 1);
    return node;
  }
  function jsxEmptyExpression() {
    return {
      type: "JSXEmptyExpression"
    };
  }
  function jsxExpressionContainer(expression) {
    const node = {
      type: "JSXExpressionContainer",
      expression
    };
    const defs = NODE_FIELDS.JSXExpressionContainer;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function jsxSpreadChild(expression) {
    const node = {
      type: "JSXSpreadChild",
      expression
    };
    const defs = NODE_FIELDS.JSXSpreadChild;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function jsxIdentifier(name) {
    const node = {
      type: "JSXIdentifier",
      name
    };
    const defs = NODE_FIELDS.JSXIdentifier;
    validate(defs.name, node, "name", name);
    return node;
  }
  function jsxMemberExpression(object, property) {
    const node = {
      type: "JSXMemberExpression",
      object,
      property
    };
    const defs = NODE_FIELDS.JSXMemberExpression;
    validate(defs.object, node, "object", object, 1);
    validate(defs.property, node, "property", property, 1);
    return node;
  }
  function jsxNamespacedName(namespace, name) {
    const node = {
      type: "JSXNamespacedName",
      namespace,
      name
    };
    const defs = NODE_FIELDS.JSXNamespacedName;
    validate(defs.namespace, node, "namespace", namespace, 1);
    validate(defs.name, node, "name", name, 1);
    return node;
  }
  function jsxOpeningElement(name, attributes, selfClosing = false) {
    const node = {
      type: "JSXOpeningElement",
      name,
      attributes,
      selfClosing
    };
    const defs = NODE_FIELDS.JSXOpeningElement;
    validate(defs.name, node, "name", name, 1);
    validate(defs.attributes, node, "attributes", attributes, 1);
    validate(defs.selfClosing, node, "selfClosing", selfClosing);
    return node;
  }
  function jsxSpreadAttribute(argument) {
    const node = {
      type: "JSXSpreadAttribute",
      argument
    };
    const defs = NODE_FIELDS.JSXSpreadAttribute;
    validate(defs.argument, node, "argument", argument, 1);
    return node;
  }
  function jsxText(value) {
    const node = {
      type: "JSXText",
      value
    };
    const defs = NODE_FIELDS.JSXText;
    validate(defs.value, node, "value", value);
    return node;
  }
  function jsxFragment(openingFragment, closingFragment, children) {
    const node = {
      type: "JSXFragment",
      openingFragment,
      closingFragment,
      children
    };
    const defs = NODE_FIELDS.JSXFragment;
    validate(defs.openingFragment, node, "openingFragment", openingFragment, 1);
    validate(defs.closingFragment, node, "closingFragment", closingFragment, 1);
    validate(defs.children, node, "children", children, 1);
    return node;
  }
  function jsxOpeningFragment() {
    return {
      type: "JSXOpeningFragment"
    };
  }
  function jsxClosingFragment() {
    return {
      type: "JSXClosingFragment"
    };
  }
  function placeholder(expectedNode, name) {
    const node = {
      type: "Placeholder",
      expectedNode,
      name
    };
    const defs = NODE_FIELDS.Placeholder;
    validate(defs.expectedNode, node, "expectedNode", expectedNode);
    validate(defs.name, node, "name", name, 1);
    return node;
  }
  function v8IntrinsicIdentifier(name) {
    const node = {
      type: "V8IntrinsicIdentifier",
      name
    };
    const defs = NODE_FIELDS.V8IntrinsicIdentifier;
    validate(defs.name, node, "name", name);
    return node;
  }
  function argumentPlaceholder() {
    return {
      type: "ArgumentPlaceholder"
    };
  }
  function bindExpression(object, callee) {
    const node = {
      type: "BindExpression",
      object,
      callee
    };
    const defs = NODE_FIELDS.BindExpression;
    validate(defs.object, node, "object", object, 1);
    validate(defs.callee, node, "callee", callee, 1);
    return node;
  }
  function classAccessorProperty(key, value = null, typeAnnotation2 = null, decorators = null, computed = false, _static = false) {
    const node = {
      type: "ClassAccessorProperty",
      key,
      value,
      typeAnnotation: typeAnnotation2,
      decorators,
      computed,
      static: _static
    };
    const defs = NODE_FIELDS.ClassAccessorProperty;
    validate(defs.key, node, "key", key, 1);
    validate(defs.value, node, "value", value, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    validate(defs.decorators, node, "decorators", decorators, 1);
    validate(defs.computed, node, "computed", computed);
    validate(defs.static, node, "static", _static);
    return node;
  }
  function decorator(expression) {
    const node = {
      type: "Decorator",
      expression
    };
    const defs = NODE_FIELDS.Decorator;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function doExpression(body, async = false) {
    const node = {
      type: "DoExpression",
      body,
      async
    };
    const defs = NODE_FIELDS.DoExpression;
    validate(defs.body, node, "body", body, 1);
    validate(defs.async, node, "async", async);
    return node;
  }
  function exportDefaultSpecifier(exported) {
    const node = {
      type: "ExportDefaultSpecifier",
      exported
    };
    const defs = NODE_FIELDS.ExportDefaultSpecifier;
    validate(defs.exported, node, "exported", exported, 1);
    return node;
  }
  function moduleExpression(body) {
    const node = {
      type: "ModuleExpression",
      body
    };
    const defs = NODE_FIELDS.ModuleExpression;
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function topicReference() {
    return {
      type: "TopicReference"
    };
  }
  function voidPattern() {
    return {
      type: "VoidPattern"
    };
  }
  function tsParameterProperty(parameter) {
    const node = {
      type: "TSParameterProperty",
      parameter
    };
    const defs = NODE_FIELDS.TSParameterProperty;
    validate(defs.parameter, node, "parameter", parameter, 1);
    return node;
  }
  function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {
    const node = {
      type: "TSDeclareFunction",
      id,
      typeParameters,
      params,
      returnType,
      async: false,
      generator: false
    };
    const defs = NODE_FIELDS.TSDeclareFunction;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function tsDeclareMethod(key, typeParameters = null, params, returnType = null) {
    const node = {
      type: "TSDeclareMethod",
      key,
      typeParameters,
      params,
      returnType,
      async: false,
      computed: false,
      generator: false,
      kind: "method",
      static: false
    };
    const defs = NODE_FIELDS.TSDeclareMethod;
    validate(defs.key, node, "key", key, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function tsQualifiedName(left, right) {
    const node = {
      type: "TSQualifiedName",
      left,
      right
    };
    const defs = NODE_FIELDS.TSQualifiedName;
    validate(defs.left, node, "left", left, 1);
    validate(defs.right, node, "right", right, 1);
    return node;
  }
  function tsCallSignatureDeclaration(typeParameters = null, params, returnType = null) {
    const node = {
      type: "TSCallSignatureDeclaration",
      typeParameters,
      params,
      returnType
    };
    const defs = NODE_FIELDS.TSCallSignatureDeclaration;
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function tsConstructSignatureDeclaration(typeParameters = null, params, returnType = null) {
    const node = {
      type: "TSConstructSignatureDeclaration",
      typeParameters,
      params,
      returnType
    };
    const defs = NODE_FIELDS.TSConstructSignatureDeclaration;
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function tsPropertySignature(key, typeAnnotation2 = null) {
    const node = {
      type: "TSPropertySignature",
      key,
      typeAnnotation: typeAnnotation2,
      computed: false
    };
    const defs = NODE_FIELDS.TSPropertySignature;
    validate(defs.key, node, "key", key, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsMethodSignature(key, typeParameters = null, params, returnType = null) {
    const node = {
      type: "TSMethodSignature",
      key,
      typeParameters,
      params,
      returnType,
      computed: false,
      kind: "method"
    };
    const defs = NODE_FIELDS.TSMethodSignature;
    validate(defs.key, node, "key", key, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function tsIndexSignature(parameters, typeAnnotation2 = null) {
    const node = {
      type: "TSIndexSignature",
      parameters,
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSIndexSignature;
    validate(defs.parameters, node, "parameters", parameters, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  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, params, returnType = null) {
    const node = {
      type: "TSFunctionType",
      typeParameters,
      params,
      returnType
    };
    const defs = NODE_FIELDS.TSFunctionType;
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function tsConstructorType(typeParameters = null, params, returnType = null) {
    const node = {
      type: "TSConstructorType",
      typeParameters,
      params,
      returnType
    };
    const defs = NODE_FIELDS.TSConstructorType;
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.params, node, "params", params, 1);
    validate(defs.returnType, node, "returnType", returnType, 1);
    return node;
  }
  function tsTypeReference(typeName, typeArguments = null) {
    const node = {
      type: "TSTypeReference",
      typeName,
      typeArguments
    };
    const defs = NODE_FIELDS.TSTypeReference;
    validate(defs.typeName, node, "typeName", typeName, 1);
    validate(defs.typeArguments, node, "typeArguments", typeArguments, 1);
    return node;
  }
  function tsTypePredicate(parameterName, typeAnnotation2 = null, asserts = null) {
    const node = {
      type: "TSTypePredicate",
      parameterName,
      typeAnnotation: typeAnnotation2,
      asserts
    };
    const defs = NODE_FIELDS.TSTypePredicate;
    validate(defs.parameterName, node, "parameterName", parameterName, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    validate(defs.asserts, node, "asserts", asserts);
    return node;
  }
  function tsTypeQuery(exprName, typeArguments = null) {
    const node = {
      type: "TSTypeQuery",
      exprName,
      typeArguments
    };
    const defs = NODE_FIELDS.TSTypeQuery;
    validate(defs.exprName, node, "exprName", exprName, 1);
    validate(defs.typeArguments, node, "typeArguments", typeArguments, 1);
    return node;
  }
  function tsTypeLiteral(members) {
    const node = {
      type: "TSTypeLiteral",
      members
    };
    const defs = NODE_FIELDS.TSTypeLiteral;
    validate(defs.members, node, "members", members, 1);
    return node;
  }
  function tsArrayType(elementType) {
    const node = {
      type: "TSArrayType",
      elementType
    };
    const defs = NODE_FIELDS.TSArrayType;
    validate(defs.elementType, node, "elementType", elementType, 1);
    return node;
  }
  function tsTupleType(elementTypes) {
    const node = {
      type: "TSTupleType",
      elementTypes
    };
    const defs = NODE_FIELDS.TSTupleType;
    validate(defs.elementTypes, node, "elementTypes", elementTypes, 1);
    return node;
  }
  function tsOptionalType(typeAnnotation2) {
    const node = {
      type: "TSOptionalType",
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSOptionalType;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsRestType(typeAnnotation2) {
    const node = {
      type: "TSRestType",
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSRestType;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsNamedTupleMember(label, elementType, optional = false) {
    const node = {
      type: "TSNamedTupleMember",
      label,
      elementType,
      optional
    };
    const defs = NODE_FIELDS.TSNamedTupleMember;
    validate(defs.label, node, "label", label, 1);
    validate(defs.elementType, node, "elementType", elementType, 1);
    validate(defs.optional, node, "optional", optional);
    return node;
  }
  function tsUnionType(types) {
    const node = {
      type: "TSUnionType",
      types
    };
    const defs = NODE_FIELDS.TSUnionType;
    validate(defs.types, node, "types", types, 1);
    return node;
  }
  function tsIntersectionType(types) {
    const node = {
      type: "TSIntersectionType",
      types
    };
    const defs = NODE_FIELDS.TSIntersectionType;
    validate(defs.types, node, "types", types, 1);
    return node;
  }
  function tsConditionalType(checkType, extendsType, trueType, falseType) {
    const node = {
      type: "TSConditionalType",
      checkType,
      extendsType,
      trueType,
      falseType
    };
    const defs = NODE_FIELDS.TSConditionalType;
    validate(defs.checkType, node, "checkType", checkType, 1);
    validate(defs.extendsType, node, "extendsType", extendsType, 1);
    validate(defs.trueType, node, "trueType", trueType, 1);
    validate(defs.falseType, node, "falseType", falseType, 1);
    return node;
  }
  function tsInferType(typeParameter2) {
    const node = {
      type: "TSInferType",
      typeParameter: typeParameter2
    };
    const defs = NODE_FIELDS.TSInferType;
    validate(defs.typeParameter, node, "typeParameter", typeParameter2, 1);
    return node;
  }
  function tsParenthesizedType(typeAnnotation2) {
    const node = {
      type: "TSParenthesizedType",
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSParenthesizedType;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsTypeOperator(typeAnnotation2, operator) {
    const node = {
      type: "TSTypeOperator",
      typeAnnotation: typeAnnotation2,
      operator
    };
    const defs = NODE_FIELDS.TSTypeOperator;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    validate(defs.operator, node, "operator", operator);
    return node;
  }
  function tsIndexedAccessType(objectType, indexType) {
    const node = {
      type: "TSIndexedAccessType",
      objectType,
      indexType
    };
    const defs = NODE_FIELDS.TSIndexedAccessType;
    validate(defs.objectType, node, "objectType", objectType, 1);
    validate(defs.indexType, node, "indexType", indexType, 1);
    return node;
  }
  function tsMappedType(key, constraint, nameType = null, typeAnnotation2 = null) {
    const node = {
      type: "TSMappedType",
      key,
      constraint,
      nameType,
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSMappedType;
    validate(defs.key, node, "key", key, 1);
    validate(defs.constraint, node, "constraint", constraint, 1);
    validate(defs.nameType, node, "nameType", nameType, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsTemplateLiteralType(quasis, types) {
    const node = {
      type: "TSTemplateLiteralType",
      quasis,
      types
    };
    const defs = NODE_FIELDS.TSTemplateLiteralType;
    validate(defs.quasis, node, "quasis", quasis, 1);
    validate(defs.types, node, "types", types, 1);
    return node;
  }
  function tsLiteralType(literal) {
    const node = {
      type: "TSLiteralType",
      literal
    };
    const defs = NODE_FIELDS.TSLiteralType;
    validate(defs.literal, node, "literal", literal, 1);
    return node;
  }
  function tsClassImplements(expression, typeArguments = null) {
    const node = {
      type: "TSClassImplements",
      expression,
      typeArguments
    };
    const defs = NODE_FIELDS.TSClassImplements;
    validate(defs.expression, node, "expression", expression, 1);
    validate(defs.typeArguments, node, "typeArguments", typeArguments, 1);
    return node;
  }
  function tsInterfaceHeritage(expression, typeArguments = null) {
    const node = {
      type: "TSInterfaceHeritage",
      expression,
      typeArguments
    };
    const defs = NODE_FIELDS.TSInterfaceHeritage;
    validate(defs.expression, node, "expression", expression, 1);
    validate(defs.typeArguments, node, "typeArguments", typeArguments, 1);
    return node;
  }
  function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {
    const node = {
      type: "TSInterfaceDeclaration",
      id,
      typeParameters,
      extends: _extends,
      body
    };
    const defs = NODE_FIELDS.TSInterfaceDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.extends, node, "extends", _extends, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function tsInterfaceBody(body) {
    const node = {
      type: "TSInterfaceBody",
      body
    };
    const defs = NODE_FIELDS.TSInterfaceBody;
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation2) {
    const node = {
      type: "TSTypeAliasDeclaration",
      id,
      typeParameters,
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSTypeAliasDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsInstantiationExpression(expression, typeArguments = null) {
    const node = {
      type: "TSInstantiationExpression",
      expression,
      typeArguments
    };
    const defs = NODE_FIELDS.TSInstantiationExpression;
    validate(defs.expression, node, "expression", expression, 1);
    validate(defs.typeArguments, node, "typeArguments", typeArguments, 1);
    return node;
  }
  function tsAsExpression(expression, typeAnnotation2) {
    const node = {
      type: "TSAsExpression",
      expression,
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSAsExpression;
    validate(defs.expression, node, "expression", expression, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsSatisfiesExpression(expression, typeAnnotation2) {
    const node = {
      type: "TSSatisfiesExpression",
      expression,
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSSatisfiesExpression;
    validate(defs.expression, node, "expression", expression, 1);
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsTypeAssertion(typeAnnotation2, expression) {
    const node = {
      type: "TSTypeAssertion",
      typeAnnotation: typeAnnotation2,
      expression
    };
    const defs = NODE_FIELDS.TSTypeAssertion;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function tsEnumBody(members) {
    const node = {
      type: "TSEnumBody",
      members
    };
    const defs = NODE_FIELDS.TSEnumBody;
    validate(defs.members, node, "members", members, 1);
    return node;
  }
  function tsEnumDeclaration(id, body) {
    const node = {
      type: "TSEnumDeclaration",
      id,
      body
    };
    const defs = NODE_FIELDS.TSEnumDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function tsEnumMember(id, initializer = null) {
    const node = {
      type: "TSEnumMember",
      id,
      initializer
    };
    const defs = NODE_FIELDS.TSEnumMember;
    validate(defs.id, node, "id", id, 1);
    validate(defs.initializer, node, "initializer", initializer, 1);
    return node;
  }
  function tsModuleDeclaration(id, body) {
    const node = {
      type: "TSModuleDeclaration",
      id,
      body,
      kind: "namespace"
    };
    const defs = NODE_FIELDS.TSModuleDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function tsModuleBlock(body) {
    const node = {
      type: "TSModuleBlock",
      body
    };
    const defs = NODE_FIELDS.TSModuleBlock;
    validate(defs.body, node, "body", body, 1);
    return node;
  }
  function tsImportType(source, qualifier = null, typeArguments = null) {
    const node = {
      type: "TSImportType",
      source,
      qualifier,
      typeArguments
    };
    const defs = NODE_FIELDS.TSImportType;
    validate(defs.source, node, "source", source, 1);
    validate(defs.qualifier, node, "qualifier", qualifier, 1);
    validate(defs.typeArguments, node, "typeArguments", typeArguments, 1);
    return node;
  }
  function tsImportEqualsDeclaration(id, moduleReference) {
    const node = {
      type: "TSImportEqualsDeclaration",
      id,
      moduleReference
    };
    const defs = NODE_FIELDS.TSImportEqualsDeclaration;
    validate(defs.id, node, "id", id, 1);
    validate(defs.moduleReference, node, "moduleReference", moduleReference, 1);
    return node;
  }
  function tsExternalModuleReference(expression) {
    const node = {
      type: "TSExternalModuleReference",
      expression
    };
    const defs = NODE_FIELDS.TSExternalModuleReference;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function tsNonNullExpression(expression) {
    const node = {
      type: "TSNonNullExpression",
      expression
    };
    const defs = NODE_FIELDS.TSNonNullExpression;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function tsExportAssignment(expression) {
    const node = {
      type: "TSExportAssignment",
      expression
    };
    const defs = NODE_FIELDS.TSExportAssignment;
    validate(defs.expression, node, "expression", expression, 1);
    return node;
  }
  function tsNamespaceExportDeclaration(id) {
    const node = {
      type: "TSNamespaceExportDeclaration",
      id
    };
    const defs = NODE_FIELDS.TSNamespaceExportDeclaration;
    validate(defs.id, node, "id", id, 1);
    return node;
  }
  function tsTypeAnnotation(typeAnnotation2) {
    const node = {
      type: "TSTypeAnnotation",
      typeAnnotation: typeAnnotation2
    };
    const defs = NODE_FIELDS.TSTypeAnnotation;
    validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation2, 1);
    return node;
  }
  function tsTypeParameterInstantiation(params) {
    const node = {
      type: "TSTypeParameterInstantiation",
      params
    };
    const defs = NODE_FIELDS.TSTypeParameterInstantiation;
    validate(defs.params, node, "params", params, 1);
    return node;
  }
  function tsTypeParameterDeclaration(params) {
    const node = {
      type: "TSTypeParameterDeclaration",
      params
    };
    const defs = NODE_FIELDS.TSTypeParameterDeclaration;
    validate(defs.params, node, "params", params, 1);
    return node;
  }
  function tsTypeParameter(constraint = null, _default = null, name) {
    const node = {
      type: "TSTypeParameter",
      constraint,
      default: _default,
      name
    };
    const defs = NODE_FIELDS.TSTypeParameter;
    validate(defs.constraint, node, "constraint", constraint, 1);
    validate(defs.default, node, "default", _default, 1);
    validate(defs.name, node, "name", name, 1);
    return node;
  }
  function NumberLiteral(value) {
    deprecationWarning("NumberLiteral", "NumericLiteral", "The node type ");
    return numericLiteral(value);
  }
  function RegexLiteral(pattern, flags = "") {
    deprecationWarning("RegexLiteral", "RegExpLiteral", "The node type ");
    return regExpLiteral(pattern, flags);
  }
  function RestProperty(argument) {
    deprecationWarning("RestProperty", "RestElement", "The node type ");
    return restElement(argument);
  }
  function SpreadProperty(argument) {
    deprecationWarning("SpreadProperty", "SpreadElement", "The node type ");
    return spreadElement(argument);
  }
  var b = /* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    anyTypeAnnotation,
    argumentPlaceholder,
    arrayExpression,
    arrayPattern,
    arrayTypeAnnotation,
    arrowFunctionExpression,
    assignmentExpression,
    assignmentPattern,
    awaitExpression,
    bigIntLiteral,
    bigIntLiteralTypeAnnotation,
    binaryExpression,
    bindExpression,
    blockStatement,
    booleanLiteral,
    booleanLiteralTypeAnnotation,
    booleanTypeAnnotation,
    breakStatement,
    callExpression,
    catchClause,
    classAccessorProperty,
    classBody,
    classDeclaration,
    classExpression,
    classImplements,
    classMethod,
    classPrivateMethod,
    classPrivateProperty,
    classProperty,
    conditionalExpression,
    continueStatement,
    debuggerStatement,
    declareClass,
    declareExportAllDeclaration,
    declareExportDeclaration,
    declareFunction,
    declareInterface,
    declareModule,
    declareModuleExports,
    declareOpaqueType,
    declareTypeAlias,
    declareVariable,
    declaredPredicate,
    decorator,
    directive,
    directiveLiteral,
    doExpression,
    doWhileStatement,
    emptyStatement,
    emptyTypeAnnotation,
    enumBooleanBody,
    enumBooleanMember,
    enumDeclaration,
    enumDefaultedMember,
    enumNumberBody,
    enumNumberMember,
    enumStringBody,
    enumStringMember,
    enumSymbolBody,
    existsTypeAnnotation,
    exportAllDeclaration,
    exportDefaultDeclaration,
    exportDefaultSpecifier,
    exportNamedDeclaration,
    exportNamespaceSpecifier,
    exportSpecifier,
    expressionStatement,
    file,
    forInStatement,
    forOfStatement,
    forStatement,
    functionDeclaration,
    functionExpression,
    functionTypeAnnotation,
    functionTypeParam,
    genericTypeAnnotation,
    identifier,
    ifStatement,
    import: _import,
    importAttribute,
    importDeclaration,
    importDefaultSpecifier,
    importExpression,
    importNamespaceSpecifier,
    importSpecifier,
    indexedAccessType,
    inferredPredicate,
    interfaceDeclaration,
    interfaceExtends,
    interfaceTypeAnnotation,
    interpreterDirective,
    intersectionTypeAnnotation,
    jsxAttribute,
    jsxClosingElement,
    jsxClosingFragment,
    jsxElement,
    jsxEmptyExpression,
    jsxExpressionContainer,
    jsxFragment,
    jsxIdentifier,
    jsxMemberExpression,
    jsxNamespacedName,
    jsxOpeningElement,
    jsxOpeningFragment,
    jsxSpreadAttribute,
    jsxSpreadChild,
    jsxText,
    labeledStatement,
    logicalExpression,
    memberExpression,
    metaProperty,
    mixedTypeAnnotation,
    moduleExpression,
    newExpression,
    nullLiteral,
    nullLiteralTypeAnnotation,
    nullableTypeAnnotation,
    numberLiteral: NumberLiteral,
    numberLiteralTypeAnnotation,
    numberTypeAnnotation,
    numericLiteral,
    objectExpression,
    objectMethod,
    objectPattern,
    objectProperty,
    objectTypeAnnotation,
    objectTypeCallProperty,
    objectTypeIndexer,
    objectTypeInternalSlot,
    objectTypeProperty,
    objectTypeSpreadProperty,
    opaqueType,
    optionalCallExpression,
    optionalIndexedAccessType,
    optionalMemberExpression,
    parenthesizedExpression,
    placeholder,
    privateName,
    program,
    qualifiedTypeIdentifier,
    regExpLiteral,
    regexLiteral: RegexLiteral,
    restElement,
    restProperty: RestProperty,
    returnStatement,
    sequenceExpression,
    spreadElement,
    spreadProperty: SpreadProperty,
    staticBlock,
    stringLiteral,
    stringLiteralTypeAnnotation,
    stringTypeAnnotation,
    super: _super,
    switchCase,
    switchStatement,
    symbolTypeAnnotation,
    taggedTemplateExpression,
    templateElement,
    templateLiteral,
    thisExpression,
    thisTypeAnnotation,
    throwStatement,
    topicReference,
    tryStatement,
    tsAnyKeyword,
    tsArrayType,
    tsAsExpression,
    tsBigIntKeyword,
    tsBooleanKeyword,
    tsCallSignatureDeclaration,
    tsClassImplements,
    tsConditionalType,
    tsConstructSignatureDeclaration,
    tsConstructorType,
    tsDeclareFunction,
    tsDeclareMethod,
    tsEnumBody,
    tsEnumDeclaration,
    tsEnumMember,
    tsExportAssignment,
    tsExternalModuleReference,
    tsFunctionType,
    tsImportEqualsDeclaration,
    tsImportType,
    tsIndexSignature,
    tsIndexedAccessType,
    tsInferType,
    tsInstantiationExpression,
    tsInterfaceBody,
    tsInterfaceDeclaration,
    tsInterfaceHeritage,
    tsIntersectionType,
    tsIntrinsicKeyword,
    tsLiteralType,
    tsMappedType,
    tsMethodSignature,
    tsModuleBlock,
    tsModuleDeclaration,
    tsNamedTupleMember,
    tsNamespaceExportDeclaration,
    tsNeverKeyword,
    tsNonNullExpression,
    tsNullKeyword,
    tsNumberKeyword,
    tsObjectKeyword,
    tsOptionalType,
    tsParameterProperty,
    tsParenthesizedType,
    tsPropertySignature,
    tsQualifiedName,
    tsRestType,
    tsSatisfiesExpression,
    tsStringKeyword,
    tsSymbolKeyword,
    tsTemplateLiteralType,
    tsThisType,
    tsTupleType,
    tsTypeAliasDeclaration,
    tsTypeAnnotation,
    tsTypeAssertion,
    tsTypeLiteral,
    tsTypeOperator,
    tsTypeParameter,
    tsTypeParameterDeclaration,
    tsTypeParameterInstantiation,
    tsTypePredicate,
    tsTypeQuery,
    tsTypeReference,
    tsUndefinedKeyword,
    tsUnionType,
    tsUnknownKeyword,
    tsVoidKeyword,
    tupleTypeAnnotation,
    typeAlias,
    typeAnnotation,
    typeCastExpression,
    typeParameter,
    typeParameterDeclaration,
    typeParameterInstantiation,
    typeofTypeAnnotation,
    unaryExpression,
    unionTypeAnnotation,
    updateExpression,
    v8IntrinsicIdentifier,
    variableDeclaration,
    variableDeclarator,
    variance,
    voidPattern,
    voidTypeAnnotation,
    whileStatement,
    withStatement,
    yieldExpression
  }, Symbol.toStringTag, { value: "Module" });
  function alias(lowercase) {
    return function() {
      deprecationWarning(lowercase.replace(/^(?:ts|jsx|[a-z])/, (x) => x.toUpperCase()), lowercase, "Usage of builders starting with an uppercase letter such as ", "uppercase builders");
      return b[lowercase](...arguments);
    };
  }
  var ArrayExpression = alias("arrayExpression");
  var AssignmentExpression = alias("assignmentExpression");
  var BinaryExpression = alias("binaryExpression");
  var InterpreterDirective = alias("interpreterDirective");
  var Directive = alias("directive");
  var DirectiveLiteral = alias("directiveLiteral");
  var BlockStatement = alias("blockStatement");
  var BreakStatement = alias("breakStatement");
  var CallExpression = alias("callExpression");
  var CatchClause = alias("catchClause");
  var ConditionalExpression = alias("conditionalExpression");
  var ContinueStatement = alias("continueStatement");
  var DebuggerStatement = alias("debuggerStatement");
  var DoWhileStatement = alias("doWhileStatement");
  var EmptyStatement = alias("emptyStatement");
  var ExpressionStatement = alias("expressionStatement");
  var File = alias("file");
  var ForInStatement = alias("forInStatement");
  var ForStatement = alias("forStatement");
  var FunctionDeclaration = alias("functionDeclaration");
  var FunctionExpression = alias("functionExpression");
  var Identifier = alias("identifier");
  var IfStatement = alias("ifStatement");
  var LabeledStatement = alias("labeledStatement");
  var StringLiteral = alias("stringLiteral");
  var NumericLiteral = alias("numericLiteral");
  var NullLiteral = alias("nullLiteral");
  var BooleanLiteral = alias("booleanLiteral");
  var RegExpLiteral = alias("regExpLiteral");
  var LogicalExpression = alias("logicalExpression");
  var MemberExpression = alias("memberExpression");
  var NewExpression = alias("newExpression");
  var Program = alias("program");
  var ObjectExpression = alias("objectExpression");
  var ObjectMethod = alias("objectMethod");
  var ObjectProperty = alias("objectProperty");
  var RestElement = alias("restElement");
  var ReturnStatement = alias("returnStatement");
  var SequenceExpression = alias("sequenceExpression");
  var ParenthesizedExpression = alias("parenthesizedExpression");
  var SwitchCase = alias("switchCase");
  var SwitchStatement = alias("switchStatement");
  var ThisExpression = alias("thisExpression");
  var ThrowStatement = alias("throwStatement");
  var TryStatement = alias("tryStatement");
  var UnaryExpression = alias("unaryExpression");
  var UpdateExpression = alias("updateExpression");
  var VariableDeclaration = alias("variableDeclaration");
  var VariableDeclarator = alias("variableDeclarator");
  var WhileStatement = alias("whileStatement");
  var WithStatement = alias("withStatement");
  var AssignmentPattern = alias("assignmentPattern");
  var ArrayPattern = alias("arrayPattern");
  var ArrowFunctionExpression = alias("arrowFunctionExpression");
  var ClassBody = alias("classBody");
  var ClassExpression = alias("classExpression");
  var ClassDeclaration = alias("classDeclaration");
  var ExportAllDeclaration = alias("exportAllDeclaration");
  var ExportDefaultDeclaration = alias("exportDefaultDeclaration");
  var ExportNamedDeclaration = alias("exportNamedDeclaration");
  var ExportSpecifier = alias("exportSpecifier");
  var ForOfStatement = alias("forOfStatement");
  var ImportDeclaration = alias("importDeclaration");
  var ImportDefaultSpecifier = alias("importDefaultSpecifier");
  var ImportNamespaceSpecifier = alias("importNamespaceSpecifier");
  var ImportSpecifier = alias("importSpecifier");
  var MetaProperty = alias("metaProperty");
  var ClassMethod = alias("classMethod");
  var ObjectPattern = alias("objectPattern");
  var SpreadElement = alias("spreadElement");
  var Super = alias("super");
  var TaggedTemplateExpression = alias("taggedTemplateExpression");
  var TemplateElement = alias("templateElement");
  var TemplateLiteral = alias("templateLiteral");
  var YieldExpression = alias("yieldExpression");
  var AwaitExpression = alias("awaitExpression");
  var ImportExpression = alias("importExpression");
  var Import = alias("import");
  var BigIntLiteral = alias("bigIntLiteral");
  var ExportNamespaceSpecifier = alias("exportNamespaceSpecifier");
  var OptionalMemberExpression = alias("optionalMemberExpression");
  var OptionalCallExpression = alias("optionalCallExpression");
  var ClassProperty = alias("classProperty");
  var ClassPrivateProperty = alias("classPrivateProperty");
  var ClassPrivateMethod = alias("classPrivateMethod");
  var PrivateName = alias("privateName");
  var StaticBlock = alias("staticBlock");
  var ImportAttribute = alias("importAttribute");
  var AnyTypeAnnotation = alias("anyTypeAnnotation");
  var ArrayTypeAnnotation = alias("arrayTypeAnnotation");
  var BooleanTypeAnnotation = alias("booleanTypeAnnotation");
  var BooleanLiteralTypeAnnotation = alias("booleanLiteralTypeAnnotation");
  var NullLiteralTypeAnnotation = alias("nullLiteralTypeAnnotation");
  var ClassImplements = alias("classImplements");
  var DeclareClass = alias("declareClass");
  var DeclareFunction = alias("declareFunction");
  var DeclareInterface = alias("declareInterface");
  var DeclareModule = alias("declareModule");
  var DeclareModuleExports = alias("declareModuleExports");
  var DeclareTypeAlias = alias("declareTypeAlias");
  var DeclareOpaqueType = alias("declareOpaqueType");
  var DeclareVariable = alias("declareVariable");
  var DeclareExportDeclaration = alias("declareExportDeclaration");
  var DeclareExportAllDeclaration = alias("declareExportAllDeclaration");
  var DeclaredPredicate = alias("declaredPredicate");
  var ExistsTypeAnnotation = alias("existsTypeAnnotation");
  var FunctionTypeAnnotation = alias("functionTypeAnnotation");
  var FunctionTypeParam = alias("functionTypeParam");
  var GenericTypeAnnotation = alias("genericTypeAnnotation");
  var InferredPredicate = alias("inferredPredicate");
  var InterfaceExtends = alias("interfaceExtends");
  var InterfaceDeclaration = alias("interfaceDeclaration");
  var InterfaceTypeAnnotation = alias("interfaceTypeAnnotation");
  var IntersectionTypeAnnotation = alias("intersectionTypeAnnotation");
  var MixedTypeAnnotation = alias("mixedTypeAnnotation");
  var EmptyTypeAnnotation = alias("emptyTypeAnnotation");
  var NullableTypeAnnotation = alias("nullableTypeAnnotation");
  var NumberLiteralTypeAnnotation = alias("numberLiteralTypeAnnotation");
  var BigIntLiteralTypeAnnotation = alias("bigIntLiteralTypeAnnotation");
  var NumberTypeAnnotation = alias("numberTypeAnnotation");
  var ObjectTypeAnnotation = alias("objectTypeAnnotation");
  var ObjectTypeInternalSlot = alias("objectTypeInternalSlot");
  var ObjectTypeCallProperty = alias("objectTypeCallProperty");
  var ObjectTypeIndexer = alias("objectTypeIndexer");
  var ObjectTypeProperty = alias("objectTypeProperty");
  var ObjectTypeSpreadProperty = alias("objectTypeSpreadProperty");
  var OpaqueType = alias("opaqueType");
  var QualifiedTypeIdentifier = alias("qualifiedTypeIdentifier");
  var StringLiteralTypeAnnotation = alias("stringLiteralTypeAnnotation");
  var StringTypeAnnotation = alias("stringTypeAnnotation");
  var SymbolTypeAnnotation = alias("symbolTypeAnnotation");
  var ThisTypeAnnotation = alias("thisTypeAnnotation");
  var TupleTypeAnnotation = alias("tupleTypeAnnotation");
  var TypeofTypeAnnotation = alias("typeofTypeAnnotation");
  var TypeAlias = alias("typeAlias");
  var TypeAnnotation = alias("typeAnnotation");
  var TypeCastExpression = alias("typeCastExpression");
  var TypeParameter = alias("typeParameter");
  var TypeParameterDeclaration = alias("typeParameterDeclaration");
  var TypeParameterInstantiation = alias("typeParameterInstantiation");
  var UnionTypeAnnotation = alias("unionTypeAnnotation");
  var Variance = alias("variance");
  var VoidTypeAnnotation = alias("voidTypeAnnotation");
  var EnumDeclaration = alias("enumDeclaration");
  var EnumBooleanBody = alias("enumBooleanBody");
  var EnumNumberBody = alias("enumNumberBody");
  var EnumStringBody = alias("enumStringBody");
  var EnumSymbolBody = alias("enumSymbolBody");
  var EnumBooleanMember = alias("enumBooleanMember");
  var EnumNumberMember = alias("enumNumberMember");
  var EnumStringMember = alias("enumStringMember");
  var EnumDefaultedMember = alias("enumDefaultedMember");
  var IndexedAccessType = alias("indexedAccessType");
  var OptionalIndexedAccessType = alias("optionalIndexedAccessType");
  var JSXAttribute = alias("jsxAttribute");
  var JSXClosingElement = alias("jsxClosingElement");
  var JSXElement = alias("jsxElement");
  var JSXEmptyExpression = alias("jsxEmptyExpression");
  var JSXExpressionContainer = alias("jsxExpressionContainer");
  var JSXSpreadChild = alias("jsxSpreadChild");
  var JSXIdentifier = alias("jsxIdentifier");
  var JSXMemberExpression = alias("jsxMemberExpression");
  var JSXNamespacedName = alias("jsxNamespacedName");
  var JSXOpeningElement = alias("jsxOpeningElement");
  var JSXSpreadAttribute = alias("jsxSpreadAttribute");
  var JSXText = alias("jsxText");
  var JSXFragment = alias("jsxFragment");
  var JSXOpeningFragment = alias("jsxOpeningFragment");
  var JSXClosingFragment = alias("jsxClosingFragment");
  var Placeholder = alias("placeholder");
  var V8IntrinsicIdentifier = alias("v8IntrinsicIdentifier");
  var ArgumentPlaceholder = alias("argumentPlaceholder");
  var BindExpression = alias("bindExpression");
  var ClassAccessorProperty = alias("classAccessorProperty");
  var Decorator = alias("decorator");
  var DoExpression = alias("doExpression");
  var ExportDefaultSpecifier = alias("exportDefaultSpecifier");
  var ModuleExpression = alias("moduleExpression");
  var TopicReference = alias("topicReference");
  var VoidPattern = alias("voidPattern");
  var TSParameterProperty = alias("tsParameterProperty");
  var TSDeclareFunction = alias("tsDeclareFunction");
  var TSDeclareMethod = alias("tsDeclareMethod");
  var TSQualifiedName = alias("tsQualifiedName");
  var TSCallSignatureDeclaration = alias("tsCallSignatureDeclaration");
  var TSConstructSignatureDeclaration = alias("tsConstructSignatureDeclaration");
  var TSPropertySignature = alias("tsPropertySignature");
  var TSMethodSignature = alias("tsMethodSignature");
  var TSIndexSignature = alias("tsIndexSignature");
  var TSAnyKeyword = alias("tsAnyKeyword");
  var TSBooleanKeyword = alias("tsBooleanKeyword");
  var TSBigIntKeyword = alias("tsBigIntKeyword");
  var TSIntrinsicKeyword = alias("tsIntrinsicKeyword");
  var TSNeverKeyword = alias("tsNeverKeyword");
  var TSNullKeyword = alias("tsNullKeyword");
  var TSNumberKeyword = alias("tsNumberKeyword");
  var TSObjectKeyword = alias("tsObjectKeyword");
  var TSStringKeyword = alias("tsStringKeyword");
  var TSSymbolKeyword = alias("tsSymbolKeyword");
  var TSUndefinedKeyword = alias("tsUndefinedKeyword");
  var TSUnknownKeyword = alias("tsUnknownKeyword");
  var TSVoidKeyword = alias("tsVoidKeyword");
  var TSThisType = alias("tsThisType");
  var TSFunctionType = alias("tsFunctionType");
  var TSConstructorType = alias("tsConstructorType");
  var TSTypeReference = alias("tsTypeReference");
  var TSTypePredicate = alias("tsTypePredicate");
  var TSTypeQuery = alias("tsTypeQuery");
  var TSTypeLiteral = alias("tsTypeLiteral");
  var TSArrayType = alias("tsArrayType");
  var TSTupleType = alias("tsTupleType");
  var TSOptionalType = alias("tsOptionalType");
  var TSRestType = alias("tsRestType");
  var TSNamedTupleMember = alias("tsNamedTupleMember");
  var TSUnionType = alias("tsUnionType");
  var TSIntersectionType = alias("tsIntersectionType");
  var TSConditionalType = alias("tsConditionalType");
  var TSInferType = alias("tsInferType");
  var TSParenthesizedType = alias("tsParenthesizedType");
  var TSTypeOperator = alias("tsTypeOperator");
  var TSIndexedAccessType = alias("tsIndexedAccessType");
  var TSMappedType = alias("tsMappedType");
  var TSTemplateLiteralType = alias("tsTemplateLiteralType");
  var TSLiteralType = alias("tsLiteralType");
  var TSClassImplements = alias("tsClassImplements");
  var TSInterfaceHeritage = alias("tsInterfaceHeritage");
  var TSInterfaceDeclaration = alias("tsInterfaceDeclaration");
  var TSInterfaceBody = alias("tsInterfaceBody");
  var TSTypeAliasDeclaration = alias("tsTypeAliasDeclaration");
  var TSInstantiationExpression = alias("tsInstantiationExpression");
  var TSAsExpression = alias("tsAsExpression");
  var TSSatisfiesExpression = alias("tsSatisfiesExpression");
  var TSTypeAssertion = alias("tsTypeAssertion");
  var TSEnumBody = alias("tsEnumBody");
  var TSEnumDeclaration = alias("tsEnumDeclaration");
  var TSEnumMember = alias("tsEnumMember");
  var TSModuleDeclaration = alias("tsModuleDeclaration");
  var TSModuleBlock = alias("tsModuleBlock");
  var TSImportType = alias("tsImportType");
  var TSImportEqualsDeclaration = alias("tsImportEqualsDeclaration");
  var TSExternalModuleReference = alias("tsExternalModuleReference");
  var TSNonNullExpression = alias("tsNonNullExpression");
  var TSExportAssignment = alias("tsExportAssignment");
  var TSNamespaceExportDeclaration = alias("tsNamespaceExportDeclaration");
  var TSTypeAnnotation = alias("tsTypeAnnotation");
  var TSTypeParameterInstantiation = alias("tsTypeParameterInstantiation");
  var TSTypeParameterDeclaration = alias("tsTypeParameterDeclaration");
  var TSTypeParameter = alias("tsTypeParameter");
  function cleanJSXElementLiteralChild(child, args) {
    const lines = child.value.split(/\r\n|\n|\r/);
    let lastNonEmptyLine = 0;
    for (let i = 0; i < lines.length; i++) {
      if (/[^ \t]/.exec(lines[i])) {
        lastNonEmptyLine = i;
      }
    }
    let str = "";
    for (let i = 0; i < lines.length; i++) {
      const line = lines[i];
      const isFirstLine = i === 0;
      const isLastLine = i === lines.length - 1;
      const isLastNonEmptyLine = i === lastNonEmptyLine;
      let trimmedLine = line.replace(/\t/g, " ");
      if (!isFirstLine) {
        trimmedLine = trimmedLine.replace(/^ +/, "");
      }
      if (!isLastLine) {
        trimmedLine = trimmedLine.replace(/ +$/, "");
      }
      if (trimmedLine) {
        if (!isLastNonEmptyLine) {
          trimmedLine += " ";
        }
        str += trimmedLine;
      }
    }
    if (str) args.push(inherits(stringLiteral(str), child));
  }
  function buildChildren(node) {
    const elements = [];
    for (let i = 0; i < node.children.length; i++) {
      let child = node.children[i];
      if (isJSXText(child)) {
        cleanJSXElementLiteralChild(child, elements);
        continue;
      }
      if (isJSXExpressionContainer(child)) child = child.expression;
      if (isJSXEmptyExpression(child)) continue;
      elements.push(child);
    }
    return elements;
  }
  function isNode(node) {
    return !!(node && VISITOR_KEYS[node.type]);
  }
  function assertNode(node) {
    var _a;
    if (!isNode(node)) {
      const type = (_a = node == null ? void 0 : node.type) != null ? _a : JSON.stringify(node);
      throw new TypeError(`Not a valid node of type "${type}"`);
    }
  }
  function assert(type, node, opts) {
    if (!is(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 assertImportExpression(node, opts) {
    assert("ImportExpression", 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 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 assertImportAttribute(node, opts) {
    assert("ImportAttribute", 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 assertBigIntLiteralTypeAnnotation(node, opts) {
    assert("BigIntLiteralTypeAnnotation", 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 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 assertClassAccessorProperty(node, opts) {
    assert("ClassAccessorProperty", 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 assertModuleExpression(node, opts) {
    assert("ModuleExpression", node, opts);
  }
  function assertTopicReference(node, opts) {
    assert("TopicReference", node, opts);
  }
  function assertVoidPattern(node, opts) {
    assert("VoidPattern", 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 assertTSTemplateLiteralType(node, opts) {
    assert("TSTemplateLiteralType", node, opts);
  }
  function assertTSLiteralType(node, opts) {
    assert("TSLiteralType", node, opts);
  }
  function assertTSClassImplements(node, opts) {
    assert("TSClassImplements", node, opts);
  }
  function assertTSInterfaceHeritage(node, opts) {
    assert("TSInterfaceHeritage", 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 assertTSSatisfiesExpression(node, opts) {
    assert("TSSatisfiesExpression", node, opts);
  }
  function assertTSTypeAssertion(node, opts) {
    assert("TSTypeAssertion", node, opts);
  }
  function assertTSEnumBody(node, opts) {
    assert("TSEnumBody", 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 assertFunctionParameter(node, opts) {
    assert("FunctionParameter", 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 assertImportOrExportDeclaration(node, opts) {
    assert("ImportOrExportDeclaration", node, opts);
  }
  function assertExportDeclaration(node, opts) {
    assert("ExportDeclaration", node, opts);
  }
  function assertModuleSpecifier(node, opts) {
    assert("ModuleSpecifier", 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 assertAccessor(node, opts) {
    assert("Accessor", 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) {
    deprecationWarning("assertNumberLiteral", "assertNumericLiteral");
    assert("NumberLiteral", node, opts);
  }
  function assertRegexLiteral(node, opts) {
    deprecationWarning("assertRegexLiteral", "assertRegExpLiteral");
    assert("RegexLiteral", node, opts);
  }
  function assertRestProperty(node, opts) {
    deprecationWarning("assertRestProperty", "assertRestElement");
    assert("RestProperty", node, opts);
  }
  function assertSpreadProperty(node, opts) {
    deprecationWarning("assertSpreadProperty", "assertSpreadElement");
    assert("SpreadProperty", node, opts);
  }
  function assertModuleDeclaration(node, opts) {
    deprecationWarning("assertModuleDeclaration", "assertImportOrExportDeclaration");
    assert("ModuleDeclaration", node, opts);
  }
  function createTypeAnnotationBasedOnTypeof(type) {
    switch (type) {
      case "string":
        return stringTypeAnnotation();
      case "number":
        return numberTypeAnnotation();
      case "undefined":
        return voidTypeAnnotation();
      case "boolean":
        return booleanTypeAnnotation();
      case "function":
        return genericTypeAnnotation(identifier("Function"));
      case "object":
        return genericTypeAnnotation(identifier("Object"));
      case "symbol":
        return genericTypeAnnotation(identifier("Symbol"));
      case "bigint":
        return anyTypeAnnotation();
    }
    throw new Error("Invalid typeof value: " + type);
  }
  function getQualifiedName$1(node) {
    return isIdentifier(node) ? node.name : `${node.id.name}.${getQualifiedName$1(node.qualification)}`;
  }
  function removeTypeDuplicates$1(nodesIn) {
    const nodes = Array.from(nodesIn);
    const generics = /* @__PURE__ */ new Map();
    const bases = /* @__PURE__ */ new Map();
    const typeGroups = /* @__PURE__ */ new Set();
    const types = [];
    for (let i = 0; i < nodes.length; i++) {
      const node = nodes[i];
      if (!node) continue;
      if (types.includes(node)) {
        continue;
      }
      if (isAnyTypeAnnotation(node)) {
        return [node];
      }
      if (isFlowBaseAnnotation(node)) {
        bases.set(node.type, node);
        continue;
      }
      if (isUnionTypeAnnotation(node)) {
        if (!typeGroups.has(node.types)) {
          nodes.push(...node.types);
          typeGroups.add(node.types);
        }
        continue;
      }
      if (isGenericTypeAnnotation(node)) {
        const name = getQualifiedName$1(node.id);
        if (generics.has(name)) {
          const existingTypeParameters = generics.get(name).typeParameters;
          if (existingTypeParameters) {
            if (node.typeParameters) {
              existingTypeParameters.params.push(...node.typeParameters.params);
              existingTypeParameters.params = removeTypeDuplicates$1(existingTypeParameters.params);
            }
          }
        } else {
          generics.set(name, node);
        }
        continue;
      }
      types.push(node);
    }
    for (const [, baseType] of bases) {
      types.push(baseType);
    }
    for (const [, genericName] of generics) {
      types.push(genericName);
    }
    return types;
  }
  function createFlowUnionType(types) {
    const flattened = removeTypeDuplicates$1(types);
    if (flattened.length === 1) {
      return flattened[0];
    } else {
      return unionTypeAnnotation(flattened);
    }
  }
  function getQualifiedName(node) {
    return isIdentifier(node) ? node.name : isThisExpression(node) ? "this" : `${node.right.name}.${getQualifiedName(node.left)}`;
  }
  function removeTypeDuplicates(nodesIn) {
    const nodes = Array.from(nodesIn);
    const generics = /* @__PURE__ */ new Map();
    const bases = /* @__PURE__ */ new Map();
    const typeGroups = /* @__PURE__ */ new Set();
    const types = [];
    for (let i = 0; i < nodes.length; i++) {
      const node = nodes[i];
      if (!node) continue;
      if (types.includes(node)) {
        continue;
      }
      if (isTSAnyKeyword(node)) {
        return [node];
      }
      if (isTSBaseType(node)) {
        bases.set(node.type, node);
        continue;
      }
      if (isTSUnionType(node)) {
        if (!typeGroups.has(node.types)) {
          nodes.push(...node.types);
          typeGroups.add(node.types);
        }
        continue;
      }
      const typeArgumentsKey = "typeArguments";
      if (isTSTypeReference(node) && node[typeArgumentsKey]) {
        const typeArguments = node[typeArgumentsKey];
        const name = getQualifiedName(node.typeName);
        if (generics.has(name)) {
          const existingTypeArguments = generics.get(name)[typeArgumentsKey];
          if (existingTypeArguments) {
            existingTypeArguments.params.push(...typeArguments.params);
            existingTypeArguments.params = removeTypeDuplicates(existingTypeArguments.params);
          }
        } else {
          generics.set(name, node);
        }
        continue;
      }
      types.push(node);
    }
    for (const [, baseType] of bases) {
      types.push(baseType);
    }
    for (const [, genericName] of generics) {
      types.push(genericName);
    }
    return types;
  }
  function createTSUnionType(typeAnnotations) {
    const types = typeAnnotations.map((type) => {
      return isTSTypeAnnotation(type) ? type.typeAnnotation : type;
    });
    const flattened = removeTypeDuplicates(types);
    if (flattened.length === 1) {
      return flattened[0];
    } else {
      return tsUnionType(flattened);
    }
  }
  function buildUndefinedNode() {
    return unaryExpression("void", numericLiteral(0), true);
  }
  var {
    hasOwn
  } = Object;
  function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
    if (obj && typeof obj.type === "string") {
      return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
    }
    return obj;
  }
  function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
    if (Array.isArray(obj)) {
      return obj.map((node) => cloneIfNode(node, deep, withoutLoc, commentsCache));
    }
    return cloneIfNode(obj, deep, withoutLoc, commentsCache);
  }
  function cloneNode(node, deep = true, withoutLoc = false) {
    if (!node) return node;
    return cloneNodeInternal(node, deep, withoutLoc, /* @__PURE__ */ new Map());
  }
  function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
    if (!node) return node;
    const {
      type
    } = node;
    const newNode = {
      type: node.type
    };
    if (isIdentifier(node)) {
      newNode.name = node.name;
      if (hasOwn(node, "optional") && typeof node.optional === "boolean") {
        newNode.optional = node.optional;
      }
      if (hasOwn(node, "typeAnnotation")) {
        newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;
      }
      if (hasOwn(node, "decorators")) {
        newNode.decorators = deep ? cloneIfNodeOrArray(node.decorators, true, withoutLoc, commentsCache) : node.decorators;
      }
    } else if (!hasOwn(NODE_FIELDS$1, type)) {
      throw new Error(`Unknown node type: "${type}"`);
    } else {
      for (const field of Object.keys(NODE_FIELDS$1[type])) {
        if (hasOwn(node, field)) {
          if (deep) {
            newNode[field] = isFile(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
          } else {
            newNode[field] = node[field];
          }
        }
      }
    }
    if (hasOwn(node, "loc")) {
      if (withoutLoc) {
        newNode.loc = null;
      } else {
        newNode.loc = node.loc;
      }
    }
    if (hasOwn(node, "leadingComments")) {
      newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);
    }
    if (hasOwn(node, "innerComments")) {
      newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);
    }
    if (hasOwn(node, "trailingComments")) {
      newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);
    }
    if (hasOwn(node, "extra")) {
      newNode.extra = {
        ...node.extra
      };
    }
    return newNode;
  }
  function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
    if (!comments || !deep) {
      return comments;
    }
    return comments.map((comment) => {
      const cache = commentsCache.get(comment);
      if (cache) return cache;
      const {
        type,
        value,
        loc
      } = comment;
      const ret = {
        type,
        value,
        loc
      };
      if (withoutLoc) {
        ret.loc = void 0;
      }
      commentsCache.set(comment, ret);
      return ret;
    });
  }
  function clone(node) {
    return cloneNode(node, false);
  }
  function cloneDeep(node) {
    return cloneNode(node);
  }
  function cloneDeepWithoutLoc(node) {
    return cloneNode(node, true, true);
  }
  function cloneWithoutLoc(node) {
    return cloneNode(node, false, true);
  }
  function addComments(node, type, comments) {
    if (!comments || !node) return node;
    const key = `${type}Comments`;
    if (node[key]) {
      if (type === "leading") {
        node[key] = comments.concat(node[key]);
      } else {
        node[key].push(...comments);
      }
    } else {
      node[key] = comments;
    }
    return node;
  }
  function addComment(node, type, content, line) {
    return addComments(node, type, [{
      type: line ? "CommentLine" : "CommentBlock",
      value: content
    }]);
  }
  function inherit(key, child, parent) {
    if (child && parent) {
      const parentVal = parent[key];
      if (!parentVal) return;
      const childVal = child[key];
      child[key] = Array.from(childVal ? new Set([...childVal, ...parentVal].filter(Boolean)) : parentVal);
    }
  }
  function inheritInnerComments(child, parent) {
    inherit("innerComments", child, parent);
  }
  function inheritLeadingComments(child, parent) {
    inherit("leadingComments", child, parent);
  }
  function inheritTrailingComments(child, parent) {
    inherit("trailingComments", child, parent);
  }
  function inheritsComments(child, parent) {
    inheritTrailingComments(child, parent);
    inheritLeadingComments(child, parent);
    inheritInnerComments(child, parent);
    return child;
  }
  function removeComments(node) {
    COMMENT_KEYS.forEach((key) => {
      node[key] = null;
    });
    return node;
  }
  var STANDARDIZED_TYPES = FLIPPED_ALIAS_KEYS["Standardized"];
  var EXPRESSION_TYPES = FLIPPED_ALIAS_KEYS["Expression"];
  var BINARY_TYPES = FLIPPED_ALIAS_KEYS["Binary"];
  var SCOPABLE_TYPES = FLIPPED_ALIAS_KEYS["Scopable"];
  var BLOCKPARENT_TYPES = FLIPPED_ALIAS_KEYS["BlockParent"];
  var BLOCK_TYPES = FLIPPED_ALIAS_KEYS["Block"];
  var STATEMENT_TYPES = FLIPPED_ALIAS_KEYS["Statement"];
  var TERMINATORLESS_TYPES = FLIPPED_ALIAS_KEYS["Terminatorless"];
  var COMPLETIONSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS["CompletionStatement"];
  var CONDITIONAL_TYPES = FLIPPED_ALIAS_KEYS["Conditional"];
  var LOOP_TYPES = FLIPPED_ALIAS_KEYS["Loop"];
  var WHILE_TYPES = FLIPPED_ALIAS_KEYS["While"];
  var EXPRESSIONWRAPPER_TYPES = FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
  var FOR_TYPES = FLIPPED_ALIAS_KEYS["For"];
  var FORXSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS["ForXStatement"];
  var FUNCTION_TYPES = FLIPPED_ALIAS_KEYS["Function"];
  var FUNCTIONPARENT_TYPES = FLIPPED_ALIAS_KEYS["FunctionParent"];
  var PUREISH_TYPES = FLIPPED_ALIAS_KEYS["Pureish"];
  var DECLARATION_TYPES = FLIPPED_ALIAS_KEYS["Declaration"];
  var FUNCTIONPARAMETER_TYPES = FLIPPED_ALIAS_KEYS["FunctionParameter"];
  var PATTERNLIKE_TYPES = FLIPPED_ALIAS_KEYS["PatternLike"];
  var LVAL_TYPES = FLIPPED_ALIAS_KEYS["LVal"];
  var TSENTITYNAME_TYPES = FLIPPED_ALIAS_KEYS["TSEntityName"];
  var LITERAL_TYPES = FLIPPED_ALIAS_KEYS["Literal"];
  var IMMUTABLE_TYPES = FLIPPED_ALIAS_KEYS["Immutable"];
  var USERWHITESPACABLE_TYPES = FLIPPED_ALIAS_KEYS["UserWhitespacable"];
  var METHOD_TYPES = FLIPPED_ALIAS_KEYS["Method"];
  var OBJECTMEMBER_TYPES = FLIPPED_ALIAS_KEYS["ObjectMember"];
  var PROPERTY_TYPES = FLIPPED_ALIAS_KEYS["Property"];
  var UNARYLIKE_TYPES = FLIPPED_ALIAS_KEYS["UnaryLike"];
  var PATTERN_TYPES = FLIPPED_ALIAS_KEYS["Pattern"];
  var CLASS_TYPES = FLIPPED_ALIAS_KEYS["Class"];
  var IMPORTOREXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"];
  var EXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS["ExportDeclaration"];
  var MODULESPECIFIER_TYPES = FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
  var PRIVATE_TYPES = FLIPPED_ALIAS_KEYS["Private"];
  var FLOW_TYPES = FLIPPED_ALIAS_KEYS["Flow"];
  var FLOWTYPE_TYPES = FLIPPED_ALIAS_KEYS["FlowType"];
  var FLOWBASEANNOTATION_TYPES = FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
  var FLOWDECLARATION_TYPES = FLIPPED_ALIAS_KEYS["FlowDeclaration"];
  var FLOWPREDICATE_TYPES = FLIPPED_ALIAS_KEYS["FlowPredicate"];
  var ENUMBODY_TYPES = FLIPPED_ALIAS_KEYS["EnumBody"];
  var ENUMMEMBER_TYPES = FLIPPED_ALIAS_KEYS["EnumMember"];
  var JSX_TYPES = FLIPPED_ALIAS_KEYS["JSX"];
  var MISCELLANEOUS_TYPES = FLIPPED_ALIAS_KEYS["Miscellaneous"];
  var ACCESSOR_TYPES = FLIPPED_ALIAS_KEYS["Accessor"];
  var TYPESCRIPT_TYPES = FLIPPED_ALIAS_KEYS["TypeScript"];
  var TSTYPEELEMENT_TYPES = FLIPPED_ALIAS_KEYS["TSTypeElement"];
  var TSTYPE_TYPES = FLIPPED_ALIAS_KEYS["TSType"];
  var TSBASETYPE_TYPES = FLIPPED_ALIAS_KEYS["TSBaseType"];
  var MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
  function toBlock(node, parent) {
    if (isBlockStatement(node)) {
      return node;
    }
    let blockNodes;
    if (isEmptyStatement(node)) {
      blockNodes = [];
    } else {
      if (!isStatement(node)) {
        if (isFunction(parent)) {
          node = returnStatement(node);
        } else {
          node = expressionStatement(node);
        }
      }
      blockNodes = [node];
    }
    return blockStatement(blockNodes);
  }
  function ensureBlock(node, key = "body") {
    const result = toBlock(node[key], node);
    node[key] = result;
    return result;
  }
  function toIdentifier(input) {
    input = input + "";
    let name = "";
    for (const c of input) {
      name += isIdentifierChar(c.codePointAt(0)) ? c : "-";
    }
    name = name.replace(/^[-0-9]+/, "");
    name = name.replace(/[-\s]+(.)?/g, function(match, c) {
      return c ? c.toUpperCase() : "";
    });
    if (!isValidIdentifier(name)) {
      name = `_${name}`;
    }
    return name || "_";
  }
  function toBindingIdentifierName(name) {
    name = toIdentifier(name);
    if (name === "eval" || name === "arguments") name = "_" + name;
    return name;
  }
  function toComputedKey(node, key = node.key || node.property) {
    if (!node.computed && isIdentifier(key)) key = stringLiteral(key.name);
    return key;
  }
  function toExpression(node) {
    if (isExpressionStatement(node)) {
      node = node.expression;
    }
    if (isExpression(node)) {
      return node;
    }
    if (isClass(node)) {
      node.type = "ClassExpression";
      node.abstract = false;
    } else if (isFunction(node)) {
      node.type = "FunctionExpression";
    }
    if (!isExpression(node)) {
      throw new Error(`cannot turn ${node.type} to an expression`);
    }
    return node;
  }
  var _skip = /* @__PURE__ */ Symbol();
  var _stop = /* @__PURE__ */ Symbol();
  function traverseFast(node, enter, opts) {
    if (!node) return false;
    const keys2 = VISITOR_KEYS[node.type];
    if (!keys2) return false;
    opts = opts || {};
    const ret = enter(node, opts);
    if (ret !== void 0) {
      switch (ret) {
        case _skip:
          return false;
        case _stop:
          return true;
      }
    }
    for (const key of keys2) {
      const subNode = node[key];
      if (!subNode) continue;
      if (Array.isArray(subNode)) {
        for (const node2 of subNode) {
          if (traverseFast(node2, enter, opts)) return true;
        }
      } else {
        if (traverseFast(subNode, enter, opts)) return true;
      }
    }
    return false;
  }
  traverseFast.skip = _skip;
  traverseFast.stop = _stop;
  var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
  var CLEAR_KEYS_PLUS_COMMENTS = [...COMMENT_KEYS, "comments", ...CLEAR_KEYS];
  function removeProperties(node, opts = {}) {
    const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
    for (const key of map) {
      if (node[key] != null) node[key] = void 0;
    }
    for (const key of Object.keys(node)) {
      if (key.startsWith("_") && node[key] != null) node[key] = void 0;
    }
    const symbols = Object.getOwnPropertySymbols(node);
    for (const sym of symbols) {
      node[sym] = null;
    }
  }
  function removePropertiesDeep(tree, opts) {
    traverseFast(tree, removeProperties, opts);
    return tree;
  }
  function toKeyAlias(node, key = node.key) {
    let alias2;
    if (node.kind === "method") {
      return toKeyAlias.increment() + "";
    } else if (isIdentifier(key)) {
      alias2 = key.name;
    } else if (isStringLiteral(key)) {
      alias2 = JSON.stringify(key.value);
    } else {
      alias2 = JSON.stringify(removePropertiesDeep(cloneNode(key)));
    }
    if (node.computed) {
      alias2 = `[${alias2}]`;
    }
    if (node.static) {
      alias2 = `static:${alias2}`;
    }
    return alias2;
  }
  toKeyAlias.uid = 0;
  toKeyAlias.increment = function() {
    if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
      return toKeyAlias.uid = 0;
    } else {
      return toKeyAlias.uid++;
    }
  };
  function toStatement(node, ignore) {
    if (isStatement(node)) {
      return node;
    }
    let mustHaveId = false;
    let newType;
    if (isClass(node)) {
      mustHaveId = true;
      newType = "ClassDeclaration";
    } else if (isFunction(node)) {
      mustHaveId = true;
      newType = "FunctionDeclaration";
    } else if (isAssignmentExpression(node)) {
      return expressionStatement(node);
    }
    if (mustHaveId && !node.id) {
      newType = false;
    }
    if (!newType) {
      if (ignore) {
        return false;
      } else {
        throw new Error(`cannot turn ${node.type} to a statement`);
      }
    }
    node.type = newType;
    return node;
  }
  var objectToString = Function.call.bind(Object.prototype.toString);
  function isRegExp(value) {
    return objectToString(value) === "[object RegExp]";
  }
  function isPlainObject(value) {
    if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") {
      return false;
    }
    const proto = Object.getPrototypeOf(value);
    return proto === null || Object.getPrototypeOf(proto) === null;
  }
  function valueToNode(value) {
    if (value === void 0) {
      return identifier("undefined");
    }
    if (value === true || value === false) {
      return booleanLiteral(value);
    }
    if (value === null) {
      return nullLiteral();
    }
    if (typeof value === "string") {
      return stringLiteral(value);
    }
    if (typeof value === "number") {
      let result;
      if (Number.isFinite(value)) {
        result = numericLiteral(Math.abs(value));
      } else {
        let numerator;
        if (Number.isNaN(value)) {
          numerator = numericLiteral(0);
        } else {
          numerator = numericLiteral(1);
        }
        result = binaryExpression("/", numerator, numericLiteral(0));
      }
      if (value < 0 || Object.is(value, -0)) {
        result = unaryExpression("-", result);
      }
      return result;
    }
    if (typeof value === "bigint") {
      if (value < 0) {
        return unaryExpression("-", bigIntLiteral(-value));
      } else {
        return bigIntLiteral(value);
      }
    }
    if (isRegExp(value)) {
      const pattern = value.source;
      const flags = /\/([a-z]*)$/.exec(value.toString())[1];
      return regExpLiteral(pattern, flags);
    }
    if (Array.isArray(value)) {
      return arrayExpression(value.map(valueToNode));
    }
    if (isPlainObject(value)) {
      const props = [];
      for (const key of Object.keys(value)) {
        let nodeKey, computed = false;
        if (isValidIdentifier(key)) {
          if (key === "__proto__") {
            computed = true;
            nodeKey = stringLiteral(key);
          } else {
            nodeKey = identifier(key);
          }
        } else {
          nodeKey = stringLiteral(key);
        }
        props.push(objectProperty(nodeKey, valueToNode(value[key]), computed));
      }
      return objectExpression(props);
    }
    throw new Error("don't know how to turn this value into a node");
  }
  function appendToMemberExpression(member, append, computed = false) {
    member.object = memberExpression(member.object, member.property, member.computed);
    member.property = append;
    member.computed = !!computed;
    return member;
  }
  function inherits(child, parent) {
    if (!child || !parent) return child;
    for (const key of INHERIT_KEYS.optional) {
      if (child[key] == null) {
        child[key] = parent[key];
      }
    }
    for (const key of Object.keys(parent)) {
      if (key.startsWith("_") && key !== "__clone") {
        child[key] = parent[key];
      }
    }
    for (const key of INHERIT_KEYS.force) {
      child[key] = parent[key];
    }
    inheritsComments(child, parent);
    return child;
  }
  function prependToMemberExpression(member, prepend) {
    if (isSuper(member.object)) {
      throw new Error("Cannot prepend node to super property access (`super.foo`).");
    }
    member.object = memberExpression(prepend, member.object);
    return member;
  }
  function getAssignmentIdentifiers(node) {
    const search = [].concat(node);
    const ids = /* @__PURE__ */ Object.create(null);
    while (search.length) {
      const id = search.pop();
      if (!id) continue;
      switch (id.type) {
        case "ArrayPattern":
          search.push(...id.elements);
          break;
        case "AssignmentExpression":
        case "AssignmentPattern":
        case "ForInStatement":
        case "ForOfStatement":
          search.push(id.left);
          break;
        case "ObjectPattern":
          search.push(...id.properties);
          break;
        case "ObjectProperty":
          search.push(id.value);
          break;
        case "RestElement":
        case "UpdateExpression":
          search.push(id.argument);
          break;
        case "UnaryExpression":
          if (id.operator === "delete") {
            search.push(id.argument);
          }
          break;
        case "Identifier":
          ids[id.name] = id;
          break;
      }
    }
    return ids;
  }
  function getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) {
    const search = [].concat(node);
    const ids = /* @__PURE__ */ Object.create(null);
    while (search.length) {
      const id = search.shift();
      if (!id) continue;
      if (newBindingsOnly && (isAssignmentExpression(id) || isUnaryExpression(id) || isUpdateExpression(id))) {
        continue;
      }
      if (isIdentifier(id)) {
        if (duplicates) {
          const _ids = ids[id.name] = ids[id.name] || [];
          _ids.push(id);
        } else {
          ids[id.name] = id;
        }
        continue;
      }
      if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {
        if (isDeclaration(id.declaration)) {
          search.push(id.declaration);
        }
        continue;
      }
      if (outerOnly) {
        if (isFunctionDeclaration(id)) {
          search.push(id.id);
          continue;
        }
        if (isFunctionExpression(id) || isClassExpression(id)) {
          continue;
        }
      }
      const keys2 = getBindingIdentifiers.keys[id.type];
      if (keys2) {
        for (let i = 0; i < keys2.length; i++) {
          const key = keys2[i];
          const nodes = id[key];
          if (nodes) {
            if (Array.isArray(nodes)) {
              search.push(...nodes);
            } else {
              search.push(nodes);
            }
          }
        }
      }
    }
    return ids;
  }
  var keys = {
    DeclareClass: ["id"],
    DeclareFunction: ["id"],
    DeclareModule: ["id"],
    DeclareVariable: ["id"],
    DeclareInterface: ["id"],
    DeclareTypeAlias: ["id"],
    DeclareOpaqueType: ["id"],
    InterfaceDeclaration: ["id"],
    TypeAlias: ["id"],
    OpaqueType: ["id"],
    CatchClause: ["param"],
    LabeledStatement: ["label"],
    UnaryExpression: ["argument"],
    AssignmentExpression: ["left"],
    ImportSpecifier: ["local"],
    ImportNamespaceSpecifier: ["local"],
    ImportDefaultSpecifier: ["local"],
    ImportDeclaration: ["specifiers"],
    TSImportEqualsDeclaration: ["id"],
    ExportSpecifier: ["exported"],
    ExportNamespaceSpecifier: ["exported"],
    ExportDefaultSpecifier: ["exported"],
    FunctionDeclaration: ["id", "params"],
    FunctionExpression: ["id", "params"],
    ArrowFunctionExpression: ["params"],
    ObjectMethod: ["params"],
    ClassMethod: ["params"],
    ClassPrivateMethod: ["params"],
    ForInStatement: ["left"],
    ForOfStatement: ["left"],
    ClassDeclaration: ["id"],
    ClassExpression: ["id"],
    RestElement: ["argument"],
    UpdateExpression: ["argument"],
    ObjectProperty: ["value"],
    AssignmentPattern: ["left"],
    ArrayPattern: ["elements"],
    ObjectPattern: ["properties"],
    VariableDeclaration: ["declarations"],
    VariableDeclarator: ["id"]
  };
  getBindingIdentifiers.keys = keys;
  function getOuterBindingIdentifiers(node, duplicates) {
    return getBindingIdentifiers(node, duplicates, true);
  }
  function getNameFromLiteralId(id) {
    if (isNullLiteral(id)) {
      return "null";
    }
    if (isRegExpLiteral(id)) {
      return `/${id.pattern}/${id.flags}`;
    }
    if (isTemplateLiteral(id)) {
      return id.quasis.map((quasi) => quasi.value.raw).join("");
    }
    if (id.value !== void 0) {
      return String(id.value);
    }
    return null;
  }
  function getObjectMemberKey(node) {
    if (!node.computed || isLiteral(node.key)) {
      return node.key;
    }
    return null;
  }
  function getFunctionName(node, parent) {
    if ("id" in node && node.id) {
      return {
        name: node.id.name,
        originalNode: node.id
      };
    }
    let prefix = "";
    let id;
    if (isObjectProperty(parent, {
      value: node
    })) {
      id = getObjectMemberKey(parent);
    } else if (isObjectMethod(node) || isClassMethod(node)) {
      id = getObjectMemberKey(node);
      if (node.kind === "get") prefix = "get ";
      else if (node.kind === "set") prefix = "set ";
    } else if (isVariableDeclarator(parent) && parent.init === node) {
      id = parent.id;
    } else if (isAssignmentExpression(parent, {
      operator: "=",
      right: node
    })) {
      id = parent.left;
    }
    if (!id) return null;
    const name = isLiteral(id) ? getNameFromLiteralId(id) : isIdentifier(id) ? id.name : isPrivateName(id) ? id.id.name : null;
    if (name == null) return null;
    return {
      name: prefix + name,
      originalNode: id
    };
  }
  function traverse(node, handlers, state) {
    if (typeof handlers === "function") {
      handlers = {
        enter: handlers
      };
    }
    const {
      enter,
      exit
    } = handlers;
    traverseSimpleImpl(node, enter, exit, state, []);
  }
  function traverseSimpleImpl(node, enter, exit, state, ancestors) {
    const keys2 = VISITOR_KEYS[node.type];
    if (!keys2) return;
    if (enter) enter(node, ancestors, state);
    for (const key of keys2) {
      const subNode = node[key];
      if (Array.isArray(subNode)) {
        for (let i = 0; i < subNode.length; i++) {
          const child = subNode[i];
          if (!child) continue;
          ancestors.push({
            node,
            key,
            index: i
          });
          traverseSimpleImpl(child, enter, exit, state, ancestors);
          ancestors.pop();
        }
      } else if (subNode) {
        ancestors.push({
          node,
          key
        });
        traverseSimpleImpl(subNode, enter, exit, state, ancestors);
        ancestors.pop();
      }
    }
    if (exit) exit(node, ancestors, state);
  }
  function isBinding(node, parent, grandparent) {
    if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") {
      return false;
    }
    const keys2 = getBindingIdentifiers.keys[parent.type];
    if (keys2) {
      for (let i = 0; i < keys2.length; i++) {
        const key = keys2[i];
        const val = parent[key];
        if (Array.isArray(val)) {
          if (val.includes(node)) return true;
        } else {
          if (val === node) return true;
        }
      }
    }
    return false;
  }
  function isLet(node) {
    return isVariableDeclaration(node) && node.kind !== "var";
  }
  function isBlockScoped(node) {
    return isFunctionDeclaration(node) || isClassDeclaration(node) || isLet(node);
  }
  function isImmutable(node) {
    if (isType(node.type, "Immutable")) return true;
    if (isIdentifier(node)) {
      if (node.name === "undefined") {
        return true;
      } else {
        return false;
      }
    }
    return false;
  }
  function isNodesEquivalent(a, b2) {
    if (typeof a !== "object" || typeof b2 !== "object" || a == null || b2 == null) {
      return a === b2;
    }
    if (a.type !== b2.type) {
      return false;
    }
    const fields = Object.keys(NODE_FIELDS$1[a.type] || a.type);
    const visitorKeys = VISITOR_KEYS[a.type];
    for (const field of fields) {
      const val_a = a[field];
      const val_b = b2[field];
      if (typeof val_a !== typeof val_b) {
        return false;
      }
      if (val_a == null && val_b == null) {
        continue;
      } else if (val_a == null || val_b == null) {
        return false;
      }
      if (Array.isArray(val_a)) {
        if (!Array.isArray(val_b)) {
          return false;
        }
        if (val_a.length !== val_b.length) {
          return false;
        }
        for (let i = 0; i < val_a.length; i++) {
          if (!isNodesEquivalent(val_a[i], val_b[i])) {
            return false;
          }
        }
        continue;
      }
      if (typeof val_a === "object" && !(visitorKeys == null ? void 0 : visitorKeys.includes(field))) {
        for (const key of Object.keys(val_a)) {
          if (val_a[key] !== val_b[key]) {
            return false;
          }
        }
        continue;
      }
      if (!isNodesEquivalent(val_a, val_b)) {
        return false;
      }
    }
    return true;
  }
  function isReferenced(node, parent, grandparent) {
    switch (parent.type) {
      case "MemberExpression":
      case "OptionalMemberExpression":
        if (parent.property === node) {
          return !!parent.computed;
        }
        return parent.object === node;
      case "JSXMemberExpression":
        return parent.object === node;
      case "VariableDeclarator":
        return parent.init === node;
      case "ArrowFunctionExpression":
        return parent.body === node;
      case "PrivateName":
        return false;
      case "ClassMethod":
      case "ClassPrivateMethod":
      case "ObjectMethod":
        if (parent.key === node) {
          return !!parent.computed;
        }
        return false;
      case "ObjectProperty":
        if (parent.key === node) {
          return !!parent.computed;
        }
        return (grandparent == null ? void 0 : grandparent.type) !== "ObjectPattern";
      case "ClassProperty":
      case "ClassAccessorProperty":
        if (parent.key === node) {
          return !!parent.computed;
        }
        return true;
      case "ClassPrivateProperty":
        return parent.key !== node;
      case "ClassDeclaration":
      case "ClassExpression":
        return parent.superClass === node;
      case "AssignmentExpression":
        return parent.right === node;
      case "AssignmentPattern":
        return parent.right === node;
      case "LabeledStatement":
        return false;
      case "CatchClause":
        return false;
      case "RestElement":
        return false;
      case "BreakStatement":
      case "ContinueStatement":
        return false;
      case "FunctionDeclaration":
      case "FunctionExpression":
        return false;
      case "ExportNamespaceSpecifier":
      case "ExportDefaultSpecifier":
        return false;
      case "ExportSpecifier":
        if (grandparent == null ? void 0 : grandparent.source) {
          return false;
        }
        return parent.local === node;
      case "ImportDefaultSpecifier":
      case "ImportNamespaceSpecifier":
      case "ImportSpecifier":
        return false;
      case "ImportAttribute":
        return false;
      case "JSXAttribute":
        return false;
      case "ObjectPattern":
      case "ArrayPattern":
        return false;
      case "MetaProperty":
        return false;
      case "ObjectTypeProperty":
        return parent.key !== node;
      case "TSEnumMember":
        return parent.id !== node;
      case "TSPropertySignature":
        if (parent.key === node) {
          return !!parent.computed;
        }
        return true;
    }
    return true;
  }
  function isScope(node, parent) {
    if (isBlockStatement(node) && (isFunction(parent) || isCatchClause(parent))) {
      return false;
    }
    if (isPattern(node) && (isFunction(parent) || isCatchClause(parent))) {
      return true;
    }
    return isScopable(node);
  }
  function isSpecifierDefault(specifier) {
    return isImportDefaultSpecifier(specifier) || isIdentifier(specifier.imported || specifier.exported, {
      name: "default"
    });
  }
  var RESERVED_WORDS_ES3_ONLY = /* @__PURE__ */ new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
  function isValidES3Identifier(name) {
    return isValidIdentifier(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
  }
  function isVar(node) {
    return isVariableDeclaration(node) && node.kind === "var";
  }
  var react = {
    isReactComponent,
    isCompatTag,
    buildChildren
  };

  // node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
  var comma = ",".charCodeAt(0);
  var semicolon = ";".charCodeAt(0);
  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var intToChar = new Uint8Array(64);
  var charToInt = new Uint8Array(128);
  for (let i = 0; i < chars.length; i++) {
    const c = chars.charCodeAt(i);
    intToChar[i] = c;
    charToInt[c] = i;
  }
  function decodeInteger(reader, relative) {
    let value = 0;
    let shift = 0;
    let integer = 0;
    do {
      const c = reader.next();
      integer = charToInt[c];
      value |= (integer & 31) << shift;
      shift += 5;
    } while (integer & 32);
    const shouldNegate = value & 1;
    value >>>= 1;
    if (shouldNegate) {
      value = -2147483648 | -value;
    }
    return relative + value;
  }
  function encodeInteger(builder, num, relative) {
    let delta = num - relative;
    delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
    do {
      let clamped = delta & 31;
      delta >>>= 5;
      if (delta > 0) clamped |= 32;
      builder.write(intToChar[clamped]);
    } while (delta > 0);
    return num;
  }
  function hasMoreVlq(reader, max) {
    if (reader.pos >= max) return false;
    return reader.peek() !== comma;
  }
  var bufLength = 1024 * 16;
  var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
    decode(buf) {
      const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
      return out.toString();
    }
  } : {
    decode(buf) {
      let out = "";
      for (let i = 0; i < buf.length; i++) {
        out += String.fromCharCode(buf[i]);
      }
      return out;
    }
  };
  var StringWriter = class {
    constructor() {
      this.pos = 0;
      this.out = "";
      this.buffer = new Uint8Array(bufLength);
    }
    write(v) {
      const { buffer } = this;
      buffer[this.pos++] = v;
      if (this.pos === bufLength) {
        this.out += td.decode(buffer);
        this.pos = 0;
      }
    }
    flush() {
      const { buffer, out, pos } = this;
      return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
    }
  };
  var StringReader = class {
    constructor(buffer) {
      this.pos = 0;
      this.buffer = buffer;
    }
    next() {
      return this.buffer.charCodeAt(this.pos++);
    }
    peek() {
      return this.buffer.charCodeAt(this.pos);
    }
    indexOf(char) {
      const { buffer, pos } = this;
      const idx = buffer.indexOf(char, pos);
      return idx === -1 ? buffer.length : idx;
    }
  };
  function decode(mappings) {
    const { length } = mappings;
    const reader = new StringReader(mappings);
    const decoded = [];
    let genColumn = 0;
    let sourcesIndex = 0;
    let sourceLine = 0;
    let sourceColumn = 0;
    let namesIndex = 0;
    do {
      const semi = reader.indexOf(";");
      const line = [];
      let sorted = true;
      let lastCol = 0;
      genColumn = 0;
      while (reader.pos < semi) {
        let seg;
        genColumn = decodeInteger(reader, genColumn);
        if (genColumn < lastCol) sorted = false;
        lastCol = genColumn;
        if (hasMoreVlq(reader, semi)) {
          sourcesIndex = decodeInteger(reader, sourcesIndex);
          sourceLine = decodeInteger(reader, sourceLine);
          sourceColumn = decodeInteger(reader, sourceColumn);
          if (hasMoreVlq(reader, semi)) {
            namesIndex = decodeInteger(reader, namesIndex);
            seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
          } else {
            seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
          }
        } else {
          seg = [genColumn];
        }
        line.push(seg);
        reader.pos++;
      }
      if (!sorted) sort(line);
      decoded.push(line);
      reader.pos = semi + 1;
    } while (reader.pos <= length);
    return decoded;
  }
  function sort(line) {
    line.sort(sortComparator);
  }
  function sortComparator(a, b2) {
    return a[0] - b2[0];
  }
  function encode(decoded) {
    const writer = new StringWriter();
    let sourcesIndex = 0;
    let sourceLine = 0;
    let sourceColumn = 0;
    let namesIndex = 0;
    for (let i = 0; i < decoded.length; i++) {
      const line = decoded[i];
      if (i > 0) writer.write(semicolon);
      if (line.length === 0) continue;
      let genColumn = 0;
      for (let j = 0; j < line.length; j++) {
        const segment = line[j];
        if (j > 0) writer.write(comma);
        genColumn = encodeInteger(writer, segment[0], genColumn);
        if (segment.length === 1) continue;
        sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
        sourceLine = encodeInteger(writer, segment[2], sourceLine);
        sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
        if (segment.length === 4) continue;
        namesIndex = encodeInteger(writer, segment[4], namesIndex);
      }
    }
    return writer.flush();
  }

  // node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
  var import_resolve_uri = __toESM(require_resolve_uri_umd(), 1);
  function stripFilename(path) {
    if (!path) return "";
    const index2 = path.lastIndexOf("/");
    return path.slice(0, index2 + 1);
  }
  function resolver(mapUrl, sourceRoot) {
    const from = stripFilename(mapUrl);
    const prefix = sourceRoot ? sourceRoot + "/" : "";
    return (source) => (0, import_resolve_uri.default)(prefix + (source || ""), from);
  }
  var COLUMN = 0;
  var SOURCES_INDEX = 1;
  var SOURCE_LINE = 2;
  var SOURCE_COLUMN = 3;
  var NAMES_INDEX = 4;
  function maybeSort(mappings, owned) {
    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
    if (unsortedIndex === mappings.length) return mappings;
    if (!owned) mappings = mappings.slice();
    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
      mappings[i] = sortSegments(mappings[i], owned);
    }
    return mappings;
  }
  function nextUnsortedSegmentLine(mappings, start) {
    for (let i = start; i < mappings.length; i++) {
      if (!isSorted(mappings[i])) return i;
    }
    return mappings.length;
  }
  function isSorted(line) {
    for (let j = 1; j < line.length; j++) {
      if (line[j][COLUMN] < line[j - 1][COLUMN]) {
        return false;
      }
    }
    return true;
  }
  function sortSegments(line, owned) {
    if (!owned) line = line.slice();
    return line.sort(sortComparator2);
  }
  function sortComparator2(a, b2) {
    return a[COLUMN] - b2[COLUMN];
  }
  var found = false;
  function binarySearch(haystack, needle, low, high) {
    while (low <= high) {
      const mid = low + (high - low >> 1);
      const cmp = haystack[mid][COLUMN] - needle;
      if (cmp === 0) {
        found = true;
        return mid;
      }
      if (cmp < 0) {
        low = mid + 1;
      } else {
        high = mid - 1;
      }
    }
    found = false;
    return low - 1;
  }
  function upperBound(haystack, needle, index2) {
    for (let i = index2 + 1; i < haystack.length; index2 = i++) {
      if (haystack[i][COLUMN] !== needle) break;
    }
    return index2;
  }
  function lowerBound(haystack, needle, index2) {
    for (let i = index2 - 1; i >= 0; index2 = i--) {
      if (haystack[i][COLUMN] !== needle) break;
    }
    return index2;
  }
  function memoizedState() {
    return {
      lastKey: -1,
      lastNeedle: -1,
      lastIndex: -1
    };
  }
  function memoizedBinarySearch(haystack, needle, state, key) {
    const { lastKey, lastNeedle, lastIndex } = state;
    let low = 0;
    let high = haystack.length - 1;
    if (key === lastKey) {
      if (needle === lastNeedle) {
        found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
        return lastIndex;
      }
      if (needle >= lastNeedle) {
        low = lastIndex === -1 ? 0 : lastIndex;
      } else {
        high = lastIndex;
      }
    }
    state.lastKey = key;
    state.lastNeedle = needle;
    return state.lastIndex = binarySearch(haystack, needle, low, high);
  }
  function parse(map) {
    return typeof map === "string" ? JSON.parse(map) : map;
  }
  var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
  var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
  var LEAST_UPPER_BOUND = -1;
  var GREATEST_LOWER_BOUND = 1;
  var TraceMap = class {
    constructor(map, mapUrl) {
      const isString = typeof map === "string";
      if (!isString && map._decodedMemo) return map;
      const parsed = parse(map);
      const { version, file: file2, names, sourceRoot, sources, sourcesContent } = parsed;
      this.version = version;
      this.file = file2;
      this.names = names || [];
      this.sourceRoot = sourceRoot;
      this.sources = sources;
      this.sourcesContent = sourcesContent;
      this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
      const resolve = resolver(mapUrl, sourceRoot);
      this.resolvedSources = sources.map(resolve);
      const { mappings } = parsed;
      if (typeof mappings === "string") {
        this._encoded = mappings;
        this._decoded = void 0;
      } else if (Array.isArray(mappings)) {
        this._encoded = void 0;
        this._decoded = maybeSort(mappings, isString);
      } else if (parsed.sections) {
        throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
      } else {
        throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
      }
      this._decodedMemo = memoizedState();
      this._bySources = void 0;
      this._bySourceMemos = void 0;
    }
  };
  function cast(map) {
    return map;
  }
  function decodedMappings(map) {
    var _a;
    return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
  }
  function originalPositionFor(map, needle) {
    let { line, column, bias } = needle;
    line--;
    if (line < 0) throw new Error(LINE_GTR_ZERO);
    if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
    const decoded = decodedMappings(map);
    if (line >= decoded.length) return OMapping(null, null, null, null);
    const segments = decoded[line];
    const index2 = traceSegmentInternal(
      segments,
      cast(map)._decodedMemo,
      line,
      column,
      bias || GREATEST_LOWER_BOUND
    );
    if (index2 === -1) return OMapping(null, null, null, null);
    const segment = segments[index2];
    if (segment.length === 1) return OMapping(null, null, null, null);
    const { names, resolvedSources } = map;
    return OMapping(
      resolvedSources[segment[SOURCES_INDEX]],
      segment[SOURCE_LINE] + 1,
      segment[SOURCE_COLUMN],
      segment.length === 5 ? names[segment[NAMES_INDEX]] : null
    );
  }
  function OMapping(source, line, column, name) {
    return { source, line, column, name };
  }
  function traceSegmentInternal(segments, memo, line, column, bias) {
    let index2 = memoizedBinarySearch(segments, column, memo, line);
    if (found) {
      index2 = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index2);
    } else if (bias === LEAST_UPPER_BOUND) index2++;
    if (index2 === -1 || index2 === segments.length) return -1;
    return index2;
  }

  // node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
  var SetArray = class {
    constructor() {
      this._indexes = { __proto__: null };
      this.array = [];
    }
  };
  function cast2(set) {
    return set;
  }
  function get(setarr, key) {
    return cast2(setarr)._indexes[key];
  }
  function put(setarr, key) {
    const index2 = get(setarr, key);
    if (index2 !== void 0) return index2;
    const { array, _indexes: indexes } = cast2(setarr);
    const length = array.push(key);
    return indexes[key] = length - 1;
  }
  var COLUMN2 = 0;
  var SOURCES_INDEX2 = 1;
  var SOURCE_LINE2 = 2;
  var SOURCE_COLUMN2 = 3;
  var NAMES_INDEX2 = 4;
  var NO_NAME = -1;
  var GenMapping = class {
    constructor({ file: file2, sourceRoot } = {}) {
      this._names = new SetArray();
      this._sources = new SetArray();
      this._sourcesContent = [];
      this._mappings = [];
      this.file = file2;
      this.sourceRoot = sourceRoot;
      this._ignoreList = new SetArray();
    }
  };
  function cast22(map) {
    return map;
  }
  var maybeAddMapping = (map, mapping) => {
    return addMappingInternal(true, map, mapping);
  };
  function setSourceContent(map, source, content) {
    const {
      _sources: sources,
      _sourcesContent: sourcesContent
      // _originalScopes: originalScopes,
    } = cast22(map);
    const index2 = put(sources, source);
    sourcesContent[index2] = content;
  }
  function toDecodedMap(map) {
    const {
      _mappings: mappings,
      _sources: sources,
      _sourcesContent: sourcesContent,
      _names: names,
      _ignoreList: ignoreList
      // _originalScopes: originalScopes,
      // _generatedRanges: generatedRanges,
    } = cast22(map);
    removeEmptyFinalLines(mappings);
    return {
      version: 3,
      file: map.file || void 0,
      names: names.array,
      sourceRoot: map.sourceRoot || void 0,
      sources: sources.array,
      sourcesContent,
      mappings,
      // originalScopes,
      // generatedRanges,
      ignoreList: ignoreList.array
    };
  }
  function toEncodedMap(map) {
    const decoded = toDecodedMap(map);
    return Object.assign({}, decoded, {
      // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
      // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
      mappings: encode(decoded.mappings)
    });
  }
  function allMappings(map) {
    const out = [];
    const { _mappings: mappings, _sources: sources, _names: names } = cast22(map);
    for (let i = 0; i < mappings.length; i++) {
      const line = mappings[i];
      for (let j = 0; j < line.length; j++) {
        const seg = line[j];
        const generated = { line: i + 1, column: seg[COLUMN2] };
        let source = void 0;
        let original = void 0;
        let name = void 0;
        if (seg.length !== 1) {
          source = sources.array[seg[SOURCES_INDEX2]];
          original = { line: seg[SOURCE_LINE2] + 1, column: seg[SOURCE_COLUMN2] };
          if (seg.length === 5) name = names.array[seg[NAMES_INDEX2]];
        }
        out.push({ generated, source, original, name });
      }
    }
    return out;
  }
  function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
    const {
      _mappings: mappings,
      _sources: sources,
      _sourcesContent: sourcesContent,
      _names: names
      // _originalScopes: originalScopes,
    } = cast22(map);
    const line = getIndex(mappings, genLine);
    const index2 = getColumnIndex(line, genColumn);
    if (!source) {
      if (skipable && skipSourceless(line, index2)) return;
      return insert(line, index2, [genColumn]);
    }
    assert2(sourceLine);
    assert2(sourceColumn);
    const sourcesIndex = put(sources, source);
    const namesIndex = name ? put(names, name) : NO_NAME;
    if (sourcesIndex === sourcesContent.length) sourcesContent[sourcesIndex] = content != null ? content : null;
    if (skipable && skipSource(line, index2, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
      return;
    }
    return insert(
      line,
      index2,
      name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
    );
  }
  function assert2(_val) {
  }
  function getIndex(arr, index2) {
    for (let i = arr.length; i <= index2; i++) {
      arr[i] = [];
    }
    return arr[index2];
  }
  function getColumnIndex(line, genColumn) {
    let index2 = line.length;
    for (let i = index2 - 1; i >= 0; index2 = i--) {
      const current = line[i];
      if (genColumn >= current[COLUMN2]) break;
    }
    return index2;
  }
  function insert(array, index2, value) {
    for (let i = array.length; i > index2; i--) {
      array[i] = array[i - 1];
    }
    array[index2] = value;
  }
  function removeEmptyFinalLines(mappings) {
    const { length } = mappings;
    let len = length;
    for (let i = len - 1; i >= 0; len = i, i--) {
      if (mappings[i].length > 0) break;
    }
    if (len < length) mappings.length = len;
  }
  function skipSourceless(line, index2) {
    if (index2 === 0) return true;
    const prev = line[index2 - 1];
    return prev.length === 1;
  }
  function skipSource(line, index2, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
    if (index2 === 0) return false;
    const prev = line[index2 - 1];
    if (prev.length === 1) return false;
    return sourcesIndex === prev[SOURCES_INDEX2] && sourceLine === prev[SOURCE_LINE2] && sourceColumn === prev[SOURCE_COLUMN2] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX2] : NO_NAME);
  }
  function addMappingInternal(skipable, map, mapping) {
    const { generated, source, original, name, content } = mapping;
    if (!source) {
      return addSegmentInternal(
        skipable,
        map,
        generated.line - 1,
        generated.column,
        null,
        null,
        null,
        null,
        null
      );
    }
    assert2(original);
    return addSegmentInternal(
      skipable,
      map,
      generated.line - 1,
      generated.column,
      source,
      original.line - 1,
      original.column,
      name,
      content
    );
  }

  // node_modules/@babel/generator/lib/index.js
  var import_jsesc = __toESM(require_jsesc(), 1);
  var SourceMap = class {
    constructor(opts, code) {
      __publicField(this, "_map");
      __publicField(this, "_rawMappings");
      __publicField(this, "_sourceFileName");
      __publicField(this, "_lastGenLine", 0);
      __publicField(this, "_lastSourceLine", 0);
      __publicField(this, "_lastSourceColumn", 0);
      __publicField(this, "_inputMap", null);
      var _a, _b;
      const map = this._map = new GenMapping({
        sourceRoot: opts.sourceRoot
      });
      this._sourceFileName = (_a = opts.sourceFileName) == null ? void 0 : _a.replace(/\\/g, "/");
      this._rawMappings = void 0;
      if (opts.inputSourceMap) {
        this._inputMap = new TraceMap(opts.inputSourceMap);
        const resolvedSources = this._inputMap.resolvedSources;
        if (resolvedSources.length) {
          for (let i = 0; i < resolvedSources.length; i++) {
            setSourceContent(map, resolvedSources[i], (_b = this._inputMap.sourcesContent) == null ? void 0 : _b[i]);
          }
        }
      }
      if (typeof code === "string" && !opts.inputSourceMap) {
        setSourceContent(map, this._sourceFileName, code);
      } else if (typeof code === "object") {
        for (const sourceFileName of Object.keys(code)) {
          setSourceContent(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
        }
      }
    }
    get() {
      return toEncodedMap(this._map);
    }
    getDecoded() {
      return toDecodedMap(this._map);
    }
    getRawMappings() {
      return this._rawMappings || (this._rawMappings = allMappings(this._map));
    }
    mark(generated, generatedIdentifierName, line, column, identifierName, identifierNamePos, filename) {
      this._rawMappings = void 0;
      let originalMapping;
      if (line != null) {
        if (this._inputMap) {
          originalMapping = originalPositionFor(this._inputMap, {
            line,
            column
          });
          if (originalMapping.name && (identifierNamePos || identifierName != null && originalMapping.column === column)) {
            identifierName = originalMapping.name;
          } else if (identifierNamePos) {
            const originalIdentifierMapping = originalPositionFor(this._inputMap, identifierNamePos);
            if (originalIdentifierMapping.name) {
              identifierName = originalIdentifierMapping.name;
            }
          }
        } else {
          originalMapping = {
            name: null,
            source: (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName,
            line,
            column
          };
        }
      }
      if (identifierName != null && identifierName === generatedIdentifierName) {
        identifierName = null;
      }
      maybeAddMapping(this._map, {
        name: identifierName,
        generated,
        source: originalMapping == null ? void 0 : originalMapping.source,
        original: originalMapping
      });
    }
  };
  var spaceIndents = [];
  for (let i = 0; i < 32; i++) {
    spaceIndents.push(" ".repeat(i * 2));
  }
  var Buffer2 = class {
    constructor(map, indentChar) {
      __publicField(this, "_map", null);
      __publicField(this, "_buf", "");
      __publicField(this, "_str", "");
      __publicField(this, "_appendCount", 0);
      __publicField(this, "_last", 0);
      __publicField(this, "_canMarkIdName", true);
      __publicField(this, "_indentChar", "");
      __publicField(this, "_queuedChar", 0);
      __publicField(this, "_position", {
        line: 1,
        column: 0
      });
      __publicField(this, "_sourcePosition", {
        identifierName: void 0,
        identifierNamePos: void 0,
        line: void 0,
        column: void 0,
        filename: void 0
      });
      this._map = map;
      this._indentChar = indentChar;
    }
    get() {
      const {
        _map,
        _last
      } = this;
      if (this._queuedChar !== 32) {
        this._flush();
      }
      const code = _last === 10 ? (this._buf + this._str).trimRight() : this._buf + this._str;
      if (_map === null) {
        return {
          code,
          decodedMap: void 0,
          map: null,
          rawMappings: void 0
        };
      }
      const result = {
        code,
        decodedMap: _map.getDecoded(),
        get map() {
          const resultMap = _map.get();
          result.map = resultMap;
          return resultMap;
        },
        set map(value) {
          Object.defineProperty(result, "map", {
            value,
            writable: true
          });
        },
        get rawMappings() {
          const mappings = _map.getRawMappings();
          result.rawMappings = mappings;
          return mappings;
        },
        set rawMappings(value) {
          Object.defineProperty(result, "rawMappings", {
            value,
            writable: true
          });
        }
      };
      return result;
    }
    append(str, maybeNewline, ignoreMapping = false) {
      this._flush();
      this._append(str, maybeNewline, ignoreMapping);
    }
    appendChar(char) {
      this._flush();
      this._appendChar(char, 1, true);
    }
    queue(char) {
      this._flush();
      this._queuedChar = char;
    }
    _flush() {
      const queuedChar = this._queuedChar;
      if (queuedChar !== 0) {
        this._appendChar(queuedChar, 1, true);
        this._queuedChar = 0;
      }
    }
    _appendChar(char, repeat, useSourcePos) {
      this._last = char;
      if (char === -1) {
        const indent = repeat >= 64 ? this._indentChar.repeat(repeat) : spaceIndents[repeat / 2];
        this._str += indent;
      } else {
        this._str += repeat > 1 ? String.fromCharCode(char).repeat(repeat) : String.fromCharCode(char);
      }
      const isSpace = char === 32;
      const position = this._position;
      if (char !== 10) {
        if (this._map) {
          const sourcePos = this._sourcePosition;
          if (useSourcePos && sourcePos) {
            this._map.mark(position, null, sourcePos.line, sourcePos.column, isSpace ? void 0 : sourcePos.identifierName, isSpace ? void 0 : sourcePos.identifierNamePos, sourcePos.filename);
            if (!isSpace && this._canMarkIdName) {
              sourcePos.identifierName = void 0;
              sourcePos.identifierNamePos = void 0;
            }
          } else {
            this._map.mark(position, null);
          }
        }
        position.column += repeat;
      } else {
        position.line++;
        position.column = 0;
      }
    }
    _append(str, maybeNewline, ignoreMapping) {
      const len = str.length;
      const position = this._position;
      const sourcePos = this._sourcePosition;
      this._last = -1;
      if (++this._appendCount > 4096) {
        +this._str;
        this._buf += this._str;
        this._str = str;
        this._appendCount = 0;
      } else {
        this._str += str;
      }
      const hasMap = !ignoreMapping && this._map !== null;
      if (!maybeNewline && !hasMap) {
        position.column += len;
        return;
      }
      const {
        column,
        identifierName,
        identifierNamePos,
        filename
      } = sourcePos;
      let line = sourcePos.line;
      if ((identifierName != null || identifierNamePos != null) && this._canMarkIdName) {
        sourcePos.identifierName = void 0;
        sourcePos.identifierNamePos = void 0;
      }
      let i = str.indexOf("\n");
      let last = 0;
      if (hasMap && i !== 0) {
        this._map.mark(position, str, line, column, identifierName, identifierNamePos, filename);
      }
      while (i !== -1) {
        position.line++;
        position.column = 0;
        last = i + 1;
        if (last < len && line !== void 0) {
          line++;
          if (hasMap) {
            this._map.mark(position, str, line, 0, void 0, void 0, filename);
          }
        }
        i = str.indexOf("\n", last);
      }
      position.column += len - last;
    }
    removeLastSemicolon() {
      if (this._queuedChar === 59) {
        this._queuedChar = 0;
      }
    }
    getLastChar(checkQueue) {
      if (!checkQueue) {
        return this._last;
      }
      const queuedChar = this._queuedChar;
      return queuedChar !== 0 ? queuedChar : this._last;
    }
    getNewlineCount() {
      return this._queuedChar === 0 && this._last === 10 ? 1 : 0;
    }
    hasContent() {
      return this._last !== 0;
    }
    exactSource(loc, cb) {
      if (!this._map) {
        cb();
        return;
      }
      this.source("start", loc);
      const identifierName = loc.identifierName;
      const sourcePos = this._sourcePosition;
      if (identifierName != null) {
        this._canMarkIdName = false;
        sourcePos.identifierName = identifierName;
      }
      cb();
      if (identifierName != null) {
        this._canMarkIdName = true;
        sourcePos.identifierName = void 0;
        sourcePos.identifierNamePos = void 0;
      }
      this.source("end", loc);
    }
    source(prop, loc) {
      if (!this._map) return;
      this._normalizePosition(prop, loc, 0);
    }
    sourceWithOffset(prop, loc, columnOffset) {
      if (!this._map) return;
      this._normalizePosition(prop, loc, columnOffset);
    }
    _normalizePosition(prop, loc, columnOffset) {
      this._flush();
      const pos = loc[prop];
      if (pos) {
        this.setSourcePosition(pos.line, Math.max(pos.column + columnOffset, 0));
        this._sourcePosition.filename = loc.filename;
      }
    }
    setSourcePosition(line, column) {
      const target = this._sourcePosition;
      target.line = line;
      target.column = column;
    }
    getCurrentColumn() {
      return this._position.column + (this._queuedChar ? 1 : 0);
    }
    getCurrentLine() {
      return this._position.line;
    }
  };
  var {
    isMemberExpression: isMemberExpression$1,
    isOptionalMemberExpression: isOptionalMemberExpression2,
    isYieldExpression: isYieldExpression2,
    isStatement: isStatement$4
  } = lib_exports;
  var PRECEDENCE = /* @__PURE__ */ new Map([["||", 0], ["??", 1], ["&&", 2], ["|", 3], ["^", 4], ["&", 5], ["==", 6], ["===", 6], ["!=", 6], ["!==", 6], ["<", 7], [">", 7], ["<=", 7], [">=", 7], ["in", 7], ["instanceof", 7], [">>", 8], ["<<", 8], [">>>", 8], ["+", 9], ["-", 9], ["*", 10], ["/", 10], ["%", 10], ["**", 11]]);
  function isTSTypeExpression(nodeId) {
    return nodeId === 154 || nodeId === 199 || nodeId === 207;
  }
  var isClassExtendsClause = (node, parent, parentId) => {
    return (parentId === 22 || parentId === 23) && parent.superClass === node;
  };
  var hasPostfixPart = (node, parent, parentId) => {
    switch (parentId) {
      case 109:
      case 133:
        return parent.object === node;
      case 18:
      case 131:
      case 113:
        return parent.callee === node;
      case 220:
        return parent.tag === node;
      case 189:
        return true;
    }
    return false;
  };
  function NullableTypeAnnotation$1(node, parent, parentId) {
    return parentId === 4;
  }
  function FunctionTypeAnnotation$1(node, parent, parentId, tokenContext) {
    return parentId === 237 || parentId === 91 || parentId === 4 || (tokenContext & 8) > 0;
  }
  function UpdateExpression$1(node, parent, parentId) {
    return hasPostfixPart(node, parent, parentId) || isClassExtendsClause(node, parent, parentId);
  }
  function needsParenBeforeExpressionBrace(tokenContext) {
    return (tokenContext & (1 | 2)) > 0;
  }
  function ObjectExpression$1(node, parent, parentId, tokenContext) {
    return needsParenBeforeExpressionBrace(tokenContext);
  }
  function DoExpression$1(node, parent, parentId, tokenContext) {
    return (tokenContext & 1) > 0 && !node.async;
  }
  function BinaryLike(node, parent, parentId, nodeType) {
    if (isClassExtendsClause(node, parent, parentId)) {
      return true;
    }
    if (hasPostfixPart(node, parent, parentId) || parentId === 236 || parentId === 143 || parentId === 8) {
      return true;
    }
    let parentPos;
    switch (parentId) {
      case 11:
      case 108:
        parentPos = PRECEDENCE.get(parent.operator);
        break;
      case 154:
      case 199:
        parentPos = 7;
    }
    if (parentPos !== void 0) {
      const nodePos = nodeType === 2 ? 7 : PRECEDENCE.get(node.operator);
      if (parentPos > nodePos) return true;
      if (parentPos === nodePos && parentId === 11 && (nodePos === 11 ? parent.left === node : parent.right === node)) {
        return true;
      }
      if (nodeType === 1 && parentId === 108 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) {
        return true;
      }
    }
    return false;
  }
  function UnionTypeAnnotation$1(node, parent, parentId) {
    switch (parentId) {
      case 4:
      case 116:
      case 91:
      case 237:
        return true;
    }
    return false;
  }
  function OptionalIndexedAccessType$1(node, parent, parentId) {
    return parentId === 85 && parent.objectType === node;
  }
  function TSAsExpression$1(node, parent, parentId) {
    if ((parentId === 6 || parentId === 7) && parent.left === node) {
      return true;
    }
    if (parentId === 11 && (parent.operator === "|" || parent.operator === "&") && node === parent.left) {
      return true;
    }
    return BinaryLike(node, parent, parentId, 2);
  }
  function TSConditionalType$1(node, parent, parentId) {
    switch (parentId) {
      case 153:
      case 193:
      case 209:
      case 210:
      case 179:
      case 217:
        return true;
      case 173:
        return parent.objectType === node;
      case 159:
        return parent.checkType === node || parent.extendsType === node;
    }
    return false;
  }
  function TSUnionType$1(node, parent, parentId) {
    switch (parentId) {
      case 179:
      case 209:
      case 153:
      case 193:
        return true;
      case 173:
        return parent.objectType === node;
    }
    return false;
  }
  function TSIntersectionType$1(node, parent, parentId) {
    return parentId === 209 || TSTypeOperator$1(node, parent, parentId);
  }
  function TSInferType$1(node, parent, parentId) {
    if (TSTypeOperator$1(node, parent, parentId)) {
      return true;
    }
    if ((parentId === 179 || parentId === 217) && node.typeParameter.constraint != null) {
      return true;
    }
    return false;
  }
  function TSTypeOperator$1(node, parent, parentId) {
    switch (parentId) {
      case 153:
      case 193:
        return true;
      case 173:
        if (parent.objectType === node) {
          return true;
        }
    }
    return false;
  }
  function TSInstantiationExpression$1(node, parent, parentId) {
    switch (parentId) {
      case 18:
      case 131:
      case 113:
      case 175:
        return parent.typeArguments != null;
    }
    return false;
  }
  function TSFunctionType$1(node, parent, parentId) {
    if (TSUnionType$1(node, parent, parentId)) return true;
    return parentId === 217 || parentId === 159 && (parent.checkType === node || parent.extendsType === node);
  }
  function BinaryExpression$1(node, parent, parentId, tokenContext) {
    if (BinaryLike(node, parent, parentId, 0)) return true;
    return (tokenContext & 128) > 0 && node.operator === "in";
  }
  function LogicalExpression2(node, parent, parentId) {
    return BinaryLike(node, parent, parentId, 1);
  }
  function SequenceExpression$1(node, parent, parentId) {
    if (parentId === 142 || parentId === 134 || parentId === 109 && parent.property === node || parentId === 133 && parent.property === node || parentId === 222) {
      return false;
    }
    if (parentId === 22) {
      return true;
    }
    if (parentId === 69) {
      return parent.right === node;
    }
    if (parentId === 61) {
      return true;
    }
    return !isStatement$4(parent);
  }
  function YieldExpression$1(node, parent, parentId) {
    return parentId === 11 || parentId === 108 || parentId === 236 || parentId === 143 || hasPostfixPart(node, parent, parentId) || parentId === 8 && isYieldExpression2(node) || parentId === 29 && node === parent.test || isClassExtendsClause(node, parent, parentId) || isTSTypeExpression(parentId);
  }
  function ClassExpression2(node, parent, parentId, tokenContext) {
    return (tokenContext & (1 | 4)) > 0;
  }
  function UnaryLike(node, parent, parentId) {
    return hasPostfixPart(node, parent, parentId) || parentId === 11 && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent, parentId);
  }
  function FunctionExpression$1(node, parent, parentId, tokenContext) {
    return (tokenContext & (1 | 4)) > 0;
  }
  function ConditionalExpression$1(node, parent, parentId) {
    switch (parentId) {
      case 236:
      case 143:
      case 11:
      case 108:
      case 8:
        return true;
      case 29:
        if (parent.test === node) {
          return true;
        }
    }
    if (isTSTypeExpression(parentId)) {
      return true;
    }
    return UnaryLike(node, parent, parentId);
  }
  function OptionalMemberExpression$1(node, parent, parentId) {
    switch (parentId) {
      case 18:
        return parent.callee === node;
      case 109:
        return parent.object === node;
    }
    return false;
  }
  function AssignmentExpression$1(node, parent, parentId, tokenContext) {
    if (needsParenBeforeExpressionBrace(tokenContext) && node.left.type === "ObjectPattern") {
      return true;
    }
    return ConditionalExpression$1(node, parent, parentId);
  }
  function Identifier$1(node, parent, parentId, tokenContext, getRawIdentifier) {
    var _a;
    if (getRawIdentifier && getRawIdentifier(node) !== node.name) {
      return false;
    }
    if (parentId === 6 && ((_a = node.extra) == null ? void 0 : _a.parenthesized) && parent.left === node) {
      const rightType = parent.right.type;
      if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) {
        return true;
      }
    }
    if (tokenContext & 64 || (parentId === 109 || parentId === 133) && tokenContext & (1 | 16 | 32)) {
      if (node.name === "let") {
        const isFollowedByBracket = isMemberExpression$1(parent, {
          object: node,
          computed: true
        }) || isOptionalMemberExpression2(parent, {
          object: node,
          computed: true,
          optional: false
        });
        if (isFollowedByBracket && tokenContext & (1 | 16 | 32)) {
          return true;
        }
        return (tokenContext & 64) > 0;
      }
    }
    return parentId === 69 && parent.left === node && node.name === "async" && !parent.await;
  }
  var parens = /* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    ArrowFunctionExpression: ConditionalExpression$1,
    AssignmentExpression: AssignmentExpression$1,
    AwaitExpression: YieldExpression$1,
    BinaryExpression: BinaryExpression$1,
    ClassExpression: ClassExpression2,
    ConditionalExpression: ConditionalExpression$1,
    DoExpression: DoExpression$1,
    FunctionExpression: FunctionExpression$1,
    FunctionTypeAnnotation: FunctionTypeAnnotation$1,
    Identifier: Identifier$1,
    IntersectionTypeAnnotation: UnionTypeAnnotation$1,
    LogicalExpression: LogicalExpression2,
    NullableTypeAnnotation: NullableTypeAnnotation$1,
    ObjectExpression: ObjectExpression$1,
    OptionalCallExpression: OptionalMemberExpression$1,
    OptionalIndexedAccessType: OptionalIndexedAccessType$1,
    OptionalMemberExpression: OptionalMemberExpression$1,
    SequenceExpression: SequenceExpression$1,
    SpreadElement: UnaryLike,
    TSAsExpression: TSAsExpression$1,
    TSConditionalType: TSConditionalType$1,
    TSConstructorType: TSFunctionType$1,
    TSFunctionType: TSFunctionType$1,
    TSInferType: TSInferType$1,
    TSInstantiationExpression: TSInstantiationExpression$1,
    TSIntersectionType: TSIntersectionType$1,
    TSSatisfiesExpression: TSAsExpression$1,
    TSTypeAssertion: UnaryLike,
    TSTypeOperator: TSTypeOperator$1,
    TSUnionType: TSUnionType$1,
    UnaryExpression: UnaryLike,
    UnionTypeAnnotation: UnionTypeAnnotation$1,
    UpdateExpression: UpdateExpression$1,
    YieldExpression: YieldExpression$1
  }, Symbol.toStringTag, {
    value: "Module"
  });
  function TaggedTemplateExpression2(node) {
    this.print(node.tag);
    this.print(node.typeArguments);
    this.print(node.quasi);
  }
  function TemplateElement2() {
    throw new Error("TemplateElement printing is handled in TemplateLiteral");
  }
  function _printTemplate(node, substitutions) {
    const quasis = node.quasis;
    let partRaw = "`";
    for (let i = 0; i < quasis.length - 1; i++) {
      partRaw += quasis[i].value.raw;
      this.token(partRaw + "${", true);
      this.print(substitutions[i]);
      partRaw = "}";
    }
    partRaw += quasis[quasis.length - 1].value.raw;
    this.token(partRaw + "`", true);
  }
  function TemplateLiteral2(node) {
    _printTemplate.call(this, node, node.expressions);
  }
  var {
    isCallExpression: isCallExpression2,
    isLiteral: isLiteral2,
    isMemberExpression: isMemberExpression2,
    isNewExpression: isNewExpression2,
    isPattern: isPattern2
  } = lib_exports;
  function UnaryExpression2(node) {
    const {
      operator
    } = node;
    const firstChar = operator.charCodeAt(0);
    if (firstChar >= 97 && firstChar <= 122) {
      this.word(operator);
      this.space();
    } else {
      this.tokenChar(firstChar);
    }
    this.print(node.argument);
  }
  function DoExpression2(node) {
    if (node.async) {
      this.word("async", true);
      this.space();
    }
    this.word("do");
    this.space();
    this.print(node.body);
  }
  function ParenthesizedExpression2(node) {
    this.tokenChar(40);
    const oldNoLineTerminatorAfterNode = this.enterDelimited();
    this.print(node.expression, void 0, true);
    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    this.rightParens(node);
  }
  function UpdateExpression2(node) {
    if (node.prefix) {
      this.token(node.operator, false, 0, true);
      this.print(node.argument);
    } else {
      this.print(node.argument, true);
      this.token(node.operator, false, 0, true);
    }
  }
  function ConditionalExpression2(node) {
    this.print(node.test);
    this.space();
    this.tokenChar(63);
    this.space();
    this.print(node.consequent);
    this.space();
    this.tokenChar(58);
    this.space();
    this.print(node.alternate);
  }
  function _printExpressionArguments(node) {
    this.tokenChar(40);
    const oldNoLineTerminatorAfterNode = this.enterDelimited();
    this.printList(node.arguments, this.shouldPrintTrailingComma(")"), void 0, void 0, void 0, true);
    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    this.rightParens(node);
  }
  function NewExpression2(node, parent) {
    this.word("new");
    this.space();
    this.print(node.callee);
    if (this.format.minified && node.arguments.length === 0 && !isCallExpression2(parent, {
      callee: node
    }) && !isMemberExpression2(parent) && !isNewExpression2(parent)) {
      return;
    }
    this.print(node.typeArguments);
    if (node.arguments.length === 0 && this.tokenMap && !this.tokenMap.endMatches(node, ")")) {
      return;
    }
    _printExpressionArguments.call(this, node);
  }
  function SequenceExpression2(node) {
    this.printList(node.expressions);
  }
  function ThisExpression2() {
    this.word("this");
  }
  function Super2() {
    this.word("super");
  }
  function _shouldPrintDecoratorsBeforeExport(node) {
    return typeof node.start === "number" && node.start === node.declaration.start;
  }
  function Decorator2(node) {
    this.tokenChar(64);
    const {
      expression
    } = node;
    this.print(expression);
    this.newline();
  }
  function OptionalMemberExpression2(node) {
    let {
      computed
    } = node;
    const {
      optional,
      property
    } = node;
    this.print(node.object);
    if (!computed && isMemberExpression2(property)) {
      throw new TypeError("Got a MemberExpression for MemberExpression property");
    }
    if (isLiteral2(property) && typeof property.value === "number") {
      computed = true;
    }
    if (optional) {
      this.token("?.");
    }
    if (computed) {
      this.tokenChar(91);
      this.print(property);
      this.tokenChar(93);
    } else {
      if (!optional) {
        this.tokenChar(46);
      }
      this.print(property);
    }
  }
  function OptionalCallExpression2(node) {
    this.print(node.callee);
    if (node.optional) {
      this.token("?.");
    }
    this.print(node.typeArguments);
    _printExpressionArguments.call(this, node);
  }
  function CallExpression2(node) {
    this.print(node.callee);
    this.print(node.typeArguments);
    _printExpressionArguments.call(this, node);
  }
  function Import2() {
    this.word("import");
  }
  function AwaitExpression2(node) {
    this.word("await");
    this.space();
    this.print(node.argument);
  }
  function YieldExpression2(node) {
    if (node.delegate) {
      this.word("yield", true);
      this.tokenChar(42);
      if (node.argument) {
        this.space();
        this.print(node.argument);
      }
    } else if (node.argument) {
      this.word("yield", true);
      this.space();
      this.print(node.argument);
    } else {
      this.word("yield");
    }
  }
  function EmptyStatement2() {
    this.semicolon(true);
  }
  function ExpressionStatement2(node) {
    this.tokenContext |= 1;
    this.print(node.expression);
    this.semicolon();
  }
  function AssignmentPattern2(node) {
    this.print(node.left);
    if (node.left.type === "Identifier" || isPattern2(node.left)) {
      if (node.left.optional) this.tokenChar(63);
      this.print(node.left.typeAnnotation);
    }
    this.space();
    this.tokenChar(61);
    this.space();
    this.print(node.right);
  }
  function AssignmentExpression2(node) {
    this.print(node.left);
    this.space();
    this.token(node.operator, false, 0, true);
    this.space();
    this.print(node.right);
  }
  function BinaryExpression2(node) {
    this.print(node.left);
    this.space();
    const {
      operator
    } = node;
    if (operator.charCodeAt(0) === 105) {
      this.word(operator);
    } else {
      this.token(operator, false, 0, true);
      this.setLastChar(operator.charCodeAt(operator.length - 1));
    }
    this.space();
    this.print(node.right);
  }
  function BindExpression2(node) {
    this.print(node.object);
    this.token("::");
    this.print(node.callee);
  }
  function MemberExpression2(node) {
    this.print(node.object);
    if (!node.computed && isMemberExpression2(node.property)) {
      throw new TypeError("Got a MemberExpression for MemberExpression property");
    }
    let computed = node.computed;
    if (isLiteral2(node.property) && typeof node.property.value === "number") {
      computed = true;
    }
    if (computed) {
      const oldNoLineTerminatorAfterNode = this.enterDelimited();
      this.tokenChar(91);
      this.print(node.property, void 0, true);
      this.tokenChar(93);
      this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    } else {
      this.tokenChar(46);
      this.print(node.property);
    }
  }
  function MetaProperty2(node) {
    this.print(node.meta);
    this.tokenChar(46);
    this.print(node.property);
  }
  function PrivateName2(node) {
    this.tokenChar(35);
    this.print(node.id);
  }
  function V8IntrinsicIdentifier2(node) {
    this.tokenChar(37);
    this.word(node.name);
  }
  function ModuleExpression2(node) {
    this.word("module", true);
    this.space();
    this.tokenChar(123);
    this.indent();
    const {
      body
    } = node;
    if (body.body.length || body.directives.length) {
      this.newline();
    }
    this.print(body);
    this.dedent();
    this.rightBrace(node);
  }
  var {
    isFor: isFor2,
    isIfStatement: isIfStatement2,
    isStatement: isStatement$3,
    isVoidPattern: isVoidPattern2
  } = lib_exports;
  function WithStatement2(node) {
    this.word("with");
    this.space();
    this.tokenChar(40);
    this.print(node.object);
    this.tokenChar(41);
    this.printBlock(node.body);
  }
  function IfStatement2(node) {
    this.word("if");
    this.space();
    this.tokenChar(40);
    this.print(node.test);
    this.tokenChar(41);
    this.space();
    const needsBlock = node.alternate && isIfStatement2(getLastStatement(node.consequent));
    if (needsBlock) {
      this.tokenChar(123);
      this.newline();
      this.indent();
    }
    this.printAndIndentOnComments(node.consequent);
    if (needsBlock) {
      this.dedent();
      this.newline();
      this.tokenChar(125);
    }
    if (node.alternate) {
      if (this.endsWith(125)) this.space();
      this.word("else");
      this.space();
      this.printAndIndentOnComments(node.alternate);
    }
  }
  function getLastStatement(statement) {
    const {
      body
    } = statement;
    if (isStatement$3(body) === false) {
      return statement;
    }
    return getLastStatement(body);
  }
  function ForStatement2(node) {
    this.word("for");
    this.space();
    this.tokenChar(40);
    this.tokenContext |= 16 | 128;
    this.print(node.init);
    this.tokenContext = 0;
    this.tokenChar(59);
    if (node.test) {
      this.space();
      this.print(node.test);
    }
    this.tokenChar(59, 1);
    if (node.update) {
      this.space();
      this.print(node.update);
    }
    this.tokenChar(41);
    this.printBlock(node.body);
  }
  function WhileStatement2(node) {
    this.word("while");
    this.space();
    this.tokenChar(40);
    this.print(node.test);
    this.tokenChar(41);
    this.printBlock(node.body);
  }
  function ForInStatement2(node) {
    this.word("for");
    this.space();
    this.noIndentInnerCommentsHere();
    this.tokenChar(40);
    this.tokenContext |= 32 | 128;
    this.print(node.left);
    this.tokenContext = 0;
    this.space();
    this.word("in");
    this.space();
    this.print(node.right);
    this.tokenChar(41);
    this.printBlock(node.body);
  }
  function ForOfStatement2(node) {
    this.word("for");
    this.space();
    if (node.await) {
      this.word("await");
      this.space();
    }
    this.noIndentInnerCommentsHere();
    this.tokenChar(40);
    this.tokenContext |= 64;
    this.print(node.left);
    this.space();
    this.word("of");
    this.space();
    this.print(node.right);
    this.tokenChar(41);
    this.printBlock(node.body);
  }
  function DoWhileStatement2(node) {
    this.word("do");
    this.space();
    this.print(node.body);
    this.space();
    this.word("while");
    this.space();
    this.tokenChar(40);
    this.print(node.test);
    this.tokenChar(41);
    this.semicolon();
  }
  function printStatementAfterKeyword(printer, node) {
    if (node) {
      printer.space();
      printer.printTerminatorless(node);
    }
    printer.semicolon();
  }
  function BreakStatement2(node) {
    this.word("break");
    printStatementAfterKeyword(this, node.label);
  }
  function ContinueStatement2(node) {
    this.word("continue");
    printStatementAfterKeyword(this, node.label);
  }
  function ReturnStatement2(node) {
    this.word("return");
    printStatementAfterKeyword(this, node.argument);
  }
  function ThrowStatement2(node) {
    this.word("throw");
    printStatementAfterKeyword(this, node.argument);
  }
  function LabeledStatement2(node) {
    this.print(node.label);
    this.tokenChar(58);
    this.space();
    this.print(node.body);
  }
  function TryStatement2(node) {
    this.word("try");
    this.space();
    this.print(node.block);
    this.space();
    if (node.handlers) {
      this.print(node.handlers[0]);
    } else {
      this.print(node.handler);
    }
    if (node.finalizer) {
      this.space();
      this.word("finally");
      this.space();
      this.print(node.finalizer);
    }
  }
  function CatchClause2(node) {
    this.word("catch");
    this.space();
    if (node.param) {
      this.tokenChar(40);
      this.print(node.param);
      this.print(node.param.typeAnnotation);
      this.tokenChar(41);
      this.space();
    }
    this.print(node.body);
  }
  function SwitchStatement2(node) {
    this.word("switch");
    this.space();
    this.tokenChar(40);
    this.print(node.discriminant);
    this.tokenChar(41);
    this.space();
    this.tokenChar(123);
    this.printSequence(node.cases, true);
    this.rightBrace(node);
  }
  function SwitchCase2(node) {
    if (node.test) {
      this.word("case");
      this.space();
      this.print(node.test);
      this.tokenChar(58);
    } else {
      this.word("default");
      this.tokenChar(58);
    }
    if (node.consequent.length) {
      this.newline();
      this.printSequence(node.consequent, true);
    }
  }
  function DebuggerStatement2() {
    this.word("debugger");
    this.semicolon();
  }
  function commaSeparatorWithNewline(occurrenceCount) {
    this.tokenChar(44, occurrenceCount);
    this.newline();
  }
  function VariableDeclaration2(node, parent) {
    if (node.declare) {
      this.word("declare");
      this.space();
    }
    const {
      kind
    } = node;
    switch (kind) {
      case "await using":
        this.word("await");
        this.space();
      case "using":
        this.word("using", true);
        break;
      default:
        this.word(kind);
    }
    this.space();
    let hasInits = false;
    if (!isFor2(parent)) {
      for (const declar of node.declarations) {
        if (declar.init) {
          hasInits = true;
          break;
        }
      }
    }
    this.printList(node.declarations, void 0, void 0, node.declarations.length > 1, hasInits ? commaSeparatorWithNewline : void 0);
    if (parent != null) {
      switch (parent.type) {
        case "ForStatement":
          if (parent.init === node) {
            return;
          }
          break;
        case "ForInStatement":
        case "ForOfStatement":
          if (parent.left === node) {
            return;
          }
      }
    }
    this.semicolon();
  }
  function VariableDeclarator2(node) {
    this.print(node.id);
    if (node.definite) this.tokenChar(33);
    if (!isVoidPattern2(node.id)) {
      this.print(node.id.typeAnnotation);
    }
    if (node.init) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node.init);
    }
  }
  var {
    isIdentifier: isIdentifier$1
  } = lib_exports;
  function _params(node, noLineTerminator, idNode, parentNode) {
    this.print(node.typeParameters);
    if (idNode !== void 0 || parentNode !== void 0) {
      const nameInfo = _getFuncIdName.call(this, idNode, parentNode);
      if (nameInfo) {
        this.sourceIdentifierName(nameInfo.name, nameInfo.pos);
      }
    }
    this.tokenChar(40);
    _parameters.call(this, node.params, 41);
    this.print(node.returnType, noLineTerminator);
    this._noLineTerminator = noLineTerminator;
  }
  function _parameters(parameters, endToken) {
    const oldNoLineTerminatorAfterNode = this.enterDelimited();
    const trailingComma = this.shouldPrintTrailingComma(endToken);
    const paramLength = parameters.length;
    for (let i = 0; i < paramLength; i++) {
      _param.call(this, parameters[i]);
      if (trailingComma || i < paramLength - 1) {
        this.tokenChar(44, i);
        this.space();
      }
    }
    this.tokenChar(endToken);
    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
  }
  function _param(parameter) {
    this.printJoin(parameter.decorators, void 0, void 0, void 0, void 0, true);
    this.print(parameter, void 0, true);
    if (parameter.optional) {
      this.tokenChar(63);
    }
    this.print(parameter.typeAnnotation, void 0, true);
  }
  function _methodHead(node) {
    const kind = node.kind;
    const key = node.key;
    if (kind === "get" || kind === "set") {
      this.word(kind);
      this.space();
    }
    if (node.async) {
      this.word("async", true);
      this.space();
    }
    if (kind === "method" || kind === "init") {
      if (node.generator) {
        this.tokenChar(42);
      }
    }
    if (node.computed) {
      this.tokenChar(91);
      this.print(key);
      this.tokenChar(93);
    } else {
      this.print(key);
    }
    if (node.optional) {
      this.tokenChar(63);
    }
    if (this._buf._map) {
      _params.call(this, node, false, node.computed && node.key.type !== "StringLiteral" ? void 0 : node.key);
    } else {
      _params.call(this, node, false);
    }
  }
  function _predicate(node, noLineTerminatorAfter) {
    if (node.predicate) {
      if (!node.returnType) {
        this.tokenChar(58);
      }
      this.space();
      this.print(node.predicate, noLineTerminatorAfter);
    }
  }
  function _functionHead(node, parent, hasPredicate) {
    if (node.async) {
      this.word("async");
      if (!this.format.preserveFormat) {
        this._innerCommentsState = 0;
      }
      this.space();
    }
    this.word("function");
    if (node.generator) {
      if (!this.format.preserveFormat) {
        this._innerCommentsState = 0;
      }
      this.tokenChar(42);
    }
    this.space();
    if (node.id) {
      this.print(node.id);
    }
    if (this._buf._map) {
      _params.call(this, node, false, node.id, parent);
    } else {
      _params.call(this, node, false);
    }
    if (hasPredicate) {
      _predicate.call(this, node);
    }
  }
  function FunctionExpression2(node, parent) {
    _functionHead.call(this, node, parent, true);
    this.space();
    this.print(node.body);
  }
  function ArrowFunctionExpression2(node, parent) {
    if (node.async) {
      this.word("async", true);
      this.space();
    }
    if (_shouldPrintArrowParamsParens.call(this, node)) {
      _params.call(this, node, true, void 0, this._buf._map ? parent : void 0);
    } else {
      this.print(node.params[0], true);
    }
    _predicate.call(this, node, true);
    this.space();
    this.printInnerComments();
    this.token("=>");
    this.space();
    this.tokenContext |= 2;
    this.print(node.body);
  }
  function _shouldPrintArrowParamsParens(node) {
    var _a, _b;
    if (node.params.length !== 1) return true;
    if (node.typeParameters || node.returnType || node.predicate) {
      return true;
    }
    const firstParam = node.params[0];
    if (!isIdentifier$1(firstParam) || firstParam.typeAnnotation || firstParam.optional || ((_a = firstParam.leadingComments) == null ? void 0 : _a.length) || ((_b = firstParam.trailingComments) == null ? void 0 : _b.length)) {
      return true;
    }
    if (this.tokenMap) {
      if (node.loc == null) return true;
      if (this.tokenMap.findMatching(node, "(") !== null) return true;
      const arrowToken = this.tokenMap.findMatching(node, "=>");
      if ((arrowToken == null ? void 0 : arrowToken.loc) == null) return true;
      return arrowToken.loc.start.line !== node.loc.start.line;
    }
    if (this.format.retainLines) return true;
    return false;
  }
  function isRenamedIdentifier(id) {
    var _a;
    return !!((_a = id.loc) == null ? void 0 : _a.identifierName) && id.loc.identifierName !== id.name;
  }
  function _getFuncIdName(idNode, parent) {
    let id = idNode;
    if (!id && parent) {
      const parentType = parent.type;
      if (parentType === "VariableDeclarator") {
        id = parent.id;
      } else if (parentType === "AssignmentExpression" || parentType === "AssignmentPattern") {
        id = parent.left;
      } else if (parentType === "ObjectProperty" || parentType === "ClassProperty") {
        if (!parent.computed || parent.key.type === "StringLiteral") {
          id = parent.key;
        }
      } else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") {
        id = parent.key;
      }
    }
    if (!(id == null ? void 0 : id.loc)) return;
    let nameInfo;
    if (id.type === "Identifier") {
      if (!isRenamedIdentifier(id)) return;
      nameInfo = {
        pos: id.loc.start,
        name: id.loc.identifierName
      };
    } else if (id.type === "PrivateName") {
      if (!isRenamedIdentifier(id.id)) return;
      nameInfo = {
        pos: id.loc.start,
        name: "#" + id.id.loc.identifierName
      };
    } else if (id.type === "StringLiteral") {
      nameInfo = {
        pos: id.loc.start,
        name: id.value
      };
    }
    return nameInfo;
  }
  function TSTypeAnnotation2(node, parent) {
    this.token((parent.type === "TSFunctionType" || parent.type === "TSConstructorType") && parent.returnType === node ? "=>" : ":");
    this.space();
    if (node.optional) this.tokenChar(63);
    this.print(node.typeAnnotation);
  }
  function TSTypeParameterInstantiation2(node, parent) {
    this.tokenChar(60);
    let printTrailingSeparator = parent.type === "ArrowFunctionExpression" && node.params.length === 1;
    if (this.tokenMap && node.start != null && node.end != null) {
      printTrailingSeparator && (printTrailingSeparator = !!this.tokenMap.find(node, (t) => this.tokenMap.matchesOriginal(t, ",")));
      printTrailingSeparator || (printTrailingSeparator = this.shouldPrintTrailingComma(">"));
    }
    this.printList(node.params, printTrailingSeparator);
    this.tokenChar(62);
  }
  function TSTypeParameter2(node) {
    if (node.const) {
      this.word("const");
      this.space();
    }
    if (node.in) {
      this.word("in");
      this.space();
    }
    if (node.out) {
      this.word("out");
      this.space();
    }
    this.word(node.name.name);
    if (node.constraint) {
      this.space();
      this.word("extends");
      this.space();
      this.print(node.constraint);
    }
    if (node.default) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node.default);
    }
  }
  function TSParameterProperty2(node) {
    if (node.accessibility) {
      this.word(node.accessibility);
      this.space();
    }
    if (node.readonly) {
      this.word("readonly");
      this.space();
    }
    _param.call(this, node.parameter);
  }
  function TSDeclareFunction2(node, parent) {
    if (node.declare) {
      this.word("declare");
      this.space();
    }
    _functionHead.call(this, node, parent, false);
    this.semicolon();
  }
  function TSDeclareMethod2(node) {
    _classMethodHead.call(this, node, false);
    this.semicolon();
  }
  function TSQualifiedName2(node) {
    this.print(node.left);
    this.tokenChar(46);
    this.print(node.right);
  }
  function TSCallSignatureDeclaration2(node) {
    tsPrintSignatureDeclarationBase.call(this, node);
    maybePrintTrailingCommaOrSemicolon(this, node);
  }
  function maybePrintTrailingCommaOrSemicolon(printer, node) {
    if (!printer.tokenMap || !node.start || !node.end) {
      printer.semicolon();
      return;
    }
    if (printer.tokenMap.endMatches(node, ",")) {
      printer.token(",");
    } else if (printer.tokenMap.endMatches(node, ";")) {
      printer.semicolon();
    }
  }
  function TSConstructSignatureDeclaration2(node) {
    this.word("new");
    this.space();
    tsPrintSignatureDeclarationBase.call(this, node);
    maybePrintTrailingCommaOrSemicolon(this, node);
  }
  function TSPropertySignature2(node) {
    const {
      readonly
    } = node;
    if (readonly) {
      this.word("readonly");
      this.space();
    }
    tsPrintPropertyOrMethodName.call(this, node);
    this.print(node.typeAnnotation);
    maybePrintTrailingCommaOrSemicolon(this, node);
  }
  function tsPrintPropertyOrMethodName(node) {
    if (node.computed) {
      this.tokenChar(91);
    }
    this.print(node.key);
    if (node.computed) {
      this.tokenChar(93);
    }
    if (node.optional) {
      this.tokenChar(63);
    }
  }
  function TSMethodSignature2(node) {
    const {
      kind
    } = node;
    if (kind === "set" || kind === "get") {
      this.word(kind);
      this.space();
    }
    tsPrintPropertyOrMethodName.call(this, node);
    tsPrintSignatureDeclarationBase.call(this, node);
    maybePrintTrailingCommaOrSemicolon(this, node);
  }
  function TSIndexSignature2(node) {
    const {
      readonly,
      static: isStatic
    } = node;
    if (isStatic) {
      this.word("static");
      this.space();
    }
    if (readonly) {
      this.word("readonly");
      this.space();
    }
    this.tokenChar(91);
    _parameters.call(this, node.parameters, 93);
    this.print(node.typeAnnotation);
    maybePrintTrailingCommaOrSemicolon(this, node);
  }
  function TSAnyKeyword2() {
    this.word("any");
  }
  function TSBigIntKeyword2() {
    this.word("bigint");
  }
  function TSUnknownKeyword2() {
    this.word("unknown");
  }
  function TSNumberKeyword2() {
    this.word("number");
  }
  function TSObjectKeyword2() {
    this.word("object");
  }
  function TSBooleanKeyword2() {
    this.word("boolean");
  }
  function TSStringKeyword2() {
    this.word("string");
  }
  function TSSymbolKeyword2() {
    this.word("symbol");
  }
  function TSVoidKeyword2() {
    this.word("void");
  }
  function TSUndefinedKeyword2() {
    this.word("undefined");
  }
  function TSNullKeyword2() {
    this.word("null");
  }
  function TSNeverKeyword2() {
    this.word("never");
  }
  function TSIntrinsicKeyword2() {
    this.word("intrinsic");
  }
  function TSThisType2() {
    this.word("this");
  }
  function TSFunctionType2(node) {
    tsPrintFunctionOrConstructorType.call(this, node);
  }
  function TSConstructorType2(node) {
    if (node.abstract) {
      this.word("abstract");
      this.space();
    }
    this.word("new");
    this.space();
    tsPrintFunctionOrConstructorType.call(this, node);
  }
  function tsPrintFunctionOrConstructorType(node) {
    const {
      typeParameters
    } = node;
    const parameters = node.params;
    this.print(typeParameters);
    this.tokenChar(40);
    _parameters.call(this, parameters, 41);
    this.space();
    const returnType = node.returnType;
    this.print(returnType);
  }
  function TSTypeReference2(node) {
    const typeArguments = node.typeArguments;
    this.print(node.typeName, !!typeArguments);
    this.print(typeArguments);
  }
  function TSTypePredicate2(node) {
    if (node.asserts) {
      this.word("asserts");
      this.space();
    }
    this.print(node.parameterName);
    if (node.typeAnnotation) {
      this.space();
      this.word("is");
      this.space();
      this.print(node.typeAnnotation.typeAnnotation);
    }
  }
  function TSTypeQuery2(node) {
    this.word("typeof");
    this.space();
    this.print(node.exprName);
    const typeArguments = node.typeArguments;
    if (typeArguments) {
      this.print(typeArguments);
    }
  }
  function TSTypeLiteral2(node) {
    printBraced(this, node, () => this.printJoin(node.members, true, true, void 0, void 0, true));
  }
  function TSArrayType2(node) {
    this.print(node.elementType, true);
    this.tokenChar(91);
    this.tokenChar(93);
  }
  function TSTupleType2(node) {
    this.tokenChar(91);
    this.printList(node.elementTypes, this.shouldPrintTrailingComma("]"));
    this.tokenChar(93);
  }
  function TSOptionalType2(node) {
    this.print(node.typeAnnotation);
    this.tokenChar(63);
  }
  function TSRestType2(node) {
    this.token("...");
    this.print(node.typeAnnotation);
  }
  function TSNamedTupleMember2(node) {
    this.print(node.label);
    if (node.optional) this.tokenChar(63);
    this.tokenChar(58);
    this.space();
    this.print(node.elementType);
  }
  function TSUnionType2(node) {
    tsPrintUnionOrIntersectionType(this, node, "|");
  }
  function TSIntersectionType2(node) {
    tsPrintUnionOrIntersectionType(this, node, "&");
  }
  function tsPrintUnionOrIntersectionType(printer, node, sep) {
    var _a;
    let hasLeadingToken = 0;
    if ((_a = printer.tokenMap) == null ? void 0 : _a.startMatches(node, sep)) {
      hasLeadingToken = 1;
      printer.token(sep);
    }
    printer.printJoin(node.types, void 0, void 0, function(i) {
      this.space();
      this.token(sep, void 0, i + hasLeadingToken);
      this.space();
    });
  }
  function TSConditionalType2(node) {
    this.print(node.checkType);
    this.space();
    this.word("extends");
    this.space();
    this.print(node.extendsType);
    this.space();
    this.tokenChar(63);
    this.space();
    this.print(node.trueType);
    this.space();
    this.tokenChar(58);
    this.space();
    this.print(node.falseType);
  }
  function TSInferType2(node) {
    this.word("infer");
    this.print(node.typeParameter);
  }
  function TSParenthesizedType2(node) {
    this.tokenChar(40);
    this.print(node.typeAnnotation);
    this.tokenChar(41);
  }
  function TSTypeOperator2(node) {
    this.word(node.operator);
    this.space();
    this.print(node.typeAnnotation);
  }
  function TSIndexedAccessType2(node) {
    this.print(node.objectType, true);
    this.tokenChar(91);
    this.print(node.indexType);
    this.tokenChar(93);
  }
  function TSMappedType2(node) {
    const {
      nameType,
      optional,
      readonly,
      typeAnnotation: typeAnnotation2
    } = node;
    this.tokenChar(123);
    const oldNoLineTerminatorAfterNode = this.enterDelimited();
    this.space();
    if (readonly) {
      tokenIfPlusMinus(this, readonly);
      this.word("readonly");
      this.space();
    }
    this.tokenChar(91);
    this.word(node.key.name);
    this.space();
    this.word("in");
    this.space();
    this.print(node.constraint);
    if (nameType) {
      this.space();
      this.word("as");
      this.space();
      this.print(nameType, void 0, true);
    }
    this.tokenChar(93);
    if (optional) {
      tokenIfPlusMinus(this, optional);
      this.tokenChar(63);
    }
    if (typeAnnotation2) {
      this.tokenChar(58);
      this.space();
      this.print(typeAnnotation2, void 0, true);
    }
    this.space();
    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    this.tokenChar(125);
  }
  function tokenIfPlusMinus(self2, tok) {
    if (tok !== true) {
      self2.token(tok);
    }
  }
  function TSTemplateLiteralType2(node) {
    _printTemplate.call(this, node, node.types);
  }
  function TSLiteralType2(node) {
    this.print(node.literal);
  }
  function TSClassImplements2(node) {
    this.print(node.expression);
    this.print(node.typeArguments);
  }
  function TSInterfaceDeclaration2(node) {
    const {
      declare,
      id,
      typeParameters,
      extends: extendz,
      body
    } = node;
    if (declare) {
      this.word("declare");
      this.space();
    }
    this.word("interface");
    this.space();
    this.print(id);
    this.print(typeParameters);
    if (extendz == null ? void 0 : extendz.length) {
      this.space();
      this.word("extends");
      this.space();
      this.printList(extendz);
    }
    this.space();
    this.print(body);
  }
  function TSInterfaceBody2(node) {
    printBraced(this, node, () => this.printJoin(node.body, true, true, void 0, void 0, true));
  }
  function TSTypeAliasDeclaration2(node) {
    const {
      declare,
      id,
      typeParameters,
      typeAnnotation: typeAnnotation2
    } = node;
    if (declare) {
      this.word("declare");
      this.space();
    }
    this.word("type");
    this.space();
    this.print(id);
    this.print(typeParameters);
    this.space();
    this.tokenChar(61);
    this.space();
    this.print(typeAnnotation2);
    this.semicolon();
  }
  function TSAsExpression2(node) {
    const {
      expression,
      typeAnnotation: typeAnnotation2
    } = node;
    this.print(expression, true);
    this.space();
    this.word("as");
    this.space();
    this.print(typeAnnotation2);
  }
  function TSSatisfiesExpression2(node) {
    const {
      expression,
      typeAnnotation: typeAnnotation2
    } = node;
    this.print(expression, true);
    this.space();
    this.word("satisfies");
    this.space();
    this.print(typeAnnotation2);
  }
  function TSTypeAssertion2(node) {
    const {
      typeAnnotation: typeAnnotation2,
      expression
    } = node;
    this.tokenChar(60);
    this.print(typeAnnotation2);
    this.tokenChar(62);
    this.space();
    this.print(expression);
  }
  function TSInstantiationExpression2(node) {
    this.print(node.expression);
    this.print(node.typeArguments);
  }
  function TSEnumDeclaration2(node) {
    const {
      declare,
      const: isConst,
      id
    } = node;
    if (declare) {
      this.word("declare");
      this.space();
    }
    if (isConst) {
      this.word("const");
      this.space();
    }
    this.word("enum");
    this.space();
    this.print(id);
    this.space();
    this.print(node.body);
  }
  function TSEnumBody2(node) {
    printBraced(this, node, () => {
      var _a;
      return this.printList(node.members, (_a = this.shouldPrintTrailingComma("}")) != null ? _a : false, true, true, void 0, true);
    });
  }
  function TSEnumMember2(node) {
    const {
      id,
      initializer
    } = node;
    this.print(id);
    if (initializer) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(initializer);
    }
  }
  function TSModuleDeclaration2(node) {
    const {
      declare,
      kind
    } = node;
    if (declare) {
      this.word("declare");
      this.space();
    }
    if (kind !== "global") {
      this.word(kind);
      this.space();
    }
    this.print(node.id);
    if (!node.body) {
      this.semicolon();
      return;
    }
    this.space();
    this.print(node.body);
  }
  function TSModuleBlock2(node) {
    printBraced(this, node, () => this.printSequence(node.body, true, true));
  }
  function TSImportType2(node) {
    const {
      qualifier,
      options
    } = node;
    this.word("import");
    this.tokenChar(40);
    this.print(node.source);
    if (options) {
      this.tokenChar(44);
      this.print(options);
    }
    this.tokenChar(41);
    if (qualifier) {
      this.tokenChar(46);
      this.print(qualifier);
    }
    const typeArguments = node.typeArguments;
    if (typeArguments) {
      this.print(typeArguments);
    }
  }
  function TSImportEqualsDeclaration2(node) {
    const {
      id,
      moduleReference
    } = node;
    this.word("import");
    this.space();
    this.print(id);
    this.space();
    this.tokenChar(61);
    this.space();
    this.print(moduleReference);
    this.semicolon();
  }
  function TSExternalModuleReference2(node) {
    this.token("require(");
    this.print(node.expression);
    this.tokenChar(41);
  }
  function TSNonNullExpression2(node) {
    this.print(node.expression);
    this.tokenChar(33);
    this.setLastChar(33);
  }
  function TSExportAssignment2(node) {
    this.word("export");
    this.space();
    this.tokenChar(61);
    this.space();
    this.print(node.expression);
    this.semicolon();
  }
  function TSNamespaceExportDeclaration2(node) {
    this.word("export");
    this.space();
    this.word("as");
    this.space();
    this.word("namespace");
    this.space();
    this.print(node.id);
    this.semicolon();
  }
  function tsPrintSignatureDeclarationBase(node) {
    const {
      typeParameters
    } = node;
    const parameters = node.params;
    this.print(typeParameters);
    this.tokenChar(40);
    _parameters.call(this, parameters, 41);
    this.print(node.returnType);
  }
  function _tsPrintClassMemberModifiers(node) {
    const isPrivateField = node.type === "ClassPrivateProperty";
    const isPublicField = node.type === "ClassAccessorProperty" || node.type === "ClassProperty";
    printModifiersList(this, node, [isPublicField && node.declare && "declare", !isPrivateField && node.accessibility]);
    if (node.static) {
      this.word("static");
      this.space();
    }
    printModifiersList(this, node, [!isPrivateField && node.abstract && "abstract", !isPrivateField && node.override && "override", (isPublicField || isPrivateField) && node.readonly && "readonly"]);
  }
  function printBraced(printer, node, cb) {
    printer.token("{");
    const oldNoLineTerminatorAfterNode = printer.enterDelimited();
    cb();
    printer._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    printer.rightBrace(node);
  }
  function printModifiersList(printer, node, modifiers) {
    var _a;
    const modifiersSet = /* @__PURE__ */ new Set();
    for (const modifier of modifiers) {
      if (modifier) modifiersSet.add(modifier);
    }
    (_a = printer.tokenMap) == null ? void 0 : _a.find(node, (tok) => {
      if (modifiersSet.has(tok.value)) {
        printer.token(tok.value);
        printer.space();
        modifiersSet.delete(tok.value);
        return modifiersSet.size === 0;
      }
      return false;
    });
    for (const modifier of modifiersSet) {
      printer.word(modifier);
      printer.space();
    }
  }
  var {
    isClassDeclaration: isClassDeclaration2,
    isExportDefaultSpecifier: isExportDefaultSpecifier2,
    isExportNamespaceSpecifier: isExportNamespaceSpecifier2,
    isImportDefaultSpecifier: isImportDefaultSpecifier2,
    isImportNamespaceSpecifier: isImportNamespaceSpecifier2,
    isStatement: isStatement$2
  } = lib_exports;
  function ImportSpecifier2(node) {
    if (node.importKind === "type" || node.importKind === "typeof") {
      this.word(node.importKind);
      this.space();
    }
    this.print(node.imported);
    if (node.local && node.local.name !== node.imported.name) {
      this.space();
      this.word("as");
      this.space();
      this.print(node.local);
    }
  }
  function ImportDefaultSpecifier2(node) {
    this.print(node.local);
  }
  function ExportDefaultSpecifier2(node) {
    this.print(node.exported);
  }
  function ExportSpecifier2(node) {
    if (node.exportKind === "type") {
      this.word("type");
      this.space();
    }
    this.print(node.local);
    if (node.exported && node.local.name !== node.exported.name) {
      this.space();
      this.word("as");
      this.space();
      this.print(node.exported);
    }
  }
  function ExportNamespaceSpecifier2(node) {
    this.tokenChar(42);
    this.space();
    this.word("as");
    this.space();
    this.print(node.exported);
  }
  function _printAttributes(node, hasPreviousBrace) {
    const {
      attributes
    } = node;
    this.word("with");
    this.space();
    const occurrenceCount = hasPreviousBrace ? 1 : 0;
    this.token("{", void 0, occurrenceCount);
    this.space();
    this.printList(attributes, this.shouldPrintTrailingComma("}"));
    this.space();
    this.token("}", void 0, occurrenceCount);
  }
  function ExportAllDeclaration2(node) {
    var _a;
    this.word("export");
    this.space();
    if (node.exportKind === "type") {
      this.word("type");
      this.space();
    }
    this.tokenChar(42);
    this.space();
    this.word("from");
    this.space();
    if ((_a = node.attributes) == null ? void 0 : _a.length) {
      this.print(node.source, true);
      this.space();
      _printAttributes.call(this, node, false);
    } else {
      this.print(node.source);
    }
    this.semicolon();
  }
  function maybePrintDecoratorsBeforeExport(printer, node) {
    if (isClassDeclaration2(node.declaration) && _shouldPrintDecoratorsBeforeExport.call(printer, node)) {
      printer.printJoin(node.declaration.decorators);
    }
  }
  function ExportNamedDeclaration2(node) {
    var _a;
    maybePrintDecoratorsBeforeExport(this, node);
    this.word("export");
    this.space();
    if (node.declaration) {
      const declar = node.declaration;
      this.print(declar);
      if (!isStatement$2(declar)) this.semicolon();
    } else {
      if (node.exportKind === "type") {
        this.word("type");
        this.space();
      }
      const specifiers = node.specifiers.slice(0);
      let hasSpecial = false;
      for (; ; ) {
        const first = specifiers[0];
        if (isExportDefaultSpecifier2(first) || isExportNamespaceSpecifier2(first)) {
          hasSpecial = true;
          this.print(specifiers.shift());
          if (specifiers.length) {
            this.tokenChar(44);
            this.space();
          }
        } else {
          break;
        }
      }
      let hasBrace = false;
      if (specifiers.length || !specifiers.length && !hasSpecial) {
        hasBrace = true;
        this.tokenChar(123);
        if (specifiers.length) {
          this.space();
          this.printList(specifiers, this.shouldPrintTrailingComma("}"));
          this.space();
        }
        this.tokenChar(125);
      }
      if (node.source) {
        this.space();
        this.word("from");
        this.space();
        if ((_a = node.attributes) == null ? void 0 : _a.length) {
          this.print(node.source, true);
          this.space();
          _printAttributes.call(this, node, hasBrace);
        } else {
          this.print(node.source);
        }
      }
      this.semicolon();
    }
  }
  function ExportDefaultDeclaration2(node) {
    maybePrintDecoratorsBeforeExport(this, node);
    this.word("export");
    this.noIndentInnerCommentsHere();
    this.space();
    this.word("default");
    this.space();
    this.tokenContext |= 4;
    const declar = node.declaration;
    this.print(declar);
    if (!isStatement$2(declar)) this.semicolon();
  }
  function ImportDeclaration2(node) {
    var _a;
    this.word("import");
    this.space();
    const isTypeKind = node.importKind === "type" || node.importKind === "typeof";
    if (isTypeKind) {
      this.noIndentInnerCommentsHere();
      this.word(node.importKind);
      this.space();
    } else if (node.module) {
      this.noIndentInnerCommentsHere();
      this.word("module");
      this.space();
    } else if (node.phase) {
      this.noIndentInnerCommentsHere();
      this.word(node.phase);
      this.space();
    }
    const specifiers = node.specifiers.slice(0);
    const hasSpecifiers = !!specifiers.length;
    while (hasSpecifiers) {
      const first = specifiers[0];
      if (isImportDefaultSpecifier2(first) || isImportNamespaceSpecifier2(first)) {
        this.print(specifiers.shift());
        if (specifiers.length) {
          this.tokenChar(44);
          this.space();
        }
      } else {
        break;
      }
    }
    let hasBrace = false;
    if (specifiers.length) {
      hasBrace = true;
      this.tokenChar(123);
      this.space();
      this.printList(specifiers, this.shouldPrintTrailingComma("}"));
      this.space();
      this.tokenChar(125);
    } else if (isTypeKind && !hasSpecifiers) {
      hasBrace = true;
      this.tokenChar(123);
      this.tokenChar(125);
    }
    if (hasSpecifiers || isTypeKind) {
      this.space();
      this.word("from");
      this.space();
    }
    if ((_a = node.attributes) == null ? void 0 : _a.length) {
      this.print(node.source, true);
      this.space();
      _printAttributes.call(this, node, hasBrace);
    } else {
      this.print(node.source);
    }
    this.semicolon();
  }
  function ImportAttribute2(node) {
    this.print(node.key);
    this.tokenChar(58);
    this.space();
    this.print(node.value);
  }
  function ImportNamespaceSpecifier2(node) {
    this.tokenChar(42);
    this.space();
    this.word("as");
    this.space();
    this.print(node.local);
  }
  function ImportExpression2(node) {
    this.word("import");
    if (node.phase) {
      this.tokenChar(46);
      this.word(node.phase);
    }
    this.tokenChar(40);
    const shouldPrintTrailingComma = this.shouldPrintTrailingComma(")");
    this.print(node.source);
    if (node.options != null) {
      this.tokenChar(44);
      this.space();
      this.print(node.options);
    }
    if (shouldPrintTrailingComma) {
      this.tokenChar(44);
    }
    this.rightParens(node);
  }
  var {
    isAssignmentPattern: isAssignmentPattern2,
    isIdentifier: isIdentifier2
  } = lib_exports;
  var lastRawIdentResult = "";
  function _getRawIdentifier(node) {
    const {
      name
    } = node;
    const token = this.tokenMap.find(node, (tok) => tok.value === name);
    if (token) {
      lastRawIdentResult = this._originalCode.slice(token.start, token.end);
      return lastRawIdentResult;
    }
    return lastRawIdentResult = node.name;
  }
  function Identifier2(node) {
    var _a;
    if (this._buf._map && ((_a = node.loc) == null ? void 0 : _a.identifierName) && node.loc.identifierName !== node.name) {
      this.sourceIdentifierName(node.loc.identifierName);
    }
    this.word(this.tokenMap ? lastRawIdentResult : node.name);
  }
  function ArgumentPlaceholder2() {
    this.tokenChar(63);
  }
  function RestElement2(node) {
    this.token("...");
    this.print(node.argument);
  }
  function ObjectExpression2(node) {
    const props = node.properties;
    this.tokenChar(123);
    if (props.length) {
      const oldNoLineTerminatorAfterNode = this.enterDelimited();
      this.space();
      this.printList(props, this.shouldPrintTrailingComma("}"), true, true, void 0, true);
      this.space();
      this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    }
    this.rightBrace(node);
  }
  function ObjectMethod2(node) {
    this.printJoin(node.decorators);
    _methodHead.call(this, node);
    this.space();
    this.print(node.body);
  }
  function ObjectProperty2(node) {
    this.printJoin(node.decorators);
    if (node.computed) {
      this.tokenChar(91);
      this.print(node.key);
      this.tokenChar(93);
    } else {
      if (isAssignmentPattern2(node.value) && isIdentifier2(node.key) && node.key.name === node.value.left.name) {
        this.print(node.value);
        return;
      }
      this.print(node.key);
      if (node.shorthand && isIdentifier2(node.key) && isIdentifier2(node.value) && node.key.name === node.value.name) {
        return;
      }
    }
    this.tokenChar(58);
    this.space();
    this.print(node.value);
  }
  function ArrayExpression2(node) {
    const elems = node.elements;
    const len = elems.length;
    this.tokenChar(91);
    const oldNoLineTerminatorAfterNode = this.enterDelimited();
    for (let i = 0; i < elems.length; i++) {
      const elem = elems[i];
      if (elem) {
        if (i > 0) this.space();
        this.print(elem, void 0, true);
        if (i < len - 1 || this.shouldPrintTrailingComma("]")) {
          this.tokenChar(44, i);
        }
      } else {
        this.tokenChar(44, i);
      }
    }
    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    this.tokenChar(93);
  }
  function RegExpLiteral2(node) {
    this.word(`/${node.pattern}/${node.flags}`, false);
  }
  function BooleanLiteral2(node) {
    this.word(node.value ? "true" : "false");
  }
  function NullLiteral2() {
    this.word("null");
  }
  function NumericLiteral2(node) {
    const raw = this.getPossibleRaw(node);
    const opts = this.format.jsescOption;
    const value = node.value;
    const str = value + "";
    if (opts.numbers) {
      this.number((0, import_jsesc.default)(value, opts), value);
    } else if (raw == null) {
      this.number(str, value);
    } else if (this.format.minified) {
      this.number(raw.length < str.length ? raw : str, value);
    } else {
      this.number(raw, value);
    }
  }
  function StringLiteral2(node) {
    const raw = this.getPossibleRaw(node);
    if (!this.format.minified && raw !== void 0) {
      this.token(raw);
      return;
    }
    const val = (0, import_jsesc.default)(node.value, this.format.jsescOption);
    this.token(val);
  }
  function BigIntLiteral2(node) {
    const raw = this.getPossibleRaw(node);
    if (!this.format.minified && raw !== void 0) {
      this.word(raw);
      return;
    }
    this.word(node.value + "n");
  }
  var validTopicTokenSet = /* @__PURE__ */ new Set(["^^", "@@", "^", "%", "#"]);
  function TopicReference2() {
    const {
      topicToken
    } = this.format;
    if (validTopicTokenSet.has(topicToken)) {
      this.token(topicToken);
    } else {
      const givenTopicTokenJSON = JSON.stringify(topicToken);
      const validTopics = Array.from(validTopicTokenSet, (v) => JSON.stringify(v));
      throw new Error(`The "topicToken" generator option must be one of ${validTopics.join(", ")} (${givenTopicTokenJSON} received instead).`);
    }
  }
  function VoidPattern2() {
    this.word("void");
  }
  var {
    isDeclareExportDeclaration: isDeclareExportDeclaration2,
    isStatement: isStatement$1
  } = lib_exports;
  function AnyTypeAnnotation2() {
    this.word("any");
  }
  function ArrayTypeAnnotation2(node) {
    this.print(node.elementType, true);
    this.tokenChar(91);
    this.tokenChar(93);
  }
  function BooleanTypeAnnotation2() {
    this.word("boolean");
  }
  function BooleanLiteralTypeAnnotation2(node) {
    this.word(node.value ? "true" : "false");
  }
  function NullLiteralTypeAnnotation2() {
    this.word("null");
  }
  function DeclareClass2(node, parent) {
    if (!isDeclareExportDeclaration2(parent)) {
      this.word("declare");
      this.space();
    }
    this.word("class");
    this.space();
    _interfaceish.call(this, node);
  }
  function DeclareFunction2(node, parent) {
    var _a;
    if (!isDeclareExportDeclaration2(parent)) {
      this.word("declare");
      this.space();
    }
    this.word("function");
    this.space();
    this.print(node.id);
    this.print((_a = node.id.typeAnnotation) == null ? void 0 : _a.typeAnnotation);
    if (node.predicate) {
      this.space();
      this.print(node.predicate);
    }
    this.semicolon();
  }
  function InferredPredicate2() {
    this.tokenChar(37);
    this.word("checks");
  }
  function DeclaredPredicate2(node) {
    this.tokenChar(37);
    this.word("checks");
    this.tokenChar(40);
    this.print(node.value);
    this.tokenChar(41);
  }
  function DeclareInterface2(node) {
    this.word("declare");
    this.space();
    InterfaceDeclaration2.call(this, node);
  }
  function DeclareModule2(node) {
    this.word("declare");
    this.space();
    this.word("module");
    this.space();
    this.print(node.id);
    this.space();
    this.print(node.body);
  }
  function DeclareModuleExports2(node) {
    this.word("declare");
    this.space();
    this.word("module");
    this.tokenChar(46);
    this.word("exports");
    this.print(node.typeAnnotation);
  }
  function DeclareTypeAlias2(node) {
    this.word("declare");
    this.space();
    TypeAlias2.call(this, node);
  }
  function DeclareOpaqueType2(node, parent) {
    if (!isDeclareExportDeclaration2(parent)) {
      this.word("declare");
      this.space();
    }
    OpaqueType2.call(this, node);
  }
  function DeclareVariable2(node, parent) {
    if (!isDeclareExportDeclaration2(parent)) {
      this.word("declare");
      this.space();
    }
    this.word("var");
    this.space();
    this.print(node.id);
    this.print(node.id.typeAnnotation);
    this.semicolon();
  }
  function DeclareExportDeclaration2(node) {
    this.word("declare");
    this.space();
    this.word("export");
    this.space();
    if (node.default) {
      this.word("default");
      this.space();
    }
    FlowExportDeclaration.call(this, node);
  }
  function DeclareExportAllDeclaration2(node) {
    this.word("declare");
    this.space();
    ExportAllDeclaration2.call(this, node);
  }
  function EnumDeclaration2(node) {
    const {
      id,
      body
    } = node;
    this.word("enum");
    this.space();
    this.print(id);
    this.print(body);
  }
  function enumExplicitType(context, name, hasExplicitType) {
    if (hasExplicitType) {
      context.space();
      context.word("of");
      context.space();
      context.word(name);
    }
    context.space();
  }
  function enumBody(context, node) {
    const {
      members
    } = node;
    context.token("{");
    context.indent();
    context.newline();
    for (const member of members) {
      context.print(member);
      context.newline();
    }
    if (node.hasUnknownMembers) {
      context.token("...");
      context.newline();
    }
    context.dedent();
    context.token("}");
  }
  function EnumBooleanBody2(node) {
    const {
      explicitType
    } = node;
    enumExplicitType(this, "boolean", explicitType);
    enumBody(this, node);
  }
  function EnumNumberBody2(node) {
    const {
      explicitType
    } = node;
    enumExplicitType(this, "number", explicitType);
    enumBody(this, node);
  }
  function EnumStringBody2(node) {
    const {
      explicitType
    } = node;
    enumExplicitType(this, "string", explicitType);
    enumBody(this, node);
  }
  function EnumSymbolBody2(node) {
    enumExplicitType(this, "symbol", true);
    enumBody(this, node);
  }
  function EnumDefaultedMember2(node) {
    const {
      id
    } = node;
    this.print(id);
    this.tokenChar(44);
  }
  function enumInitializedMember(context, node) {
    context.print(node.id);
    context.space();
    context.token("=");
    context.space();
    context.print(node.init);
    context.token(",");
  }
  function EnumBooleanMember2(node) {
    enumInitializedMember(this, node);
  }
  function EnumNumberMember2(node) {
    enumInitializedMember(this, node);
  }
  function EnumStringMember2(node) {
    enumInitializedMember(this, node);
  }
  function FlowExportDeclaration(node) {
    if (node.declaration) {
      const declar = node.declaration;
      this.print(declar);
      if (!isStatement$1(declar)) this.semicolon();
    } else {
      this.tokenChar(123);
      if (node.specifiers.length) {
        this.space();
        this.printList(node.specifiers);
        this.space();
      }
      this.tokenChar(125);
      if (node.source) {
        this.space();
        this.word("from");
        this.space();
        this.print(node.source);
      }
      this.semicolon();
    }
  }
  function ExistsTypeAnnotation2() {
    this.tokenChar(42);
  }
  function FunctionTypeAnnotation2(node, parent) {
    this.print(node.typeParameters);
    this.tokenChar(40);
    if (node.this) {
      this.word("this");
      this.tokenChar(58);
      this.space();
      this.print(node.this.typeAnnotation);
      if (node.params.length || node.rest) {
        this.tokenChar(44);
        this.space();
      }
    }
    this.printList(node.params);
    if (node.rest) {
      if (node.params.length) {
        this.tokenChar(44);
        this.space();
      }
      this.token("...");
      this.print(node.rest);
    }
    this.tokenChar(41);
    const type = parent == null ? void 0 : parent.type;
    if (type != null && (type === "ObjectTypeCallProperty" || type === "ObjectTypeInternalSlot" || type === "DeclareFunction" || type === "ObjectTypeProperty" && parent.method)) {
      this.tokenChar(58);
    } else {
      this.space();
      this.token("=>");
    }
    this.space();
    this.print(node.returnType);
  }
  function FunctionTypeParam2(node) {
    this.print(node.name);
    if (node.optional) this.tokenChar(63);
    if (node.name) {
      this.tokenChar(58);
      this.space();
    }
    this.print(node.typeAnnotation);
  }
  function InterfaceExtends2(node) {
    this.print(node.id);
    this.print(node.typeParameters, true);
  }
  function _interfaceish(node) {
    var _a, _b, _c;
    this.print(node.id);
    this.print(node.typeParameters);
    if ((_a = node.extends) == null ? void 0 : _a.length) {
      this.space();
      this.word("extends");
      this.space();
      this.printList(node.extends);
    }
    if (node.type === "DeclareClass") {
      if ((_b = node.mixins) == null ? void 0 : _b.length) {
        this.space();
        this.word("mixins");
        this.space();
        this.printList(node.mixins);
      }
      if ((_c = node.implements) == null ? void 0 : _c.length) {
        this.space();
        this.word("implements");
        this.space();
        this.printList(node.implements);
      }
    }
    this.space();
    this.print(node.body);
  }
  function _variance(node) {
    var _a;
    const kind = (_a = node.variance) == null ? void 0 : _a.kind;
    if (kind != null) {
      if (kind === "plus") {
        this.tokenChar(43);
      } else if (kind === "minus") {
        this.tokenChar(45);
      }
    }
  }
  function InterfaceDeclaration2(node) {
    this.word("interface");
    this.space();
    _interfaceish.call(this, node);
  }
  function andSeparator(occurrenceCount) {
    this.space();
    this.token("&", false, occurrenceCount);
    this.space();
  }
  function InterfaceTypeAnnotation2(node) {
    var _a;
    this.word("interface");
    if ((_a = node.extends) == null ? void 0 : _a.length) {
      this.space();
      this.word("extends");
      this.space();
      this.printList(node.extends);
    }
    this.space();
    this.print(node.body);
  }
  function IntersectionTypeAnnotation2(node) {
    this.printJoin(node.types, void 0, void 0, andSeparator);
  }
  function MixedTypeAnnotation2() {
    this.word("mixed");
  }
  function EmptyTypeAnnotation2() {
    this.word("empty");
  }
  function NullableTypeAnnotation2(node) {
    this.tokenChar(63);
    this.print(node.typeAnnotation);
  }
  function NumberTypeAnnotation2() {
    this.word("number");
  }
  function StringTypeAnnotation2() {
    this.word("string");
  }
  function ThisTypeAnnotation2() {
    this.word("this");
  }
  function TupleTypeAnnotation2(node) {
    this.tokenChar(91);
    this.printList(node.types);
    this.tokenChar(93);
  }
  function TypeofTypeAnnotation2(node) {
    this.word("typeof");
    this.space();
    this.print(node.argument);
  }
  function TypeAlias2(node) {
    this.word("type");
    this.space();
    this.print(node.id);
    this.print(node.typeParameters);
    this.space();
    this.tokenChar(61);
    this.space();
    this.print(node.right);
    this.semicolon();
  }
  function TypeAnnotation2(node, parent) {
    this.tokenChar(58);
    this.space();
    if (parent.type === "ArrowFunctionExpression") {
      this.tokenContext |= 8;
    } else if (node.optional) {
      this.tokenChar(63);
    }
    this.print(node.typeAnnotation);
  }
  function TypeParameterInstantiation2(node) {
    this.tokenChar(60);
    this.printList(node.params);
    this.tokenChar(62);
  }
  function TypeParameter2(node) {
    _variance.call(this, node);
    this.word(node.name);
    if (node.bound) {
      this.print(node.bound);
    }
    if (node.default) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node.default);
    }
  }
  function OpaqueType2(node) {
    this.word("opaque");
    this.space();
    this.word("type");
    this.space();
    this.print(node.id);
    this.print(node.typeParameters);
    if (node.supertype) {
      this.tokenChar(58);
      this.space();
      this.print(node.supertype);
    }
    if (node.impltype) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node.impltype);
    }
    this.semicolon();
  }
  function ObjectTypeAnnotation2(node) {
    if (node.exact) {
      this.token("{|");
    } else {
      this.tokenChar(123);
    }
    const props = [...node.properties, ...node.callProperties || [], ...node.indexers || [], ...node.internalSlots || []];
    if (props.length) {
      this.newline();
      this.space();
      this.printJoin(props, true, true, () => {
        if (props.length !== 1 || node.inexact) {
          this.tokenChar(44);
          this.space();
        }
      }, true);
      this.space();
    }
    if (node.inexact) {
      this.indent();
      this.token("...");
      if (props.length) {
        this.newline();
      }
      this.dedent();
    }
    if (node.exact) {
      this.token("|}");
    } else {
      this.tokenChar(125);
    }
  }
  function ObjectTypeInternalSlot2(node) {
    if (node.static) {
      this.word("static");
      this.space();
    }
    this.tokenChar(91);
    this.tokenChar(91);
    this.print(node.id);
    this.tokenChar(93);
    this.tokenChar(93);
    if (node.optional) this.tokenChar(63);
    if (!node.method) {
      this.tokenChar(58);
      this.space();
    }
    this.print(node.value);
  }
  function ObjectTypeCallProperty2(node) {
    if (node.static) {
      this.word("static");
      this.space();
    }
    this.print(node.value);
  }
  function ObjectTypeIndexer2(node) {
    if (node.static) {
      this.word("static");
      this.space();
    }
    _variance.call(this, node);
    this.tokenChar(91);
    if (node.id) {
      this.print(node.id);
      this.tokenChar(58);
      this.space();
    }
    this.print(node.key);
    this.tokenChar(93);
    this.tokenChar(58);
    this.space();
    this.print(node.value);
  }
  function ObjectTypeProperty2(node) {
    if (node.proto) {
      this.word("proto");
      this.space();
    }
    if (node.static) {
      this.word("static");
      this.space();
    }
    if (node.kind === "get" || node.kind === "set") {
      this.word(node.kind);
      this.space();
    }
    _variance.call(this, node);
    this.print(node.key);
    if (node.optional) this.tokenChar(63);
    if (!node.method) {
      this.tokenChar(58);
      this.space();
    }
    this.print(node.value);
  }
  function ObjectTypeSpreadProperty2(node) {
    this.token("...");
    this.print(node.argument);
  }
  function QualifiedTypeIdentifier2(node) {
    this.print(node.qualification);
    this.tokenChar(46);
    this.print(node.id);
  }
  function SymbolTypeAnnotation2() {
    this.word("symbol");
  }
  function orSeparator(occurrenceCount) {
    this.space();
    this.token("|", false, occurrenceCount);
    this.space();
  }
  function UnionTypeAnnotation2(node) {
    this.printJoin(node.types, void 0, void 0, orSeparator);
  }
  function TypeCastExpression2(node) {
    this.tokenChar(40);
    this.print(node.expression);
    this.print(node.typeAnnotation);
    this.tokenChar(41);
  }
  function Variance2(node) {
    if (node.kind === "plus") {
      this.tokenChar(43);
    } else {
      this.tokenChar(45);
    }
  }
  function VoidTypeAnnotation2() {
    this.word("void");
  }
  function IndexedAccessType2(node) {
    this.print(node.objectType, true);
    this.tokenChar(91);
    this.print(node.indexType);
    this.tokenChar(93);
  }
  function OptionalIndexedAccessType2(node) {
    this.print(node.objectType);
    if (node.optional) {
      this.token("?.");
    }
    this.tokenChar(91);
    this.print(node.indexType);
    this.tokenChar(93);
  }
  var {
    isExportDefaultDeclaration: isExportDefaultDeclaration2,
    isExportNamedDeclaration: isExportNamedDeclaration2
  } = lib_exports;
  function ClassDeclaration2(node, parent) {
    const inExport = isExportDefaultDeclaration2(parent) || isExportNamedDeclaration2(parent);
    if (!inExport || !_shouldPrintDecoratorsBeforeExport.call(this, parent)) {
      this.printJoin(node.decorators);
    }
    if (node.declare) {
      this.word("declare");
      this.space();
    }
    if (node.abstract) {
      this.word("abstract");
      this.space();
    }
    this.word("class");
    if (node.id) {
      this.space();
      this.print(node.id);
    }
    this.print(node.typeParameters);
    if (node.superClass) {
      this.space();
      this.word("extends");
      this.space();
      this.print(node.superClass);
      this.print(node.superTypeArguments);
    }
    if (node.implements) {
      this.space();
      this.word("implements");
      this.space();
      this.printList(node.implements);
    }
    this.space();
    this.print(node.body);
  }
  function ClassBody2(node) {
    this.tokenChar(123);
    if (node.body.length === 0) {
      this.tokenChar(125);
    } else {
      const separator = classBodyEmptySemicolonsPrinter(this, node);
      separator == null ? void 0 : separator(-1);
      const oldNoLineTerminatorAfterNode = this.enterDelimited();
      this.printJoin(node.body, true, true, separator, true, true);
      this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
      if (!this.endsWith(10)) this.newline();
      this.rightBrace(node);
    }
  }
  function classBodyEmptySemicolonsPrinter(printer, node) {
    if (!printer.tokenMap || node.start == null || node.end == null) {
      return null;
    }
    const indexes = printer.tokenMap.getIndexes(node);
    if (!indexes) return null;
    let k = 1;
    let occurrenceCount = 0;
    let nextLocIndex = 0;
    const advanceNextLocIndex = () => {
      while (nextLocIndex < node.body.length && node.body[nextLocIndex].start == null) {
        nextLocIndex++;
      }
    };
    advanceNextLocIndex();
    return (i) => {
      if (nextLocIndex <= i) {
        nextLocIndex = i + 1;
        advanceNextLocIndex();
      }
      const end = nextLocIndex === node.body.length ? node.end : node.body[nextLocIndex].start;
      let tok;
      while (k < indexes.length && printer.tokenMap.matchesOriginal(tok = printer._tokens[indexes[k]], ";") && tok.start < end) {
        printer.tokenChar(59, occurrenceCount++);
        k++;
      }
    };
  }
  function ClassProperty2(node) {
    var _a, _b;
    this.printJoin(node.decorators);
    if (!node.static && !this.format.preserveFormat) {
      const endLine = (_b = (_a = node.key.loc) == null ? void 0 : _a.end) == null ? void 0 : _b.line;
      if (endLine) this.catchUp(endLine);
    }
    _tsPrintClassMemberModifiers.call(this, node);
    if (node.computed) {
      this.tokenChar(91);
      this.print(node.key);
      this.tokenChar(93);
    } else {
      _variance.call(this, node);
      this.print(node.key);
    }
    if (node.optional) {
      this.tokenChar(63);
    }
    if (node.definite) {
      this.tokenChar(33);
    }
    this.print(node.typeAnnotation);
    if (node.value) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node.value);
    }
    this.semicolon();
  }
  function ClassAccessorProperty2(node) {
    var _a, _b;
    this.printJoin(node.decorators);
    const endLine = (_b = (_a = node.key.loc) == null ? void 0 : _a.end) == null ? void 0 : _b.line;
    if (endLine) this.catchUp(endLine);
    _tsPrintClassMemberModifiers.call(this, node);
    this.word("accessor", true);
    this.space();
    if (node.computed) {
      this.tokenChar(91);
      this.print(node.key);
      this.tokenChar(93);
    } else {
      _variance.call(this, node);
      this.print(node.key);
    }
    if (node.optional) {
      this.tokenChar(63);
    }
    if (node.definite) {
      this.tokenChar(33);
    }
    this.print(node.typeAnnotation);
    if (node.value) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node.value);
    }
    this.semicolon();
  }
  function ClassPrivateProperty2(node) {
    this.printJoin(node.decorators);
    _tsPrintClassMemberModifiers.call(this, node);
    this.print(node.key);
    if (node.optional) {
      this.tokenChar(63);
    }
    if (node.definite) {
      this.tokenChar(33);
    }
    this.print(node.typeAnnotation);
    if (node.value) {
      this.space();
      this.tokenChar(61);
      this.space();
      this.print(node.value);
    }
    this.semicolon();
  }
  function ClassMethod2(node) {
    _classMethodHead.call(this, node);
    this.space();
    this.print(node.body);
  }
  function ClassPrivateMethod2(node) {
    _classMethodHead.call(this, node);
    this.space();
    this.print(node.body);
  }
  function _classMethodHead(node, allowDecorators = true) {
    var _a, _b;
    if (allowDecorators) {
      this.printJoin(node.decorators);
    }
    if (!this.format.preserveFormat) {
      const endLine = (_b = (_a = node.key.loc) == null ? void 0 : _a.end) == null ? void 0 : _b.line;
      if (endLine) this.catchUp(endLine);
    }
    _tsPrintClassMemberModifiers.call(this, node);
    _methodHead.call(this, node);
  }
  function StaticBlock2(node) {
    this.word("static");
    this.space();
    this.tokenChar(123);
    if (node.body.length === 0) {
      this.tokenChar(125);
    } else {
      this.newline();
      this.printSequence(node.body, true);
      this.rightBrace(node);
    }
  }
  function File2(node) {
    if (node.program) {
      this.print(node.program.interpreter);
    }
    this.print(node.program);
  }
  function Program2(node) {
    var _a, _b;
    this.printInnerComments(false);
    const directivesLen = (_a = node.directives) == null ? void 0 : _a.length;
    if (directivesLen) {
      const newline = node.body.length ? 2 : 1;
      this.printSequence(node.directives, void 0, void 0, newline);
      if (!((_b = node.directives[directivesLen - 1].trailingComments) == null ? void 0 : _b.length)) {
        this.newline(newline);
      }
    }
    this.printSequence(node.body);
  }
  function BlockStatement2(node) {
    var _a, _b;
    this.tokenChar(123);
    const oldNoLineTerminatorAfterNode = this.enterDelimited();
    const directivesLen = (_a = node.directives) == null ? void 0 : _a.length;
    if (directivesLen) {
      const newline = node.body.length ? 2 : 1;
      this.printSequence(node.directives, true, true, newline);
      if (!((_b = node.directives[directivesLen - 1].trailingComments) == null ? void 0 : _b.length)) {
        this.newline(newline);
      }
    }
    this.printSequence(node.body, true, true);
    this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
    this.rightBrace(node);
  }
  function Directive2(node) {
    this.print(node.value);
    this.semicolon();
  }
  var unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
  var unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
  function DirectiveLiteral2(node) {
    const raw = this.getPossibleRaw(node);
    if (!this.format.minified && raw !== void 0) {
      this.token(raw);
      return;
    }
    const {
      value
    } = node;
    if (!unescapedDoubleQuoteRE.test(value)) {
      this.token(`"${value}"`);
    } else if (!unescapedSingleQuoteRE.test(value)) {
      this.token(`'${value}'`);
    } else {
      throw new Error("Malformed AST: it is not possible to print a directive containing both unescaped single and double quotes.");
    }
  }
  function InterpreterDirective2(node) {
    this.token(`#!${node.value}`);
    this._newline();
  }
  function Placeholder2(node) {
    this.token("%%");
    this.print(node.name);
    this.token("%%");
    if (node.expectedNode === "Statement") {
      this.semicolon();
    }
  }
  function JSXAttribute2(node) {
    this.print(node.name);
    if (node.value) {
      this.tokenChar(61);
      this.print(node.value);
    }
  }
  function JSXIdentifier2(node) {
    this.word(node.name);
  }
  function JSXNamespacedName2(node) {
    this.print(node.namespace);
    this.tokenChar(58);
    this.print(node.name);
  }
  function JSXMemberExpression2(node) {
    this.print(node.object);
    this.tokenChar(46);
    this.print(node.property);
  }
  function JSXSpreadAttribute2(node) {
    this.tokenChar(123);
    this.token("...");
    this.print(node.argument);
    this.rightBrace(node);
  }
  function JSXExpressionContainer2(node) {
    this.tokenChar(123);
    this.print(node.expression);
    this.rightBrace(node);
  }
  function JSXSpreadChild2(node) {
    this.tokenChar(123);
    this.token("...");
    this.print(node.expression);
    this.rightBrace(node);
  }
  function JSXText2(node) {
    const raw = this.getPossibleRaw(node);
    if (raw !== void 0) {
      this.token(raw, true);
    } else {
      this.token(node.value, true);
    }
  }
  function JSXElement2(node) {
    const open = node.openingElement;
    this.print(open);
    if (open.selfClosing) return;
    this.indent();
    for (const child of node.children) {
      this.print(child);
    }
    this.dedent();
    this.print(node.closingElement);
  }
  function spaceSeparator() {
    this.space();
  }
  function JSXOpeningElement2(node) {
    this.tokenChar(60);
    this.print(node.name);
    this.print(node.typeArguments);
    if (node.attributes.length > 0) {
      this.space();
      this.printJoin(node.attributes, void 0, void 0, spaceSeparator);
    }
    if (node.selfClosing) {
      this.space();
      this.tokenChar(47);
    }
    this.tokenChar(62);
  }
  function JSXClosingElement2(node) {
    this.tokenChar(60);
    this.tokenChar(47);
    this.print(node.name);
    this.tokenChar(62);
  }
  function JSXEmptyExpression2() {
    this.printInnerComments();
  }
  function JSXFragment2(node) {
    this.print(node.openingFragment);
    this.indent();
    for (const child of node.children) {
      this.print(child);
    }
    this.dedent();
    this.print(node.closingFragment);
  }
  function JSXOpeningFragment2() {
    this.tokenChar(60);
    this.tokenChar(62);
  }
  function JSXClosingFragment2() {
    this.token("</");
    this.tokenChar(62);
  }
  var generatorFunctions = /* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    AnyTypeAnnotation: AnyTypeAnnotation2,
    ArgumentPlaceholder: ArgumentPlaceholder2,
    ArrayExpression: ArrayExpression2,
    ArrayPattern: ArrayExpression2,
    ArrayTypeAnnotation: ArrayTypeAnnotation2,
    ArrowFunctionExpression: ArrowFunctionExpression2,
    AssignmentExpression: AssignmentExpression2,
    AssignmentPattern: AssignmentPattern2,
    AwaitExpression: AwaitExpression2,
    BigIntLiteral: BigIntLiteral2,
    BigIntLiteralTypeAnnotation: BigIntLiteral2,
    BinaryExpression: BinaryExpression2,
    BindExpression: BindExpression2,
    BlockStatement: BlockStatement2,
    BooleanLiteral: BooleanLiteral2,
    BooleanLiteralTypeAnnotation: BooleanLiteralTypeAnnotation2,
    BooleanTypeAnnotation: BooleanTypeAnnotation2,
    BreakStatement: BreakStatement2,
    CallExpression: CallExpression2,
    CatchClause: CatchClause2,
    ClassAccessorProperty: ClassAccessorProperty2,
    ClassBody: ClassBody2,
    ClassDeclaration: ClassDeclaration2,
    ClassExpression: ClassDeclaration2,
    ClassImplements: InterfaceExtends2,
    ClassMethod: ClassMethod2,
    ClassPrivateMethod: ClassPrivateMethod2,
    ClassPrivateProperty: ClassPrivateProperty2,
    ClassProperty: ClassProperty2,
    ConditionalExpression: ConditionalExpression2,
    ContinueStatement: ContinueStatement2,
    DebuggerStatement: DebuggerStatement2,
    DeclareClass: DeclareClass2,
    DeclareExportAllDeclaration: DeclareExportAllDeclaration2,
    DeclareExportDeclaration: DeclareExportDeclaration2,
    DeclareFunction: DeclareFunction2,
    DeclareInterface: DeclareInterface2,
    DeclareModule: DeclareModule2,
    DeclareModuleExports: DeclareModuleExports2,
    DeclareOpaqueType: DeclareOpaqueType2,
    DeclareTypeAlias: DeclareTypeAlias2,
    DeclareVariable: DeclareVariable2,
    DeclaredPredicate: DeclaredPredicate2,
    Decorator: Decorator2,
    Directive: Directive2,
    DirectiveLiteral: DirectiveLiteral2,
    DoExpression: DoExpression2,
    DoWhileStatement: DoWhileStatement2,
    EmptyStatement: EmptyStatement2,
    EmptyTypeAnnotation: EmptyTypeAnnotation2,
    EnumBooleanBody: EnumBooleanBody2,
    EnumBooleanMember: EnumBooleanMember2,
    EnumDeclaration: EnumDeclaration2,
    EnumDefaultedMember: EnumDefaultedMember2,
    EnumNumberBody: EnumNumberBody2,
    EnumNumberMember: EnumNumberMember2,
    EnumStringBody: EnumStringBody2,
    EnumStringMember: EnumStringMember2,
    EnumSymbolBody: EnumSymbolBody2,
    ExistsTypeAnnotation: ExistsTypeAnnotation2,
    ExportAllDeclaration: ExportAllDeclaration2,
    ExportDefaultDeclaration: ExportDefaultDeclaration2,
    ExportDefaultSpecifier: ExportDefaultSpecifier2,
    ExportNamedDeclaration: ExportNamedDeclaration2,
    ExportNamespaceSpecifier: ExportNamespaceSpecifier2,
    ExportSpecifier: ExportSpecifier2,
    ExpressionStatement: ExpressionStatement2,
    File: File2,
    ForInStatement: ForInStatement2,
    ForOfStatement: ForOfStatement2,
    ForStatement: ForStatement2,
    FunctionDeclaration: FunctionExpression2,
    FunctionExpression: FunctionExpression2,
    FunctionTypeAnnotation: FunctionTypeAnnotation2,
    FunctionTypeParam: FunctionTypeParam2,
    GenericTypeAnnotation: InterfaceExtends2,
    Identifier: Identifier2,
    IfStatement: IfStatement2,
    Import: Import2,
    ImportAttribute: ImportAttribute2,
    ImportDeclaration: ImportDeclaration2,
    ImportDefaultSpecifier: ImportDefaultSpecifier2,
    ImportExpression: ImportExpression2,
    ImportNamespaceSpecifier: ImportNamespaceSpecifier2,
    ImportSpecifier: ImportSpecifier2,
    IndexedAccessType: IndexedAccessType2,
    InferredPredicate: InferredPredicate2,
    InterfaceDeclaration: InterfaceDeclaration2,
    InterfaceExtends: InterfaceExtends2,
    InterfaceTypeAnnotation: InterfaceTypeAnnotation2,
    InterpreterDirective: InterpreterDirective2,
    IntersectionTypeAnnotation: IntersectionTypeAnnotation2,
    JSXAttribute: JSXAttribute2,
    JSXClosingElement: JSXClosingElement2,
    JSXClosingFragment: JSXClosingFragment2,
    JSXElement: JSXElement2,
    JSXEmptyExpression: JSXEmptyExpression2,
    JSXExpressionContainer: JSXExpressionContainer2,
    JSXFragment: JSXFragment2,
    JSXIdentifier: JSXIdentifier2,
    JSXMemberExpression: JSXMemberExpression2,
    JSXNamespacedName: JSXNamespacedName2,
    JSXOpeningElement: JSXOpeningElement2,
    JSXOpeningFragment: JSXOpeningFragment2,
    JSXSpreadAttribute: JSXSpreadAttribute2,
    JSXSpreadChild: JSXSpreadChild2,
    JSXText: JSXText2,
    LabeledStatement: LabeledStatement2,
    LogicalExpression: AssignmentExpression2,
    MemberExpression: MemberExpression2,
    MetaProperty: MetaProperty2,
    MixedTypeAnnotation: MixedTypeAnnotation2,
    ModuleExpression: ModuleExpression2,
    NewExpression: NewExpression2,
    NullLiteral: NullLiteral2,
    NullLiteralTypeAnnotation: NullLiteralTypeAnnotation2,
    NullableTypeAnnotation: NullableTypeAnnotation2,
    NumberLiteralTypeAnnotation: NumericLiteral2,
    NumberTypeAnnotation: NumberTypeAnnotation2,
    NumericLiteral: NumericLiteral2,
    ObjectExpression: ObjectExpression2,
    ObjectMethod: ObjectMethod2,
    ObjectPattern: ObjectExpression2,
    ObjectProperty: ObjectProperty2,
    ObjectTypeAnnotation: ObjectTypeAnnotation2,
    ObjectTypeCallProperty: ObjectTypeCallProperty2,
    ObjectTypeIndexer: ObjectTypeIndexer2,
    ObjectTypeInternalSlot: ObjectTypeInternalSlot2,
    ObjectTypeProperty: ObjectTypeProperty2,
    ObjectTypeSpreadProperty: ObjectTypeSpreadProperty2,
    OpaqueType: OpaqueType2,
    OptionalCallExpression: OptionalCallExpression2,
    OptionalIndexedAccessType: OptionalIndexedAccessType2,
    OptionalMemberExpression: OptionalMemberExpression2,
    ParenthesizedExpression: ParenthesizedExpression2,
    Placeholder: Placeholder2,
    PrivateName: PrivateName2,
    Program: Program2,
    QualifiedTypeIdentifier: QualifiedTypeIdentifier2,
    RegExpLiteral: RegExpLiteral2,
    RestElement: RestElement2,
    ReturnStatement: ReturnStatement2,
    SequenceExpression: SequenceExpression2,
    SpreadElement: RestElement2,
    StaticBlock: StaticBlock2,
    StringLiteral: StringLiteral2,
    StringLiteralTypeAnnotation: StringLiteral2,
    StringTypeAnnotation: StringTypeAnnotation2,
    Super: Super2,
    SwitchCase: SwitchCase2,
    SwitchStatement: SwitchStatement2,
    SymbolTypeAnnotation: SymbolTypeAnnotation2,
    TSAnyKeyword: TSAnyKeyword2,
    TSArrayType: TSArrayType2,
    TSAsExpression: TSAsExpression2,
    TSBigIntKeyword: TSBigIntKeyword2,
    TSBooleanKeyword: TSBooleanKeyword2,
    TSCallSignatureDeclaration: TSCallSignatureDeclaration2,
    TSClassImplements: TSClassImplements2,
    TSConditionalType: TSConditionalType2,
    TSConstructSignatureDeclaration: TSConstructSignatureDeclaration2,
    TSConstructorType: TSConstructorType2,
    TSDeclareFunction: TSDeclareFunction2,
    TSDeclareMethod: TSDeclareMethod2,
    TSEnumBody: TSEnumBody2,
    TSEnumDeclaration: TSEnumDeclaration2,
    TSEnumMember: TSEnumMember2,
    TSExportAssignment: TSExportAssignment2,
    TSExternalModuleReference: TSExternalModuleReference2,
    TSFunctionType: TSFunctionType2,
    TSImportEqualsDeclaration: TSImportEqualsDeclaration2,
    TSImportType: TSImportType2,
    TSIndexSignature: TSIndexSignature2,
    TSIndexedAccessType: TSIndexedAccessType2,
    TSInferType: TSInferType2,
    TSInstantiationExpression: TSInstantiationExpression2,
    TSInterfaceBody: TSInterfaceBody2,
    TSInterfaceDeclaration: TSInterfaceDeclaration2,
    TSInterfaceHeritage: TSClassImplements2,
    TSIntersectionType: TSIntersectionType2,
    TSIntrinsicKeyword: TSIntrinsicKeyword2,
    TSLiteralType: TSLiteralType2,
    TSMappedType: TSMappedType2,
    TSMethodSignature: TSMethodSignature2,
    TSModuleBlock: TSModuleBlock2,
    TSModuleDeclaration: TSModuleDeclaration2,
    TSNamedTupleMember: TSNamedTupleMember2,
    TSNamespaceExportDeclaration: TSNamespaceExportDeclaration2,
    TSNeverKeyword: TSNeverKeyword2,
    TSNonNullExpression: TSNonNullExpression2,
    TSNullKeyword: TSNullKeyword2,
    TSNumberKeyword: TSNumberKeyword2,
    TSObjectKeyword: TSObjectKeyword2,
    TSOptionalType: TSOptionalType2,
    TSParameterProperty: TSParameterProperty2,
    TSParenthesizedType: TSParenthesizedType2,
    TSPropertySignature: TSPropertySignature2,
    TSQualifiedName: TSQualifiedName2,
    TSRestType: TSRestType2,
    TSSatisfiesExpression: TSSatisfiesExpression2,
    TSStringKeyword: TSStringKeyword2,
    TSSymbolKeyword: TSSymbolKeyword2,
    TSTemplateLiteralType: TSTemplateLiteralType2,
    TSThisType: TSThisType2,
    TSTupleType: TSTupleType2,
    TSTypeAliasDeclaration: TSTypeAliasDeclaration2,
    TSTypeAnnotation: TSTypeAnnotation2,
    TSTypeAssertion: TSTypeAssertion2,
    TSTypeLiteral: TSTypeLiteral2,
    TSTypeOperator: TSTypeOperator2,
    TSTypeParameter: TSTypeParameter2,
    TSTypeParameterDeclaration: TSTypeParameterInstantiation2,
    TSTypeParameterInstantiation: TSTypeParameterInstantiation2,
    TSTypePredicate: TSTypePredicate2,
    TSTypeQuery: TSTypeQuery2,
    TSTypeReference: TSTypeReference2,
    TSUndefinedKeyword: TSUndefinedKeyword2,
    TSUnionType: TSUnionType2,
    TSUnknownKeyword: TSUnknownKeyword2,
    TSVoidKeyword: TSVoidKeyword2,
    TaggedTemplateExpression: TaggedTemplateExpression2,
    TemplateElement: TemplateElement2,
    TemplateLiteral: TemplateLiteral2,
    ThisExpression: ThisExpression2,
    ThisTypeAnnotation: ThisTypeAnnotation2,
    ThrowStatement: ThrowStatement2,
    TopicReference: TopicReference2,
    TryStatement: TryStatement2,
    TupleTypeAnnotation: TupleTypeAnnotation2,
    TypeAlias: TypeAlias2,
    TypeAnnotation: TypeAnnotation2,
    TypeCastExpression: TypeCastExpression2,
    TypeParameter: TypeParameter2,
    TypeParameterDeclaration: TypeParameterInstantiation2,
    TypeParameterInstantiation: TypeParameterInstantiation2,
    TypeofTypeAnnotation: TypeofTypeAnnotation2,
    UnaryExpression: UnaryExpression2,
    UnionTypeAnnotation: UnionTypeAnnotation2,
    UpdateExpression: UpdateExpression2,
    V8IntrinsicIdentifier: V8IntrinsicIdentifier2,
    VariableDeclaration: VariableDeclaration2,
    VariableDeclarator: VariableDeclarator2,
    Variance: Variance2,
    VoidPattern: VoidPattern2,
    VoidTypeAnnotation: VoidTypeAnnotation2,
    WhileStatement: WhileStatement2,
    WithStatement: WithStatement2,
    YieldExpression: YieldExpression2,
    _classMethodHead,
    _functionHead,
    _getRawIdentifier,
    _interfaceish,
    _methodHead,
    _param,
    _parameters,
    _params,
    _predicate,
    _printAttributes,
    _printTemplate,
    _shouldPrintArrowParamsParens,
    _shouldPrintDecoratorsBeforeExport,
    _tsPrintClassMemberModifiers,
    _variance
  }, Symbol.toStringTag, {
    value: "Module"
  });
  var generatorInfosMap = /* @__PURE__ */ new Map();
  var index = 0;
  for (const key of Object.keys(generatorFunctions).sort()) {
    if (key.startsWith("_")) continue;
    generatorInfosMap.set(key, [generatorFunctions[key], index++, void 0]);
  }
  var {
    VISITOR_KEYS: VISITOR_KEYS$1
  } = lib_exports;
  for (const type of Object.keys(parens)) {
    const func = parens[type];
    if (generatorInfosMap.has(type)) {
      generatorInfosMap.get(type)[2] = func;
    }
  }
  function newCalleeNeedsParens(node) {
    let current = node;
    while (true) {
      switch (current.type) {
        case "CallExpression":
        case "ImportExpression":
        case "OptionalCallExpression":
        case "OptionalMemberExpression":
          return true;
        case "MemberExpression":
          current = current.object;
          break;
        case "TaggedTemplateExpression":
          current = current.tag;
          break;
        case "TSNonNullExpression":
          current = current.expression;
          break;
        default:
          return false;
      }
    }
  }
  function parentNeedsParens(node, parent, parentId) {
    switch (parentId) {
      case 113:
        if (parent.callee === node) {
          return newCalleeNeedsParens(node);
        }
        break;
      case 43:
        return !isDecoratorMemberExpression(node) && !(node.type === "CallExpression" && isDecoratorMemberExpression(node.callee)) && node.type !== "ParenthesizedExpression";
    }
    return false;
  }
  function isDecoratorMemberExpression(node) {
    switch (node.type) {
      case "Identifier":
        return true;
      case "MemberExpression":
        return !node.computed && node.property.type === "Identifier" && isDecoratorMemberExpression(node.object);
      default:
        return false;
    }
  }
  function isLastChild(parent, child) {
    const visitorKeys = VISITOR_KEYS$1[parent.type];
    for (let i = visitorKeys.length - 1; i >= 0; i--) {
      const val = parent[visitorKeys[i]];
      if (val === child) {
        return true;
      } else if (Array.isArray(val)) {
        let j = val.length - 1;
        while (j >= 0 && val[j] === null) j--;
        return j >= 0 && val[j] === child;
      } else if (val) {
        return false;
      }
    }
    return false;
  }
  var {
    traverseFast: traverseFast2,
    VISITOR_KEYS: VISITOR_KEYS2
  } = lib_exports;
  var TokenMap = class {
    constructor(ast, tokens, source) {
      __publicField(this, "_tokens");
      __publicField(this, "_source");
      __publicField(this, "_nodesToTokenIndexes", /* @__PURE__ */ new Map());
      __publicField(this, "_nodesOccurrencesCountCache", /* @__PURE__ */ new Map());
      __publicField(this, "_tokensCache", /* @__PURE__ */ new Map());
      this._tokens = tokens;
      this._source = source;
      traverseFast2(ast, (node) => {
        const indexes = this._getTokensIndexesOfNode(node);
        if (indexes.length > 0) this._nodesToTokenIndexes.set(node, indexes);
      });
      this._tokensCache.clear();
    }
    has(node) {
      return this._nodesToTokenIndexes.has(node);
    }
    getIndexes(node) {
      return this._nodesToTokenIndexes.get(node);
    }
    find(node, condition) {
      const indexes = this._nodesToTokenIndexes.get(node);
      if (indexes) {
        for (let k = 0; k < indexes.length; k++) {
          const index2 = indexes[k];
          const tok = this._tokens[index2];
          if (condition(tok, index2)) return tok;
        }
      }
      return null;
    }
    findLastIndex(node, condition) {
      const indexes = this._nodesToTokenIndexes.get(node);
      if (indexes) {
        for (let k = indexes.length - 1; k >= 0; k--) {
          const index2 = indexes[k];
          const tok = this._tokens[index2];
          if (condition(tok, index2)) return index2;
        }
      }
      return -1;
    }
    findMatching(node, test, occurrenceCount = 0) {
      const indexes = this._nodesToTokenIndexes.get(node);
      if (indexes) {
        if (typeof test === "number") {
          test = String.fromCharCode(test);
        }
        let i = 0;
        const count = occurrenceCount;
        if (count > 1) {
          const cache = this._nodesOccurrencesCountCache.get(node);
          if ((cache == null ? void 0 : cache.test) === test && cache.count < count) {
            i = cache.i + 1;
            occurrenceCount -= cache.count + 1;
          }
        }
        for (; i < indexes.length; i++) {
          const tok = this._tokens[indexes[i]];
          if (this.matchesOriginal(tok, test)) {
            if (occurrenceCount === 0) {
              if (count > 0) {
                this._nodesOccurrencesCountCache.set(node, {
                  test,
                  count,
                  i
                });
              }
              return tok;
            }
            occurrenceCount--;
          }
        }
      }
      return null;
    }
    matchesOriginal(token, test) {
      if (token.end - token.start !== test.length) return false;
      if (token.value != null) return token.value === test;
      return this._source.startsWith(test, token.start);
    }
    startMatches(node, test) {
      const indexes = this._nodesToTokenIndexes.get(node);
      if (!indexes) return false;
      const tok = this._tokens[indexes[0]];
      if (tok.start !== node.start) return false;
      return this.matchesOriginal(tok, test);
    }
    endMatches(node, test) {
      const indexes = this._nodesToTokenIndexes.get(node);
      if (!indexes) return false;
      const tok = this._tokens[indexes[indexes.length - 1]];
      if (tok.end !== node.end) return false;
      return this.matchesOriginal(tok, test);
    }
    _getTokensIndexesOfNode(node) {
      var _a;
      if (node.start == null || node.end == null) return [];
      const {
        first,
        last
      } = this._findTokensOfNode(node, 0, this._tokens.length - 1);
      let low = first;
      const children = childrenIterator(node);
      if ((node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") && ((_a = node.declaration) == null ? void 0 : _a.type) === "ClassDeclaration") {
        children.next();
      }
      const indexes = [];
      for (const child of children) {
        if (child == null) continue;
        if (child.start == null || child.end == null) continue;
        const childTok = this._findTokensOfNode(child, low, last);
        const high = childTok.first;
        for (let k = low; k < high; k++) indexes.push(k);
        low = childTok.last + 1;
      }
      for (let k = low; k <= last; k++) indexes.push(k);
      return indexes;
    }
    _findTokensOfNode(node, low, high) {
      const cached = this._tokensCache.get(node);
      if (cached) return cached;
      const first = this._findFirstTokenOfNode(node.start, low, high);
      const last = this._findLastTokenOfNode(node.end, first, high);
      this._tokensCache.set(node, {
        first,
        last
      });
      return {
        first,
        last
      };
    }
    _findFirstTokenOfNode(start, low, high) {
      while (low <= high) {
        const mid = high + low >> 1;
        if (start < this._tokens[mid].start) {
          high = mid - 1;
        } else if (start > this._tokens[mid].start) {
          low = mid + 1;
        } else {
          return mid;
        }
      }
      return low;
    }
    _findLastTokenOfNode(end, low, high) {
      while (low <= high) {
        const mid = high + low >> 1;
        if (end < this._tokens[mid].end) {
          high = mid - 1;
        } else if (end > this._tokens[mid].end) {
          low = mid + 1;
        } else {
          return mid;
        }
      }
      return high;
    }
  };
  function* childrenIterator(node) {
    if (node.type === "TemplateLiteral") {
      yield node.quasis[0];
      for (let i = 1; i < node.quasis.length; i++) {
        yield node.expressions[i - 1];
        yield node.quasis[i];
      }
      return;
    }
    const keys2 = VISITOR_KEYS2[node.type];
    for (const key of keys2) {
      const child = node[key];
      if (!child) continue;
      if (Array.isArray(child)) {
        yield* child;
      } else {
        yield child;
      }
    }
  }
  var {
    isExpression: isExpression2,
    isFunction: isFunction2,
    isStatement: isStatement2,
    isClassBody: isClassBody2,
    isTSInterfaceBody: isTSInterfaceBody2,
    isTSEnumMember: isTSEnumMember2
  } = lib_exports;
  var SCIENTIFIC_NOTATION = /e/i;
  var ZERO_DECIMAL_INTEGER = /\.0+$/;
  var HAS_NEWLINE = /[\n\r\u2028\u2029]/;
  var HAS_NEWLINE_OR_BlOCK_COMMENT_END = /[\n\r\u2028\u2029]|\*\//;
  function commentIsNewline(c) {
    return c.type === "CommentLine" || HAS_NEWLINE.test(c.value);
  }
  var Printer = class {
    constructor(format, map, tokens = null, originalCode = null) {
      __publicField(this, "tokenContext", 0);
      __publicField(this, "_tokens", null);
      __publicField(this, "_originalCode", null);
      __publicField(this, "_currentNode", null);
      __publicField(this, "_currentTypeId", null);
      __publicField(this, "_indent", 0);
      __publicField(this, "_indentRepeat", 0);
      __publicField(this, "_insideAux", false);
      __publicField(this, "_noLineTerminator", false);
      __publicField(this, "_noLineTerminatorAfterNode", null);
      __publicField(this, "_printAuxAfterOnNextUserNode", false);
      __publicField(this, "_printedComments", /* @__PURE__ */ new Set());
      __publicField(this, "_lastCommentLine", 0);
      __publicField(this, "_innerCommentsState", 0);
      __publicField(this, "_flags", 0);
      __publicField(this, "tokenMap", null);
      __publicField(this, "_boundGetRawIdentifier", null);
      __publicField(this, "_printSemicolonBeforeNextNode", -1);
      __publicField(this, "_printSemicolonBeforeNextToken", -1);
      this.format = format;
      this._tokens = tokens;
      this._originalCode = originalCode;
      this._indentRepeat = format.indent.style.length;
      this._inputMap = (map == null ? void 0 : map._inputMap) || null;
      this._buf = new Buffer2(map, format.indent.style[0]);
      const {
        preserveFormat,
        compact,
        concise,
        retainLines,
        retainFunctionParens
      } = format;
      if (preserveFormat) {
        this._flags |= 1;
      }
      if (compact) {
        this._flags |= 2;
      }
      if (concise) {
        this._flags |= 4;
      }
      if (retainLines) {
        this._flags |= 8;
      }
      if (retainFunctionParens) {
        this._flags |= 16;
      }
      if (format.auxiliaryCommentBefore || format.auxiliaryCommentAfter) {
        this._flags |= 32;
      }
    }
    enterDelimited() {
      const oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
      if (oldNoLineTerminatorAfterNode !== null) {
        this._noLineTerminatorAfterNode = null;
      }
      return oldNoLineTerminatorAfterNode;
    }
    generate(ast) {
      if (this.format.preserveFormat) {
        this.tokenMap = new TokenMap(ast, this._tokens, this._originalCode);
        this._boundGetRawIdentifier = _getRawIdentifier.bind(this);
      }
      this.print(ast);
      this._maybeAddAuxComment();
      return this._buf.get();
    }
    indent(flags = this._flags) {
      if (flags & (1 | 2 | 4)) {
        return;
      }
      this._indent += this._indentRepeat;
    }
    dedent(flags = this._flags) {
      if (flags & (1 | 2 | 4)) {
        return;
      }
      this._indent -= this._indentRepeat;
    }
    semicolon(force = false) {
      const flags = this._flags;
      if (flags & 32) {
        this._maybeAddAuxComment();
      }
      if (flags & 1) {
        const node = this._currentNode;
        if (node.start != null && node.end != null) {
          if (!this.tokenMap.endMatches(node, ";")) {
            this._printSemicolonBeforeNextNode = this._buf.getCurrentLine();
            return;
          }
          const indexes = this.tokenMap.getIndexes(this._currentNode);
          this._catchUpTo(this._tokens[indexes[indexes.length - 1]].loc.start);
        }
      }
      if (force) {
        this._appendChar(59);
      } else {
        this._queue(59);
      }
      this._noLineTerminator = false;
    }
    rightBrace(node) {
      if (this.format.minified) {
        this._buf.removeLastSemicolon();
      }
      this.sourceWithOffset("end", node.loc, -1);
      this.tokenChar(125);
    }
    rightParens(node) {
      this.sourceWithOffset("end", node.loc, -1);
      this.tokenChar(41);
    }
    space(force = false) {
      if (this._flags & (1 | 2)) {
        return;
      }
      if (force) {
        this._space();
      } else {
        const lastCp = this.getLastChar(true);
        if (lastCp !== 0 && lastCp !== 32 && lastCp !== 10) {
          this._space();
        }
      }
    }
    word(str, noLineTerminatorAfter = false) {
      this.tokenContext &= 128;
      this._maybePrintInnerComments(str);
      const flags = this._flags;
      if (flags & 32) {
        this._maybeAddAuxComment();
      }
      if (flags & 1) this._catchUpToCurrentToken(str);
      const lastChar = this.getLastChar();
      if (lastChar === -2 || lastChar === -3 || lastChar === 47 && str.charCodeAt(0) === 47) {
        this._space();
      }
      this._append(str, false);
      this.setLastChar(-3);
      this._noLineTerminator = noLineTerminatorAfter;
    }
    number(str, number) {
      function isNonDecimalLiteral(str2) {
        if (str2.length > 2 && str2.charCodeAt(0) === 48) {
          const secondChar = str2.charCodeAt(1);
          return secondChar === 98 || secondChar === 111 || secondChar === 120;
        }
        return false;
      }
      this.word(str);
      if (Number.isInteger(number) && !isNonDecimalLiteral(str) && !SCIENTIFIC_NOTATION.test(str) && !ZERO_DECIMAL_INTEGER.test(str) && str.charCodeAt(str.length - 1) !== 46) {
        this.setLastChar(-2);
      }
    }
    token(str, maybeNewline = false, occurrenceCount = 0, mayNeedSpace = false) {
      this.tokenContext &= 128;
      this._maybePrintInnerComments(str, occurrenceCount);
      const flags = this._flags;
      if (flags & 32) {
        this._maybeAddAuxComment();
      }
      if (flags & 1) {
        this._catchUpToCurrentToken(str, occurrenceCount);
      }
      if (mayNeedSpace) {
        const strFirst = str.charCodeAt(0);
        if ((strFirst === 45 && str === "--" || strFirst === 61) && this.getLastChar() === 33 || strFirst === 43 && this.getLastChar() === 43 || strFirst === 45 && this.getLastChar() === 45 || strFirst === 46 && this.getLastChar() === -2) {
          this._space();
        }
      }
      this._append(str, maybeNewline);
      this._noLineTerminator = false;
    }
    tokenChar(char, occurrenceCount = 0) {
      this.tokenContext &= 128;
      this._maybePrintInnerComments(char, occurrenceCount);
      const flags = this._flags;
      if (flags & 32) {
        this._maybeAddAuxComment();
      }
      if (flags & 1) {
        this._catchUpToCurrentToken(char, occurrenceCount);
      }
      if (char === 43 && this.getLastChar() === 43 || char === 45 && this.getLastChar() === 45 || char === 46 && this.getLastChar() === -2) {
        this._space();
      }
      this._appendChar(char);
      this._noLineTerminator = false;
    }
    newline(i = 1, flags = this._flags) {
      if (i <= 0) return;
      if (flags & (8 | 2)) {
        return;
      }
      if (flags & 4) {
        this.space();
        return;
      }
      if (i > 2) i = 2;
      i -= this._buf.getNewlineCount();
      for (let j = 0; j < i; j++) {
        this._newline();
      }
    }
    endsWith(char) {
      return this.getLastChar(true) === char;
    }
    getLastChar(checkQueue) {
      return this._buf.getLastChar(checkQueue);
    }
    setLastChar(char) {
      this._buf._last = char;
    }
    exactSource(loc, cb) {
      if (!loc) {
        cb();
        return;
      }
      this._catchUp("start", loc);
      this._buf.exactSource(loc, cb);
    }
    source(prop, loc) {
      if (!loc) return;
      this._catchUp(prop, loc);
      this._buf.source(prop, loc);
    }
    sourceWithOffset(prop, loc, columnOffset) {
      if (!loc || this.format.preserveFormat) return;
      this._catchUp(prop, loc);
      this._buf.sourceWithOffset(prop, loc, columnOffset);
    }
    sourceIdentifierName(identifierName, pos) {
      if (!this._buf._canMarkIdName) return;
      const sourcePosition = this._buf._sourcePosition;
      sourcePosition.identifierNamePos = pos;
      sourcePosition.identifierName = identifierName;
    }
    _space() {
      this._queue(32);
    }
    _newline() {
      if (this._buf._queuedChar === 32) this._buf._queuedChar = 0;
      this._appendChar(10, true);
    }
    _catchUpToCurrentToken(str, occurrenceCount = 0) {
      const token = this.tokenMap.findMatching(this._currentNode, str, occurrenceCount);
      if (token) this._catchUpTo(token.loc.start);
      if (this._printSemicolonBeforeNextToken !== -1 && this._printSemicolonBeforeNextToken === this._buf.getCurrentLine()) {
        this._appendChar(59, true);
      }
      this._printSemicolonBeforeNextToken = -1;
      this._printSemicolonBeforeNextNode = -1;
    }
    _append(str, maybeNewline) {
      this._maybeIndent();
      this._buf.append(str, maybeNewline);
    }
    _appendChar(char, noIndent) {
      if (!noIndent) {
        this._maybeIndent();
      }
      this._buf.appendChar(char);
    }
    _queue(char) {
      this._buf.queue(char);
      this.setLastChar(-1);
    }
    _maybeIndent() {
      const indent = this._shouldIndent();
      if (indent > 0) {
        this._buf._appendChar(-1, indent, false);
      }
    }
    _shouldIndent() {
      return this.endsWith(10) ? this._indent : 0;
    }
    catchUp(line) {
      if (!this.format.retainLines) return;
      const count = line - this._buf.getCurrentLine();
      for (let i = 0; i < count; i++) {
        this._newline();
      }
    }
    _catchUp(prop, loc) {
      const flags = this._flags;
      if ((flags & 1) === 0) {
        if (flags & 8 && (loc == null ? void 0 : loc[prop])) {
          this.catchUp(loc[prop].line);
        }
        return;
      }
      const pos = loc == null ? void 0 : loc[prop];
      if (pos != null) this._catchUpTo(pos);
    }
    _catchUpTo({
      line,
      column,
      index: index2
    }) {
      const count = line - this._buf.getCurrentLine();
      if (count > 0 && this._noLineTerminator) {
        return;
      }
      for (let i = 0; i < count; i++) {
        this._newline();
      }
      const spacesCount = count > 0 ? column : column - this._buf.getCurrentColumn();
      if (spacesCount > 0) {
        const spaces = this._originalCode ? this._originalCode.slice(index2 - spacesCount, index2).replace(/[^\t\v\f\uFEFF\p{Space_Separator}]/gu, " ") : " ".repeat(spacesCount);
        this._buf.append(spaces, false, true);
        this._buf.setSourcePosition(line, column);
        this.setLastChar(32);
      }
    }
    printTerminatorless(node) {
      this._noLineTerminator = true;
      this.print(node);
    }
    print(node, noLineTerminatorAfter = false, resetTokenContext = false, trailingCommentsLineOffset) {
      var _a, _b, _c;
      if (!node) return;
      this._innerCommentsState = 0;
      const {
        type,
        loc,
        extra
      } = node;
      const flags = this._flags;
      let changedFlags = false;
      if (node._compact) {
        this._flags |= 4;
        changedFlags = true;
      }
      const nodeInfo = generatorInfosMap.get(type);
      if (nodeInfo === void 0) {
        throw new ReferenceError(`unknown node of type ${JSON.stringify(type)} with constructor ${JSON.stringify(node.constructor.name)}`);
      }
      const [printMethod, nodeId, needsParens] = nodeInfo;
      const parent = this._currentNode;
      const parentId = this._currentTypeId;
      this._currentNode = node;
      this._currentTypeId = nodeId;
      if (flags & 1) {
        this._printSemicolonBeforeNextToken = this._printSemicolonBeforeNextNode;
      }
      let oldInAux;
      if (flags & 32) {
        oldInAux = this._insideAux;
        this._insideAux = loc == null;
        this._maybeAddAuxComment(this._insideAux && !oldInAux);
      }
      let oldTokenContext = 0;
      if (resetTokenContext) {
        oldTokenContext = this.tokenContext;
        if (oldTokenContext & 128) {
          this.tokenContext = 0;
        } else {
          oldTokenContext = 0;
        }
      }
      const parenthesized = extra != null && extra.parenthesized;
      let shouldPrintParens = parenthesized && flags & 1 || parenthesized && flags & 16 && nodeId === 72 || parent && (parentNeedsParens(node, parent, parentId) || needsParens != null && needsParens(node, parent, parentId, this.tokenContext, flags & 1 ? this._boundGetRawIdentifier : void 0));
      if (!shouldPrintParens && parenthesized && ((_a = node.leadingComments) == null ? void 0 : _a.length) && node.leadingComments[0].type === "CommentBlock") {
        switch (parentId) {
          case 66:
          case 241:
          case 6:
          case 141:
            break;
          case 18:
          case 131:
          case 113:
            if (parent.callee !== node) break;
          default:
            shouldPrintParens = true;
        }
      }
      let indentParenthesized = false;
      if (!shouldPrintParens && this._noLineTerminator && (((_b = node.leadingComments) == null ? void 0 : _b.some(commentIsNewline)) || flags & 8 && loc && loc.start.line > this._buf.getCurrentLine())) {
        shouldPrintParens = true;
        indentParenthesized = true;
      }
      let oldNoLineTerminatorAfterNode;
      if (!shouldPrintParens) {
        noLineTerminatorAfter || (noLineTerminatorAfter = !!parent && this._noLineTerminatorAfterNode === parent && isLastChild(parent, node));
        if (noLineTerminatorAfter) {
          if ((_c = node.trailingComments) == null ? void 0 : _c.some(commentIsNewline)) {
            if (isExpression2(node)) shouldPrintParens = true;
          } else {
            oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
            this._noLineTerminatorAfterNode = node;
          }
        }
      }
      if (shouldPrintParens) {
        this.tokenChar(40);
        if (indentParenthesized) this.indent();
        this._innerCommentsState = 0;
        if (!resetTokenContext) {
          oldTokenContext = this.tokenContext;
        }
        if (oldTokenContext & 128) {
          this.tokenContext = 0;
        }
        oldNoLineTerminatorAfterNode = this._noLineTerminatorAfterNode;
        this._noLineTerminatorAfterNode = null;
      }
      this._printLeadingComments(node, parent);
      this.exactSource(nodeId === 137 || nodeId === 67 ? null : loc, printMethod.bind(this, node, parent));
      if (shouldPrintParens) {
        this._printTrailingComments(node, parent);
        if (indentParenthesized) {
          this.dedent();
          this.newline();
        }
        this.tokenChar(41);
        this._noLineTerminator = noLineTerminatorAfter;
      } else if (noLineTerminatorAfter && !this._noLineTerminator) {
        this._noLineTerminator = true;
        this._printTrailingComments(node, parent);
      } else {
        this._printTrailingComments(node, parent, trailingCommentsLineOffset);
      }
      if (oldTokenContext) this.tokenContext = oldTokenContext;
      this._currentNode = parent;
      this._currentTypeId = parentId;
      if (changedFlags) {
        this._flags = flags;
      }
      if (flags & 32) {
        this._insideAux = oldInAux;
      }
      if (oldNoLineTerminatorAfterNode != null) {
        this._noLineTerminatorAfterNode = oldNoLineTerminatorAfterNode;
      }
      this._innerCommentsState = 0;
    }
    _maybeAddAuxComment(enteredPositionlessNode) {
      if (enteredPositionlessNode) this._printAuxBeforeComment();
      if (!this._insideAux) this._printAuxAfterComment();
    }
    _printAuxBeforeComment() {
      if (this._printAuxAfterOnNextUserNode) return;
      this._printAuxAfterOnNextUserNode = true;
      const comment = this.format.auxiliaryCommentBefore;
      if (comment) {
        this._printComment({
          type: "CommentBlock",
          value: comment
        }, 0);
      }
    }
    _printAuxAfterComment() {
      if (!this._printAuxAfterOnNextUserNode) return;
      this._printAuxAfterOnNextUserNode = false;
      const comment = this.format.auxiliaryCommentAfter;
      if (comment) {
        this._printComment({
          type: "CommentBlock",
          value: comment
        }, 0);
      }
    }
    getPossibleRaw(node) {
      const extra = node.extra;
      if ((extra == null ? void 0 : extra.raw) != null && extra.rawValue != null && node.value === extra.rawValue) {
        return extra.raw;
      }
    }
    printJoin(nodes, statement, indent, separator, printTrailingSeparator, resetTokenContext, trailingCommentsLineOffset) {
      var _a, _b;
      if (!(nodes == null ? void 0 : nodes.length)) return;
      const flags = this._flags;
      if (indent == null && flags & 8) {
        const startLine = (_a = nodes[0].loc) == null ? void 0 : _a.start.line;
        if (startLine != null && startLine !== this._buf.getCurrentLine()) {
          indent = true;
        }
      }
      if (indent) this.indent(flags);
      const len = nodes.length;
      for (let i = 0; i < len; i++) {
        const node = nodes[i];
        if (!node) continue;
        if (statement && i === 0 && this._buf.hasContent()) {
          this.newline(1, flags);
        }
        this.print(node, false, resetTokenContext, trailingCommentsLineOffset || 0);
        if (separator != null) {
          if (i < len - 1) separator.call(this, i, false);
          else if (printTrailingSeparator) separator.call(this, i, true);
        }
        if (statement) {
          if (i + 1 === len) {
            this.newline(1, flags);
          } else {
            const lastCommentLine = this._lastCommentLine;
            if (lastCommentLine > 0) {
              const offset = (((_b = nodes[i + 1].loc) == null ? void 0 : _b.start.line) || 0) - lastCommentLine;
              if (offset >= 0) {
                this.newline(offset || 1, flags);
                continue;
              }
            }
            this.newline(1, flags);
          }
        }
      }
      if (indent) this.dedent(flags);
    }
    printAndIndentOnComments(node) {
      const indent = node.leadingComments && node.leadingComments.length > 0;
      if (indent) this.indent();
      this.print(node);
      if (indent) this.dedent();
    }
    printBlock(body) {
      if (body.type !== "EmptyStatement") {
        this.space();
      }
      this.print(body);
    }
    _printTrailingComments(node, parent, lineOffset) {
      const {
        innerComments,
        trailingComments
      } = node;
      if (innerComments == null ? void 0 : innerComments.length) {
        this._printComments(2, innerComments, node, parent, lineOffset);
      }
      if (trailingComments == null ? void 0 : trailingComments.length) {
        this._printComments(2, trailingComments, node, parent, lineOffset);
      } else {
        this._lastCommentLine = 0;
      }
    }
    _printLeadingComments(node, parent) {
      const comments = node.leadingComments;
      if (!(comments == null ? void 0 : comments.length)) return;
      this._printComments(0, comments, node, parent);
    }
    _maybePrintInnerComments(nextTokenStr, nextTokenOccurrenceCount) {
      var _a;
      const state = this._innerCommentsState;
      switch (state & 3) {
        case 0:
          this._innerCommentsState = 1 | 4;
          return;
        case 1:
          this.printInnerComments((state & 4) > 0, (_a = this.tokenMap) == null ? void 0 : _a.findMatching(this._currentNode, nextTokenStr, nextTokenOccurrenceCount));
      }
    }
    printInnerComments(indent = true, nextToken) {
      const node = this._currentNode;
      const comments = node.innerComments;
      if (!(comments == null ? void 0 : comments.length)) {
        this._innerCommentsState = 2;
        return;
      }
      const hasSpace = this.endsWith(32);
      if (indent) this.indent();
      switch (this._printComments(1, comments, node, void 0, void 0, nextToken)) {
        case 2:
          this._innerCommentsState = 2;
        case 1:
          if (hasSpace) this.space();
      }
      if (indent) this.dedent();
    }
    noIndentInnerCommentsHere() {
      this._innerCommentsState &= -5;
    }
    printSequence(nodes, indent, resetTokenContext, trailingCommentsLineOffset) {
      this.printJoin(nodes, true, indent != null ? indent : false, void 0, void 0, resetTokenContext, trailingCommentsLineOffset);
    }
    printList(items, printTrailingSeparator, statement, indent, separator, resetTokenContext) {
      this.printJoin(items, statement, indent, separator != null ? separator : commaSeparator, printTrailingSeparator, resetTokenContext);
    }
    shouldPrintTrailingComma(listEnd) {
      if (!this.tokenMap) return null;
      const listEndIndex = this.tokenMap.findLastIndex(this._currentNode, (token) => this.tokenMap.matchesOriginal(token, typeof listEnd === "number" ? String.fromCharCode(listEnd) : listEnd));
      if (listEndIndex <= 0) return null;
      return this.tokenMap.matchesOriginal(this._tokens[listEndIndex - 1], ",");
    }
    _shouldPrintComment(comment, nextToken) {
      if (comment.ignore) return 0;
      if (this._printedComments.has(comment)) return 0;
      if (this._noLineTerminator && HAS_NEWLINE_OR_BlOCK_COMMENT_END.test(comment.value)) {
        return 2;
      }
      if (nextToken && this.tokenMap) {
        const commentTok = this.tokenMap.find(this._currentNode, (token) => token.value === comment.value);
        if (commentTok && commentTok.start > nextToken.start) {
          return 2;
        }
      }
      this._printedComments.add(comment);
      if (!this.format.shouldPrintComment(comment.value)) {
        return 0;
      }
      return 1;
    }
    _printComment(comment, skipNewLines) {
      var _a;
      const noLineTerminator = this._noLineTerminator;
      const isBlockComment = comment.type === "CommentBlock";
      const printNewLines = isBlockComment && skipNewLines !== 1 && !noLineTerminator;
      if (printNewLines && this._buf.hasContent() && skipNewLines !== 2) {
        this.newline(1);
      }
      switch (this.getLastChar(true)) {
        case 47:
          this._space();
        case 91:
        case 123:
        case 40:
          break;
        default:
          this.space();
      }
      let val;
      if (isBlockComment) {
        val = `/*${comment.value}*/`;
        if (this.format.indent.adjustMultilineComment) {
          const offset = (_a = comment.loc) == null ? void 0 : _a.start.column;
          if (offset) {
            const newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
            val = val.replace(newlineRegex, "\n");
          }
          if (this._flags & 4) {
            val = val.replace(/\n(?!$)/g, `
`);
          } else {
            let indentSize = this.format.retainLines ? 0 : this._buf.getCurrentColumn();
            if (this._shouldIndent() || this.format.retainLines) {
              indentSize += this._indent;
            }
            val = val.replace(/\n(?!$)/g, `
${" ".repeat(indentSize)}`);
          }
        }
      } else if (!noLineTerminator) {
        val = `//${comment.value}`;
      } else {
        val = `/*${comment.value}*/`;
      }
      this.source("start", comment.loc);
      this._append(val, isBlockComment);
      if (!isBlockComment && !noLineTerminator) {
        this._newline();
      }
      if (printNewLines && skipNewLines !== 3) {
        this.newline(1);
      }
    }
    _printComments(type, comments, node, parent, lineOffset = 0, nextToken) {
      const nodeLoc = node.loc;
      const len = comments.length;
      let hasLoc = !!nodeLoc;
      const nodeStartLine = hasLoc ? nodeLoc.start.line : 0;
      const nodeEndLine = hasLoc ? nodeLoc.end.line : 0;
      let lastLine = 0;
      let leadingCommentNewline = 0;
      const {
        _noLineTerminator,
        _flags
      } = this;
      for (let i = 0; i < len; i++) {
        const comment = comments[i];
        const shouldPrint = this._shouldPrintComment(comment, nextToken);
        if (shouldPrint === 2) {
          return i === 0 ? 0 : 1;
        }
        if (hasLoc && comment.loc && shouldPrint === 1) {
          const commentStartLine = comment.loc.start.line;
          const commentEndLine = comment.loc.end.line;
          if (type === 0) {
            let offset = 0;
            if (i === 0) {
              if (this._buf.hasContent() && (comment.type === "CommentLine" || commentStartLine !== commentEndLine)) {
                offset = leadingCommentNewline = 1;
              }
            } else {
              offset = commentStartLine - lastLine;
            }
            lastLine = commentEndLine;
            if (offset > 0 && !_noLineTerminator) {
              this.newline(offset, _flags);
            }
            this._printComment(comment, 1);
            if (i + 1 === len) {
              const count = Math.max(nodeStartLine - lastLine, leadingCommentNewline);
              if (count > 0 && !_noLineTerminator) {
                this.newline(count, _flags);
              }
              lastLine = nodeStartLine;
            }
          } else if (type === 1) {
            const offset = commentStartLine - (i === 0 ? nodeStartLine : lastLine);
            lastLine = commentEndLine;
            if (offset > 0 && !_noLineTerminator) {
              this.newline(offset, _flags);
            }
            this._printComment(comment, 1);
            if (i + 1 === len) {
              const count = Math.min(1, nodeEndLine - lastLine);
              if (count > 0 && !_noLineTerminator) {
                this.newline(count, _flags);
              }
              lastLine = nodeEndLine;
            }
          } else {
            const offset = commentStartLine - (i === 0 ? nodeEndLine - lineOffset : lastLine);
            lastLine = commentEndLine;
            if (offset > 0 && !_noLineTerminator) {
              this.newline(offset, _flags);
            }
            this._printComment(comment, 1);
          }
        } else {
          hasLoc = false;
          if (shouldPrint !== 1) {
            continue;
          }
          if (len === 1) {
            const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
            const shouldSkipNewline = singleLine && !isStatement2(node) && !isClassBody2(parent) && !isTSInterfaceBody2(parent) && !isTSEnumMember2(node);
            if (type === 0) {
              this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction2(parent) && parent.body === node ? 1 : 0);
            } else if (shouldSkipNewline && type === 2) {
              this._printComment(comment, 1);
            } else {
              this._printComment(comment, 0);
            }
          } else if (type === 1 && !(node.type === "ObjectExpression" && node.properties.length > 1) && node.type !== "ClassBody" && node.type !== "TSInterfaceBody") {
            this._printComment(comment, i === 0 ? 2 : i === len - 1 ? 3 : 0);
          } else {
            this._printComment(comment, 0);
          }
        }
      }
      if (type === 2 && hasLoc && lastLine) {
        this._lastCommentLine = lastLine;
      }
      return 2;
    }
  };
  function commaSeparator(occurrenceCount, last) {
    this.tokenChar(44, occurrenceCount);
    if (!last) this.space();
  }
  function normalizeOptions(code, opts, ast) {
    if (opts.experimental_preserveFormat) {
      if (typeof code !== "string") {
        throw new Error("`experimental_preserveFormat` requires the original `code` to be passed to @babel/generator as a string");
      }
      if (!opts.retainLines) {
        throw new Error("`experimental_preserveFormat` requires `retainLines` to be set to `true`");
      }
      if (opts.compact && opts.compact !== "auto") {
        throw new Error("`experimental_preserveFormat` is not compatible with the `compact` option");
      }
      if (opts.minified) {
        throw new Error("`experimental_preserveFormat` is not compatible with the `minified` option");
      }
      if (opts.jsescOption) {
        throw new Error("`experimental_preserveFormat` is not compatible with the `jsescOption` option");
      }
      if (!Array.isArray(ast.tokens)) {
        throw new Error("`experimental_preserveFormat` requires the AST to have attached the token of the input code. Make sure to enable the `tokens: true` parser option.");
      }
    }
    const format = {
      auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
      auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
      shouldPrintComment: opts.shouldPrintComment,
      preserveFormat: opts.experimental_preserveFormat,
      retainLines: opts.retainLines,
      retainFunctionParens: opts.retainFunctionParens,
      comments: opts.comments == null || opts.comments,
      compact: opts.compact,
      minified: opts.minified,
      concise: opts.concise,
      indent: {
        adjustMultilineComment: true,
        style: "  "
      },
      jsescOption: {
        quotes: "double",
        wrap: true,
        minimal: true,
        ...opts.jsescOption
      },
      topicToken: opts.topicToken
    };
    if (format.minified) {
      format.compact = true;
      format.shouldPrintComment = format.shouldPrintComment || (() => format.comments);
    } else {
      format.shouldPrintComment = format.shouldPrintComment || ((value) => format.comments || value.includes("@license") || value.includes("@preserve"));
    }
    if (format.compact === "auto") {
      format.compact = typeof code === "string" && code.length > 5e5;
      if (format.compact) {
        console.error(`[BABEL] Note: The code generator has deoptimised the styling of ${opts.filename} as it exceeds the max of ${"500KB"}.`);
      }
    }
    if (format.compact || format.preserveFormat) {
      format.indent.adjustMultilineComment = false;
    }
    const {
      auxiliaryCommentBefore,
      auxiliaryCommentAfter,
      shouldPrintComment
    } = format;
    if (auxiliaryCommentBefore && !shouldPrintComment(auxiliaryCommentBefore)) {
      format.auxiliaryCommentBefore = void 0;
    }
    if (auxiliaryCommentAfter && !shouldPrintComment(auxiliaryCommentAfter)) {
      format.auxiliaryCommentAfter = void 0;
    }
    return format;
  }
  function generate(ast, opts = {}, code) {
    const format = normalizeOptions(code, opts, ast);
    const map = opts.sourceMaps ? new SourceMap(opts, code) : null;
    const printer = new Printer(format, map, ast.tokens, typeof code === "string" ? code : null);
    return printer.generate(ast);
  }

  // scripts/ast-sdk-entry.mjs
  var generator = generate.default || generate;
  var AST = {
    types: lib_exports,
    generator,
    generate(node, options) {
      return generator(node, options).code;
    }
  };
  globalThis.AST = AST;
  if (typeof unsafeWindow !== "undefined") {
    unsafeWindow.AST = AST;
    unsafeWindow.__AST_SDK_INJECTED__ = true;
  } else if (typeof window !== "undefined") {
    window.AST = AST;
    window.__AST_SDK_INJECTED__ = true;
  }
})();