untyped/dist/loader/babel.js

[![npm version][npm-version-src]][npm-version-href] [![npm downloads][npm-downloads-src]][npm-downloads-href] [![Github Actions][github-actions-src]][github-actions-href] [![Codecov][codecov-src]][codecov-href] [![bundle][bundle-src]][bundle-href]

'use strict';

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function getAugmentedNamespace(n) {
	if (n.__esModule) return n;
	var a = Object.defineProperty({}, '__esModule', {value: true});
	Object.keys(n).forEach(function (k) {
		var d = Object.getOwnPropertyDescriptor(n, k);
		Object.defineProperty(a, k, d.get ? d : {
			enumerable: true,
			get: function () {
				return n[k];
			}
		});
	});
	return a;
}

function createCommonjsModule(fn) {
  var module = { exports: {} };
	return fn(module, module.exports), module.exports;
}

var _default$V = shallowEqual;

function shallowEqual(actual, expected) {
  const keys = Object.keys(expected);

  for (const key of keys) {
    if (actual[key] !== expected[key]) {
      return false;
    }
  }

  return true;
}

var shallowEqual_1 = /*#__PURE__*/Object.defineProperty({
	default: _default$V
}, '__esModule', {value: true});

var isArrayExpression_1 = isArrayExpression;
var isAssignmentExpression_1 = isAssignmentExpression;
var isBinaryExpression_1 = isBinaryExpression;
var isInterpreterDirective_1 = isInterpreterDirective;
var isDirective_1 = isDirective;
var isDirectiveLiteral_1 = isDirectiveLiteral;
var isBlockStatement_1 = isBlockStatement;
var isBreakStatement_1 = isBreakStatement;
var isCallExpression_1 = isCallExpression;
var isCatchClause_1 = isCatchClause;
var isConditionalExpression_1 = isConditionalExpression;
var isContinueStatement_1 = isContinueStatement;
var isDebuggerStatement_1 = isDebuggerStatement;
var isDoWhileStatement_1 = isDoWhileStatement;
var isEmptyStatement_1 = isEmptyStatement;
var isExpressionStatement_1 = isExpressionStatement;
var isFile_1 = isFile;
var isForInStatement_1 = isForInStatement;
var isForStatement_1 = isForStatement;
var isFunctionDeclaration_1 = isFunctionDeclaration;
var isFunctionExpression_1 = isFunctionExpression;
var isIdentifier_1 = isIdentifier;
var isIfStatement_1 = isIfStatement;
var isLabeledStatement_1 = isLabeledStatement;
var isStringLiteral_1 = isStringLiteral;
var isNumericLiteral_1 = isNumericLiteral;
var isNullLiteral_1 = isNullLiteral;
var isBooleanLiteral_1 = isBooleanLiteral;
var isRegExpLiteral_1 = isRegExpLiteral;
var isLogicalExpression_1 = isLogicalExpression;
var isMemberExpression_1 = isMemberExpression;
var isNewExpression_1 = isNewExpression;
var isProgram_1 = isProgram;
var isObjectExpression_1 = isObjectExpression;
var isObjectMethod_1 = isObjectMethod;
var isObjectProperty_1 = isObjectProperty;
var isRestElement_1 = isRestElement;
var isReturnStatement_1 = isReturnStatement;
var isSequenceExpression_1 = isSequenceExpression;
var isParenthesizedExpression_1 = isParenthesizedExpression;
var isSwitchCase_1 = isSwitchCase;
var isSwitchStatement_1 = isSwitchStatement;
var isThisExpression_1 = isThisExpression;
var isThrowStatement_1 = isThrowStatement;
var isTryStatement_1 = isTryStatement;
var isUnaryExpression_1 = isUnaryExpression;
var isUpdateExpression_1 = isUpdateExpression;
var isVariableDeclaration_1 = isVariableDeclaration;
var isVariableDeclarator_1 = isVariableDeclarator;
var isWhileStatement_1 = isWhileStatement;
var isWithStatement_1 = isWithStatement;
var isAssignmentPattern_1 = isAssignmentPattern;
var isArrayPattern_1 = isArrayPattern;
var isArrowFunctionExpression_1 = isArrowFunctionExpression;
var isClassBody_1 = isClassBody;
var isClassExpression_1 = isClassExpression;
var isClassDeclaration_1 = isClassDeclaration;
var isExportAllDeclaration_1 = isExportAllDeclaration;
var isExportDefaultDeclaration_1 = isExportDefaultDeclaration;
var isExportNamedDeclaration_1 = isExportNamedDeclaration;
var isExportSpecifier_1 = isExportSpecifier;
var isForOfStatement_1 = isForOfStatement;
var isImportDeclaration_1 = isImportDeclaration;
var isImportDefaultSpecifier_1 = isImportDefaultSpecifier;
var isImportNamespaceSpecifier_1 = isImportNamespaceSpecifier;
var isImportSpecifier_1 = isImportSpecifier;
var isMetaProperty_1 = isMetaProperty;
var isClassMethod_1 = isClassMethod;
var isObjectPattern_1 = isObjectPattern;
var isSpreadElement_1 = isSpreadElement;
var isSuper_1 = isSuper;
var isTaggedTemplateExpression_1 = isTaggedTemplateExpression;
var isTemplateElement_1 = isTemplateElement;
var isTemplateLiteral_1 = isTemplateLiteral;
var isYieldExpression_1 = isYieldExpression;
var isAwaitExpression_1 = isAwaitExpression;
var isImport_1 = isImport;
var isBigIntLiteral_1 = isBigIntLiteral;
var isExportNamespaceSpecifier_1 = isExportNamespaceSpecifier;
var isOptionalMemberExpression_1 = isOptionalMemberExpression;
var isOptionalCallExpression_1 = isOptionalCallExpression;
var isAnyTypeAnnotation_1 = isAnyTypeAnnotation;
var isArrayTypeAnnotation_1 = isArrayTypeAnnotation;
var isBooleanTypeAnnotation_1 = isBooleanTypeAnnotation;
var isBooleanLiteralTypeAnnotation_1 = isBooleanLiteralTypeAnnotation;
var isNullLiteralTypeAnnotation_1 = isNullLiteralTypeAnnotation;
var isClassImplements_1 = isClassImplements;
var isDeclareClass_1 = isDeclareClass;
var isDeclareFunction_1 = isDeclareFunction;
var isDeclareInterface_1 = isDeclareInterface;
var isDeclareModule_1 = isDeclareModule;
var isDeclareModuleExports_1 = isDeclareModuleExports;
var isDeclareTypeAlias_1 = isDeclareTypeAlias;
var isDeclareOpaqueType_1 = isDeclareOpaqueType;
var isDeclareVariable_1 = isDeclareVariable;
var isDeclareExportDeclaration_1 = isDeclareExportDeclaration;
var isDeclareExportAllDeclaration_1 = isDeclareExportAllDeclaration;
var isDeclaredPredicate_1 = isDeclaredPredicate;
var isExistsTypeAnnotation_1 = isExistsTypeAnnotation;
var isFunctionTypeAnnotation_1 = isFunctionTypeAnnotation;
var isFunctionTypeParam_1 = isFunctionTypeParam;
var isGenericTypeAnnotation_1 = isGenericTypeAnnotation;
var isInferredPredicate_1 = isInferredPredicate;
var isInterfaceExtends_1 = isInterfaceExtends;
var isInterfaceDeclaration_1 = isInterfaceDeclaration;
var isInterfaceTypeAnnotation_1 = isInterfaceTypeAnnotation;
var isIntersectionTypeAnnotation_1 = isIntersectionTypeAnnotation;
var isMixedTypeAnnotation_1 = isMixedTypeAnnotation;
var isEmptyTypeAnnotation_1 = isEmptyTypeAnnotation;
var isNullableTypeAnnotation_1 = isNullableTypeAnnotation;
var isNumberLiteralTypeAnnotation_1 = isNumberLiteralTypeAnnotation;
var isNumberTypeAnnotation_1 = isNumberTypeAnnotation;
var isObjectTypeAnnotation_1 = isObjectTypeAnnotation;
var isObjectTypeInternalSlot_1 = isObjectTypeInternalSlot;
var isObjectTypeCallProperty_1 = isObjectTypeCallProperty;
var isObjectTypeIndexer_1 = isObjectTypeIndexer;
var isObjectTypeProperty_1 = isObjectTypeProperty;
var isObjectTypeSpreadProperty_1 = isObjectTypeSpreadProperty;
var isOpaqueType_1 = isOpaqueType;
var isQualifiedTypeIdentifier_1 = isQualifiedTypeIdentifier;
var isStringLiteralTypeAnnotation_1 = isStringLiteralTypeAnnotation;
var isStringTypeAnnotation_1 = isStringTypeAnnotation;
var isSymbolTypeAnnotation_1 = isSymbolTypeAnnotation;
var isThisTypeAnnotation_1 = isThisTypeAnnotation;
var isTupleTypeAnnotation_1 = isTupleTypeAnnotation;
var isTypeofTypeAnnotation_1 = isTypeofTypeAnnotation;
var isTypeAlias_1 = isTypeAlias;
var isTypeAnnotation_1 = isTypeAnnotation;
var isTypeCastExpression_1 = isTypeCastExpression;
var isTypeParameter_1 = isTypeParameter;
var isTypeParameterDeclaration_1 = isTypeParameterDeclaration;
var isTypeParameterInstantiation_1 = isTypeParameterInstantiation;
var isUnionTypeAnnotation_1 = isUnionTypeAnnotation;
var isVariance_1 = isVariance;
var isVoidTypeAnnotation_1 = isVoidTypeAnnotation;
var isEnumDeclaration_1 = isEnumDeclaration;
var isEnumBooleanBody_1 = isEnumBooleanBody;
var isEnumNumberBody_1 = isEnumNumberBody;
var isEnumStringBody_1 = isEnumStringBody;
var isEnumSymbolBody_1 = isEnumSymbolBody;
var isEnumBooleanMember_1 = isEnumBooleanMember;
var isEnumNumberMember_1 = isEnumNumberMember;
var isEnumStringMember_1 = isEnumStringMember;
var isEnumDefaultedMember_1 = isEnumDefaultedMember;
var isJSXAttribute_1 = isJSXAttribute;
var isJSXClosingElement_1 = isJSXClosingElement;
var isJSXElement_1 = isJSXElement;
var isJSXEmptyExpression_1 = isJSXEmptyExpression;
var isJSXExpressionContainer_1 = isJSXExpressionContainer;
var isJSXSpreadChild_1 = isJSXSpreadChild;
var isJSXIdentifier_1 = isJSXIdentifier;
var isJSXMemberExpression_1 = isJSXMemberExpression;
var isJSXNamespacedName_1 = isJSXNamespacedName;
var isJSXOpeningElement_1 = isJSXOpeningElement;
var isJSXSpreadAttribute_1 = isJSXSpreadAttribute;
var isJSXText_1 = isJSXText;
var isJSXFragment_1 = isJSXFragment;
var isJSXOpeningFragment_1 = isJSXOpeningFragment;
var isJSXClosingFragment_1 = isJSXClosingFragment;
var isNoop_1 = isNoop;
var isPlaceholder_1 = isPlaceholder;
var isV8IntrinsicIdentifier_1 = isV8IntrinsicIdentifier;
var isArgumentPlaceholder_1 = isArgumentPlaceholder;
var isBindExpression_1 = isBindExpression;
var isClassProperty_1 = isClassProperty;
var isPipelineTopicExpression_1 = isPipelineTopicExpression;
var isPipelineBareFunction_1 = isPipelineBareFunction;
var isPipelinePrimaryTopicReference_1 = isPipelinePrimaryTopicReference;
var isClassPrivateProperty_1 = isClassPrivateProperty;
var isClassPrivateMethod_1 = isClassPrivateMethod;
var isImportAttribute_1 = isImportAttribute;
var isDecorator_1 = isDecorator;
var isDoExpression_1 = isDoExpression;
var isExportDefaultSpecifier_1 = isExportDefaultSpecifier;
var isPrivateName_1 = isPrivateName;
var isRecordExpression_1 = isRecordExpression;
var isTupleExpression_1 = isTupleExpression;
var isDecimalLiteral_1 = isDecimalLiteral;
var isStaticBlock_1 = isStaticBlock;
var isModuleExpression_1 = isModuleExpression;
var isTSParameterProperty_1 = isTSParameterProperty;
var isTSDeclareFunction_1 = isTSDeclareFunction;
var isTSDeclareMethod_1 = isTSDeclareMethod;
var isTSQualifiedName_1 = isTSQualifiedName;
var isTSCallSignatureDeclaration_1 = isTSCallSignatureDeclaration;
var isTSConstructSignatureDeclaration_1 = isTSConstructSignatureDeclaration;
var isTSPropertySignature_1 = isTSPropertySignature;
var isTSMethodSignature_1 = isTSMethodSignature;
var isTSIndexSignature_1 = isTSIndexSignature;
var isTSAnyKeyword_1 = isTSAnyKeyword;
var isTSBooleanKeyword_1 = isTSBooleanKeyword;
var isTSBigIntKeyword_1 = isTSBigIntKeyword;
var isTSIntrinsicKeyword_1 = isTSIntrinsicKeyword;
var isTSNeverKeyword_1 = isTSNeverKeyword;
var isTSNullKeyword_1 = isTSNullKeyword;
var isTSNumberKeyword_1 = isTSNumberKeyword;
var isTSObjectKeyword_1 = isTSObjectKeyword;
var isTSStringKeyword_1 = isTSStringKeyword;
var isTSSymbolKeyword_1 = isTSSymbolKeyword;
var isTSUndefinedKeyword_1 = isTSUndefinedKeyword;
var isTSUnknownKeyword_1 = isTSUnknownKeyword;
var isTSVoidKeyword_1 = isTSVoidKeyword;
var isTSThisType_1 = isTSThisType;
var isTSFunctionType_1 = isTSFunctionType;
var isTSConstructorType_1 = isTSConstructorType;
var isTSTypeReference_1 = isTSTypeReference;
var isTSTypePredicate_1 = isTSTypePredicate;
var isTSTypeQuery_1 = isTSTypeQuery;
var isTSTypeLiteral_1 = isTSTypeLiteral;
var isTSArrayType_1 = isTSArrayType;
var isTSTupleType_1 = isTSTupleType;
var isTSOptionalType_1 = isTSOptionalType;
var isTSRestType_1 = isTSRestType;
var isTSNamedTupleMember_1 = isTSNamedTupleMember;
var isTSUnionType_1 = isTSUnionType;
var isTSIntersectionType_1 = isTSIntersectionType;
var isTSConditionalType_1 = isTSConditionalType;
var isTSInferType_1 = isTSInferType;
var isTSParenthesizedType_1 = isTSParenthesizedType;
var isTSTypeOperator_1 = isTSTypeOperator;
var isTSIndexedAccessType_1 = isTSIndexedAccessType;
var isTSMappedType_1 = isTSMappedType;
var isTSLiteralType_1 = isTSLiteralType;
var isTSExpressionWithTypeArguments_1 = isTSExpressionWithTypeArguments;
var isTSInterfaceDeclaration_1 = isTSInterfaceDeclaration;
var isTSInterfaceBody_1 = isTSInterfaceBody;
var isTSTypeAliasDeclaration_1 = isTSTypeAliasDeclaration;
var isTSAsExpression_1 = isTSAsExpression;
var isTSTypeAssertion_1 = isTSTypeAssertion;
var isTSEnumDeclaration_1 = isTSEnumDeclaration;
var isTSEnumMember_1 = isTSEnumMember;
var isTSModuleDeclaration_1 = isTSModuleDeclaration;
var isTSModuleBlock_1 = isTSModuleBlock;
var isTSImportType_1 = isTSImportType;
var isTSImportEqualsDeclaration_1 = isTSImportEqualsDeclaration;
var isTSExternalModuleReference_1 = isTSExternalModuleReference;
var isTSNonNullExpression_1 = isTSNonNullExpression;
var isTSExportAssignment_1 = isTSExportAssignment;
var isTSNamespaceExportDeclaration_1 = isTSNamespaceExportDeclaration;
var isTSTypeAnnotation_1 = isTSTypeAnnotation;
var isTSTypeParameterInstantiation_1 = isTSTypeParameterInstantiation;
var isTSTypeParameterDeclaration_1 = isTSTypeParameterDeclaration;
var isTSTypeParameter_1 = isTSTypeParameter;
var isExpression_1 = isExpression;
var isBinary_1 = isBinary;
var isScopable_1 = isScopable;
var isBlockParent_1 = isBlockParent;
var isBlock_1 = isBlock;
var isStatement_1 = isStatement;
var isTerminatorless_1 = isTerminatorless;
var isCompletionStatement_1 = isCompletionStatement;
var isConditional_1 = isConditional;
var isLoop_1 = isLoop;
var isWhile_1 = isWhile;
var isExpressionWrapper_1 = isExpressionWrapper;
var isFor_1 = isFor;
var isForXStatement_1 = isForXStatement;
var isFunction_1$1 = isFunction$1;
var isFunctionParent_1 = isFunctionParent;
var isPureish_1 = isPureish;
var isDeclaration_1 = isDeclaration;
var isPatternLike_1 = isPatternLike;
var isLVal_1 = isLVal;
var isTSEntityName_1 = isTSEntityName;
var isLiteral_1 = isLiteral;
var isImmutable_1$1 = isImmutable$1;
var isUserWhitespacable_1 = isUserWhitespacable;
var isMethod_1 = isMethod;
var isObjectMember_1 = isObjectMember;
var isProperty_1 = isProperty;
var isUnaryLike_1 = isUnaryLike;
var isPattern_1 = isPattern;
var isClass_1 = isClass;
var isModuleDeclaration_1 = isModuleDeclaration;
var isExportDeclaration_1 = isExportDeclaration;
var isModuleSpecifier_1 = isModuleSpecifier;
var isFlow_1 = isFlow;
var isFlowType_1 = isFlowType;
var isFlowBaseAnnotation_1 = isFlowBaseAnnotation;
var isFlowDeclaration_1 = isFlowDeclaration;
var isFlowPredicate_1 = isFlowPredicate;
var isEnumBody_1 = isEnumBody;
var isEnumMember_1 = isEnumMember;
var isJSX_1 = isJSX;
var isPrivate_1 = isPrivate;
var isTSTypeElement_1 = isTSTypeElement;
var isTSType_1 = isTSType;
var isTSBaseType_1 = isTSBaseType;
var isNumberLiteral_1 = isNumberLiteral;
var isRegexLiteral_1 = isRegexLiteral;
var isRestProperty_1 = isRestProperty;
var isSpreadProperty_1 = isSpreadProperty;

var _shallowEqual$1 = _interopRequireDefault$t(shallowEqual_1);

function _interopRequireDefault$t(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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.default)(node, opts);
    }
  }

  return false;
}

function isOpaqueType(node, opts) {
  if (!node) return false;
  const nodeType = node.type;

  if (nodeType === "OpaqueType") {
    if (typeof opts === "undefined") {