condenser 0.0.4 → 0.0.5

data/lib/condenser/processors/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js

@@ -7,11 +7,7 @@ exports.default = appendToMemberExpression;
 
 var _generated = require("../builders/generated");
 
-function appendToMemberExpression(member, append, computed) {
-  if (computed === void 0) {
-    computed = false;
-  }
-
+function appendToMemberExpression(member, append, computed = false) {
   member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
   member.property = append;
   member.computed = !!computed;

data/lib/condenser/processors/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js

@@ -8,13 +8,13 @@ exports.default = removeTypeDuplicates;
 var _generated = require("../../validators/generated");
 
 function removeTypeDuplicates(nodes) {
-  var generics = {};
-  var bases = {};
-  var typeGroups = [];
-  var types = [];
+  const generics = {};
+  const bases = {};
+  const typeGroups = [];
+  const types = [];
 
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
     if (!node) continue;
 
     if (types.indexOf(node) >= 0) {
@@ -40,10 +40,10 @@ function removeTypeDuplicates(nodes) {
     }
 
     if ((0, _generated.isGenericTypeAnnotation)(node)) {
-      var name = node.id.name;
+      const name = node.id.name;
 
       if (generics[name]) {
-        var existing = generics[name];
+        let existing = generics[name];
 
         if (existing.typeParameters) {
           if (node.typeParameters) {
@@ -62,12 +62,12 @@ function removeTypeDuplicates(nodes) {
     types.push(node);
   }
 
-  for (var type in bases) {
+  for (const type of Object.keys(bases)) {
     types.push(bases[type]);
   }
 
-  for (var _name in generics) {
-    types.push(generics[_name]);
+  for (const name of Object.keys(generics)) {
+    types.push(generics[name]);
   }
 
   return types;

data/lib/condenser/processors/node_modules/@babel/types/lib/modifications/inherits.js

@@ -13,25 +13,19 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 function inherits(child, parent) {
   if (!child || !parent) return child;
-  var _arr = _constants.INHERIT_KEYS.optional;
 
-  for (var _i = 0; _i < _arr.length; _i++) {
-    var _key = _arr[_i];
-
-    if (child[_key] == null) {
-      child[_key] = parent[_key];
+  for (const key of _constants.INHERIT_KEYS.optional) {
+    if (child[key] == null) {
+      child[key] = parent[key];
     }
   }
 
-  for (var key in parent) {
+  for (const key of Object.keys(parent)) {
     if (key[0] === "_" && key !== "__clone") child[key] = parent[key];
   }
 
-  var _arr2 = _constants.INHERIT_KEYS.force;
-
-  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
-    var _key2 = _arr2[_i2];
-    child[_key2] = parent[_key2];
+  for (const key of _constants.INHERIT_KEYS.force) {
+    child[key] = parent[key];
   }
 
   (0, _inheritsComments.default)(child, parent);

data/lib/condenser/processors/node_modules/@babel/types/lib/modifications/removeProperties.js

@@ -7,52 +7,24 @@ exports.default = removeProperties;
 
 var _constants = require("../constants");
 
-var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
+const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
 
-var CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
+const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
 
-function removeProperties(node, opts) {
-  if (opts === void 0) {
-    opts = {};
-  }
-
-  var map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
-
-  for (var _iterator = map, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-    var _ref;
+function removeProperties(node, opts = {}) {
+  const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
 
-    if (_isArray) {
-      if (_i >= _iterator.length) break;
-      _ref = _iterator[_i++];
-    } else {
-      _i = _iterator.next();
-      if (_i.done) break;
-      _ref = _i.value;
-    }
-
-    var _key = _ref;
-    if (node[_key] != null) node[_key] = undefined;
+  for (const key of map) {
+    if (node[key] != null) node[key] = undefined;
   }
 
-  for (var key in node) {
+  for (const key of Object.keys(node)) {
     if (key[0] === "_" && node[key] != null) node[key] = undefined;
   }
 
-  var symbols = Object.getOwnPropertySymbols(node);
-
-  for (var _iterator2 = symbols, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
-    var _ref2;
-
-    if (_isArray2) {
-      if (_i2 >= _iterator2.length) break;
-      _ref2 = _iterator2[_i2++];
-    } else {
-      _i2 = _iterator2.next();
-      if (_i2.done) break;
-      _ref2 = _i2.value;
-    }
+  const symbols = Object.getOwnPropertySymbols(node);
 
-    var sym = _ref2;
+  for (const sym of symbols) {
     node[sym] = null;
   }
 }

data/lib/condenser/processors/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js

@@ -8,17 +8,17 @@ exports.default = getBindingIdentifiers;
 var _generated = require("../validators/generated");
 
 function getBindingIdentifiers(node, duplicates, outerOnly) {
-  var search = [].concat(node);
-  var ids = Object.create(null);
+  let search = [].concat(node);
+  const ids = Object.create(null);
 
   while (search.length) {
-    var id = search.shift();
+    const id = search.shift();
     if (!id) continue;
-    var keys = getBindingIdentifiers.keys[id.type];
+    const keys = getBindingIdentifiers.keys[id.type];
 
     if ((0, _generated.isIdentifier)(id)) {
       if (duplicates) {
-        var _ids = ids[id.name] = ids[id.name] || [];
+        const _ids = ids[id.name] = ids[id.name] || [];
 
         _ids.push(id);
       } else {
@@ -48,8 +48,8 @@ function getBindingIdentifiers(node, duplicates, outerOnly) {
     }
 
     if (keys) {
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
 
         if (id[key]) {
           search = search.concat(id[key]);
@@ -66,6 +66,9 @@ getBindingIdentifiers.keys = {
   DeclareFunction: ["id"],
   DeclareModule: ["id"],
   DeclareVariable: ["id"],
+  DeclareInterface: ["id"],
+  DeclareTypeAlias: ["id"],
+  DeclareOpaqueType: ["id"],
   InterfaceDeclaration: ["id"],
   TypeAlias: ["id"],
   OpaqueType: ["id"],

data/lib/condenser/processors/node_modules/@babel/types/lib/traverse/traverse.js

@@ -14,39 +14,28 @@ function traverse(node, handlers, state) {
     };
   }
 
-  var _ref = handlers,
-      enter = _ref.enter,
-      exit = _ref.exit;
+  const {
+    enter,
+    exit
+  } = handlers;
   traverseSimpleImpl(node, enter, exit, state, []);
 }
 
 function traverseSimpleImpl(node, enter, exit, state, ancestors) {
-  var keys = _definitions.VISITOR_KEYS[node.type];
+  const keys = _definitions.VISITOR_KEYS[node.type];
   if (!keys) return;
   if (enter) enter(node, ancestors, state);
 
-  for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-    var _ref2;
-
-    if (_isArray) {
-      if (_i >= _iterator.length) break;
-      _ref2 = _iterator[_i++];
-    } else {
-      _i = _iterator.next();
-      if (_i.done) break;
-      _ref2 = _i.value;
-    }
-
-    var _key = _ref2;
-    var subNode = node[_key];
+  for (const key of keys) {
+    const subNode = node[key];
 
     if (Array.isArray(subNode)) {
-      for (var i = 0; i < subNode.length; i++) {
-        var child = subNode[i];
+      for (let i = 0; i < subNode.length; i++) {
+        const child = subNode[i];
         if (!child) continue;
         ancestors.push({
-          node: node,
-          key: _key,
+          node,
+          key,
           index: i
         });
         traverseSimpleImpl(child, enter, exit, state, ancestors);
@@ -54,8 +43,8 @@ function traverseSimpleImpl(node, enter, exit, state, ancestors) {
       }
     } else if (subNode) {
       ancestors.push({
-        node: node,
-        key: _key
+        node,
+        key
       });
       traverseSimpleImpl(subNode, enter, exit, state, ancestors);
       ancestors.pop();

data/lib/condenser/processors/node_modules/@babel/types/lib/traverse/traverseFast.js

@@ -9,41 +9,17 @@ var _definitions = require("../definitions");
 
 function traverseFast(node, enter, opts) {
   if (!node) return;
-  var keys = _definitions.VISITOR_KEYS[node.type];
+  const keys = _definitions.VISITOR_KEYS[node.type];
   if (!keys) return;
   opts = opts || {};
   enter(node, opts);
 
-  for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-    var _ref;
-
-    if (_isArray) {
-      if (_i >= _iterator.length) break;
-      _ref = _iterator[_i++];
-    } else {
-      _i = _iterator.next();
-      if (_i.done) break;
-      _ref = _i.value;
-    }
-
-    var key = _ref;
-    var subNode = node[key];
+  for (const key of keys) {
+    const subNode = node[key];
 
     if (Array.isArray(subNode)) {
-      for (var _iterator2 = subNode, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
-        var _ref2;
-
-        if (_isArray2) {
-          if (_i2 >= _iterator2.length) break;
-          _ref2 = _iterator2[_i2++];
-        } else {
-          _i2 = _iterator2.next();
-          if (_i2.done) break;
-          _ref2 = _i2.value;
-        }
-
-        var _node = _ref2;
-        traverseFast(_node, enter, opts);
+      for (const node of subNode) {
+        traverseFast(node, enter, opts);
       }
     } else {
       traverseFast(subNode, enter, opts);

data/lib/condenser/processors/node_modules/@babel/types/lib/utils/inherit.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = inherit;
 
 function _uniq() {
-  var data = _interopRequireDefault(require("lodash/uniq"));
+  const data = _interopRequireDefault(require("lodash/uniq"));
 
-  _uniq = function _uniq() {
+  _uniq = function () {
     return data;
   };
 

data/lib/condenser/processors/node_modules/@babel/types/lib/utils/react/cleanJSXElementLiteralChild.js

@@ -8,23 +8,23 @@ exports.default = cleanJSXElementLiteralChild;
 var _generated = require("../../builders/generated");
 
 function cleanJSXElementLiteralChild(child, args) {
-  var lines = child.value.split(/\r\n|\n|\r/);
-  var lastNonEmptyLine = 0;
+  const lines = child.value.split(/\r\n|\n|\r/);
+  let lastNonEmptyLine = 0;
 
-  for (var i = 0; i < lines.length; i++) {
+  for (let i = 0; i < lines.length; i++) {
     if (lines[i].match(/[^ \t]/)) {
       lastNonEmptyLine = i;
     }
   }
 
-  var str = "";
+  let str = "";
 
-  for (var _i = 0; _i < lines.length; _i++) {
-    var line = lines[_i];
-    var isFirstLine = _i === 0;
-    var isLastLine = _i === lines.length - 1;
-    var isLastNonEmptyLine = _i === lastNonEmptyLine;
-    var trimmedLine = line.replace(/\t/g, " ");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isFirstLine = i === 0;
+    const isLastLine = i === lines.length - 1;
+    const isLastNonEmptyLine = i === lastNonEmptyLine;
+    let trimmedLine = line.replace(/\t/g, " ");
 
     if (!isFirstLine) {
       trimmedLine = trimmedLine.replace(/^[ ]+/, "");

data/lib/condenser/processors/node_modules/@babel/types/lib/utils/shallowEqual.js

@@ -6,12 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = shallowEqual;
 
 function shallowEqual(actual, expected) {
-  var keys = Object.keys(expected);
-  var _arr = keys;
-
-  for (var _i = 0; _i < _arr.length; _i++) {
-    var key = _arr[_i];
+  const keys = Object.keys(expected);
 
+  for (const key of keys) {
     if (actual[key] !== expected[key]) {
       return false;
     }

data/lib/condenser/processors/node_modules/@babel/types/lib/validators/buildMatchMemberExpression.js

@@ -10,8 +10,6 @@ var _matchesPattern = _interopRequireDefault(require("./matchesPattern"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function buildMatchMemberExpression(match, allowPartial) {
-  var parts = match.split(".");
-  return function (member) {
-    return (0, _matchesPattern.default)(member, parts, allowPartial);
-  };
+  const parts = match.split(".");
+  return member => (0, _matchesPattern.default)(member, parts, allowPartial);
 }

data/lib/condenser/processors/node_modules/@babel/types/lib/validators/generated/index.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.isArrayExpression = isArrayExpression;
 exports.isAssignmentExpression = isAssignmentExpression;
 exports.isBinaryExpression = isBinaryExpression;
+exports.isInterpreterDirective = isInterpreterDirective;
 exports.isDirective = isDirective;
 exports.isDirectiveLiteral = isDirectiveLiteral;
 exports.isBlockStatement = isBlockStatement;
@@ -41,6 +42,7 @@ exports.isObjectProperty = isObjectProperty;
 exports.isRestElement = isRestElement;
 exports.isReturnStatement = isReturnStatement;
 exports.isSequenceExpression = isSequenceExpression;
+exports.isParenthesizedExpression = isParenthesizedExpression;
 exports.isSwitchCase = isSwitchCase;
 exports.isSwitchStatement = isSwitchStatement;
 exports.isThisExpression = isThisExpression;
@@ -100,6 +102,7 @@ exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
 exports.isInferredPredicate = isInferredPredicate;
 exports.isInterfaceExtends = isInterfaceExtends;
 exports.isInterfaceDeclaration = isInterfaceDeclaration;
+exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
 exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
 exports.isMixedTypeAnnotation = isMixedTypeAnnotation;
 exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
@@ -107,6 +110,7 @@ exports.isNullableTypeAnnotation = isNullableTypeAnnotation;
 exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
 exports.isNumberTypeAnnotation = isNumberTypeAnnotation;
 exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
+exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
 exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
 exports.isObjectTypeIndexer = isObjectTypeIndexer;
 exports.isObjectTypeProperty = isObjectTypeProperty;
@@ -143,17 +147,25 @@ exports.isJSXFragment = isJSXFragment;
 exports.isJSXOpeningFragment = isJSXOpeningFragment;
 exports.isJSXClosingFragment = isJSXClosingFragment;
 exports.isNoop = isNoop;
-exports.isParenthesizedExpression = isParenthesizedExpression;
+exports.isPlaceholder = isPlaceholder;
+exports.isArgumentPlaceholder = isArgumentPlaceholder;
 exports.isAwaitExpression = isAwaitExpression;
 exports.isBindExpression = isBindExpression;
 exports.isClassProperty = isClassProperty;
 exports.isOptionalMemberExpression = isOptionalMemberExpression;
+exports.isPipelineTopicExpression = isPipelineTopicExpression;
+exports.isPipelineBareFunction = isPipelineBareFunction;
+exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
 exports.isOptionalCallExpression = isOptionalCallExpression;
+exports.isClassPrivateProperty = isClassPrivateProperty;
+exports.isClassPrivateMethod = isClassPrivateMethod;
 exports.isImport = isImport;
 exports.isDecorator = isDecorator;
 exports.isDoExpression = isDoExpression;
 exports.isExportDefaultSpecifier = isExportDefaultSpecifier;
 exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
+exports.isPrivateName = isPrivateName;
+exports.isBigIntLiteral = isBigIntLiteral;
 exports.isTSParameterProperty = isTSParameterProperty;
 exports.isTSDeclareFunction = isTSDeclareFunction;
 exports.isTSDeclareMethod = isTSDeclareMethod;
@@ -164,6 +176,7 @@ exports.isTSPropertySignature = isTSPropertySignature;
 exports.isTSMethodSignature = isTSMethodSignature;
 exports.isTSIndexSignature = isTSIndexSignature;
 exports.isTSAnyKeyword = isTSAnyKeyword;
+exports.isTSUnknownKeyword = isTSUnknownKeyword;
 exports.isTSNumberKeyword = isTSNumberKeyword;
 exports.isTSObjectKeyword = isTSObjectKeyword;
 exports.isTSBooleanKeyword = isTSBooleanKeyword;
@@ -182,6 +195,8 @@ exports.isTSTypeQuery = isTSTypeQuery;
 exports.isTSTypeLiteral = isTSTypeLiteral;
 exports.isTSArrayType = isTSArrayType;
 exports.isTSTupleType = isTSTupleType;
+exports.isTSOptionalType = isTSOptionalType;
+exports.isTSRestType = isTSRestType;
 exports.isTSUnionType = isTSUnionType;
 exports.isTSIntersectionType = isTSIntersectionType;
 exports.isTSConditionalType = isTSConditionalType;
@@ -201,6 +216,7 @@ exports.isTSEnumDeclaration = isTSEnumDeclaration;
 exports.isTSEnumMember = isTSEnumMember;
 exports.isTSModuleDeclaration = isTSModuleDeclaration;
 exports.isTSModuleBlock = isTSModuleBlock;
+exports.isTSImportType = isTSImportType;
 exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
 exports.isTSExternalModuleReference = isTSExternalModuleReference;
 exports.isTSNonNullExpression = isTSNonNullExpression;
@@ -249,6 +265,7 @@ exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
 exports.isFlowDeclaration = isFlowDeclaration;
 exports.isFlowPredicate = isFlowPredicate;
 exports.isJSX = isJSX;
+exports.isPrivate = isPrivate;
 exports.isTSTypeElement = isTSTypeElement;
 exports.isTSType = isTSType;
 exports.isNumberLiteral = isNumberLiteral;
@@ -256,1018 +273,4045 @@ exports.isRegexLiteral = isRegexLiteral;
 exports.isRestProperty = isRestProperty;
 exports.isSpreadProperty = isSpreadProperty;
 
-var _is = _interopRequireDefault(require("../is"));
+var _shallowEqual = _interopRequireDefault(require("../../utils/shallowEqual"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function isArrayExpression(node, opts) {
-  return (0, _is.default)("ArrayExpression", 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) {
-  return (0, _is.default)("AssignmentExpression", 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) {
-  return (0, _is.default)("BinaryExpression", 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) {
-  return (0, _is.default)("Directive", 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) {
-  return (0, _is.default)("DirectiveLiteral", 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) {
-  return (0, _is.default)("BlockStatement", 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) {
-  return (0, _is.default)("BreakStatement", 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) {
-  return (0, _is.default)("CallExpression", 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) {
-  return (0, _is.default)("CatchClause", 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) {
-  return (0, _is.default)("ConditionalExpression", 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) {
-  return (0, _is.default)("ContinueStatement", 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) {
-  return (0, _is.default)("DebuggerStatement", 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) {
-  return (0, _is.default)("DoWhileStatement", 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) {
-  return (0, _is.default)("EmptyStatement", 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) {
-  return (0, _is.default)("ExpressionStatement", 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) {
-  return (0, _is.default)("File", 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) {
-  return (0, _is.default)("ForInStatement", 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) {
-  return (0, _is.default)("ForStatement", 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) {
-  return (0, _is.default)("FunctionDeclaration", 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) {
-  return (0, _is.default)("FunctionExpression", 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) {
-  return (0, _is.default)("Identifier", 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) {
-  return (0, _is.default)("IfStatement", 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) {
-  return (0, _is.default)("LabeledStatement", 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) {
-  return (0, _is.default)("StringLiteral", 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) {
-  return (0, _is.default)("NumericLiteral", 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) {
-  return (0, _is.default)("NullLiteral", 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) {
-  return (0, _is.default)("BooleanLiteral", 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) {
-  return (0, _is.default)("RegExpLiteral", 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) {
-  return (0, _is.default)("LogicalExpression", 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) {
-  return (0, _is.default)("MemberExpression", 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) {
-  return (0, _is.default)("NewExpression", 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) {
-  return (0, _is.default)("Program", 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) {
-  return (0, _is.default)("ObjectExpression", 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) {
-  return (0, _is.default)("ObjectMethod", 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) {
-  return (0, _is.default)("ObjectProperty", 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) {
-  return (0, _is.default)("RestElement", 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) {
-  return (0, _is.default)("ReturnStatement", 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) {
-  return (0, _is.default)("SequenceExpression", 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) {
-  return (0, _is.default)("SwitchCase", 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) {
-  return (0, _is.default)("SwitchStatement", 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) {
-  return (0, _is.default)("ThisExpression", 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) {
-  return (0, _is.default)("ThrowStatement", 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) {
-  return (0, _is.default)("TryStatement", 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) {
-  return (0, _is.default)("UnaryExpression", 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) {
-  return (0, _is.default)("UpdateExpression", 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) {
-  return (0, _is.default)("VariableDeclaration", 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) {
-  return (0, _is.default)("VariableDeclarator", 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) {
-  return (0, _is.default)("WhileStatement", 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) {
-  return (0, _is.default)("WithStatement", 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) {
-  return (0, _is.default)("AssignmentPattern", 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) {
-  return (0, _is.default)("ArrayPattern", 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) {
-  return (0, _is.default)("ArrowFunctionExpression", 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) {
-  return (0, _is.default)("ClassBody", 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 isClassDeclaration(node, opts) {
-  return (0, _is.default)("ClassDeclaration", 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 isClassExpression(node, opts) {
-  return (0, _is.default)("ClassExpression", 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 isExportAllDeclaration(node, opts) {
-  return (0, _is.default)("ExportAllDeclaration", 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) {
-  return (0, _is.default)("ExportDefaultDeclaration", 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) {
-  return (0, _is.default)("ExportNamedDeclaration", 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) {
-  return (0, _is.default)("ExportSpecifier", 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) {
-  return (0, _is.default)("ForOfStatement", 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) {
-  return (0, _is.default)("ImportDeclaration", 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) {
-  return (0, _is.default)("ImportDefaultSpecifier", 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) {
-  return (0, _is.default)("ImportNamespaceSpecifier", 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) {
-  return (0, _is.default)("ImportSpecifier", 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) {
-  return (0, _is.default)("MetaProperty", 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) {
-  return (0, _is.default)("ClassMethod", 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) {
-  return (0, _is.default)("ObjectPattern", 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) {
-  return (0, _is.default)("SpreadElement", 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) {
-  return (0, _is.default)("Super", 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) {
-  return (0, _is.default)("TaggedTemplateExpression", 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) {
-  return (0, _is.default)("TemplateElement", 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) {
-  return (0, _is.default)("TemplateLiteral", 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) {
-  return (0, _is.default)("YieldExpression", 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 isAnyTypeAnnotation(node, opts) {
-  return (0, _is.default)("AnyTypeAnnotation", 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) {
-  return (0, _is.default)("ArrayTypeAnnotation", 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) {
-  return (0, _is.default)("BooleanTypeAnnotation", 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) {
-  return (0, _is.default)("BooleanLiteralTypeAnnotation", 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) {
-  return (0, _is.default)("NullLiteralTypeAnnotation", 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) {
-  return (0, _is.default)("ClassImplements", 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) {
-  return (0, _is.default)("DeclareClass", 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) {
-  return (0, _is.default)("DeclareFunction", 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) {
-  return (0, _is.default)("DeclareInterface", 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) {
-  return (0, _is.default)("DeclareModule", 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) {
-  return (0, _is.default)("DeclareModuleExports", 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) {
-  return (0, _is.default)("DeclareTypeAlias", 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) {
-  return (0, _is.default)("DeclareOpaqueType", 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) {
-  return (0, _is.default)("DeclareVariable", 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) {
-  return (0, _is.default)("DeclareExportDeclaration", 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) {
-  return (0, _is.default)("DeclareExportAllDeclaration", 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) {
-  return (0, _is.default)("DeclaredPredicate", 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) {
-  return (0, _is.default)("ExistsTypeAnnotation", 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) {
-  return (0, _is.default)("FunctionTypeAnnotation", 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) {
-  return (0, _is.default)("FunctionTypeParam", 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) {
-  return (0, _is.default)("GenericTypeAnnotation", 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) {
-  return (0, _is.default)("InferredPredicate", 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) {
-  return (0, _is.default)("InterfaceExtends", 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) {
-  return (0, _is.default)("InterfaceDeclaration", 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) {
-  return (0, _is.default)("IntersectionTypeAnnotation", 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) {
-  return (0, _is.default)("MixedTypeAnnotation", 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) {
-  return (0, _is.default)("EmptyTypeAnnotation", 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) {
-  return (0, _is.default)("NullableTypeAnnotation", 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) {
-  return (0, _is.default)("NumberLiteralTypeAnnotation", 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) {
-  return (0, _is.default)("NumberTypeAnnotation", 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) {
-  return (0, _is.default)("ObjectTypeAnnotation", 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) {
-  return (0, _is.default)("ObjectTypeCallProperty", 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) {
-  return (0, _is.default)("ObjectTypeIndexer", 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) {
-  return (0, _is.default)("ObjectTypeProperty", 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) {
-  return (0, _is.default)("ObjectTypeSpreadProperty", 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) {
-  return (0, _is.default)("OpaqueType", 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) {
-  return (0, _is.default)("QualifiedTypeIdentifier", 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) {
-  return (0, _is.default)("StringLiteralTypeAnnotation", 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) {
-  return (0, _is.default)("StringTypeAnnotation", 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 isThisTypeAnnotation(node, opts) {
-  return (0, _is.default)("ThisTypeAnnotation", 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) {
-  return (0, _is.default)("TupleTypeAnnotation", 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) {
-  return (0, _is.default)("TypeofTypeAnnotation", 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) {
-  return (0, _is.default)("TypeAlias", 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) {
-  return (0, _is.default)("TypeAnnotation", 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) {
-  return (0, _is.default)("TypeCastExpression", 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) {
-  return (0, _is.default)("TypeParameter", 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) {
-  return (0, _is.default)("TypeParameterDeclaration", 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) {
-  return (0, _is.default)("TypeParameterInstantiation", 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) {
-  return (0, _is.default)("UnionTypeAnnotation", 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) {
-  return (0, _is.default)("Variance", 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) {
-  return (0, _is.default)("VoidTypeAnnotation", 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 isJSXAttribute(node, opts) {
-  return (0, _is.default)("JSXAttribute", 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) {
-  return (0, _is.default)("JSXClosingElement", 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) {
-  return (0, _is.default)("JSXElement", 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) {
-  return (0, _is.default)("JSXEmptyExpression", 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) {
-  return (0, _is.default)("JSXExpressionContainer", 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) {
-  return (0, _is.default)("JSXSpreadChild", 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) {
-  return (0, _is.default)("JSXIdentifier", 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) {
-  return (0, _is.default)("JSXMemberExpression", 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) {
-  return (0, _is.default)("JSXNamespacedName", 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) {
-  return (0, _is.default)("JSXOpeningElement", 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) {
-  return (0, _is.default)("JSXSpreadAttribute", 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) {
-  return (0, _is.default)("JSXText", 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) {
-  return (0, _is.default)("JSXFragment", 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) {
-  return (0, _is.default)("JSXOpeningFragment", 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) {
-  return (0, _is.default)("JSXClosingFragment", 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) {
-  return (0, _is.default)("Noop", 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 isParenthesizedExpression(node, opts) {
-  return (0, _is.default)("ParenthesizedExpression", node, opts);
+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 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 isAwaitExpression(node, opts) {
-  return (0, _is.default)("AwaitExpression", 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 isBindExpression(node, opts) {
-  return (0, _is.default)("BindExpression", 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) {
-  return (0, _is.default)("ClassProperty", 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 isOptionalMemberExpression(node, opts) {
-  return (0, _is.default)("OptionalMemberExpression", 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 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 isOptionalCallExpression(node, opts) {
-  return (0, _is.default)("OptionalCallExpression", 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 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 isImport(node, opts) {
-  return (0, _is.default)("Import", 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 isDecorator(node, opts) {
-  return (0, _is.default)("Decorator", 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) {
-  return (0, _is.default)("DoExpression", 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) {
-  return (0, _is.default)("ExportDefaultSpecifier", 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 isExportNamespaceSpecifier(node, opts) {
-  return (0, _is.default)("ExportNamespaceSpecifier", 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 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 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 isTSParameterProperty(node, opts) {
-  return (0, _is.default)("TSParameterProperty", 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) {
-  return (0, _is.default)("TSDeclareFunction", 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) {
-  return (0, _is.default)("TSDeclareMethod", 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) {
-  return (0, _is.default)("TSQualifiedName", 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) {
-  return (0, _is.default)("TSCallSignatureDeclaration", 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) {
-  return (0, _is.default)("TSConstructSignatureDeclaration", 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) {
-  return (0, _is.default)("TSPropertySignature", 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) {
-  return (0, _is.default)("TSMethodSignature", 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) {
-  return (0, _is.default)("TSIndexSignature", 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) {
-  return (0, _is.default)("TSAnyKeyword", 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 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 isTSNumberKeyword(node, opts) {
-  return (0, _is.default)("TSNumberKeyword", 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) {
-  return (0, _is.default)("TSObjectKeyword", 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 isTSBooleanKeyword(node, opts) {
-  return (0, _is.default)("TSBooleanKeyword", 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 isTSStringKeyword(node, opts) {
-  return (0, _is.default)("TSStringKeyword", 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) {
-  return (0, _is.default)("TSSymbolKeyword", 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 isTSVoidKeyword(node, opts) {
-  return (0, _is.default)("TSVoidKeyword", 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 isTSUndefinedKeyword(node, opts) {
-  return (0, _is.default)("TSUndefinedKeyword", 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 isTSNullKeyword(node, opts) {
-  return (0, _is.default)("TSNullKeyword", 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 isTSNeverKeyword(node, opts) {
-  return (0, _is.default)("TSNeverKeyword", 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 isTSThisType(node, opts) {
-  return (0, _is.default)("TSThisType", 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) {
-  return (0, _is.default)("TSFunctionType", 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) {
-  return (0, _is.default)("TSConstructorType", 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) {
-  return (0, _is.default)("TSTypeReference", 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) {
-  return (0, _is.default)("TSTypePredicate", 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) {
-  return (0, _is.default)("TSTypeQuery", 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) {
-  return (0, _is.default)("TSTypeLiteral", 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) {
-  return (0, _is.default)("TSArrayType", 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) {
-  return (0, _is.default)("TSTupleType", 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 isTSUnionType(node, opts) {
-  return (0, _is.default)("TSUnionType", 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) {
-  return (0, _is.default)("TSIntersectionType", 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) {
-  return (0, _is.default)("TSConditionalType", 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) {
-  return (0, _is.default)("TSInferType", 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) {
-  return (0, _is.default)("TSParenthesizedType", 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) {
-  return (0, _is.default)("TSTypeOperator", 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) {
-  return (0, _is.default)("TSIndexedAccessType", 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) {
-  return (0, _is.default)("TSMappedType", 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) {
-  return (0, _is.default)("TSLiteralType", 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) {
-  return (0, _is.default)("TSExpressionWithTypeArguments", 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) {
-  return (0, _is.default)("TSInterfaceDeclaration", 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) {
-  return (0, _is.default)("TSInterfaceBody", 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) {
-  return (0, _is.default)("TSTypeAliasDeclaration", 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) {
-  return (0, _is.default)("TSAsExpression", 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) {
-  return (0, _is.default)("TSTypeAssertion", 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) {
-  return (0, _is.default)("TSEnumDeclaration", 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) {
-  return (0, _is.default)("TSEnumMember", 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) {
-  return (0, _is.default)("TSModuleDeclaration", 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) {
-  return (0, _is.default)("TSModuleBlock", 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) {
-  return (0, _is.default)("TSImportEqualsDeclaration", 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) {
-  return (0, _is.default)("TSExternalModuleReference", 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) {
-  return (0, _is.default)("TSNonNullExpression", 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) {
-  return (0, _is.default)("TSExportAssignment", 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) {
-  return (0, _is.default)("TSNamespaceExportDeclaration", 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) {
-  return (0, _is.default)("TSTypeAnnotation", 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) {
-  return (0, _is.default)("TSTypeParameterInstantiation", 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) {
-  return (0, _is.default)("TSTypeParameterDeclaration", 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) {
-  return (0, _is.default)("TSTypeParameter", 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) {
-  return (0, _is.default)("Expression", 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 || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "AwaitExpression" === nodeType || "BindExpression" === nodeType || "OptionalMemberExpression" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "OptionalCallExpression" === nodeType || "Import" === nodeType || "DoExpression" === nodeType || "BigIntLiteral" === 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) {
-  return (0, _is.default)("Binary", 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) {
-  return (0, _is.default)("Scopable", 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 || "ClassDeclaration" === nodeType || "ClassExpression" === 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) {
-  return (0, _is.default)("BlockParent", 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) {
-  return (0, _is.default)("Block", 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) {
-  return (0, _is.default)("Statement", 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 || "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) {
-  return (0, _is.default)("Terminatorless", 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) {
-  return (0, _is.default)("CompletionStatement", 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) {
-  return (0, _is.default)("Conditional", 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) {
-  return (0, _is.default)("Loop", 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) {
-  return (0, _is.default)("While", 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) {
-  return (0, _is.default)("ExpressionWrapper", 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) {
-  return (0, _is.default)("For", 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) {
-  return (0, _is.default)("ForXStatement", 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) {
-  return (0, _is.default)("Function", 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) {
-  return (0, _is.default)("FunctionParent", 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) {
-  return (0, _is.default)("Pureish", 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 || "ArrowFunctionExpression" === nodeType || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType || "BigIntLiteral" === 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) {
-  return (0, _is.default)("Declaration", 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 || "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) {
-  return (0, _is.default)("PatternLike", 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) {
-  return (0, _is.default)("LVal", 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) {
-  return (0, _is.default)("TSEntityName", 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) {
-  return (0, _is.default)("Literal", 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 || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
 }
 
 function isImmutable(node, opts) {
-  return (0, _is.default)("Immutable", node, opts);
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Immutable" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType || "BigIntLiteral" === 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) {
-  return (0, _is.default)("UserWhitespacable", 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) {
-  return (0, _is.default)("Method", 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) {
-  return (0, _is.default)("ObjectMember", 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) {
-  return (0, _is.default)("Property", 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) {
-  return (0, _is.default)("UnaryLike", 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) {
-  return (0, _is.default)("Pattern", 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) {
-  return (0, _is.default)("Class", node, opts);
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "Class" || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
 }
 
 function isModuleDeclaration(node, opts) {
-  return (0, _is.default)("ModuleDeclaration", 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) {
-  return (0, _is.default)("ExportDeclaration", 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) {
-  return (0, _is.default)("ModuleSpecifier", node, opts);
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "ModuleSpecifier" || "ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
 }
 
 function isFlow(node, opts) {
-  return (0, _is.default)("Flow", 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 || "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) {
-  return (0, _is.default)("FlowType", 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 || "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) {
-  return (0, _is.default)("FlowBaseAnnotation", 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 || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
+    if (typeof opts === "undefined") {
+      return true;
+    } else {
+      return (0, _shallowEqual.default)(node, opts);
+    }
+  }
+
+  return false;
 }
 
 function isFlowDeclaration(node, opts) {
-  return (0, _is.default)("FlowDeclaration", 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) {
-  return (0, _is.default)("FlowPredicate", 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 isJSX(node, opts) {
-  return (0, _is.default)("JSX", 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) {
-  return (0, _is.default)("TSTypeElement", 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) {
-  return (0, _is.default)("TSType", node, opts);
+  if (!node) return false;
+  const nodeType = node.type;
+
+  if (nodeType === "TSType" || "TSAnyKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNeverKeyword" === 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 isNumberLiteral(node, opts) {
   console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
-  return (0, _is.default)("NumberLiteral", node, opts);
+  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");
-  return (0, _is.default)("RegexLiteral", node, opts);
+  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");
-  return (0, _is.default)("RestProperty", node, opts);
+  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");
-  return (0, _is.default)("SpreadProperty", node, opts);
+  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;
 }