text: "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.isArrayExpression = isArrayExpression;
  exports.isAssignmentExpression = isAssignmentExpression;
  exports.isBinaryExpression = isBinaryExpression;
  exports.isInterpreterDirective = isInterpreterDirective;
  exports.isDirective = isDirective;
  exports.isDirectiveLiteral = isDirectiveLiteral;
  exports.isBlockStatement = isBlockStatement;
  exports.isBreakStatement = isBreakStatement;
  exports.isCallExpression = isCallExpression;
  exports.isCatchClause = isCatchClause;
  exports.isConditionalExpression = isConditionalExpression;
  exports.isContinueStatement = isContinueStatement;
  exports.isDebuggerStatement = isDebuggerStatement;
  exports.isDoWhileStatement = isDoWhileStatement;
  exports.isEmptyStatement = isEmptyStatement;
  exports.isExpressionStatement = isExpressionStatement;
  exports.isFile = isFile;
  exports.isForInStatement = isForInStatement;
  exports.isForStatement = isForStatement;
  exports.isFunctionDeclaration = isFunctionDeclaration;
  exports.isFunctionExpression = isFunctionExpression;
  exports.isIdentifier = isIdentifier;
  exports.isIfStatement = isIfStatement;
  exports.isLabeledStatement = isLabeledStatement;
  exports.isStringLiteral = isStringLiteral;
  exports.isNumericLiteral = isNumericLiteral;
  exports.isNullLiteral = isNullLiteral;
  exports.isBooleanLiteral = isBooleanLiteral;
  exports.isRegExpLiteral = isRegExpLiteral;
  exports.isLogicalExpression = isLogicalExpression;
  exports.isMemberExpression = isMemberExpression;
  exports.isNewExpression = isNewExpression;
  exports.isProgram = isProgram;
  exports.isObjectExpression = isObjectExpression;
  exports.isObjectMethod = isObjectMethod;
  exports.isObjectProperty = isObjectProperty;
  exports.isRestElement = isRestElement;
  exports.isReturnStatement = isReturnStatement;
  exports.isSequenceExpression = isSequenceExpression;
  exports.isParenthesizedExpression = isParenthesizedExpression;
  exports.isSwitchCase = isSwitchCase;
  exports.isSwitchStatement = isSwitchStatement;
  exports.isThisExpression = isThisExpression;
  exports.isThrowStatement = isThrowStatement;
  exports.isTryStatement = isTryStatement;
  exports.isUnaryExpression = isUnaryExpression;
  exports.isUpdateExpression = isUpdateExpression;
  exports.isVariableDeclaration = isVariableDeclaration;
  exports.isVariableDeclarator = isVariableDeclarator;
  exports.isWhileStatement = isWhileStatement;
  exports.isWithStatement = isWithStatement;
  exports.isAssignmentPattern = isAssignmentPattern;
  exports.isArrayPattern = isArrayPattern;
  exports.isArrowFunctionExpression = isArrowFunctionExpression;
  exports.isClassBody = isClassBody;
  exports.isClassExpression = isClassExpression;
  exports.isClassDeclaration = isClassDeclaration;
  exports.isExportAllDeclaration = isExportAllDeclaration;
  exports.isExportDefaultDeclaration = isExportDefaultDeclaration;
  exports.isExportNamedDeclaration = isExportNamedDeclaration;
  exports.isExportSpecifier = isExportSpecifier;
  exports.isForOfStatement = isForOfStatement;
  exports.isImportDeclaration = isImportDeclaration;
  exports.isImportDefaultSpecifier = isImportDefaultSpecifier;
  exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
  exports.isImportSpecifier = isImportSpecifier;
  exports.isMetaProperty = isMetaProperty;
  exports.isClassMethod = isClassMethod;
  exports.isObjectPattern = isObjectPattern;
  exports.isSpreadElement = isSpreadElement;
  exports.isSuper = isSuper;
  exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
  exports.isTemplateElement = isTemplateElement;
  exports.isTemplateLiteral = isTemplateLiteral;
  exports.isYieldExpression = isYieldExpression;
  exports.isAwaitExpression = isAwaitExpression;
  exports.isImport = isImport;
  exports.isBigIntLiteral = isBigIntLiteral;
  exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
  exports.isOptionalMemberExpression = isOptionalMemberExpression;
  exports.isOptionalCallExpression = isOptionalCallExpression;
  exports.isAnyTypeAnnotation = isAnyTypeAnnotation;
  exports.isArrayTypeAnnotation = isArrayTypeAnnotation;
  exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
  exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
  exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
  exports.isClassImplements = isClassImplements;
  exports.isDeclareClass = isDeclareClass;
  exports.isDeclareFunction = isDeclareFunction;
  exports.isDeclareInterface = isDeclareInterface;
  exports.isDeclareModule = isDeclareModule;
  exports.isDeclareModuleExports = isDeclareModuleExports;
  exports.isDeclareTypeAlias = isDeclareTypeAlias;
  exports.isDeclareOpaqueType = isDeclareOpaqueType;
  exports.isDeclareVariable = isDeclareVariable;
  exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
  exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
  exports.isDeclaredPredicate = isDeclaredPredicate;
  exports.isExistsTypeAnnotation = isExistsTypeAnnotation;
  exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
  exports.isFunctionTypeParam = isFunctionTypeParam;
  exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
  exports.isInferredPredicate = isInferredPredicate;
  exports.isInterfaceExtends = isInterfaceExtends;
  exports.isInterfaceDeclaration = isInterfaceDeclaration;
  exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
  exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
  exports.isMixedTypeAnnotation = isMixedTypeAnnotation;
  exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
  exports.isNullableTypeAnnotation = isNullableTypeAnnotation;
  exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
  exports.isNumberTypeAnnotation = isNumberTypeAnnotation;
  exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
  exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
  exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
  exports.isObjectTypeIndexer = isObjectTypeIndexer;
  exports.isObjectTypeProperty = isObjectTypeProperty;
  exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
  exports.isOpaqueType = isOpaqueType;
  exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
  exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
  exports.isStringTypeAnnotation = isStringTypeAnnotation;
  exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation;
  exports.isThisTypeAnnotation = isThisTypeAnnotation;
  exports.isTupleTypeAnnotation = isTupleTypeAnnotation;
  exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
  exports.isTypeAlias = isTypeAlias;
  exports.isTypeAnnotation = isTypeAnnotation;
  exports.isTypeCastExpression = isTypeCastExpression;
  exports.isTypeParameter = isTypeParameter;
  exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
  exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
  exports.isUnionTypeAnnotation = isUnionTypeAnnotation;
  exports.isVariance = isVariance;
  exports.isVoidTypeAnnotation = isVoidTypeAnnotation;
  exports.isEnumDeclaration = isEnumDeclaration;
  exports.isEnumBooleanBody = isEnumBooleanBody;
  exports.isEnumNumberBody = isEnumNumberBody;
  exports.isEnumStringBody = isEnumStringBody;
  exports.isEnumSymbolBody = isEnumSymbolBody;
  exports.isEnumBooleanMember = isEnumBooleanMember;
  exports.isEnumNumberMember = isEnumNumberMember;
  exports.isEnumStringMember = isEnumStringMember;
  exports.isEnumDefaultedMember = isEnumDefaultedMember;
  exports.isJSXAttribute = isJSXAttribute;
  exports.isJSXClosingElement = isJSXClosingElement;
  exports.isJSXElement = isJSXElement;
  exports.isJSXEmptyExpression = isJSXEmptyExpression;
  exports.isJSXExpressionContainer = isJSXExpressionContainer;
  exports.isJSXSpreadChild = isJSXSpreadChild;
  exports.isJSXIdentifier = isJSXIdentifier;
  exports.isJSXMemberExpression = isJSXMemberExpression;
  exports.isJSXNamespacedName = isJSXNamespacedName;
  exports.isJSXOpeningElement = isJSXOpeningElement;
  exports.isJSXSpreadAttribute = isJSXSpreadAttribute;
  exports.isJSXText = isJSXText;
  exports.isJSXFragment = isJSXFragment;
  exports.isJSXOpeningFragment = isJSXOpeningFragment;
  exports.isJSXClosingFragment = isJSXClosingFragment;
  exports.isNoop = isNoop;
  exports.isPlaceholder = isPlaceholder;
  exports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier;
  exports.isArgumentPlaceholder = isArgumentPlaceholder;
  exports.isBindExpression = isBindExpression;
  exports.isClassProperty = isClassProperty;
  exports.isPipelineTopicExpression = isPipelineTopicExpression;
  exports.isPipelineBareFunction = isPipelineBareFunction;
  exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
  exports.isClassPrivateProperty = isClassPrivateProperty;
  exports.isClassPrivateMethod = isClassPrivateMethod;
  exports.isImportAttribute = isImportAttribute;
  exports.isDecorator = isDecorator;
  exports.isDoExpression = isDoExpression;
  exports.isExportDefaultSpecifier = isExportDefaultSpecifier;
  exports.isPrivateName = isPrivateName;
  exports.isRecordExpression = isRecordExpression;
  exports.isTupleExpression = isTupleExpression;
  exports.isDecimalLiteral = isDecimalLiteral;
  exports.isTSParameterProperty = isTSParameterProperty;
  exports.isTSDeclareFunction = isTSDeclareFunction;
  exports.isTSDeclareMethod = isTSDeclareMethod;
  exports.isTSQualifiedName = isTSQualifiedName;
  exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
  exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
  exports.isTSPropertySignature = isTSPropertySignature;
  exports.isTSMethodSignature = isTSMethodSignature;
  exports.isTSIndexSignature = isTSIndexSignature;
  exports.isTSAnyKeyword = isTSAnyKeyword;
  exports.isTSBooleanKeyword = isTSBooleanKeyword;
  exports.isTSBigIntKeyword = isTSBigIntKeyword;
  exports.isTSNeverKeyword = isTSNeverKeyword;
  exports.isTSNullKeyword = isTSNullKeyword;
  exports.isTSNumberKeyword = isTSNumberKeyword;
  exports.isTSObjectKeyword = isTSObjectKeyword;
  exports.isTSStringKeyword = isTSStringKeyword;
  exports.isTSSymbolKeyword = isTSSymbolKeyword;
  exports.isTSUndefinedKeyword = isTSUndefinedKeyword;
  exports.isTSUnknownKeyword = isTSUnknownKeyword;
  exports.isTSVoidKeyword = isTSVoidKeyword;
  exports.isTSThisType = isTSThisType;
  exports.isTSFunctionType = isTSFunctionType;
  exports.isTSConstructorType = isTSConstructorType;
  exports.isTSTypeReference = isTSTypeReference;
  exports.isTSTypePredicate = isTSTypePredicate;
  exports.isTSTypeQuery = isTSTypeQuery;
  exports.isTSTypeLiteral = isTSTypeLiteral;
  exports.isTSArrayType = isTSArrayType;
  exports.isTSTupleType = isTSTupleType;
  exports.isTSOptionalType = isTSOptionalType;
  exports.isTSRestType = isTSRestType;
  exports.isTSNamedTupleMember = isTSNamedTupleMember;
  exports.isTSUnionType = isTSUnionType;
  exports.isTSIntersectionType = isTSIntersectionType;
  exports.isTSConditionalType = isTSConditionalType;
  exports.isTSInferType = isTSInferType;
  exports.isTSParenthesizedType = isTSParenthesizedType;
  exports.isTSTypeOperator = isTSTypeOperator;
  exports.isTSIndexedAccessType = isTSIndexedAccessType;
  exports.isTSMappedType = isTSMappedType;
  exports.isTSLiteralType = isTSLiteralType;
  exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
  exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
  exports.isTSInterfaceBody = isTSInterfaceBody;
  exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
  exports.isTSAsExpression = isTSAsExpression;
  exports.isTSTypeAssertion = isTSTypeAssertion;
  exports.isTSEnumDeclaration = isTSEnumDeclaration;
  exports.isTSEnumMember = isTSEnumMember;
  exports.isTSModuleDeclaration = isTSModuleDeclaration;
  exports.isTSModuleBlock = isTSModuleBlock;
  exports.isTSImportType = isTSImportType;
  exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
  exports.isTSExternalModuleReference = isTSExternalModuleReference;
  exports.isTSNonNullExpression = isTSNonNullExpression;
  exports.isTSExportAssignment = isTSExportAssignment;
  exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
  exports.isTSTypeAnnotation = isTSTypeAnnotation;
  exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
  exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
  exports.isTSTypeParameter = isTSTypeParameter;
  exports.isExpression = isExpression;
  exports.isBinary = isBinary;
  exports.isScopable = isScopable;
  exports.isBlockParent = isBlockParent;
  exports.isBlock = isBlock;
  exports.isStatement = isStatement;
  exports.isTerminatorless = isTerminatorless;
  exports.isCompletionStatement = isCompletionStatement;
  exports.isConditional = isConditional;
  exports.isLoop = isLoop;
  exports.isWhile = isWhile;
  exports.isExpressionWrapper = isExpressionWrapper;
  exports.isFor = isFor;
  exports.isForXStatement = isForXStatement;
  exports.isFunction = isFunction;
  exports.isFunctionParent = isFunctionParent;
  exports.isPureish = isPureish;
  exports.isDeclaration = isDeclaration;
  exports.isPatternLike = isPatternLike;
  exports.isLVal = isLVal;
  exports.isTSEntityName = isTSEntityName;
  exports.isLiteral = isLiteral;
  exports.isImmutable = isImmutable;
  exports.isUserWhitespacable = isUserWhitespacable;
  exports.isMethod = isMethod;
  exports.isObjectMember = isObjectMember;
  exports.isProperty = isProperty;
  exports.isUnaryLike = isUnaryLike;
  exports.isPattern = isPattern;
  exports.isClass = isClass;
  exports.isModuleDeclaration = isModuleDeclaration;
  exports.isExportDeclaration = isExportDeclaration;
  exports.isModuleSpecifier = isModuleSpecifier;
  exports.isFlow = isFlow;
  exports.isFlowType = isFlowType;
  exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
  exports.isFlowDeclaration = isFlowDeclaration;
  exports.isFlowPredicate = isFlowPredicate;
  exports.isEnumBody = isEnumBody;
  exports.isEnumMember = isEnumMember;
  exports.isJSX = isJSX;
  exports.isPrivate = isPrivate;
  exports.isTSTypeElement = isTSTypeElement;
  exports.isTSType = isTSType;
  exports.isTSBaseType = isTSBaseType;
  exports.isNumberLiteral = isNumberLiteral;
  exports.isRegexLiteral = isRegexLiteral;
  exports.isRestProperty = isRestProperty;
  exports.isSpreadProperty = isSpreadProperty;
  
  var _shallowEqual = _interopRequireDefault(require("../../utils/shallowEqual"));
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function isArrayExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrayExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAssignmentExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AssignmentExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBinaryExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BinaryExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterpreterDirective(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterpreterDirective") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDirective(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Directive") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDirectiveLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DirectiveLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBlockStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BlockStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBreakStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BreakStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isCallExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "CallExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isCatchClause(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "CatchClause") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isConditionalExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ConditionalExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isContinueStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ContinueStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDebuggerStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DebuggerStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDoWhileStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DoWhileStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEmptyStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EmptyStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExpressionStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExpressionStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFile(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "File") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForInStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ForInStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ForStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Identifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isIfStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "IfStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLabeledStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "LabeledStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStringLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "StringLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumericLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumericLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNullLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NullLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBooleanLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BooleanLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRegExpLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RegExpLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLogicalExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "LogicalExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMemberExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "MemberExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNewExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NewExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isProgram(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Program") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRestElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RestElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isReturnStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ReturnStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSequenceExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SequenceExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isParenthesizedExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ParenthesizedExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSwitchCase(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SwitchCase") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSwitchStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SwitchStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isThisExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ThisExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isThrowStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ThrowStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTryStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TryStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUnaryExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UnaryExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUpdateExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UpdateExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVariableDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "VariableDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVariableDeclarator(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "VariableDeclarator") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isWhileStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "WhileStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isWithStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "WithStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAssignmentPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AssignmentPattern") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArrayPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrayPattern") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArrowFunctionExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrowFunctionExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportAllDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportAllDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportDefaultDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportDefaultDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportNamedDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportNamedDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForOfStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ForOfStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportDefaultSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportDefaultSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportNamespaceSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportNamespaceSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMetaProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "MetaProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectPattern") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSpreadElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SpreadElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSuper(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Super") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTaggedTemplateExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TaggedTemplateExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTemplateElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TemplateElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTemplateLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TemplateLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isYieldExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "YieldExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAwaitExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AwaitExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImport(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Import") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBigIntLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BigIntLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportNamespaceSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportNamespaceSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isOptionalMemberExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "OptionalMemberExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isOptionalCallExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "OptionalCallExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAnyTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AnyTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArrayTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrayTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBooleanTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BooleanTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBooleanLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BooleanLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNullLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NullLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassImplements(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassImplements") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareClass(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareClass") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareFunction") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareInterface(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareInterface") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareModule(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareModule") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareModuleExports(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareModuleExports") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareTypeAlias(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareTypeAlias") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareOpaqueType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareOpaqueType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareVariable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareVariable") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareExportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareExportDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareExportAllDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareExportAllDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclaredPredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclaredPredicate") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExistsTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExistsTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionTypeParam(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionTypeParam") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isGenericTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "GenericTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInferredPredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InferredPredicate") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterfaceExtends(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterfaceExtends") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterfaceDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterfaceDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterfaceTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterfaceTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isIntersectionTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "IntersectionTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMixedTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "MixedTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEmptyTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EmptyTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNullableTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NullableTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumberLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumberLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumberTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumberTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeInternalSlot(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeInternalSlot") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeCallProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeCallProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeIndexer(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeIndexer") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeSpreadProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeSpreadProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isOpaqueType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "OpaqueType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isQualifiedTypeIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "QualifiedTypeIdentifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStringLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "StringLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStringTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "StringTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSymbolTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SymbolTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isThisTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ThisTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTupleTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TupleTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeofTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeofTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeAlias(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeAlias") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeCastExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeCastExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeParameter(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeParameter") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeParameterDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeParameterDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeParameterInstantiation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeParameterInstantiation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUnionTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UnionTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVariance(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Variance") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVoidTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "VoidTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumBooleanBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumBooleanBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumNumberBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumNumberBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumStringBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumStringBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumSymbolBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumSymbolBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumBooleanMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumBooleanMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumNumberMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumNumberMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumStringMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumStringMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumDefaultedMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumDefaultedMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXAttribute(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXAttribute") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXClosingElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXClosingElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXEmptyExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXEmptyExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXExpressionContainer(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXExpressionContainer") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXSpreadChild(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXSpreadChild") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXIdentifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXMemberExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXMemberExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXNamespacedName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXNamespacedName") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXOpeningElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXOpeningElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXSpreadAttribute(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXSpreadAttribute") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXText(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXText") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXFragment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXFragment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXOpeningFragment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXOpeningFragment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXClosingFragment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXClosingFragment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNoop(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Noop") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPlaceholder(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Placeholder") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isV8IntrinsicIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "V8IntrinsicIdentifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArgumentPlaceholder(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArgumentPlaceholder") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBindExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BindExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPipelineTopicExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PipelineTopicExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPipelineBareFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PipelineBareFunction") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPipelinePrimaryTopicReference(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PipelinePrimaryTopicReference") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassPrivateProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassPrivateProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassPrivateMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassPrivateMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportAttribute(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportAttribute") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDecorator(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Decorator") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDoExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DoExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportDefaultSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportDefaultSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPrivateName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PrivateName") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRecordExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RecordExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTupleExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TupleExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDecimalLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DecimalLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSParameterProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSParameterProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSDeclareFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSDeclareFunction") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSDeclareMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSDeclareMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSQualifiedName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSQualifiedName") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSCallSignatureDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSCallSignatureDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSConstructSignatureDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSConstructSignatureDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSPropertySignature(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSPropertySignature") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSMethodSignature(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSMethodSignature") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSIndexSignature(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSIndexSignature") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSAnyKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSAnyKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSBooleanKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSBooleanKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSBigIntKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSBigIntKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNeverKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNeverKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNullKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNullKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNumberKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNumberKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSObjectKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSObjectKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSStringKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSStringKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSSymbolKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSSymbolKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSUndefinedKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSUndefinedKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSUnknownKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSUnknownKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSVoidKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSVoidKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSThisType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSThisType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSFunctionType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSFunctionType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSConstructorType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSConstructorType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeReference(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeReference") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypePredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypePredicate") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeQuery(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeQuery") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSArrayType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSArrayType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTupleType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTupleType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSOptionalType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSOptionalType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSRestType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSRestType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNamedTupleMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNamedTupleMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSUnionType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSUnionType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSIntersectionType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSIntersectionType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSConditionalType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSConditionalType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSInferType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSInferType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSParenthesizedType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSParenthesizedType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeOperator(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeOperator") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSIndexedAccessType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSIndexedAccessType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSMappedType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSMappedType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSLiteralType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSLiteralType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSExpressionWithTypeArguments(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSExpressionWithTypeArguments") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSInterfaceDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSInterfaceDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSInterfaceBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSInterfaceBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeAliasDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeAliasDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSAsExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSAsExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeAssertion(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeAssertion") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSEnumDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSEnumDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSEnumMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSEnumMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSModuleDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSModuleDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSModuleBlock(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSModuleBlock") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSImportType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSImportType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSImportEqualsDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSImportEqualsDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSExternalModuleReference(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSExternalModuleReference") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNonNullExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNonNullExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSExportAssignment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSExportAssignment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNamespaceExportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNamespaceExportDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeParameterInstantiation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeParameterInstantiation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeParameterDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeParameterDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeParameter(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeParameter") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Expression" || "ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "BindExpression" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "DoExpression" === nodeType || "RecordExpression" === nodeType || "TupleExpression" === nodeType || "DecimalLiteral" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Expression" === node.expectedNode || "Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBinary(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Binary" || "BinaryExpression" === nodeType || "LogicalExpression" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isScopable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Scopable" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBlockParent(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BlockParent" || "BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBlock(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Block" || "BlockStatement" === nodeType || "Program" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Statement" || "BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || nodeType === "Placeholder" && ("Statement" === node.expectedNode || "Declaration" === node.expectedNode || "BlockStatement" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTerminatorless(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Terminatorless" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isCompletionStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "CompletionStatement" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isConditional(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Conditional" || "ConditionalExpression" === nodeType || "IfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLoop(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Loop" || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isWhile(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "While" || "DoWhileStatement" === nodeType || "WhileStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExpressionWrapper(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExpressionWrapper" || "ExpressionStatement" === nodeType || "ParenthesizedExpression" === nodeType || "TypeCastExpression" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFor(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "For" || "ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForXStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ForXStatement" || "ForInStatement" === nodeType || "ForOfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Function" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionParent(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionParent" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPureish(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Pureish" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Declaration" || "FunctionDeclaration" === nodeType || "VariableDeclaration" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || nodeType === "Placeholder" && "Declaration" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPatternLike(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PatternLike" || "Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLVal(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "LVal" || "Identifier" === nodeType || "MemberExpression" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSParameterProperty" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSEntityName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSEntityName" || "Identifier" === nodeType || "TSQualifiedName" === nodeType || nodeType === "Placeholder" && "Identifier" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Literal" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImmutable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Immutable" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "BigIntLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUserWhitespacable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UserWhitespacable" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Method" || "ObjectMethod" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectMember" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Property" || "ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassPrivateProperty" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUnaryLike(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UnaryLike" || "UnaryExpression" === nodeType || "SpreadElement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Pattern" || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && "Pattern" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClass(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Class" || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isModuleDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ModuleDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isModuleSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ModuleSpecifier" || "ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlow(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Flow" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FlowType" || "AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowBaseAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FlowBaseAnnotation" || "AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FlowDeclaration" || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowPredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FlowPredicate" || "DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumBody" || "EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumMember" || "EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSX(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSX" || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXEmptyExpression" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXIdentifier" === nodeType || "JSXMemberExpression" === nodeType || "JSXNamespacedName" === nodeType || "JSXOpeningElement" === nodeType || "JSXSpreadAttribute" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPrivate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Private" || "ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeElement" || "TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSType" || "TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSImportType" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSBaseType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSBaseType" || "TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSLiteralType" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumberLiteral(node, opts) {
    console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumberLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRegexLiteral(node, opts) {
    console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RegexLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRestProperty(node, opts) {
    console.trace("The node type RestProperty has been renamed to RestElement");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RestProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSpreadProperty(node, opts) {
    console.trace("The node type SpreadProperty has been renamed to SpreadElement");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SpreadProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }