• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1"use strict";
2
3Object.defineProperty(exports, "__esModule", {
4  value: true
5});
6exports.isArrayExpression = isArrayExpression;
7exports.isAssignmentExpression = isAssignmentExpression;
8exports.isBinaryExpression = isBinaryExpression;
9exports.isInterpreterDirective = isInterpreterDirective;
10exports.isDirective = isDirective;
11exports.isDirectiveLiteral = isDirectiveLiteral;
12exports.isBlockStatement = isBlockStatement;
13exports.isBreakStatement = isBreakStatement;
14exports.isCallExpression = isCallExpression;
15exports.isCatchClause = isCatchClause;
16exports.isConditionalExpression = isConditionalExpression;
17exports.isContinueStatement = isContinueStatement;
18exports.isDebuggerStatement = isDebuggerStatement;
19exports.isDoWhileStatement = isDoWhileStatement;
20exports.isEmptyStatement = isEmptyStatement;
21exports.isExpressionStatement = isExpressionStatement;
22exports.isFile = isFile;
23exports.isForInStatement = isForInStatement;
24exports.isForStatement = isForStatement;
25exports.isFunctionDeclaration = isFunctionDeclaration;
26exports.isFunctionExpression = isFunctionExpression;
27exports.isIdentifier = isIdentifier;
28exports.isIfStatement = isIfStatement;
29exports.isLabeledStatement = isLabeledStatement;
30exports.isStringLiteral = isStringLiteral;
31exports.isNumericLiteral = isNumericLiteral;
32exports.isNullLiteral = isNullLiteral;
33exports.isBooleanLiteral = isBooleanLiteral;
34exports.isRegExpLiteral = isRegExpLiteral;
35exports.isLogicalExpression = isLogicalExpression;
36exports.isMemberExpression = isMemberExpression;
37exports.isNewExpression = isNewExpression;
38exports.isProgram = isProgram;
39exports.isObjectExpression = isObjectExpression;
40exports.isObjectMethod = isObjectMethod;
41exports.isObjectProperty = isObjectProperty;
42exports.isRestElement = isRestElement;
43exports.isReturnStatement = isReturnStatement;
44exports.isSequenceExpression = isSequenceExpression;
45exports.isParenthesizedExpression = isParenthesizedExpression;
46exports.isSwitchCase = isSwitchCase;
47exports.isSwitchStatement = isSwitchStatement;
48exports.isThisExpression = isThisExpression;
49exports.isThrowStatement = isThrowStatement;
50exports.isTryStatement = isTryStatement;
51exports.isUnaryExpression = isUnaryExpression;
52exports.isUpdateExpression = isUpdateExpression;
53exports.isVariableDeclaration = isVariableDeclaration;
54exports.isVariableDeclarator = isVariableDeclarator;
55exports.isWhileStatement = isWhileStatement;
56exports.isWithStatement = isWithStatement;
57exports.isAssignmentPattern = isAssignmentPattern;
58exports.isArrayPattern = isArrayPattern;
59exports.isArrowFunctionExpression = isArrowFunctionExpression;
60exports.isClassBody = isClassBody;
61exports.isClassDeclaration = isClassDeclaration;
62exports.isClassExpression = isClassExpression;
63exports.isExportAllDeclaration = isExportAllDeclaration;
64exports.isExportDefaultDeclaration = isExportDefaultDeclaration;
65exports.isExportNamedDeclaration = isExportNamedDeclaration;
66exports.isExportSpecifier = isExportSpecifier;
67exports.isForOfStatement = isForOfStatement;
68exports.isImportDeclaration = isImportDeclaration;
69exports.isImportDefaultSpecifier = isImportDefaultSpecifier;
70exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
71exports.isImportSpecifier = isImportSpecifier;
72exports.isMetaProperty = isMetaProperty;
73exports.isClassMethod = isClassMethod;
74exports.isObjectPattern = isObjectPattern;
75exports.isSpreadElement = isSpreadElement;
76exports.isSuper = isSuper;
77exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
78exports.isTemplateElement = isTemplateElement;
79exports.isTemplateLiteral = isTemplateLiteral;
80exports.isYieldExpression = isYieldExpression;
81exports.isAnyTypeAnnotation = isAnyTypeAnnotation;
82exports.isArrayTypeAnnotation = isArrayTypeAnnotation;
83exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
84exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
85exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
86exports.isClassImplements = isClassImplements;
87exports.isDeclareClass = isDeclareClass;
88exports.isDeclareFunction = isDeclareFunction;
89exports.isDeclareInterface = isDeclareInterface;
90exports.isDeclareModule = isDeclareModule;
91exports.isDeclareModuleExports = isDeclareModuleExports;
92exports.isDeclareTypeAlias = isDeclareTypeAlias;
93exports.isDeclareOpaqueType = isDeclareOpaqueType;
94exports.isDeclareVariable = isDeclareVariable;
95exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
96exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
97exports.isDeclaredPredicate = isDeclaredPredicate;
98exports.isExistsTypeAnnotation = isExistsTypeAnnotation;
99exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
100exports.isFunctionTypeParam = isFunctionTypeParam;
101exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
102exports.isInferredPredicate = isInferredPredicate;
103exports.isInterfaceExtends = isInterfaceExtends;
104exports.isInterfaceDeclaration = isInterfaceDeclaration;
105exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
106exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
107exports.isMixedTypeAnnotation = isMixedTypeAnnotation;
108exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
109exports.isNullableTypeAnnotation = isNullableTypeAnnotation;
110exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
111exports.isNumberTypeAnnotation = isNumberTypeAnnotation;
112exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
113exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
114exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
115exports.isObjectTypeIndexer = isObjectTypeIndexer;
116exports.isObjectTypeProperty = isObjectTypeProperty;
117exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
118exports.isOpaqueType = isOpaqueType;
119exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
120exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
121exports.isStringTypeAnnotation = isStringTypeAnnotation;
122exports.isThisTypeAnnotation = isThisTypeAnnotation;
123exports.isTupleTypeAnnotation = isTupleTypeAnnotation;
124exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
125exports.isTypeAlias = isTypeAlias;
126exports.isTypeAnnotation = isTypeAnnotation;
127exports.isTypeCastExpression = isTypeCastExpression;
128exports.isTypeParameter = isTypeParameter;
129exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
130exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
131exports.isUnionTypeAnnotation = isUnionTypeAnnotation;
132exports.isVariance = isVariance;
133exports.isVoidTypeAnnotation = isVoidTypeAnnotation;
134exports.isJSXAttribute = isJSXAttribute;
135exports.isJSXClosingElement = isJSXClosingElement;
136exports.isJSXElement = isJSXElement;
137exports.isJSXEmptyExpression = isJSXEmptyExpression;
138exports.isJSXExpressionContainer = isJSXExpressionContainer;
139exports.isJSXSpreadChild = isJSXSpreadChild;
140exports.isJSXIdentifier = isJSXIdentifier;
141exports.isJSXMemberExpression = isJSXMemberExpression;
142exports.isJSXNamespacedName = isJSXNamespacedName;
143exports.isJSXOpeningElement = isJSXOpeningElement;
144exports.isJSXSpreadAttribute = isJSXSpreadAttribute;
145exports.isJSXText = isJSXText;
146exports.isJSXFragment = isJSXFragment;
147exports.isJSXOpeningFragment = isJSXOpeningFragment;
148exports.isJSXClosingFragment = isJSXClosingFragment;
149exports.isNoop = isNoop;
150exports.isPlaceholder = isPlaceholder;
151exports.isArgumentPlaceholder = isArgumentPlaceholder;
152exports.isAwaitExpression = isAwaitExpression;
153exports.isBindExpression = isBindExpression;
154exports.isClassProperty = isClassProperty;
155exports.isOptionalMemberExpression = isOptionalMemberExpression;
156exports.isPipelineTopicExpression = isPipelineTopicExpression;
157exports.isPipelineBareFunction = isPipelineBareFunction;
158exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
159exports.isOptionalCallExpression = isOptionalCallExpression;
160exports.isClassPrivateProperty = isClassPrivateProperty;
161exports.isClassPrivateMethod = isClassPrivateMethod;
162exports.isImport = isImport;
163exports.isDecorator = isDecorator;
164exports.isDoExpression = isDoExpression;
165exports.isExportDefaultSpecifier = isExportDefaultSpecifier;
166exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
167exports.isPrivateName = isPrivateName;
168exports.isBigIntLiteral = isBigIntLiteral;
169exports.isTSParameterProperty = isTSParameterProperty;
170exports.isTSDeclareFunction = isTSDeclareFunction;
171exports.isTSDeclareMethod = isTSDeclareMethod;
172exports.isTSQualifiedName = isTSQualifiedName;
173exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
174exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
175exports.isTSPropertySignature = isTSPropertySignature;
176exports.isTSMethodSignature = isTSMethodSignature;
177exports.isTSIndexSignature = isTSIndexSignature;
178exports.isTSAnyKeyword = isTSAnyKeyword;
179exports.isTSUnknownKeyword = isTSUnknownKeyword;
180exports.isTSNumberKeyword = isTSNumberKeyword;
181exports.isTSObjectKeyword = isTSObjectKeyword;
182exports.isTSBooleanKeyword = isTSBooleanKeyword;
183exports.isTSStringKeyword = isTSStringKeyword;
184exports.isTSSymbolKeyword = isTSSymbolKeyword;
185exports.isTSVoidKeyword = isTSVoidKeyword;
186exports.isTSUndefinedKeyword = isTSUndefinedKeyword;
187exports.isTSNullKeyword = isTSNullKeyword;
188exports.isTSNeverKeyword = isTSNeverKeyword;
189exports.isTSThisType = isTSThisType;
190exports.isTSFunctionType = isTSFunctionType;
191exports.isTSConstructorType = isTSConstructorType;
192exports.isTSTypeReference = isTSTypeReference;
193exports.isTSTypePredicate = isTSTypePredicate;
194exports.isTSTypeQuery = isTSTypeQuery;
195exports.isTSTypeLiteral = isTSTypeLiteral;
196exports.isTSArrayType = isTSArrayType;
197exports.isTSTupleType = isTSTupleType;
198exports.isTSOptionalType = isTSOptionalType;
199exports.isTSRestType = isTSRestType;
200exports.isTSUnionType = isTSUnionType;
201exports.isTSIntersectionType = isTSIntersectionType;
202exports.isTSConditionalType = isTSConditionalType;
203exports.isTSInferType = isTSInferType;
204exports.isTSParenthesizedType = isTSParenthesizedType;
205exports.isTSTypeOperator = isTSTypeOperator;
206exports.isTSIndexedAccessType = isTSIndexedAccessType;
207exports.isTSMappedType = isTSMappedType;
208exports.isTSLiteralType = isTSLiteralType;
209exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
210exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
211exports.isTSInterfaceBody = isTSInterfaceBody;
212exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
213exports.isTSAsExpression = isTSAsExpression;
214exports.isTSTypeAssertion = isTSTypeAssertion;
215exports.isTSEnumDeclaration = isTSEnumDeclaration;
216exports.isTSEnumMember = isTSEnumMember;
217exports.isTSModuleDeclaration = isTSModuleDeclaration;
218exports.isTSModuleBlock = isTSModuleBlock;
219exports.isTSImportType = isTSImportType;
220exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
221exports.isTSExternalModuleReference = isTSExternalModuleReference;
222exports.isTSNonNullExpression = isTSNonNullExpression;
223exports.isTSExportAssignment = isTSExportAssignment;
224exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
225exports.isTSTypeAnnotation = isTSTypeAnnotation;
226exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
227exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
228exports.isTSTypeParameter = isTSTypeParameter;
229exports.isExpression = isExpression;
230exports.isBinary = isBinary;
231exports.isScopable = isScopable;
232exports.isBlockParent = isBlockParent;
233exports.isBlock = isBlock;
234exports.isStatement = isStatement;
235exports.isTerminatorless = isTerminatorless;
236exports.isCompletionStatement = isCompletionStatement;
237exports.isConditional = isConditional;
238exports.isLoop = isLoop;
239exports.isWhile = isWhile;
240exports.isExpressionWrapper = isExpressionWrapper;
241exports.isFor = isFor;
242exports.isForXStatement = isForXStatement;
243exports.isFunction = isFunction;
244exports.isFunctionParent = isFunctionParent;
245exports.isPureish = isPureish;
246exports.isDeclaration = isDeclaration;
247exports.isPatternLike = isPatternLike;
248exports.isLVal = isLVal;
249exports.isTSEntityName = isTSEntityName;
250exports.isLiteral = isLiteral;
251exports.isImmutable = isImmutable;
252exports.isUserWhitespacable = isUserWhitespacable;
253exports.isMethod = isMethod;
254exports.isObjectMember = isObjectMember;
255exports.isProperty = isProperty;
256exports.isUnaryLike = isUnaryLike;
257exports.isPattern = isPattern;
258exports.isClass = isClass;
259exports.isModuleDeclaration = isModuleDeclaration;
260exports.isExportDeclaration = isExportDeclaration;
261exports.isModuleSpecifier = isModuleSpecifier;
262exports.isFlow = isFlow;
263exports.isFlowType = isFlowType;
264exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
265exports.isFlowDeclaration = isFlowDeclaration;
266exports.isFlowPredicate = isFlowPredicate;
267exports.isJSX = isJSX;
268exports.isPrivate = isPrivate;
269exports.isTSTypeElement = isTSTypeElement;
270exports.isTSType = isTSType;
271exports.isNumberLiteral = isNumberLiteral;
272exports.isRegexLiteral = isRegexLiteral;
273exports.isRestProperty = isRestProperty;
274exports.isSpreadProperty = isSpreadProperty;
275
276var _shallowEqual = _interopRequireDefault(require("../../utils/shallowEqual"));
277
278function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
279
280function isArrayExpression(node, opts) {
281  if (!node) return false;
282  const nodeType = node.type;
283
284  if (nodeType === "ArrayExpression") {
285    if (typeof opts === "undefined") {
286      return true;
287    } else {
288      return (0, _shallowEqual.default)(node, opts);
289    }
290  }
291
292  return false;
293}
294
295function isAssignmentExpression(node, opts) {
296  if (!node) return false;
297  const nodeType = node.type;
298
299  if (nodeType === "AssignmentExpression") {
300    if (typeof opts === "undefined") {
301      return true;
302    } else {
303      return (0, _shallowEqual.default)(node, opts);
304    }
305  }
306
307  return false;
308}
309
310function isBinaryExpression(node, opts) {
311  if (!node) return false;
312  const nodeType = node.type;
313
314  if (nodeType === "BinaryExpression") {
315    if (typeof opts === "undefined") {
316      return true;
317    } else {
318      return (0, _shallowEqual.default)(node, opts);
319    }
320  }
321
322  return false;
323}
324
325function isInterpreterDirective(node, opts) {
326  if (!node) return false;
327  const nodeType = node.type;
328
329  if (nodeType === "InterpreterDirective") {
330    if (typeof opts === "undefined") {
331      return true;
332    } else {
333      return (0, _shallowEqual.default)(node, opts);
334    }
335  }
336
337  return false;
338}
339
340function isDirective(node, opts) {
341  if (!node) return false;
342  const nodeType = node.type;
343
344  if (nodeType === "Directive") {
345    if (typeof opts === "undefined") {
346      return true;
347    } else {
348      return (0, _shallowEqual.default)(node, opts);
349    }
350  }
351
352  return false;
353}
354
355function isDirectiveLiteral(node, opts) {
356  if (!node) return false;
357  const nodeType = node.type;
358
359  if (nodeType === "DirectiveLiteral") {
360    if (typeof opts === "undefined") {
361      return true;
362    } else {
363      return (0, _shallowEqual.default)(node, opts);
364    }
365  }
366
367  return false;
368}
369
370function isBlockStatement(node, opts) {
371  if (!node) return false;
372  const nodeType = node.type;
373
374  if (nodeType === "BlockStatement") {
375    if (typeof opts === "undefined") {
376      return true;
377    } else {
378      return (0, _shallowEqual.default)(node, opts);
379    }
380  }
381
382  return false;
383}
384
385function isBreakStatement(node, opts) {
386  if (!node) return false;
387  const nodeType = node.type;
388
389  if (nodeType === "BreakStatement") {
390    if (typeof opts === "undefined") {
391      return true;
392    } else {
393      return (0, _shallowEqual.default)(node, opts);
394    }
395  }
396
397  return false;
398}
399
400function isCallExpression(node, opts) {
401  if (!node) return false;
402  const nodeType = node.type;
403
404  if (nodeType === "CallExpression") {
405    if (typeof opts === "undefined") {
406      return true;
407    } else {
408      return (0, _shallowEqual.default)(node, opts);
409    }
410  }
411
412  return false;
413}
414
415function isCatchClause(node, opts) {
416  if (!node) return false;
417  const nodeType = node.type;
418
419  if (nodeType === "CatchClause") {
420    if (typeof opts === "undefined") {
421      return true;
422    } else {
423      return (0, _shallowEqual.default)(node, opts);
424    }
425  }
426
427  return false;
428}
429
430function isConditionalExpression(node, opts) {
431  if (!node) return false;
432  const nodeType = node.type;
433
434  if (nodeType === "ConditionalExpression") {
435    if (typeof opts === "undefined") {
436      return true;
437    } else {
438      return (0, _shallowEqual.default)(node, opts);
439    }
440  }
441
442  return false;
443}
444
445function isContinueStatement(node, opts) {
446  if (!node) return false;
447  const nodeType = node.type;
448
449  if (nodeType === "ContinueStatement") {
450    if (typeof opts === "undefined") {
451      return true;
452    } else {
453      return (0, _shallowEqual.default)(node, opts);
454    }
455  }
456
457  return false;
458}
459
460function isDebuggerStatement(node, opts) {
461  if (!node) return false;
462  const nodeType = node.type;
463
464  if (nodeType === "DebuggerStatement") {
465    if (typeof opts === "undefined") {
466      return true;
467    } else {
468      return (0, _shallowEqual.default)(node, opts);
469    }
470  }
471
472  return false;
473}
474
475function isDoWhileStatement(node, opts) {
476  if (!node) return false;
477  const nodeType = node.type;
478
479  if (nodeType === "DoWhileStatement") {
480    if (typeof opts === "undefined") {
481      return true;
482    } else {
483      return (0, _shallowEqual.default)(node, opts);
484    }
485  }
486
487  return false;
488}
489
490function isEmptyStatement(node, opts) {
491  if (!node) return false;
492  const nodeType = node.type;
493
494  if (nodeType === "EmptyStatement") {
495    if (typeof opts === "undefined") {
496      return true;
497    } else {
498      return (0, _shallowEqual.default)(node, opts);
499    }
500  }
501
502  return false;
503}
504
505function isExpressionStatement(node, opts) {
506  if (!node) return false;
507  const nodeType = node.type;
508
509  if (nodeType === "ExpressionStatement") {
510    if (typeof opts === "undefined") {
511      return true;
512    } else {
513      return (0, _shallowEqual.default)(node, opts);
514    }
515  }
516
517  return false;
518}
519
520function isFile(node, opts) {
521  if (!node) return false;
522  const nodeType = node.type;
523
524  if (nodeType === "File") {
525    if (typeof opts === "undefined") {
526      return true;
527    } else {
528      return (0, _shallowEqual.default)(node, opts);
529    }
530  }
531
532  return false;
533}
534
535function isForInStatement(node, opts) {
536  if (!node) return false;
537  const nodeType = node.type;
538
539  if (nodeType === "ForInStatement") {
540    if (typeof opts === "undefined") {
541      return true;
542    } else {
543      return (0, _shallowEqual.default)(node, opts);
544    }
545  }
546
547  return false;
548}
549
550function isForStatement(node, opts) {
551  if (!node) return false;
552  const nodeType = node.type;
553
554  if (nodeType === "ForStatement") {
555    if (typeof opts === "undefined") {
556      return true;
557    } else {
558      return (0, _shallowEqual.default)(node, opts);
559    }
560  }
561
562  return false;
563}
564
565function isFunctionDeclaration(node, opts) {
566  if (!node) return false;
567  const nodeType = node.type;
568
569  if (nodeType === "FunctionDeclaration") {
570    if (typeof opts === "undefined") {
571      return true;
572    } else {
573      return (0, _shallowEqual.default)(node, opts);
574    }
575  }
576
577  return false;
578}
579
580function isFunctionExpression(node, opts) {
581  if (!node) return false;
582  const nodeType = node.type;
583
584  if (nodeType === "FunctionExpression") {
585    if (typeof opts === "undefined") {
586      return true;
587    } else {
588      return (0, _shallowEqual.default)(node, opts);
589    }
590  }
591
592  return false;
593}
594
595function isIdentifier(node, opts) {
596  if (!node) return false;
597  const nodeType = node.type;
598
599  if (nodeType === "Identifier") {
600    if (typeof opts === "undefined") {
601      return true;
602    } else {
603      return (0, _shallowEqual.default)(node, opts);
604    }
605  }
606
607  return false;
608}
609
610function isIfStatement(node, opts) {
611  if (!node) return false;
612  const nodeType = node.type;
613
614  if (nodeType === "IfStatement") {
615    if (typeof opts === "undefined") {
616      return true;
617    } else {
618      return (0, _shallowEqual.default)(node, opts);
619    }
620  }
621
622  return false;
623}
624
625function isLabeledStatement(node, opts) {
626  if (!node) return false;
627  const nodeType = node.type;
628
629  if (nodeType === "LabeledStatement") {
630    if (typeof opts === "undefined") {
631      return true;
632    } else {
633      return (0, _shallowEqual.default)(node, opts);
634    }
635  }
636
637  return false;
638}
639
640function isStringLiteral(node, opts) {
641  if (!node) return false;
642  const nodeType = node.type;
643
644  if (nodeType === "StringLiteral") {
645    if (typeof opts === "undefined") {
646      return true;
647    } else {
648      return (0, _shallowEqual.default)(node, opts);
649    }
650  }
651
652  return false;
653}
654
655function isNumericLiteral(node, opts) {
656  if (!node) return false;
657  const nodeType = node.type;
658
659  if (nodeType === "NumericLiteral") {
660    if (typeof opts === "undefined") {
661      return true;
662    } else {
663      return (0, _shallowEqual.default)(node, opts);
664    }
665  }
666
667  return false;
668}
669
670function isNullLiteral(node, opts) {
671  if (!node) return false;
672  const nodeType = node.type;
673
674  if (nodeType === "NullLiteral") {
675    if (typeof opts === "undefined") {
676      return true;
677    } else {
678      return (0, _shallowEqual.default)(node, opts);
679    }
680  }
681
682  return false;
683}
684
685function isBooleanLiteral(node, opts) {
686  if (!node) return false;
687  const nodeType = node.type;
688
689  if (nodeType === "BooleanLiteral") {
690    if (typeof opts === "undefined") {
691      return true;
692    } else {
693      return (0, _shallowEqual.default)(node, opts);
694    }
695  }
696
697  return false;
698}
699
700function isRegExpLiteral(node, opts) {
701  if (!node) return false;
702  const nodeType = node.type;
703
704  if (nodeType === "RegExpLiteral") {
705    if (typeof opts === "undefined") {
706      return true;
707    } else {
708      return (0, _shallowEqual.default)(node, opts);
709    }
710  }
711
712  return false;
713}
714
715function isLogicalExpression(node, opts) {
716  if (!node) return false;
717  const nodeType = node.type;
718
719  if (nodeType === "LogicalExpression") {
720    if (typeof opts === "undefined") {
721      return true;
722    } else {
723      return (0, _shallowEqual.default)(node, opts);
724    }
725  }
726
727  return false;
728}
729
730function isMemberExpression(node, opts) {
731  if (!node) return false;
732  const nodeType = node.type;
733
734  if (nodeType === "MemberExpression") {
735    if (typeof opts === "undefined") {
736      return true;
737    } else {
738      return (0, _shallowEqual.default)(node, opts);
739    }
740  }
741
742  return false;
743}
744
745function isNewExpression(node, opts) {
746  if (!node) return false;
747  const nodeType = node.type;
748
749  if (nodeType === "NewExpression") {
750    if (typeof opts === "undefined") {
751      return true;
752    } else {
753      return (0, _shallowEqual.default)(node, opts);
754    }
755  }
756
757  return false;
758}
759
760function isProgram(node, opts) {
761  if (!node) return false;
762  const nodeType = node.type;
763
764  if (nodeType === "Program") {
765    if (typeof opts === "undefined") {
766      return true;
767    } else {
768      return (0, _shallowEqual.default)(node, opts);
769    }
770  }
771
772  return false;
773}
774
775function isObjectExpression(node, opts) {
776  if (!node) return false;
777  const nodeType = node.type;
778
779  if (nodeType === "ObjectExpression") {
780    if (typeof opts === "undefined") {
781      return true;
782    } else {
783      return (0, _shallowEqual.default)(node, opts);
784    }
785  }
786
787  return false;
788}
789
790function isObjectMethod(node, opts) {
791  if (!node) return false;
792  const nodeType = node.type;
793
794  if (nodeType === "ObjectMethod") {
795    if (typeof opts === "undefined") {
796      return true;
797    } else {
798      return (0, _shallowEqual.default)(node, opts);
799    }
800  }
801
802  return false;
803}
804
805function isObjectProperty(node, opts) {
806  if (!node) return false;
807  const nodeType = node.type;
808
809  if (nodeType === "ObjectProperty") {
810    if (typeof opts === "undefined") {
811      return true;
812    } else {
813      return (0, _shallowEqual.default)(node, opts);
814    }
815  }
816
817  return false;
818}
819
820function isRestElement(node, opts) {
821  if (!node) return false;
822  const nodeType = node.type;
823
824  if (nodeType === "RestElement") {
825    if (typeof opts === "undefined") {
826      return true;
827    } else {
828      return (0, _shallowEqual.default)(node, opts);
829    }
830  }
831
832  return false;
833}
834
835function isReturnStatement(node, opts) {
836  if (!node) return false;
837  const nodeType = node.type;
838
839  if (nodeType === "ReturnStatement") {
840    if (typeof opts === "undefined") {
841      return true;
842    } else {
843      return (0, _shallowEqual.default)(node, opts);
844    }
845  }
846
847  return false;
848}
849
850function isSequenceExpression(node, opts) {
851  if (!node) return false;
852  const nodeType = node.type;
853
854  if (nodeType === "SequenceExpression") {
855    if (typeof opts === "undefined") {
856      return true;
857    } else {
858      return (0, _shallowEqual.default)(node, opts);
859    }
860  }
861
862  return false;
863}
864
865function isParenthesizedExpression(node, opts) {
866  if (!node) return false;
867  const nodeType = node.type;
868
869  if (nodeType === "ParenthesizedExpression") {
870    if (typeof opts === "undefined") {
871      return true;
872    } else {
873      return (0, _shallowEqual.default)(node, opts);
874    }
875  }
876
877  return false;
878}
879
880function isSwitchCase(node, opts) {
881  if (!node) return false;
882  const nodeType = node.type;
883
884  if (nodeType === "SwitchCase") {
885    if (typeof opts === "undefined") {
886      return true;
887    } else {
888      return (0, _shallowEqual.default)(node, opts);
889    }
890  }
891
892  return false;
893}
894
895function isSwitchStatement(node, opts) {
896  if (!node) return false;
897  const nodeType = node.type;
898
899  if (nodeType === "SwitchStatement") {
900    if (typeof opts === "undefined") {
901      return true;
902    } else {
903      return (0, _shallowEqual.default)(node, opts);
904    }
905  }
906
907  return false;
908}
909
910function isThisExpression(node, opts) {
911  if (!node) return false;
912  const nodeType = node.type;
913
914  if (nodeType === "ThisExpression") {
915    if (typeof opts === "undefined") {
916      return true;
917    } else {
918      return (0, _shallowEqual.default)(node, opts);
919    }
920  }
921
922  return false;
923}
924
925function isThrowStatement(node, opts) {
926  if (!node) return false;
927  const nodeType = node.type;
928
929  if (nodeType === "ThrowStatement") {
930    if (typeof opts === "undefined") {
931      return true;
932    } else {
933      return (0, _shallowEqual.default)(node, opts);
934    }
935  }
936
937  return false;
938}
939
940function isTryStatement(node, opts) {
941  if (!node) return false;
942  const nodeType = node.type;
943
944  if (nodeType === "TryStatement") {
945    if (typeof opts === "undefined") {
946      return true;
947    } else {
948      return (0, _shallowEqual.default)(node, opts);
949    }
950  }
951
952  return false;
953}
954
955function isUnaryExpression(node, opts) {
956  if (!node) return false;
957  const nodeType = node.type;
958
959  if (nodeType === "UnaryExpression") {
960    if (typeof opts === "undefined") {
961      return true;
962    } else {
963      return (0, _shallowEqual.default)(node, opts);
964    }
965  }
966
967  return false;
968}
969
970function isUpdateExpression(node, opts) {
971  if (!node) return false;
972  const nodeType = node.type;
973
974  if (nodeType === "UpdateExpression") {
975    if (typeof opts === "undefined") {
976      return true;
977    } else {
978      return (0, _shallowEqual.default)(node, opts);
979    }
980  }
981
982  return false;
983}
984
985function isVariableDeclaration(node, opts) {
986  if (!node) return false;
987  const nodeType = node.type;
988
989  if (nodeType === "VariableDeclaration") {
990    if (typeof opts === "undefined") {
991      return true;
992    } else {
993      return (0, _shallowEqual.default)(node, opts);
994    }
995  }
996
997  return false;
998}
999
1000function isVariableDeclarator(node, opts) {
1001  if (!node) return false;
1002  const nodeType = node.type;
1003
1004  if (nodeType === "VariableDeclarator") {
1005    if (typeof opts === "undefined") {
1006      return true;
1007    } else {
1008      return (0, _shallowEqual.default)(node, opts);
1009    }
1010  }
1011
1012  return false;
1013}
1014
1015function isWhileStatement(node, opts) {
1016  if (!node) return false;
1017  const nodeType = node.type;
1018
1019  if (nodeType === "WhileStatement") {
1020    if (typeof opts === "undefined") {
1021      return true;
1022    } else {
1023      return (0, _shallowEqual.default)(node, opts);
1024    }
1025  }
1026
1027  return false;
1028}
1029
1030function isWithStatement(node, opts) {
1031  if (!node) return false;
1032  const nodeType = node.type;
1033
1034  if (nodeType === "WithStatement") {
1035    if (typeof opts === "undefined") {
1036      return true;
1037    } else {
1038      return (0, _shallowEqual.default)(node, opts);
1039    }
1040  }
1041
1042  return false;
1043}
1044
1045function isAssignmentPattern(node, opts) {
1046  if (!node) return false;
1047  const nodeType = node.type;
1048
1049  if (nodeType === "AssignmentPattern") {
1050    if (typeof opts === "undefined") {
1051      return true;
1052    } else {
1053      return (0, _shallowEqual.default)(node, opts);
1054    }
1055  }
1056
1057  return false;
1058}
1059
1060function isArrayPattern(node, opts) {
1061  if (!node) return false;
1062  const nodeType = node.type;
1063
1064  if (nodeType === "ArrayPattern") {
1065    if (typeof opts === "undefined") {
1066      return true;
1067    } else {
1068      return (0, _shallowEqual.default)(node, opts);
1069    }
1070  }
1071
1072  return false;
1073}
1074
1075function isArrowFunctionExpression(node, opts) {
1076  if (!node) return false;
1077  const nodeType = node.type;
1078
1079  if (nodeType === "ArrowFunctionExpression") {
1080    if (typeof opts === "undefined") {
1081      return true;
1082    } else {
1083      return (0, _shallowEqual.default)(node, opts);
1084    }
1085  }
1086
1087  return false;
1088}
1089
1090function isClassBody(node, opts) {
1091  if (!node) return false;
1092  const nodeType = node.type;
1093
1094  if (nodeType === "ClassBody") {
1095    if (typeof opts === "undefined") {
1096      return true;
1097    } else {
1098      return (0, _shallowEqual.default)(node, opts);
1099    }
1100  }
1101
1102  return false;
1103}
1104
1105function isClassDeclaration(node, opts) {
1106  if (!node) return false;
1107  const nodeType = node.type;
1108
1109  if (nodeType === "ClassDeclaration") {
1110    if (typeof opts === "undefined") {
1111      return true;
1112    } else {
1113      return (0, _shallowEqual.default)(node, opts);
1114    }
1115  }
1116
1117  return false;
1118}
1119
1120function isClassExpression(node, opts) {
1121  if (!node) return false;
1122  const nodeType = node.type;
1123
1124  if (nodeType === "ClassExpression") {
1125    if (typeof opts === "undefined") {
1126      return true;
1127    } else {
1128      return (0, _shallowEqual.default)(node, opts);
1129    }
1130  }
1131
1132  return false;
1133}
1134
1135function isExportAllDeclaration(node, opts) {
1136  if (!node) return false;
1137  const nodeType = node.type;
1138
1139  if (nodeType === "ExportAllDeclaration") {
1140    if (typeof opts === "undefined") {
1141      return true;
1142    } else {
1143      return (0, _shallowEqual.default)(node, opts);
1144    }
1145  }
1146
1147  return false;
1148}
1149
1150function isExportDefaultDeclaration(node, opts) {
1151  if (!node) return false;
1152  const nodeType = node.type;
1153
1154  if (nodeType === "ExportDefaultDeclaration") {
1155    if (typeof opts === "undefined") {
1156      return true;
1157    } else {
1158      return (0, _shallowEqual.default)(node, opts);
1159    }
1160  }
1161
1162  return false;
1163}
1164
1165function isExportNamedDeclaration(node, opts) {
1166  if (!node) return false;
1167  const nodeType = node.type;
1168
1169  if (nodeType === "ExportNamedDeclaration") {
1170    if (typeof opts === "undefined") {
1171      return true;
1172    } else {
1173      return (0, _shallowEqual.default)(node, opts);
1174    }
1175  }
1176
1177  return false;
1178}
1179
1180function isExportSpecifier(node, opts) {
1181  if (!node) return false;
1182  const nodeType = node.type;
1183
1184  if (nodeType === "ExportSpecifier") {
1185    if (typeof opts === "undefined") {
1186      return true;
1187    } else {
1188      return (0, _shallowEqual.default)(node, opts);
1189    }
1190  }
1191
1192  return false;
1193}
1194
1195function isForOfStatement(node, opts) {
1196  if (!node) return false;
1197  const nodeType = node.type;
1198
1199  if (nodeType === "ForOfStatement") {
1200    if (typeof opts === "undefined") {
1201      return true;
1202    } else {
1203      return (0, _shallowEqual.default)(node, opts);
1204    }
1205  }
1206
1207  return false;
1208}
1209
1210function isImportDeclaration(node, opts) {
1211  if (!node) return false;
1212  const nodeType = node.type;
1213
1214  if (nodeType === "ImportDeclaration") {
1215    if (typeof opts === "undefined") {
1216      return true;
1217    } else {
1218      return (0, _shallowEqual.default)(node, opts);
1219    }
1220  }
1221
1222  return false;
1223}
1224
1225function isImportDefaultSpecifier(node, opts) {
1226  if (!node) return false;
1227  const nodeType = node.type;
1228
1229  if (nodeType === "ImportDefaultSpecifier") {
1230    if (typeof opts === "undefined") {
1231      return true;
1232    } else {
1233      return (0, _shallowEqual.default)(node, opts);
1234    }
1235  }
1236
1237  return false;
1238}
1239
1240function isImportNamespaceSpecifier(node, opts) {
1241  if (!node) return false;
1242  const nodeType = node.type;
1243
1244  if (nodeType === "ImportNamespaceSpecifier") {
1245    if (typeof opts === "undefined") {
1246      return true;
1247    } else {
1248      return (0, _shallowEqual.default)(node, opts);
1249    }
1250  }
1251
1252  return false;
1253}
1254
1255function isImportSpecifier(node, opts) {
1256  if (!node) return false;
1257  const nodeType = node.type;
1258
1259  if (nodeType === "ImportSpecifier") {
1260    if (typeof opts === "undefined") {
1261      return true;
1262    } else {
1263      return (0, _shallowEqual.default)(node, opts);
1264    }
1265  }
1266
1267  return false;
1268}
1269
1270function isMetaProperty(node, opts) {
1271  if (!node) return false;
1272  const nodeType = node.type;
1273
1274  if (nodeType === "MetaProperty") {
1275    if (typeof opts === "undefined") {
1276      return true;
1277    } else {
1278      return (0, _shallowEqual.default)(node, opts);
1279    }
1280  }
1281
1282  return false;
1283}
1284
1285function isClassMethod(node, opts) {
1286  if (!node) return false;
1287  const nodeType = node.type;
1288
1289  if (nodeType === "ClassMethod") {
1290    if (typeof opts === "undefined") {
1291      return true;
1292    } else {
1293      return (0, _shallowEqual.default)(node, opts);
1294    }
1295  }
1296
1297  return false;
1298}
1299
1300function isObjectPattern(node, opts) {
1301  if (!node) return false;
1302  const nodeType = node.type;
1303
1304  if (nodeType === "ObjectPattern") {
1305    if (typeof opts === "undefined") {
1306      return true;
1307    } else {
1308      return (0, _shallowEqual.default)(node, opts);
1309    }
1310  }
1311
1312  return false;
1313}
1314
1315function isSpreadElement(node, opts) {
1316  if (!node) return false;
1317  const nodeType = node.type;
1318
1319  if (nodeType === "SpreadElement") {
1320    if (typeof opts === "undefined") {
1321      return true;
1322    } else {
1323      return (0, _shallowEqual.default)(node, opts);
1324    }
1325  }
1326
1327  return false;
1328}
1329
1330function isSuper(node, opts) {
1331  if (!node) return false;
1332  const nodeType = node.type;
1333
1334  if (nodeType === "Super") {
1335    if (typeof opts === "undefined") {
1336      return true;
1337    } else {
1338      return (0, _shallowEqual.default)(node, opts);
1339    }
1340  }
1341
1342  return false;
1343}
1344
1345function isTaggedTemplateExpression(node, opts) {
1346  if (!node) return false;
1347  const nodeType = node.type;
1348
1349  if (nodeType === "TaggedTemplateExpression") {
1350    if (typeof opts === "undefined") {
1351      return true;
1352    } else {
1353      return (0, _shallowEqual.default)(node, opts);
1354    }
1355  }
1356
1357  return false;
1358}
1359
1360function isTemplateElement(node, opts) {
1361  if (!node) return false;
1362  const nodeType = node.type;
1363
1364  if (nodeType === "TemplateElement") {
1365    if (typeof opts === "undefined") {
1366      return true;
1367    } else {
1368      return (0, _shallowEqual.default)(node, opts);
1369    }
1370  }
1371
1372  return false;
1373}
1374
1375function isTemplateLiteral(node, opts) {
1376  if (!node) return false;
1377  const nodeType = node.type;
1378
1379  if (nodeType === "TemplateLiteral") {
1380    if (typeof opts === "undefined") {
1381      return true;
1382    } else {
1383      return (0, _shallowEqual.default)(node, opts);
1384    }
1385  }
1386
1387  return false;
1388}
1389
1390function isYieldExpression(node, opts) {
1391  if (!node) return false;
1392  const nodeType = node.type;
1393
1394  if (nodeType === "YieldExpression") {
1395    if (typeof opts === "undefined") {
1396      return true;
1397    } else {
1398      return (0, _shallowEqual.default)(node, opts);
1399    }
1400  }
1401
1402  return false;
1403}
1404
1405function isAnyTypeAnnotation(node, opts) {
1406  if (!node) return false;
1407  const nodeType = node.type;
1408
1409  if (nodeType === "AnyTypeAnnotation") {
1410    if (typeof opts === "undefined") {
1411      return true;
1412    } else {
1413      return (0, _shallowEqual.default)(node, opts);
1414    }
1415  }
1416
1417  return false;
1418}
1419
1420function isArrayTypeAnnotation(node, opts) {
1421  if (!node) return false;
1422  const nodeType = node.type;
1423
1424  if (nodeType === "ArrayTypeAnnotation") {
1425    if (typeof opts === "undefined") {
1426      return true;
1427    } else {
1428      return (0, _shallowEqual.default)(node, opts);
1429    }
1430  }
1431
1432  return false;
1433}
1434
1435function isBooleanTypeAnnotation(node, opts) {
1436  if (!node) return false;
1437  const nodeType = node.type;
1438
1439  if (nodeType === "BooleanTypeAnnotation") {
1440    if (typeof opts === "undefined") {
1441      return true;
1442    } else {
1443      return (0, _shallowEqual.default)(node, opts);
1444    }
1445  }
1446
1447  return false;
1448}
1449
1450function isBooleanLiteralTypeAnnotation(node, opts) {
1451  if (!node) return false;
1452  const nodeType = node.type;
1453
1454  if (nodeType === "BooleanLiteralTypeAnnotation") {
1455    if (typeof opts === "undefined") {
1456      return true;
1457    } else {
1458      return (0, _shallowEqual.default)(node, opts);
1459    }
1460  }
1461
1462  return false;
1463}
1464
1465function isNullLiteralTypeAnnotation(node, opts) {
1466  if (!node) return false;
1467  const nodeType = node.type;
1468
1469  if (nodeType === "NullLiteralTypeAnnotation") {
1470    if (typeof opts === "undefined") {
1471      return true;
1472    } else {
1473      return (0, _shallowEqual.default)(node, opts);
1474    }
1475  }
1476
1477  return false;
1478}
1479
1480function isClassImplements(node, opts) {
1481  if (!node) return false;
1482  const nodeType = node.type;
1483
1484  if (nodeType === "ClassImplements") {
1485    if (typeof opts === "undefined") {
1486      return true;
1487    } else {
1488      return (0, _shallowEqual.default)(node, opts);
1489    }
1490  }
1491
1492  return false;
1493}
1494
1495function isDeclareClass(node, opts) {
1496  if (!node) return false;
1497  const nodeType = node.type;
1498
1499  if (nodeType === "DeclareClass") {
1500    if (typeof opts === "undefined") {
1501      return true;
1502    } else {
1503      return (0, _shallowEqual.default)(node, opts);
1504    }
1505  }
1506
1507  return false;
1508}
1509
1510function isDeclareFunction(node, opts) {
1511  if (!node) return false;
1512  const nodeType = node.type;
1513
1514  if (nodeType === "DeclareFunction") {
1515    if (typeof opts === "undefined") {
1516      return true;
1517    } else {
1518      return (0, _shallowEqual.default)(node, opts);
1519    }
1520  }
1521
1522  return false;
1523}
1524
1525function isDeclareInterface(node, opts) {
1526  if (!node) return false;
1527  const nodeType = node.type;
1528
1529  if (nodeType === "DeclareInterface") {
1530    if (typeof opts === "undefined") {
1531      return true;
1532    } else {
1533      return (0, _shallowEqual.default)(node, opts);
1534    }
1535  }
1536
1537  return false;
1538}
1539
1540function isDeclareModule(node, opts) {
1541  if (!node) return false;
1542  const nodeType = node.type;
1543
1544  if (nodeType === "DeclareModule") {
1545    if (typeof opts === "undefined") {
1546      return true;
1547    } else {
1548      return (0, _shallowEqual.default)(node, opts);
1549    }
1550  }
1551
1552  return false;
1553}
1554
1555function isDeclareModuleExports(node, opts) {
1556  if (!node) return false;
1557  const nodeType = node.type;
1558
1559  if (nodeType === "DeclareModuleExports") {
1560    if (typeof opts === "undefined") {
1561      return true;
1562    } else {
1563      return (0, _shallowEqual.default)(node, opts);
1564    }
1565  }
1566
1567  return false;
1568}
1569
1570function isDeclareTypeAlias(node, opts) {
1571  if (!node) return false;
1572  const nodeType = node.type;
1573
1574  if (nodeType === "DeclareTypeAlias") {
1575    if (typeof opts === "undefined") {
1576      return true;
1577    } else {
1578      return (0, _shallowEqual.default)(node, opts);
1579    }
1580  }
1581
1582  return false;
1583}
1584
1585function isDeclareOpaqueType(node, opts) {
1586  if (!node) return false;
1587  const nodeType = node.type;
1588
1589  if (nodeType === "DeclareOpaqueType") {
1590    if (typeof opts === "undefined") {
1591      return true;
1592    } else {
1593      return (0, _shallowEqual.default)(node, opts);
1594    }
1595  }
1596
1597  return false;
1598}
1599
1600function isDeclareVariable(node, opts) {
1601  if (!node) return false;
1602  const nodeType = node.type;
1603
1604  if (nodeType === "DeclareVariable") {
1605    if (typeof opts === "undefined") {
1606      return true;
1607    } else {
1608      return (0, _shallowEqual.default)(node, opts);
1609    }
1610  }
1611
1612  return false;
1613}
1614
1615function isDeclareExportDeclaration(node, opts) {
1616  if (!node) return false;
1617  const nodeType = node.type;
1618
1619  if (nodeType === "DeclareExportDeclaration") {
1620    if (typeof opts === "undefined") {
1621      return true;
1622    } else {
1623      return (0, _shallowEqual.default)(node, opts);
1624    }
1625  }
1626
1627  return false;
1628}
1629
1630function isDeclareExportAllDeclaration(node, opts) {
1631  if (!node) return false;
1632  const nodeType = node.type;
1633
1634  if (nodeType === "DeclareExportAllDeclaration") {
1635    if (typeof opts === "undefined") {
1636      return true;
1637    } else {
1638      return (0, _shallowEqual.default)(node, opts);
1639    }
1640  }
1641
1642  return false;
1643}
1644
1645function isDeclaredPredicate(node, opts) {
1646  if (!node) return false;
1647  const nodeType = node.type;
1648
1649  if (nodeType === "DeclaredPredicate") {
1650    if (typeof opts === "undefined") {
1651      return true;
1652    } else {
1653      return (0, _shallowEqual.default)(node, opts);
1654    }
1655  }
1656
1657  return false;
1658}
1659
1660function isExistsTypeAnnotation(node, opts) {
1661  if (!node) return false;
1662  const nodeType = node.type;
1663
1664  if (nodeType === "ExistsTypeAnnotation") {
1665    if (typeof opts === "undefined") {
1666      return true;
1667    } else {
1668      return (0, _shallowEqual.default)(node, opts);
1669    }
1670  }
1671
1672  return false;
1673}
1674
1675function isFunctionTypeAnnotation(node, opts) {
1676  if (!node) return false;
1677  const nodeType = node.type;
1678
1679  if (nodeType === "FunctionTypeAnnotation") {
1680    if (typeof opts === "undefined") {
1681      return true;
1682    } else {
1683      return (0, _shallowEqual.default)(node, opts);
1684    }
1685  }
1686
1687  return false;
1688}
1689
1690function isFunctionTypeParam(node, opts) {
1691  if (!node) return false;
1692  const nodeType = node.type;
1693
1694  if (nodeType === "FunctionTypeParam") {
1695    if (typeof opts === "undefined") {
1696      return true;
1697    } else {
1698      return (0, _shallowEqual.default)(node, opts);
1699    }
1700  }
1701
1702  return false;
1703}
1704
1705function isGenericTypeAnnotation(node, opts) {
1706  if (!node) return false;
1707  const nodeType = node.type;
1708
1709  if (nodeType === "GenericTypeAnnotation") {
1710    if (typeof opts === "undefined") {
1711      return true;
1712    } else {
1713      return (0, _shallowEqual.default)(node, opts);
1714    }
1715  }
1716
1717  return false;
1718}
1719
1720function isInferredPredicate(node, opts) {
1721  if (!node) return false;
1722  const nodeType = node.type;
1723
1724  if (nodeType === "InferredPredicate") {
1725    if (typeof opts === "undefined") {
1726      return true;
1727    } else {
1728      return (0, _shallowEqual.default)(node, opts);
1729    }
1730  }
1731
1732  return false;
1733}
1734
1735function isInterfaceExtends(node, opts) {
1736  if (!node) return false;
1737  const nodeType = node.type;
1738
1739  if (nodeType === "InterfaceExtends") {
1740    if (typeof opts === "undefined") {
1741      return true;
1742    } else {
1743      return (0, _shallowEqual.default)(node, opts);
1744    }
1745  }
1746
1747  return false;
1748}
1749
1750function isInterfaceDeclaration(node, opts) {
1751  if (!node) return false;
1752  const nodeType = node.type;
1753
1754  if (nodeType === "InterfaceDeclaration") {
1755    if (typeof opts === "undefined") {
1756      return true;
1757    } else {
1758      return (0, _shallowEqual.default)(node, opts);
1759    }
1760  }
1761
1762  return false;
1763}
1764
1765function isInterfaceTypeAnnotation(node, opts) {
1766  if (!node) return false;
1767  const nodeType = node.type;
1768
1769  if (nodeType === "InterfaceTypeAnnotation") {
1770    if (typeof opts === "undefined") {
1771      return true;
1772    } else {
1773      return (0, _shallowEqual.default)(node, opts);
1774    }
1775  }
1776
1777  return false;
1778}
1779
1780function isIntersectionTypeAnnotation(node, opts) {
1781  if (!node) return false;
1782  const nodeType = node.type;
1783
1784  if (nodeType === "IntersectionTypeAnnotation") {
1785    if (typeof opts === "undefined") {
1786      return true;
1787    } else {
1788      return (0, _shallowEqual.default)(node, opts);
1789    }
1790  }
1791
1792  return false;
1793}
1794
1795function isMixedTypeAnnotation(node, opts) {
1796  if (!node) return false;
1797  const nodeType = node.type;
1798
1799  if (nodeType === "MixedTypeAnnotation") {
1800    if (typeof opts === "undefined") {
1801      return true;
1802    } else {
1803      return (0, _shallowEqual.default)(node, opts);
1804    }
1805  }
1806
1807  return false;
1808}
1809
1810function isEmptyTypeAnnotation(node, opts) {
1811  if (!node) return false;
1812  const nodeType = node.type;
1813
1814  if (nodeType === "EmptyTypeAnnotation") {
1815    if (typeof opts === "undefined") {
1816      return true;
1817    } else {
1818      return (0, _shallowEqual.default)(node, opts);
1819    }
1820  }
1821
1822  return false;
1823}
1824
1825function isNullableTypeAnnotation(node, opts) {
1826  if (!node) return false;
1827  const nodeType = node.type;
1828
1829  if (nodeType === "NullableTypeAnnotation") {
1830    if (typeof opts === "undefined") {
1831      return true;
1832    } else {
1833      return (0, _shallowEqual.default)(node, opts);
1834    }
1835  }
1836
1837  return false;
1838}
1839
1840function isNumberLiteralTypeAnnotation(node, opts) {
1841  if (!node) return false;
1842  const nodeType = node.type;
1843
1844  if (nodeType === "NumberLiteralTypeAnnotation") {
1845    if (typeof opts === "undefined") {
1846      return true;
1847    } else {
1848      return (0, _shallowEqual.default)(node, opts);
1849    }
1850  }
1851
1852  return false;
1853}
1854
1855function isNumberTypeAnnotation(node, opts) {
1856  if (!node) return false;
1857  const nodeType = node.type;
1858
1859  if (nodeType === "NumberTypeAnnotation") {
1860    if (typeof opts === "undefined") {
1861      return true;
1862    } else {
1863      return (0, _shallowEqual.default)(node, opts);
1864    }
1865  }
1866
1867  return false;
1868}
1869
1870function isObjectTypeAnnotation(node, opts) {
1871  if (!node) return false;
1872  const nodeType = node.type;
1873
1874  if (nodeType === "ObjectTypeAnnotation") {
1875    if (typeof opts === "undefined") {
1876      return true;
1877    } else {
1878      return (0, _shallowEqual.default)(node, opts);
1879    }
1880  }
1881
1882  return false;
1883}
1884
1885function isObjectTypeInternalSlot(node, opts) {
1886  if (!node) return false;
1887  const nodeType = node.type;
1888
1889  if (nodeType === "ObjectTypeInternalSlot") {
1890    if (typeof opts === "undefined") {
1891      return true;
1892    } else {
1893      return (0, _shallowEqual.default)(node, opts);
1894    }
1895  }
1896
1897  return false;
1898}
1899
1900function isObjectTypeCallProperty(node, opts) {
1901  if (!node) return false;
1902  const nodeType = node.type;
1903
1904  if (nodeType === "ObjectTypeCallProperty") {
1905    if (typeof opts === "undefined") {
1906      return true;
1907    } else {
1908      return (0, _shallowEqual.default)(node, opts);
1909    }
1910  }
1911
1912  return false;
1913}
1914
1915function isObjectTypeIndexer(node, opts) {
1916  if (!node) return false;
1917  const nodeType = node.type;
1918
1919  if (nodeType === "ObjectTypeIndexer") {
1920    if (typeof opts === "undefined") {
1921      return true;
1922    } else {
1923      return (0, _shallowEqual.default)(node, opts);
1924    }
1925  }
1926
1927  return false;
1928}
1929
1930function isObjectTypeProperty(node, opts) {
1931  if (!node) return false;
1932  const nodeType = node.type;
1933
1934  if (nodeType === "ObjectTypeProperty") {
1935    if (typeof opts === "undefined") {
1936      return true;
1937    } else {
1938      return (0, _shallowEqual.default)(node, opts);
1939    }
1940  }
1941
1942  return false;
1943}
1944
1945function isObjectTypeSpreadProperty(node, opts) {
1946  if (!node) return false;
1947  const nodeType = node.type;
1948
1949  if (nodeType === "ObjectTypeSpreadProperty") {
1950    if (typeof opts === "undefined") {
1951      return true;
1952    } else {
1953      return (0, _shallowEqual.default)(node, opts);
1954    }
1955  }
1956
1957  return false;
1958}
1959
1960function isOpaqueType(node, opts) {
1961  if (!node) return false;
1962  const nodeType = node.type;
1963
1964  if (nodeType === "OpaqueType") {
1965    if (typeof opts === "undefined") {
1966      return true;
1967    } else {
1968      return (0, _shallowEqual.default)(node, opts);
1969    }
1970  }
1971
1972  return false;
1973}
1974
1975function isQualifiedTypeIdentifier(node, opts) {
1976  if (!node) return false;
1977  const nodeType = node.type;
1978
1979  if (nodeType === "QualifiedTypeIdentifier") {
1980    if (typeof opts === "undefined") {
1981      return true;
1982    } else {
1983      return (0, _shallowEqual.default)(node, opts);
1984    }
1985  }
1986
1987  return false;
1988}
1989
1990function isStringLiteralTypeAnnotation(node, opts) {
1991  if (!node) return false;
1992  const nodeType = node.type;
1993
1994  if (nodeType === "StringLiteralTypeAnnotation") {
1995    if (typeof opts === "undefined") {
1996      return true;
1997    } else {
1998      return (0, _shallowEqual.default)(node, opts);
1999    }
2000  }
2001
2002  return false;
2003}
2004
2005function isStringTypeAnnotation(node, opts) {
2006  if (!node) return false;
2007  const nodeType = node.type;
2008
2009  if (nodeType === "StringTypeAnnotation") {
2010    if (typeof opts === "undefined") {
2011      return true;
2012    } else {
2013      return (0, _shallowEqual.default)(node, opts);
2014    }
2015  }
2016
2017  return false;
2018}
2019
2020function isThisTypeAnnotation(node, opts) {
2021  if (!node) return false;
2022  const nodeType = node.type;
2023
2024  if (nodeType === "ThisTypeAnnotation") {
2025    if (typeof opts === "undefined") {
2026      return true;
2027    } else {
2028      return (0, _shallowEqual.default)(node, opts);
2029    }
2030  }
2031
2032  return false;
2033}
2034
2035function isTupleTypeAnnotation(node, opts) {
2036  if (!node) return false;
2037  const nodeType = node.type;
2038
2039  if (nodeType === "TupleTypeAnnotation") {
2040    if (typeof opts === "undefined") {
2041      return true;
2042    } else {
2043      return (0, _shallowEqual.default)(node, opts);
2044    }
2045  }
2046
2047  return false;
2048}
2049
2050function isTypeofTypeAnnotation(node, opts) {
2051  if (!node) return false;
2052  const nodeType = node.type;
2053
2054  if (nodeType === "TypeofTypeAnnotation") {
2055    if (typeof opts === "undefined") {
2056      return true;
2057    } else {
2058      return (0, _shallowEqual.default)(node, opts);
2059    }
2060  }
2061
2062  return false;
2063}
2064
2065function isTypeAlias(node, opts) {
2066  if (!node) return false;
2067  const nodeType = node.type;
2068
2069  if (nodeType === "TypeAlias") {
2070    if (typeof opts === "undefined") {
2071      return true;
2072    } else {
2073      return (0, _shallowEqual.default)(node, opts);
2074    }
2075  }
2076
2077  return false;
2078}
2079
2080function isTypeAnnotation(node, opts) {
2081  if (!node) return false;
2082  const nodeType = node.type;
2083
2084  if (nodeType === "TypeAnnotation") {
2085    if (typeof opts === "undefined") {
2086      return true;
2087    } else {
2088      return (0, _shallowEqual.default)(node, opts);
2089    }
2090  }
2091
2092  return false;
2093}
2094
2095function isTypeCastExpression(node, opts) {
2096  if (!node) return false;
2097  const nodeType = node.type;
2098
2099  if (nodeType === "TypeCastExpression") {
2100    if (typeof opts === "undefined") {
2101      return true;
2102    } else {
2103      return (0, _shallowEqual.default)(node, opts);
2104    }
2105  }
2106
2107  return false;
2108}
2109
2110function isTypeParameter(node, opts) {
2111  if (!node) return false;
2112  const nodeType = node.type;
2113
2114  if (nodeType === "TypeParameter") {
2115    if (typeof opts === "undefined") {
2116      return true;
2117    } else {
2118      return (0, _shallowEqual.default)(node, opts);
2119    }
2120  }
2121
2122  return false;
2123}
2124
2125function isTypeParameterDeclaration(node, opts) {
2126  if (!node) return false;
2127  const nodeType = node.type;
2128
2129  if (nodeType === "TypeParameterDeclaration") {
2130    if (typeof opts === "undefined") {
2131      return true;
2132    } else {
2133      return (0, _shallowEqual.default)(node, opts);
2134    }
2135  }
2136
2137  return false;
2138}
2139
2140function isTypeParameterInstantiation(node, opts) {
2141  if (!node) return false;
2142  const nodeType = node.type;
2143
2144  if (nodeType === "TypeParameterInstantiation") {
2145    if (typeof opts === "undefined") {
2146      return true;
2147    } else {
2148      return (0, _shallowEqual.default)(node, opts);
2149    }
2150  }
2151
2152  return false;
2153}
2154
2155function isUnionTypeAnnotation(node, opts) {
2156  if (!node) return false;
2157  const nodeType = node.type;
2158
2159  if (nodeType === "UnionTypeAnnotation") {
2160    if (typeof opts === "undefined") {
2161      return true;
2162    } else {
2163      return (0, _shallowEqual.default)(node, opts);
2164    }
2165  }
2166
2167  return false;
2168}
2169
2170function isVariance(node, opts) {
2171  if (!node) return false;
2172  const nodeType = node.type;
2173
2174  if (nodeType === "Variance") {
2175    if (typeof opts === "undefined") {
2176      return true;
2177    } else {
2178      return (0, _shallowEqual.default)(node, opts);
2179    }
2180  }
2181
2182  return false;
2183}
2184
2185function isVoidTypeAnnotation(node, opts) {
2186  if (!node) return false;
2187  const nodeType = node.type;
2188
2189  if (nodeType === "VoidTypeAnnotation") {
2190    if (typeof opts === "undefined") {
2191      return true;
2192    } else {
2193      return (0, _shallowEqual.default)(node, opts);
2194    }
2195  }
2196
2197  return false;
2198}
2199
2200function isJSXAttribute(node, opts) {
2201  if (!node) return false;
2202  const nodeType = node.type;
2203
2204  if (nodeType === "JSXAttribute") {
2205    if (typeof opts === "undefined") {
2206      return true;
2207    } else {
2208      return (0, _shallowEqual.default)(node, opts);
2209    }
2210  }
2211
2212  return false;
2213}
2214
2215function isJSXClosingElement(node, opts) {
2216  if (!node) return false;
2217  const nodeType = node.type;
2218
2219  if (nodeType === "JSXClosingElement") {
2220    if (typeof opts === "undefined") {
2221      return true;
2222    } else {
2223      return (0, _shallowEqual.default)(node, opts);
2224    }
2225  }
2226
2227  return false;
2228}
2229
2230function isJSXElement(node, opts) {
2231  if (!node) return false;
2232  const nodeType = node.type;
2233
2234  if (nodeType === "JSXElement") {
2235    if (typeof opts === "undefined") {
2236      return true;
2237    } else {
2238      return (0, _shallowEqual.default)(node, opts);
2239    }
2240  }
2241
2242  return false;
2243}
2244
2245function isJSXEmptyExpression(node, opts) {
2246  if (!node) return false;
2247  const nodeType = node.type;
2248
2249  if (nodeType === "JSXEmptyExpression") {
2250    if (typeof opts === "undefined") {
2251      return true;
2252    } else {
2253      return (0, _shallowEqual.default)(node, opts);
2254    }
2255  }
2256
2257  return false;
2258}
2259
2260function isJSXExpressionContainer(node, opts) {
2261  if (!node) return false;
2262  const nodeType = node.type;
2263
2264  if (nodeType === "JSXExpressionContainer") {
2265    if (typeof opts === "undefined") {
2266      return true;
2267    } else {
2268      return (0, _shallowEqual.default)(node, opts);
2269    }
2270  }
2271
2272  return false;
2273}
2274
2275function isJSXSpreadChild(node, opts) {
2276  if (!node) return false;
2277  const nodeType = node.type;
2278
2279  if (nodeType === "JSXSpreadChild") {
2280    if (typeof opts === "undefined") {
2281      return true;
2282    } else {
2283      return (0, _shallowEqual.default)(node, opts);
2284    }
2285  }
2286
2287  return false;
2288}
2289
2290function isJSXIdentifier(node, opts) {
2291  if (!node) return false;
2292  const nodeType = node.type;
2293
2294  if (nodeType === "JSXIdentifier") {
2295    if (typeof opts === "undefined") {
2296      return true;
2297    } else {
2298      return (0, _shallowEqual.default)(node, opts);
2299    }
2300  }
2301
2302  return false;
2303}
2304
2305function isJSXMemberExpression(node, opts) {
2306  if (!node) return false;
2307  const nodeType = node.type;
2308
2309  if (nodeType === "JSXMemberExpression") {
2310    if (typeof opts === "undefined") {
2311      return true;
2312    } else {
2313      return (0, _shallowEqual.default)(node, opts);
2314    }
2315  }
2316
2317  return false;
2318}
2319
2320function isJSXNamespacedName(node, opts) {
2321  if (!node) return false;
2322  const nodeType = node.type;
2323
2324  if (nodeType === "JSXNamespacedName") {
2325    if (typeof opts === "undefined") {
2326      return true;
2327    } else {
2328      return (0, _shallowEqual.default)(node, opts);
2329    }
2330  }
2331
2332  return false;
2333}
2334
2335function isJSXOpeningElement(node, opts) {
2336  if (!node) return false;
2337  const nodeType = node.type;
2338
2339  if (nodeType === "JSXOpeningElement") {
2340    if (typeof opts === "undefined") {
2341      return true;
2342    } else {
2343      return (0, _shallowEqual.default)(node, opts);
2344    }
2345  }
2346
2347  return false;
2348}
2349
2350function isJSXSpreadAttribute(node, opts) {
2351  if (!node) return false;
2352  const nodeType = node.type;
2353
2354  if (nodeType === "JSXSpreadAttribute") {
2355    if (typeof opts === "undefined") {
2356      return true;
2357    } else {
2358      return (0, _shallowEqual.default)(node, opts);
2359    }
2360  }
2361
2362  return false;
2363}
2364
2365function isJSXText(node, opts) {
2366  if (!node) return false;
2367  const nodeType = node.type;
2368
2369  if (nodeType === "JSXText") {
2370    if (typeof opts === "undefined") {
2371      return true;
2372    } else {
2373      return (0, _shallowEqual.default)(node, opts);
2374    }
2375  }
2376
2377  return false;
2378}
2379
2380function isJSXFragment(node, opts) {
2381  if (!node) return false;
2382  const nodeType = node.type;
2383
2384  if (nodeType === "JSXFragment") {
2385    if (typeof opts === "undefined") {
2386      return true;
2387    } else {
2388      return (0, _shallowEqual.default)(node, opts);
2389    }
2390  }
2391
2392  return false;
2393}
2394
2395function isJSXOpeningFragment(node, opts) {
2396  if (!node) return false;
2397  const nodeType = node.type;
2398
2399  if (nodeType === "JSXOpeningFragment") {
2400    if (typeof opts === "undefined") {
2401      return true;
2402    } else {
2403      return (0, _shallowEqual.default)(node, opts);
2404    }
2405  }
2406
2407  return false;
2408}
2409
2410function isJSXClosingFragment(node, opts) {
2411  if (!node) return false;
2412  const nodeType = node.type;
2413
2414  if (nodeType === "JSXClosingFragment") {
2415    if (typeof opts === "undefined") {
2416      return true;
2417    } else {
2418      return (0, _shallowEqual.default)(node, opts);
2419    }
2420  }
2421
2422  return false;
2423}
2424
2425function isNoop(node, opts) {
2426  if (!node) return false;
2427  const nodeType = node.type;
2428
2429  if (nodeType === "Noop") {
2430    if (typeof opts === "undefined") {
2431      return true;
2432    } else {
2433      return (0, _shallowEqual.default)(node, opts);
2434    }
2435  }
2436
2437  return false;
2438}
2439
2440function isPlaceholder(node, opts) {
2441  if (!node) return false;
2442  const nodeType = node.type;
2443
2444  if (nodeType === "Placeholder") {
2445    if (typeof opts === "undefined") {
2446      return true;
2447    } else {
2448      return (0, _shallowEqual.default)(node, opts);
2449    }
2450  }
2451
2452  return false;
2453}
2454
2455function isArgumentPlaceholder(node, opts) {
2456  if (!node) return false;
2457  const nodeType = node.type;
2458
2459  if (nodeType === "ArgumentPlaceholder") {
2460    if (typeof opts === "undefined") {
2461      return true;
2462    } else {
2463      return (0, _shallowEqual.default)(node, opts);
2464    }
2465  }
2466
2467  return false;
2468}
2469
2470function isAwaitExpression(node, opts) {
2471  if (!node) return false;
2472  const nodeType = node.type;
2473
2474  if (nodeType === "AwaitExpression") {
2475    if (typeof opts === "undefined") {
2476      return true;
2477    } else {
2478      return (0, _shallowEqual.default)(node, opts);
2479    }
2480  }
2481
2482  return false;
2483}
2484
2485function isBindExpression(node, opts) {
2486  if (!node) return false;
2487  const nodeType = node.type;
2488
2489  if (nodeType === "BindExpression") {
2490    if (typeof opts === "undefined") {
2491      return true;
2492    } else {
2493      return (0, _shallowEqual.default)(node, opts);
2494    }
2495  }
2496
2497  return false;
2498}
2499
2500function isClassProperty(node, opts) {
2501  if (!node) return false;
2502  const nodeType = node.type;
2503
2504  if (nodeType === "ClassProperty") {
2505    if (typeof opts === "undefined") {
2506      return true;
2507    } else {
2508      return (0, _shallowEqual.default)(node, opts);
2509    }
2510  }
2511
2512  return false;
2513}
2514
2515function isOptionalMemberExpression(node, opts) {
2516  if (!node) return false;
2517  const nodeType = node.type;
2518
2519  if (nodeType === "OptionalMemberExpression") {
2520    if (typeof opts === "undefined") {
2521      return true;
2522    } else {
2523      return (0, _shallowEqual.default)(node, opts);
2524    }
2525  }
2526
2527  return false;
2528}
2529
2530function isPipelineTopicExpression(node, opts) {
2531  if (!node) return false;
2532  const nodeType = node.type;
2533
2534  if (nodeType === "PipelineTopicExpression") {
2535    if (typeof opts === "undefined") {
2536      return true;
2537    } else {
2538      return (0, _shallowEqual.default)(node, opts);
2539    }
2540  }
2541
2542  return false;
2543}
2544
2545function isPipelineBareFunction(node, opts) {
2546  if (!node) return false;
2547  const nodeType = node.type;
2548
2549  if (nodeType === "PipelineBareFunction") {
2550    if (typeof opts === "undefined") {
2551      return true;
2552    } else {
2553      return (0, _shallowEqual.default)(node, opts);
2554    }
2555  }
2556
2557  return false;
2558}
2559
2560function isPipelinePrimaryTopicReference(node, opts) {
2561  if (!node) return false;
2562  const nodeType = node.type;
2563
2564  if (nodeType === "PipelinePrimaryTopicReference") {
2565    if (typeof opts === "undefined") {
2566      return true;
2567    } else {
2568      return (0, _shallowEqual.default)(node, opts);
2569    }
2570  }
2571
2572  return false;
2573}
2574
2575function isOptionalCallExpression(node, opts) {
2576  if (!node) return false;
2577  const nodeType = node.type;
2578
2579  if (nodeType === "OptionalCallExpression") {
2580    if (typeof opts === "undefined") {
2581      return true;
2582    } else {
2583      return (0, _shallowEqual.default)(node, opts);
2584    }
2585  }
2586
2587  return false;
2588}
2589
2590function isClassPrivateProperty(node, opts) {
2591  if (!node) return false;
2592  const nodeType = node.type;
2593
2594  if (nodeType === "ClassPrivateProperty") {
2595    if (typeof opts === "undefined") {
2596      return true;
2597    } else {
2598      return (0, _shallowEqual.default)(node, opts);
2599    }
2600  }
2601
2602  return false;
2603}
2604
2605function isClassPrivateMethod(node, opts) {
2606  if (!node) return false;
2607  const nodeType = node.type;
2608
2609  if (nodeType === "ClassPrivateMethod") {
2610    if (typeof opts === "undefined") {
2611      return true;
2612    } else {
2613      return (0, _shallowEqual.default)(node, opts);
2614    }
2615  }
2616
2617  return false;
2618}
2619
2620function isImport(node, opts) {
2621  if (!node) return false;
2622  const nodeType = node.type;
2623
2624  if (nodeType === "Import") {
2625    if (typeof opts === "undefined") {
2626      return true;
2627    } else {
2628      return (0, _shallowEqual.default)(node, opts);
2629    }
2630  }
2631
2632  return false;
2633}
2634
2635function isDecorator(node, opts) {
2636  if (!node) return false;
2637  const nodeType = node.type;
2638
2639  if (nodeType === "Decorator") {
2640    if (typeof opts === "undefined") {
2641      return true;
2642    } else {
2643      return (0, _shallowEqual.default)(node, opts);
2644    }
2645  }
2646
2647  return false;
2648}
2649
2650function isDoExpression(node, opts) {
2651  if (!node) return false;
2652  const nodeType = node.type;
2653
2654  if (nodeType === "DoExpression") {
2655    if (typeof opts === "undefined") {
2656      return true;
2657    } else {
2658      return (0, _shallowEqual.default)(node, opts);
2659    }
2660  }
2661
2662  return false;
2663}
2664
2665function isExportDefaultSpecifier(node, opts) {
2666  if (!node) return false;
2667  const nodeType = node.type;
2668
2669  if (nodeType === "ExportDefaultSpecifier") {
2670    if (typeof opts === "undefined") {
2671      return true;
2672    } else {
2673      return (0, _shallowEqual.default)(node, opts);
2674    }
2675  }
2676
2677  return false;
2678}
2679
2680function isExportNamespaceSpecifier(node, opts) {
2681  if (!node) return false;
2682  const nodeType = node.type;
2683
2684  if (nodeType === "ExportNamespaceSpecifier") {
2685    if (typeof opts === "undefined") {
2686      return true;
2687    } else {
2688      return (0, _shallowEqual.default)(node, opts);
2689    }
2690  }
2691
2692  return false;
2693}
2694
2695function isPrivateName(node, opts) {
2696  if (!node) return false;
2697  const nodeType = node.type;
2698
2699  if (nodeType === "PrivateName") {
2700    if (typeof opts === "undefined") {
2701      return true;
2702    } else {
2703      return (0, _shallowEqual.default)(node, opts);
2704    }
2705  }
2706
2707  return false;
2708}
2709
2710function isBigIntLiteral(node, opts) {
2711  if (!node) return false;
2712  const nodeType = node.type;
2713
2714  if (nodeType === "BigIntLiteral") {
2715    if (typeof opts === "undefined") {
2716      return true;
2717    } else {
2718      return (0, _shallowEqual.default)(node, opts);
2719    }
2720  }
2721
2722  return false;
2723}
2724
2725function isTSParameterProperty(node, opts) {
2726  if (!node) return false;
2727  const nodeType = node.type;
2728
2729  if (nodeType === "TSParameterProperty") {
2730    if (typeof opts === "undefined") {
2731      return true;
2732    } else {
2733      return (0, _shallowEqual.default)(node, opts);
2734    }
2735  }
2736
2737  return false;
2738}
2739
2740function isTSDeclareFunction(node, opts) {
2741  if (!node) return false;
2742  const nodeType = node.type;
2743
2744  if (nodeType === "TSDeclareFunction") {
2745    if (typeof opts === "undefined") {
2746      return true;
2747    } else {
2748      return (0, _shallowEqual.default)(node, opts);
2749    }
2750  }
2751
2752  return false;
2753}
2754
2755function isTSDeclareMethod(node, opts) {
2756  if (!node) return false;
2757  const nodeType = node.type;
2758
2759  if (nodeType === "TSDeclareMethod") {
2760    if (typeof opts === "undefined") {
2761      return true;
2762    } else {
2763      return (0, _shallowEqual.default)(node, opts);
2764    }
2765  }
2766
2767  return false;
2768}
2769
2770function isTSQualifiedName(node, opts) {
2771  if (!node) return false;
2772  const nodeType = node.type;
2773
2774  if (nodeType === "TSQualifiedName") {
2775    if (typeof opts === "undefined") {
2776      return true;
2777    } else {
2778      return (0, _shallowEqual.default)(node, opts);
2779    }
2780  }
2781
2782  return false;
2783}
2784
2785function isTSCallSignatureDeclaration(node, opts) {
2786  if (!node) return false;
2787  const nodeType = node.type;
2788
2789  if (nodeType === "TSCallSignatureDeclaration") {
2790    if (typeof opts === "undefined") {
2791      return true;
2792    } else {
2793      return (0, _shallowEqual.default)(node, opts);
2794    }
2795  }
2796
2797  return false;
2798}
2799
2800function isTSConstructSignatureDeclaration(node, opts) {
2801  if (!node) return false;
2802  const nodeType = node.type;
2803
2804  if (nodeType === "TSConstructSignatureDeclaration") {
2805    if (typeof opts === "undefined") {
2806      return true;
2807    } else {
2808      return (0, _shallowEqual.default)(node, opts);
2809    }
2810  }
2811
2812  return false;
2813}
2814
2815function isTSPropertySignature(node, opts) {
2816  if (!node) return false;
2817  const nodeType = node.type;
2818
2819  if (nodeType === "TSPropertySignature") {
2820    if (typeof opts === "undefined") {
2821      return true;
2822    } else {
2823      return (0, _shallowEqual.default)(node, opts);
2824    }
2825  }
2826
2827  return false;
2828}
2829
2830function isTSMethodSignature(node, opts) {
2831  if (!node) return false;
2832  const nodeType = node.type;
2833
2834  if (nodeType === "TSMethodSignature") {
2835    if (typeof opts === "undefined") {
2836      return true;
2837    } else {
2838      return (0, _shallowEqual.default)(node, opts);
2839    }
2840  }
2841
2842  return false;
2843}
2844
2845function isTSIndexSignature(node, opts) {
2846  if (!node) return false;
2847  const nodeType = node.type;
2848
2849  if (nodeType === "TSIndexSignature") {
2850    if (typeof opts === "undefined") {
2851      return true;
2852    } else {
2853      return (0, _shallowEqual.default)(node, opts);
2854    }
2855  }
2856
2857  return false;
2858}
2859
2860function isTSAnyKeyword(node, opts) {
2861  if (!node) return false;
2862  const nodeType = node.type;
2863
2864  if (nodeType === "TSAnyKeyword") {
2865    if (typeof opts === "undefined") {
2866      return true;
2867    } else {
2868      return (0, _shallowEqual.default)(node, opts);
2869    }
2870  }
2871
2872  return false;
2873}
2874
2875function isTSUnknownKeyword(node, opts) {
2876  if (!node) return false;
2877  const nodeType = node.type;
2878
2879  if (nodeType === "TSUnknownKeyword") {
2880    if (typeof opts === "undefined") {
2881      return true;
2882    } else {
2883      return (0, _shallowEqual.default)(node, opts);
2884    }
2885  }
2886
2887  return false;
2888}
2889
2890function isTSNumberKeyword(node, opts) {
2891  if (!node) return false;
2892  const nodeType = node.type;
2893
2894  if (nodeType === "TSNumberKeyword") {
2895    if (typeof opts === "undefined") {
2896      return true;
2897    } else {
2898      return (0, _shallowEqual.default)(node, opts);
2899    }
2900  }
2901
2902  return false;
2903}
2904
2905function isTSObjectKeyword(node, opts) {
2906  if (!node) return false;
2907  const nodeType = node.type;
2908
2909  if (nodeType === "TSObjectKeyword") {
2910    if (typeof opts === "undefined") {
2911      return true;
2912    } else {
2913      return (0, _shallowEqual.default)(node, opts);
2914    }
2915  }
2916
2917  return false;
2918}
2919
2920function isTSBooleanKeyword(node, opts) {
2921  if (!node) return false;
2922  const nodeType = node.type;
2923
2924  if (nodeType === "TSBooleanKeyword") {
2925    if (typeof opts === "undefined") {
2926      return true;
2927    } else {
2928      return (0, _shallowEqual.default)(node, opts);
2929    }
2930  }
2931
2932  return false;
2933}
2934
2935function isTSStringKeyword(node, opts) {
2936  if (!node) return false;
2937  const nodeType = node.type;
2938
2939  if (nodeType === "TSStringKeyword") {
2940    if (typeof opts === "undefined") {
2941      return true;
2942    } else {
2943      return (0, _shallowEqual.default)(node, opts);
2944    }
2945  }
2946
2947  return false;
2948}
2949
2950function isTSSymbolKeyword(node, opts) {
2951  if (!node) return false;
2952  const nodeType = node.type;
2953
2954  if (nodeType === "TSSymbolKeyword") {
2955    if (typeof opts === "undefined") {
2956      return true;
2957    } else {
2958      return (0, _shallowEqual.default)(node, opts);
2959    }
2960  }
2961
2962  return false;
2963}
2964
2965function isTSVoidKeyword(node, opts) {
2966  if (!node) return false;
2967  const nodeType = node.type;
2968
2969  if (nodeType === "TSVoidKeyword") {
2970    if (typeof opts === "undefined") {
2971      return true;
2972    } else {
2973      return (0, _shallowEqual.default)(node, opts);
2974    }
2975  }
2976
2977  return false;
2978}
2979
2980function isTSUndefinedKeyword(node, opts) {
2981  if (!node) return false;
2982  const nodeType = node.type;
2983
2984  if (nodeType === "TSUndefinedKeyword") {
2985    if (typeof opts === "undefined") {
2986      return true;
2987    } else {
2988      return (0, _shallowEqual.default)(node, opts);
2989    }
2990  }
2991
2992  return false;
2993}
2994
2995function isTSNullKeyword(node, opts) {
2996  if (!node) return false;
2997  const nodeType = node.type;
2998
2999  if (nodeType === "TSNullKeyword") {
3000    if (typeof opts === "undefined") {
3001      return true;
3002    } else {
3003      return (0, _shallowEqual.default)(node, opts);
3004    }
3005  }
3006
3007  return false;
3008}
3009
3010function isTSNeverKeyword(node, opts) {
3011  if (!node) return false;
3012  const nodeType = node.type;
3013
3014  if (nodeType === "TSNeverKeyword") {
3015    if (typeof opts === "undefined") {
3016      return true;
3017    } else {
3018      return (0, _shallowEqual.default)(node, opts);
3019    }
3020  }
3021
3022  return false;
3023}
3024
3025function isTSThisType(node, opts) {
3026  if (!node) return false;
3027  const nodeType = node.type;
3028
3029  if (nodeType === "TSThisType") {
3030    if (typeof opts === "undefined") {
3031      return true;
3032    } else {
3033      return (0, _shallowEqual.default)(node, opts);
3034    }
3035  }
3036
3037  return false;
3038}
3039
3040function isTSFunctionType(node, opts) {
3041  if (!node) return false;
3042  const nodeType = node.type;
3043
3044  if (nodeType === "TSFunctionType") {
3045    if (typeof opts === "undefined") {
3046      return true;
3047    } else {
3048      return (0, _shallowEqual.default)(node, opts);
3049    }
3050  }
3051
3052  return false;
3053}
3054
3055function isTSConstructorType(node, opts) {
3056  if (!node) return false;
3057  const nodeType = node.type;
3058
3059  if (nodeType === "TSConstructorType") {
3060    if (typeof opts === "undefined") {
3061      return true;
3062    } else {
3063      return (0, _shallowEqual.default)(node, opts);
3064    }
3065  }
3066
3067  return false;
3068}
3069
3070function isTSTypeReference(node, opts) {
3071  if (!node) return false;
3072  const nodeType = node.type;
3073
3074  if (nodeType === "TSTypeReference") {
3075    if (typeof opts === "undefined") {
3076      return true;
3077    } else {
3078      return (0, _shallowEqual.default)(node, opts);
3079    }
3080  }
3081
3082  return false;
3083}
3084
3085function isTSTypePredicate(node, opts) {
3086  if (!node) return false;
3087  const nodeType = node.type;
3088
3089  if (nodeType === "TSTypePredicate") {
3090    if (typeof opts === "undefined") {
3091      return true;
3092    } else {
3093      return (0, _shallowEqual.default)(node, opts);
3094    }
3095  }
3096
3097  return false;
3098}
3099
3100function isTSTypeQuery(node, opts) {
3101  if (!node) return false;
3102  const nodeType = node.type;
3103
3104  if (nodeType === "TSTypeQuery") {
3105    if (typeof opts === "undefined") {
3106      return true;
3107    } else {
3108      return (0, _shallowEqual.default)(node, opts);
3109    }
3110  }
3111
3112  return false;
3113}
3114
3115function isTSTypeLiteral(node, opts) {
3116  if (!node) return false;
3117  const nodeType = node.type;
3118
3119  if (nodeType === "TSTypeLiteral") {
3120    if (typeof opts === "undefined") {
3121      return true;
3122    } else {
3123      return (0, _shallowEqual.default)(node, opts);
3124    }
3125  }
3126
3127  return false;
3128}
3129
3130function isTSArrayType(node, opts) {
3131  if (!node) return false;
3132  const nodeType = node.type;
3133
3134  if (nodeType === "TSArrayType") {
3135    if (typeof opts === "undefined") {
3136      return true;
3137    } else {
3138      return (0, _shallowEqual.default)(node, opts);
3139    }
3140  }
3141
3142  return false;
3143}
3144
3145function isTSTupleType(node, opts) {
3146  if (!node) return false;
3147  const nodeType = node.type;
3148
3149  if (nodeType === "TSTupleType") {
3150    if (typeof opts === "undefined") {
3151      return true;
3152    } else {
3153      return (0, _shallowEqual.default)(node, opts);
3154    }
3155  }
3156
3157  return false;
3158}
3159
3160function isTSOptionalType(node, opts) {
3161  if (!node) return false;
3162  const nodeType = node.type;
3163
3164  if (nodeType === "TSOptionalType") {
3165    if (typeof opts === "undefined") {
3166      return true;
3167    } else {
3168      return (0, _shallowEqual.default)(node, opts);
3169    }
3170  }
3171
3172  return false;
3173}
3174
3175function isTSRestType(node, opts) {
3176  if (!node) return false;
3177  const nodeType = node.type;
3178
3179  if (nodeType === "TSRestType") {
3180    if (typeof opts === "undefined") {
3181      return true;
3182    } else {
3183      return (0, _shallowEqual.default)(node, opts);
3184    }
3185  }
3186
3187  return false;
3188}
3189
3190function isTSUnionType(node, opts) {
3191  if (!node) return false;
3192  const nodeType = node.type;
3193
3194  if (nodeType === "TSUnionType") {
3195    if (typeof opts === "undefined") {
3196      return true;
3197    } else {
3198      return (0, _shallowEqual.default)(node, opts);
3199    }
3200  }
3201
3202  return false;
3203}
3204
3205function isTSIntersectionType(node, opts) {
3206  if (!node) return false;
3207  const nodeType = node.type;
3208
3209  if (nodeType === "TSIntersectionType") {
3210    if (typeof opts === "undefined") {
3211      return true;
3212    } else {
3213      return (0, _shallowEqual.default)(node, opts);
3214    }
3215  }
3216
3217  return false;
3218}
3219
3220function isTSConditionalType(node, opts) {
3221  if (!node) return false;
3222  const nodeType = node.type;
3223
3224  if (nodeType === "TSConditionalType") {
3225    if (typeof opts === "undefined") {
3226      return true;
3227    } else {
3228      return (0, _shallowEqual.default)(node, opts);
3229    }
3230  }
3231
3232  return false;
3233}
3234
3235function isTSInferType(node, opts) {
3236  if (!node) return false;
3237  const nodeType = node.type;
3238
3239  if (nodeType === "TSInferType") {
3240    if (typeof opts === "undefined") {
3241      return true;
3242    } else {
3243      return (0, _shallowEqual.default)(node, opts);
3244    }
3245  }
3246
3247  return false;
3248}
3249
3250function isTSParenthesizedType(node, opts) {
3251  if (!node) return false;
3252  const nodeType = node.type;
3253
3254  if (nodeType === "TSParenthesizedType") {
3255    if (typeof opts === "undefined") {
3256      return true;
3257    } else {
3258      return (0, _shallowEqual.default)(node, opts);
3259    }
3260  }
3261
3262  return false;
3263}
3264
3265function isTSTypeOperator(node, opts) {
3266  if (!node) return false;
3267  const nodeType = node.type;
3268
3269  if (nodeType === "TSTypeOperator") {
3270    if (typeof opts === "undefined") {
3271      return true;
3272    } else {
3273      return (0, _shallowEqual.default)(node, opts);
3274    }
3275  }
3276
3277  return false;
3278}
3279
3280function isTSIndexedAccessType(node, opts) {
3281  if (!node) return false;
3282  const nodeType = node.type;
3283
3284  if (nodeType === "TSIndexedAccessType") {
3285    if (typeof opts === "undefined") {
3286      return true;
3287    } else {
3288      return (0, _shallowEqual.default)(node, opts);
3289    }
3290  }
3291
3292  return false;
3293}
3294
3295function isTSMappedType(node, opts) {
3296  if (!node) return false;
3297  const nodeType = node.type;
3298
3299  if (nodeType === "TSMappedType") {
3300    if (typeof opts === "undefined") {
3301      return true;
3302    } else {
3303      return (0, _shallowEqual.default)(node, opts);
3304    }
3305  }
3306
3307  return false;
3308}
3309
3310function isTSLiteralType(node, opts) {
3311  if (!node) return false;
3312  const nodeType = node.type;
3313
3314  if (nodeType === "TSLiteralType") {
3315    if (typeof opts === "undefined") {
3316      return true;
3317    } else {
3318      return (0, _shallowEqual.default)(node, opts);
3319    }
3320  }
3321
3322  return false;
3323}
3324
3325function isTSExpressionWithTypeArguments(node, opts) {
3326  if (!node) return false;
3327  const nodeType = node.type;
3328
3329  if (nodeType === "TSExpressionWithTypeArguments") {
3330    if (typeof opts === "undefined") {
3331      return true;
3332    } else {
3333      return (0, _shallowEqual.default)(node, opts);
3334    }
3335  }
3336
3337  return false;
3338}
3339
3340function isTSInterfaceDeclaration(node, opts) {
3341  if (!node) return false;
3342  const nodeType = node.type;
3343
3344  if (nodeType === "TSInterfaceDeclaration") {
3345    if (typeof opts === "undefined") {
3346      return true;
3347    } else {
3348      return (0, _shallowEqual.default)(node, opts);
3349    }
3350  }
3351
3352  return false;
3353}
3354
3355function isTSInterfaceBody(node, opts) {
3356  if (!node) return false;
3357  const nodeType = node.type;
3358
3359  if (nodeType === "TSInterfaceBody") {
3360    if (typeof opts === "undefined") {
3361      return true;
3362    } else {
3363      return (0, _shallowEqual.default)(node, opts);
3364    }
3365  }
3366
3367  return false;
3368}
3369
3370function isTSTypeAliasDeclaration(node, opts) {
3371  if (!node) return false;
3372  const nodeType = node.type;
3373
3374  if (nodeType === "TSTypeAliasDeclaration") {
3375    if (typeof opts === "undefined") {
3376      return true;
3377    } else {
3378      return (0, _shallowEqual.default)(node, opts);
3379    }
3380  }
3381
3382  return false;
3383}
3384
3385function isTSAsExpression(node, opts) {
3386  if (!node) return false;
3387  const nodeType = node.type;
3388
3389  if (nodeType === "TSAsExpression") {
3390    if (typeof opts === "undefined") {
3391      return true;
3392    } else {
3393      return (0, _shallowEqual.default)(node, opts);
3394    }
3395  }
3396
3397  return false;
3398}
3399
3400function isTSTypeAssertion(node, opts) {
3401  if (!node) return false;
3402  const nodeType = node.type;
3403
3404  if (nodeType === "TSTypeAssertion") {
3405    if (typeof opts === "undefined") {
3406      return true;
3407    } else {
3408      return (0, _shallowEqual.default)(node, opts);
3409    }
3410  }
3411
3412  return false;
3413}
3414
3415function isTSEnumDeclaration(node, opts) {
3416  if (!node) return false;
3417  const nodeType = node.type;
3418
3419  if (nodeType === "TSEnumDeclaration") {
3420    if (typeof opts === "undefined") {
3421      return true;
3422    } else {
3423      return (0, _shallowEqual.default)(node, opts);
3424    }
3425  }
3426
3427  return false;
3428}
3429
3430function isTSEnumMember(node, opts) {
3431  if (!node) return false;
3432  const nodeType = node.type;
3433
3434  if (nodeType === "TSEnumMember") {
3435    if (typeof opts === "undefined") {
3436      return true;
3437    } else {
3438      return (0, _shallowEqual.default)(node, opts);
3439    }
3440  }
3441
3442  return false;
3443}
3444
3445function isTSModuleDeclaration(node, opts) {
3446  if (!node) return false;
3447  const nodeType = node.type;
3448
3449  if (nodeType === "TSModuleDeclaration") {
3450    if (typeof opts === "undefined") {
3451      return true;
3452    } else {
3453      return (0, _shallowEqual.default)(node, opts);
3454    }
3455  }
3456
3457  return false;
3458}
3459
3460function isTSModuleBlock(node, opts) {
3461  if (!node) return false;
3462  const nodeType = node.type;
3463
3464  if (nodeType === "TSModuleBlock") {
3465    if (typeof opts === "undefined") {
3466      return true;
3467    } else {
3468      return (0, _shallowEqual.default)(node, opts);
3469    }
3470  }
3471
3472  return false;
3473}
3474
3475function isTSImportType(node, opts) {
3476  if (!node) return false;
3477  const nodeType = node.type;
3478
3479  if (nodeType === "TSImportType") {
3480    if (typeof opts === "undefined") {
3481      return true;
3482    } else {
3483      return (0, _shallowEqual.default)(node, opts);
3484    }
3485  }
3486
3487  return false;
3488}
3489
3490function isTSImportEqualsDeclaration(node, opts) {
3491  if (!node) return false;
3492  const nodeType = node.type;
3493
3494  if (nodeType === "TSImportEqualsDeclaration") {
3495    if (typeof opts === "undefined") {
3496      return true;
3497    } else {
3498      return (0, _shallowEqual.default)(node, opts);
3499    }
3500  }
3501
3502  return false;
3503}
3504
3505function isTSExternalModuleReference(node, opts) {
3506  if (!node) return false;
3507  const nodeType = node.type;
3508
3509  if (nodeType === "TSExternalModuleReference") {
3510    if (typeof opts === "undefined") {
3511      return true;
3512    } else {
3513      return (0, _shallowEqual.default)(node, opts);
3514    }
3515  }
3516
3517  return false;
3518}
3519
3520function isTSNonNullExpression(node, opts) {
3521  if (!node) return false;
3522  const nodeType = node.type;
3523
3524  if (nodeType === "TSNonNullExpression") {
3525    if (typeof opts === "undefined") {
3526      return true;
3527    } else {
3528      return (0, _shallowEqual.default)(node, opts);
3529    }
3530  }
3531
3532  return false;
3533}
3534
3535function isTSExportAssignment(node, opts) {
3536  if (!node) return false;
3537  const nodeType = node.type;
3538
3539  if (nodeType === "TSExportAssignment") {
3540    if (typeof opts === "undefined") {
3541      return true;
3542    } else {
3543      return (0, _shallowEqual.default)(node, opts);
3544    }
3545  }
3546
3547  return false;
3548}
3549
3550function isTSNamespaceExportDeclaration(node, opts) {
3551  if (!node) return false;
3552  const nodeType = node.type;
3553
3554  if (nodeType === "TSNamespaceExportDeclaration") {
3555    if (typeof opts === "undefined") {
3556      return true;
3557    } else {
3558      return (0, _shallowEqual.default)(node, opts);
3559    }
3560  }
3561
3562  return false;
3563}
3564
3565function isTSTypeAnnotation(node, opts) {
3566  if (!node) return false;
3567  const nodeType = node.type;
3568
3569  if (nodeType === "TSTypeAnnotation") {
3570    if (typeof opts === "undefined") {
3571      return true;
3572    } else {
3573      return (0, _shallowEqual.default)(node, opts);
3574    }
3575  }
3576
3577  return false;
3578}
3579
3580function isTSTypeParameterInstantiation(node, opts) {
3581  if (!node) return false;
3582  const nodeType = node.type;
3583
3584  if (nodeType === "TSTypeParameterInstantiation") {
3585    if (typeof opts === "undefined") {
3586      return true;
3587    } else {
3588      return (0, _shallowEqual.default)(node, opts);
3589    }
3590  }
3591
3592  return false;
3593}
3594
3595function isTSTypeParameterDeclaration(node, opts) {
3596  if (!node) return false;
3597  const nodeType = node.type;
3598
3599  if (nodeType === "TSTypeParameterDeclaration") {
3600    if (typeof opts === "undefined") {
3601      return true;
3602    } else {
3603      return (0, _shallowEqual.default)(node, opts);
3604    }
3605  }
3606
3607  return false;
3608}
3609
3610function isTSTypeParameter(node, opts) {
3611  if (!node) return false;
3612  const nodeType = node.type;
3613
3614  if (nodeType === "TSTypeParameter") {
3615    if (typeof opts === "undefined") {
3616      return true;
3617    } else {
3618      return (0, _shallowEqual.default)(node, opts);
3619    }
3620  }
3621
3622  return false;
3623}
3624
3625function isExpression(node, opts) {
3626  if (!node) return false;
3627  const nodeType = node.type;
3628
3629  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)) {
3630    if (typeof opts === "undefined") {
3631      return true;
3632    } else {
3633      return (0, _shallowEqual.default)(node, opts);
3634    }
3635  }
3636
3637  return false;
3638}
3639
3640function isBinary(node, opts) {
3641  if (!node) return false;
3642  const nodeType = node.type;
3643
3644  if (nodeType === "Binary" || "BinaryExpression" === nodeType || "LogicalExpression" === nodeType) {
3645    if (typeof opts === "undefined") {
3646      return true;
3647    } else {
3648      return (0, _shallowEqual.default)(node, opts);
3649    }
3650  }
3651
3652  return false;
3653}
3654
3655function isScopable(node, opts) {
3656  if (!node) return false;
3657  const nodeType = node.type;
3658
3659  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) {
3660    if (typeof opts === "undefined") {
3661      return true;
3662    } else {
3663      return (0, _shallowEqual.default)(node, opts);
3664    }
3665  }
3666
3667  return false;
3668}
3669
3670function isBlockParent(node, opts) {
3671  if (!node) return false;
3672  const nodeType = node.type;
3673
3674  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) {
3675    if (typeof opts === "undefined") {
3676      return true;
3677    } else {
3678      return (0, _shallowEqual.default)(node, opts);
3679    }
3680  }
3681
3682  return false;
3683}
3684
3685function isBlock(node, opts) {
3686  if (!node) return false;
3687  const nodeType = node.type;
3688
3689  if (nodeType === "Block" || "BlockStatement" === nodeType || "Program" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) {
3690    if (typeof opts === "undefined") {
3691      return true;
3692    } else {
3693      return (0, _shallowEqual.default)(node, opts);
3694    }
3695  }
3696
3697  return false;
3698}
3699
3700function isStatement(node, opts) {
3701  if (!node) return false;
3702  const nodeType = node.type;
3703
3704  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)) {
3705    if (typeof opts === "undefined") {
3706      return true;
3707    } else {
3708      return (0, _shallowEqual.default)(node, opts);
3709    }
3710  }
3711
3712  return false;
3713}
3714
3715function isTerminatorless(node, opts) {
3716  if (!node) return false;
3717  const nodeType = node.type;
3718
3719  if (nodeType === "Terminatorless" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) {
3720    if (typeof opts === "undefined") {
3721      return true;
3722    } else {
3723      return (0, _shallowEqual.default)(node, opts);
3724    }
3725  }
3726
3727  return false;
3728}
3729
3730function isCompletionStatement(node, opts) {
3731  if (!node) return false;
3732  const nodeType = node.type;
3733
3734  if (nodeType === "CompletionStatement" || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) {
3735    if (typeof opts === "undefined") {
3736      return true;
3737    } else {
3738      return (0, _shallowEqual.default)(node, opts);
3739    }
3740  }
3741
3742  return false;
3743}
3744
3745function isConditional(node, opts) {
3746  if (!node) return false;
3747  const nodeType = node.type;
3748
3749  if (nodeType === "Conditional" || "ConditionalExpression" === nodeType || "IfStatement" === nodeType) {
3750    if (typeof opts === "undefined") {
3751      return true;
3752    } else {
3753      return (0, _shallowEqual.default)(node, opts);
3754    }
3755  }
3756
3757  return false;
3758}
3759
3760function isLoop(node, opts) {
3761  if (!node) return false;
3762  const nodeType = node.type;
3763
3764  if (nodeType === "Loop" || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) {
3765    if (typeof opts === "undefined") {
3766      return true;
3767    } else {
3768      return (0, _shallowEqual.default)(node, opts);
3769    }
3770  }
3771
3772  return false;
3773}
3774
3775function isWhile(node, opts) {
3776  if (!node) return false;
3777  const nodeType = node.type;
3778
3779  if (nodeType === "While" || "DoWhileStatement" === nodeType || "WhileStatement" === nodeType) {
3780    if (typeof opts === "undefined") {
3781      return true;
3782    } else {
3783      return (0, _shallowEqual.default)(node, opts);
3784    }
3785  }
3786
3787  return false;
3788}
3789
3790function isExpressionWrapper(node, opts) {
3791  if (!node) return false;
3792  const nodeType = node.type;
3793
3794  if (nodeType === "ExpressionWrapper" || "ExpressionStatement" === nodeType || "ParenthesizedExpression" === nodeType || "TypeCastExpression" === nodeType) {
3795    if (typeof opts === "undefined") {
3796      return true;
3797    } else {
3798      return (0, _shallowEqual.default)(node, opts);
3799    }
3800  }
3801
3802  return false;
3803}
3804
3805function isFor(node, opts) {
3806  if (!node) return false;
3807  const nodeType = node.type;
3808
3809  if (nodeType === "For" || "ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) {
3810    if (typeof opts === "undefined") {
3811      return true;
3812    } else {
3813      return (0, _shallowEqual.default)(node, opts);
3814    }
3815  }
3816
3817  return false;
3818}
3819
3820function isForXStatement(node, opts) {
3821  if (!node) return false;
3822  const nodeType = node.type;
3823
3824  if (nodeType === "ForXStatement" || "ForInStatement" === nodeType || "ForOfStatement" === nodeType) {
3825    if (typeof opts === "undefined") {
3826      return true;
3827    } else {
3828      return (0, _shallowEqual.default)(node, opts);
3829    }
3830  }
3831
3832  return false;
3833}
3834
3835function isFunction(node, opts) {
3836  if (!node) return false;
3837  const nodeType = node.type;
3838
3839  if (nodeType === "Function" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
3840    if (typeof opts === "undefined") {
3841      return true;
3842    } else {
3843      return (0, _shallowEqual.default)(node, opts);
3844    }
3845  }
3846
3847  return false;
3848}
3849
3850function isFunctionParent(node, opts) {
3851  if (!node) return false;
3852  const nodeType = node.type;
3853
3854  if (nodeType === "FunctionParent" || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
3855    if (typeof opts === "undefined") {
3856      return true;
3857    } else {
3858      return (0, _shallowEqual.default)(node, opts);
3859    }
3860  }
3861
3862  return false;
3863}
3864
3865function isPureish(node, opts) {
3866  if (!node) return false;
3867  const nodeType = node.type;
3868
3869  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) {
3870    if (typeof opts === "undefined") {
3871      return true;
3872    } else {
3873      return (0, _shallowEqual.default)(node, opts);
3874    }
3875  }
3876
3877  return false;
3878}
3879
3880function isDeclaration(node, opts) {
3881  if (!node) return false;
3882  const nodeType = node.type;
3883
3884  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) {
3885    if (typeof opts === "undefined") {
3886      return true;
3887    } else {
3888      return (0, _shallowEqual.default)(node, opts);
3889    }
3890  }
3891
3892  return false;
3893}
3894
3895function isPatternLike(node, opts) {
3896  if (!node) return false;
3897  const nodeType = node.type;
3898
3899  if (nodeType === "PatternLike" || "Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) {
3900    if (typeof opts === "undefined") {
3901      return true;
3902    } else {
3903      return (0, _shallowEqual.default)(node, opts);
3904    }
3905  }
3906
3907  return false;
3908}
3909
3910function isLVal(node, opts) {
3911  if (!node) return false;
3912  const nodeType = node.type;
3913
3914  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)) {
3915    if (typeof opts === "undefined") {
3916      return true;
3917    } else {
3918      return (0, _shallowEqual.default)(node, opts);
3919    }
3920  }
3921
3922  return false;
3923}
3924
3925function isTSEntityName(node, opts) {
3926  if (!node) return false;
3927  const nodeType = node.type;
3928
3929  if (nodeType === "TSEntityName" || "Identifier" === nodeType || "TSQualifiedName" === nodeType || nodeType === "Placeholder" && "Identifier" === node.expectedNode) {
3930    if (typeof opts === "undefined") {
3931      return true;
3932    } else {
3933      return (0, _shallowEqual.default)(node, opts);
3934    }
3935  }
3936
3937  return false;
3938}
3939
3940function isLiteral(node, opts) {
3941  if (!node) return false;
3942  const nodeType = node.type;
3943
3944  if (nodeType === "Literal" || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType || "BigIntLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
3945    if (typeof opts === "undefined") {
3946      return true;
3947    } else {
3948      return (0, _shallowEqual.default)(node, opts);
3949    }
3950  }
3951
3952  return false;
3953}
3954
3955function isImmutable(node, opts) {
3956  if (!node) return false;
3957  const nodeType = node.type;
3958
3959  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) {
3960    if (typeof opts === "undefined") {
3961      return true;
3962    } else {
3963      return (0, _shallowEqual.default)(node, opts);
3964    }
3965  }
3966
3967  return false;
3968}
3969
3970function isUserWhitespacable(node, opts) {
3971  if (!node) return false;
3972  const nodeType = node.type;
3973
3974  if (nodeType === "UserWhitespacable" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) {
3975    if (typeof opts === "undefined") {
3976      return true;
3977    } else {
3978      return (0, _shallowEqual.default)(node, opts);
3979    }
3980  }
3981
3982  return false;
3983}
3984
3985function isMethod(node, opts) {
3986  if (!node) return false;
3987  const nodeType = node.type;
3988
3989  if (nodeType === "Method" || "ObjectMethod" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
3990    if (typeof opts === "undefined") {
3991      return true;
3992    } else {
3993      return (0, _shallowEqual.default)(node, opts);
3994    }
3995  }
3996
3997  return false;
3998}
3999
4000function isObjectMember(node, opts) {
4001  if (!node) return false;
4002  const nodeType = node.type;
4003
4004  if (nodeType === "ObjectMember" || "ObjectMethod" === nodeType || "ObjectProperty" === nodeType) {
4005    if (typeof opts === "undefined") {
4006      return true;
4007    } else {
4008      return (0, _shallowEqual.default)(node, opts);
4009    }
4010  }
4011
4012  return false;
4013}
4014
4015function isProperty(node, opts) {
4016  if (!node) return false;
4017  const nodeType = node.type;
4018
4019  if (nodeType === "Property" || "ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassPrivateProperty" === nodeType) {
4020    if (typeof opts === "undefined") {
4021      return true;
4022    } else {
4023      return (0, _shallowEqual.default)(node, opts);
4024    }
4025  }
4026
4027  return false;
4028}
4029
4030function isUnaryLike(node, opts) {
4031  if (!node) return false;
4032  const nodeType = node.type;
4033
4034  if (nodeType === "UnaryLike" || "UnaryExpression" === nodeType || "SpreadElement" === nodeType) {
4035    if (typeof opts === "undefined") {
4036      return true;
4037    } else {
4038      return (0, _shallowEqual.default)(node, opts);
4039    }
4040  }
4041
4042  return false;
4043}
4044
4045function isPattern(node, opts) {
4046  if (!node) return false;
4047  const nodeType = node.type;
4048
4049  if (nodeType === "Pattern" || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && "Pattern" === node.expectedNode) {
4050    if (typeof opts === "undefined") {
4051      return true;
4052    } else {
4053      return (0, _shallowEqual.default)(node, opts);
4054    }
4055  }
4056
4057  return false;
4058}
4059
4060function isClass(node, opts) {
4061  if (!node) return false;
4062  const nodeType = node.type;
4063
4064  if (nodeType === "Class" || "ClassDeclaration" === nodeType || "ClassExpression" === nodeType) {
4065    if (typeof opts === "undefined") {
4066      return true;
4067    } else {
4068      return (0, _shallowEqual.default)(node, opts);
4069    }
4070  }
4071
4072  return false;
4073}
4074
4075function isModuleDeclaration(node, opts) {
4076  if (!node) return false;
4077  const nodeType = node.type;
4078
4079  if (nodeType === "ModuleDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) {
4080    if (typeof opts === "undefined") {
4081      return true;
4082    } else {
4083      return (0, _shallowEqual.default)(node, opts);
4084    }
4085  }
4086
4087  return false;
4088}
4089
4090function isExportDeclaration(node, opts) {
4091  if (!node) return false;
4092  const nodeType = node.type;
4093
4094  if (nodeType === "ExportDeclaration" || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) {
4095    if (typeof opts === "undefined") {
4096      return true;
4097    } else {
4098      return (0, _shallowEqual.default)(node, opts);
4099    }
4100  }
4101
4102  return false;
4103}
4104
4105function isModuleSpecifier(node, opts) {
4106  if (!node) return false;
4107  const nodeType = node.type;
4108
4109  if (nodeType === "ModuleSpecifier" || "ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType) {
4110    if (typeof opts === "undefined") {
4111      return true;
4112    } else {
4113      return (0, _shallowEqual.default)(node, opts);
4114    }
4115  }
4116
4117  return false;
4118}
4119
4120function isFlow(node, opts) {
4121  if (!node) return false;
4122  const nodeType = node.type;
4123
4124  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) {
4125    if (typeof opts === "undefined") {
4126      return true;
4127    } else {
4128      return (0, _shallowEqual.default)(node, opts);
4129    }
4130  }
4131
4132  return false;
4133}
4134
4135function isFlowType(node, opts) {
4136  if (!node) return false;
4137  const nodeType = node.type;
4138
4139  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) {
4140    if (typeof opts === "undefined") {
4141      return true;
4142    } else {
4143      return (0, _shallowEqual.default)(node, opts);
4144    }
4145  }
4146
4147  return false;
4148}
4149
4150function isFlowBaseAnnotation(node, opts) {
4151  if (!node) return false;
4152  const nodeType = node.type;
4153
4154  if (nodeType === "FlowBaseAnnotation" || "AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
4155    if (typeof opts === "undefined") {
4156      return true;
4157    } else {
4158      return (0, _shallowEqual.default)(node, opts);
4159    }
4160  }
4161
4162  return false;
4163}
4164
4165function isFlowDeclaration(node, opts) {
4166  if (!node) return false;
4167  const nodeType = node.type;
4168
4169  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) {
4170    if (typeof opts === "undefined") {
4171      return true;
4172    } else {
4173      return (0, _shallowEqual.default)(node, opts);
4174    }
4175  }
4176
4177  return false;
4178}
4179
4180function isFlowPredicate(node, opts) {
4181  if (!node) return false;
4182  const nodeType = node.type;
4183
4184  if (nodeType === "FlowPredicate" || "DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) {
4185    if (typeof opts === "undefined") {
4186      return true;
4187    } else {
4188      return (0, _shallowEqual.default)(node, opts);
4189    }
4190  }
4191
4192  return false;
4193}
4194
4195function isJSX(node, opts) {
4196  if (!node) return false;
4197  const nodeType = node.type;
4198
4199  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) {
4200    if (typeof opts === "undefined") {
4201      return true;
4202    } else {
4203      return (0, _shallowEqual.default)(node, opts);
4204    }
4205  }
4206
4207  return false;
4208}
4209
4210function isPrivate(node, opts) {
4211  if (!node) return false;
4212  const nodeType = node.type;
4213
4214  if (nodeType === "Private" || "ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType) {
4215    if (typeof opts === "undefined") {
4216      return true;
4217    } else {
4218      return (0, _shallowEqual.default)(node, opts);
4219    }
4220  }
4221
4222  return false;
4223}
4224
4225function isTSTypeElement(node, opts) {
4226  if (!node) return false;
4227  const nodeType = node.type;
4228
4229  if (nodeType === "TSTypeElement" || "TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) {
4230    if (typeof opts === "undefined") {
4231      return true;
4232    } else {
4233      return (0, _shallowEqual.default)(node, opts);
4234    }
4235  }
4236
4237  return false;
4238}
4239
4240function isTSType(node, opts) {
4241  if (!node) return false;
4242  const nodeType = node.type;
4243
4244  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) {
4245    if (typeof opts === "undefined") {
4246      return true;
4247    } else {
4248      return (0, _shallowEqual.default)(node, opts);
4249    }
4250  }
4251
4252  return false;
4253}
4254
4255function isNumberLiteral(node, opts) {
4256  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
4257  if (!node) return false;
4258  const nodeType = node.type;
4259
4260  if (nodeType === "NumberLiteral") {
4261    if (typeof opts === "undefined") {
4262      return true;
4263    } else {
4264      return (0, _shallowEqual.default)(node, opts);
4265    }
4266  }
4267
4268  return false;
4269}
4270
4271function isRegexLiteral(node, opts) {
4272  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
4273  if (!node) return false;
4274  const nodeType = node.type;
4275
4276  if (nodeType === "RegexLiteral") {
4277    if (typeof opts === "undefined") {
4278      return true;
4279    } else {
4280      return (0, _shallowEqual.default)(node, opts);
4281    }
4282  }
4283
4284  return false;
4285}
4286
4287function isRestProperty(node, opts) {
4288  console.trace("The node type RestProperty has been renamed to RestElement");
4289  if (!node) return false;
4290  const nodeType = node.type;
4291
4292  if (nodeType === "RestProperty") {
4293    if (typeof opts === "undefined") {
4294      return true;
4295    } else {
4296      return (0, _shallowEqual.default)(node, opts);
4297    }
4298  }
4299
4300  return false;
4301}
4302
4303function isSpreadProperty(node, opts) {
4304  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
4305  if (!node) return false;
4306  const nodeType = node.type;
4307
4308  if (nodeType === "SpreadProperty") {
4309    if (typeof opts === "undefined") {
4310      return true;
4311    } else {
4312      return (0, _shallowEqual.default)(node, opts);
4313    }
4314  }
4315
4316  return false;
4317}