
Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/C/Firefox/devtools/client/debugger/dist/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 1 MB

Quellcode-Bibliothek parser-worker.js Sprache: JAVA

(function (factory) {
    typeof define === 'function' && define.amd ? define(factory) :
    factory();
})((function () { 'use strict';

    (function() {
        const env = {"NODE_ENV":"production"};
        try {
            if (process) {
                process.env = Object.assign({}, process.env);
                Object.assign(process.env, env);
                return;
            }
        } catch (e) {} // avoid ReferenceError: process is not defined
        globalThis.process = { env:env };
    })();

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

    function getDefaultExportFromCjs (x) {
     return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
    }

    var lib$4 = {};

    var isReactComponent = {};

    var buildMatchMemberExpression = {};

    var matchesPattern = {};

    var generated$3 = {};

    var shallowEqual = {};

    var hasRequiredShallowEqual;

    function requireShallowEqual () {
     if (hasRequiredShallowEqual) return shallowEqual;
     hasRequiredShallowEqual = 1;

     Object.defineProperty(shallowEqual, "__esModule", {
       value: true
     });
     shallowEqual.default = shallowEqual$1;
     function shallowEqual$1(actual, expected) {
       const keys = Object.keys(expected);
       for (const key of keys) {
         if (actual[key] !== expected[key]) {
           return false;
         }
       }
       return true;
     }


     return shallowEqual;
    }

    var deprecationWarning = {};

    var hasRequiredDeprecationWarning;

    function requireDeprecationWarning () {
     if (hasRequiredDeprecationWarning) return deprecationWarning;
     hasRequiredDeprecationWarning = 1;

     Object.defineProperty(deprecationWarning, "__esModule", {
       value: true
     });
     deprecationWarning.default = deprecationWarning$1;
     const warnings = new Set();
     function deprecationWarning$1(oldName, newName, prefix = "") {
       if (warnings.has(oldName)) return;
       warnings.add(oldName);
       const {
         internal,
         trace
       } = captureShortStackTrace(1, 2);
       if (internal) {
         return;
       }
       console.warn(`${prefix}\`${oldName}\` has been deprecated, please migrate to \`${newName}\`\n${trace}`);
     }
     function captureShortStackTrace(skip, length) {
       const {
         stackTraceLimit,
         prepareStackTrace
       } = Error;
       let stackTrace;
       Error.stackTraceLimit = 1 + skip + length;
       Error.prepareStackTrace = function (err, stack) {
         stackTrace = stack;
       };
       new Error().stack;
       Error.stackTraceLimit = stackTraceLimit;
       Error.prepareStackTrace = prepareStackTrace;
       if (!stackTrace) return {
         internal: false,
         trace: ""
       };
       const shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);
       return {
         internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()),
         trace: shortStackTrace.map(frame => `    at ${frame}`).join("\n")
       };
     }


     return deprecationWarning;
    }

    var hasRequiredGenerated$3;

    function requireGenerated$3 () {
     if (hasRequiredGenerated$3) return generated$3;
     hasRequiredGenerated$3 = 1;

     Object.defineProperty(generated$3, "__esModule", {
       value: true
     });
     generated$3.isAccessor = isAccessor;
     generated$3.isAnyTypeAnnotation = isAnyTypeAnnotation;
     generated$3.isArgumentPlaceholder = isArgumentPlaceholder;
     generated$3.isArrayExpression = isArrayExpression;
     generated$3.isArrayPattern = isArrayPattern;
     generated$3.isArrayTypeAnnotation = isArrayTypeAnnotation;
     generated$3.isArrowFunctionExpression = isArrowFunctionExpression;
     generated$3.isAssignmentExpression = isAssignmentExpression;
     generated$3.isAssignmentPattern = isAssignmentPattern;
     generated$3.isAwaitExpression = isAwaitExpression;
     generated$3.isBigIntLiteral = isBigIntLiteral;
     generated$3.isBinary = isBinary;
     generated$3.isBinaryExpression = isBinaryExpression;
     generated$3.isBindExpression = isBindExpression;
     generated$3.isBlock = isBlock;
     generated$3.isBlockParent = isBlockParent;
     generated$3.isBlockStatement = isBlockStatement;
     generated$3.isBooleanLiteral = isBooleanLiteral;
     generated$3.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
     generated$3.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
     generated$3.isBreakStatement = isBreakStatement;
     generated$3.isCallExpression = isCallExpression;
     generated$3.isCatchClause = isCatchClause;
     generated$3.isClass = isClass;
     generated$3.isClassAccessorProperty = isClassAccessorProperty;
     generated$3.isClassBody = isClassBody;
     generated$3.isClassDeclaration = isClassDeclaration;
     generated$3.isClassExpression = isClassExpression;
     generated$3.isClassImplements = isClassImplements;
     generated$3.isClassMethod = isClassMethod;
     generated$3.isClassPrivateMethod = isClassPrivateMethod;
     generated$3.isClassPrivateProperty = isClassPrivateProperty;
     generated$3.isClassProperty = isClassProperty;
     generated$3.isCompletionStatement = isCompletionStatement;
     generated$3.isConditional = isConditional;
     generated$3.isConditionalExpression = isConditionalExpression;
     generated$3.isContinueStatement = isContinueStatement;
     generated$3.isDebuggerStatement = isDebuggerStatement;
     generated$3.isDecimalLiteral = isDecimalLiteral;
     generated$3.isDeclaration = isDeclaration;
     generated$3.isDeclareClass = isDeclareClass;
     generated$3.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
     generated$3.isDeclareExportDeclaration = isDeclareExportDeclaration;
     generated$3.isDeclareFunction = isDeclareFunction;
     generated$3.isDeclareInterface = isDeclareInterface;
     generated$3.isDeclareModule = isDeclareModule;
     generated$3.isDeclareModuleExports = isDeclareModuleExports;
     generated$3.isDeclareOpaqueType = isDeclareOpaqueType;
     generated$3.isDeclareTypeAlias = isDeclareTypeAlias;
     generated$3.isDeclareVariable = isDeclareVariable;
     generated$3.isDeclaredPredicate = isDeclaredPredicate;
     generated$3.isDecorator = isDecorator;
     generated$3.isDirective = isDirective;
     generated$3.isDirectiveLiteral = isDirectiveLiteral;
     generated$3.isDoExpression = isDoExpression;
     generated$3.isDoWhileStatement = isDoWhileStatement;
     generated$3.isEmptyStatement = isEmptyStatement;
     generated$3.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
     generated$3.isEnumBody = isEnumBody;
     generated$3.isEnumBooleanBody = isEnumBooleanBody;
     generated$3.isEnumBooleanMember = isEnumBooleanMember;
     generated$3.isEnumDeclaration = isEnumDeclaration;
     generated$3.isEnumDefaultedMember = isEnumDefaultedMember;
     generated$3.isEnumMember = isEnumMember;
     generated$3.isEnumNumberBody = isEnumNumberBody;
     generated$3.isEnumNumberMember = isEnumNumberMember;
     generated$3.isEnumStringBody = isEnumStringBody;
     generated$3.isEnumStringMember = isEnumStringMember;
     generated$3.isEnumSymbolBody = isEnumSymbolBody;
     generated$3.isExistsTypeAnnotation = isExistsTypeAnnotation;
     generated$3.isExportAllDeclaration = isExportAllDeclaration;
     generated$3.isExportDeclaration = isExportDeclaration;
     generated$3.isExportDefaultDeclaration = isExportDefaultDeclaration;
     generated$3.isExportDefaultSpecifier = isExportDefaultSpecifier;
     generated$3.isExportNamedDeclaration = isExportNamedDeclaration;
     generated$3.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
     generated$3.isExportSpecifier = isExportSpecifier;
     generated$3.isExpression = isExpression;
     generated$3.isExpressionStatement = isExpressionStatement;
     generated$3.isExpressionWrapper = isExpressionWrapper;
     generated$3.isFile = isFile;
     generated$3.isFlow = isFlow;
     generated$3.isFlowBaseAnnotation = isFlowBaseAnnotation;
     generated$3.isFlowDeclaration = isFlowDeclaration;
     generated$3.isFlowPredicate = isFlowPredicate;
     generated$3.isFlowType = isFlowType;
     generated$3.isFor = isFor;
     generated$3.isForInStatement = isForInStatement;
     generated$3.isForOfStatement = isForOfStatement;
     generated$3.isForStatement = isForStatement;
     generated$3.isForXStatement = isForXStatement;
     generated$3.isFunction = isFunction;
     generated$3.isFunctionDeclaration = isFunctionDeclaration;
     generated$3.isFunctionExpression = isFunctionExpression;
     generated$3.isFunctionParent = isFunctionParent;
     generated$3.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
     generated$3.isFunctionTypeParam = isFunctionTypeParam;
     generated$3.isGenericTypeAnnotation = isGenericTypeAnnotation;
     generated$3.isIdentifier = isIdentifier;
     generated$3.isIfStatement = isIfStatement;
     generated$3.isImmutable = isImmutable;
     generated$3.isImport = isImport;
     generated$3.isImportAttribute = isImportAttribute;
     generated$3.isImportDeclaration = isImportDeclaration;
     generated$3.isImportDefaultSpecifier = isImportDefaultSpecifier;
     generated$3.isImportExpression = isImportExpression;
     generated$3.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
     generated$3.isImportOrExportDeclaration = isImportOrExportDeclaration;
     generated$3.isImportSpecifier = isImportSpecifier;
     generated$3.isIndexedAccessType = isIndexedAccessType;
     generated$3.isInferredPredicate = isInferredPredicate;
     generated$3.isInterfaceDeclaration = isInterfaceDeclaration;
     generated$3.isInterfaceExtends = isInterfaceExtends;
     generated$3.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
     generated$3.isInterpreterDirective = isInterpreterDirective;
     generated$3.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
     generated$3.isJSX = isJSX;
     generated$3.isJSXAttribute = isJSXAttribute;
     generated$3.isJSXClosingElement = isJSXClosingElement;
     generated$3.isJSXClosingFragment = isJSXClosingFragment;
     generated$3.isJSXElement = isJSXElement;
     generated$3.isJSXEmptyExpression = isJSXEmptyExpression;
     generated$3.isJSXExpressionContainer = isJSXExpressionContainer;
     generated$3.isJSXFragment = isJSXFragment;
     generated$3.isJSXIdentifier = isJSXIdentifier;
     generated$3.isJSXMemberExpression = isJSXMemberExpression;
     generated$3.isJSXNamespacedName = isJSXNamespacedName;
     generated$3.isJSXOpeningElement = isJSXOpeningElement;
     generated$3.isJSXOpeningFragment = isJSXOpeningFragment;
     generated$3.isJSXSpreadAttribute = isJSXSpreadAttribute;
     generated$3.isJSXSpreadChild = isJSXSpreadChild;
     generated$3.isJSXText = isJSXText;
     generated$3.isLVal = isLVal;
     generated$3.isLabeledStatement = isLabeledStatement;
     generated$3.isLiteral = isLiteral;
     generated$3.isLogicalExpression = isLogicalExpression;
     generated$3.isLoop = isLoop;
     generated$3.isMemberExpression = isMemberExpression;
     generated$3.isMetaProperty = isMetaProperty;
     generated$3.isMethod = isMethod;
     generated$3.isMiscellaneous = isMiscellaneous;
     generated$3.isMixedTypeAnnotation = isMixedTypeAnnotation;
     generated$3.isModuleDeclaration = isModuleDeclaration;
     generated$3.isModuleExpression = isModuleExpression;
     generated$3.isModuleSpecifier = isModuleSpecifier;
     generated$3.isNewExpression = isNewExpression;
     generated$3.isNoop = isNoop;
     generated$3.isNullLiteral = isNullLiteral;
     generated$3.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
     generated$3.isNullableTypeAnnotation = isNullableTypeAnnotation;
     generated$3.isNumberLiteral = isNumberLiteral;
     generated$3.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
     generated$3.isNumberTypeAnnotation = isNumberTypeAnnotation;
     generated$3.isNumericLiteral = isNumericLiteral;
     generated$3.isObjectExpression = isObjectExpression;
     generated$3.isObjectMember = isObjectMember;
     generated$3.isObjectMethod = isObjectMethod;
     generated$3.isObjectPattern = isObjectPattern;
     generated$3.isObjectProperty = isObjectProperty;
     generated$3.isObjectTypeAnnotation = isObjectTypeAnnotation;
     generated$3.isObjectTypeCallProperty = isObjectTypeCallProperty;
     generated$3.isObjectTypeIndexer = isObjectTypeIndexer;
     generated$3.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
     generated$3.isObjectTypeProperty = isObjectTypeProperty;
     generated$3.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
     generated$3.isOpaqueType = isOpaqueType;
     generated$3.isOptionalCallExpression = isOptionalCallExpression;
     generated$3.isOptionalIndexedAccessType = isOptionalIndexedAccessType;
     generated$3.isOptionalMemberExpression = isOptionalMemberExpression;
     generated$3.isParenthesizedExpression = isParenthesizedExpression;
     generated$3.isPattern = isPattern;
     generated$3.isPatternLike = isPatternLike;
     generated$3.isPipelineBareFunction = isPipelineBareFunction;
     generated$3.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
     generated$3.isPipelineTopicExpression = isPipelineTopicExpression;
     generated$3.isPlaceholder = isPlaceholder;
     generated$3.isPrivate = isPrivate;
     generated$3.isPrivateName = isPrivateName;
     generated$3.isProgram = isProgram;
     generated$3.isProperty = isProperty;
     generated$3.isPureish = isPureish;
     generated$3.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
     generated$3.isRecordExpression = isRecordExpression;
     generated$3.isRegExpLiteral = isRegExpLiteral;
     generated$3.isRegexLiteral = isRegexLiteral;
     generated$3.isRestElement = isRestElement;
     generated$3.isRestProperty = isRestProperty;
     generated$3.isReturnStatement = isReturnStatement;
     generated$3.isScopable = isScopable;
     generated$3.isSequenceExpression = isSequenceExpression;
     generated$3.isSpreadElement = isSpreadElement;
     generated$3.isSpreadProperty = isSpreadProperty;
     generated$3.isStandardized = isStandardized;
     generated$3.isStatement = isStatement;
     generated$3.isStaticBlock = isStaticBlock;
     generated$3.isStringLiteral = isStringLiteral;
     generated$3.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
     generated$3.isStringTypeAnnotation = isStringTypeAnnotation;
     generated$3.isSuper = isSuper;
     generated$3.isSwitchCase = isSwitchCase;
     generated$3.isSwitchStatement = isSwitchStatement;
     generated$3.isSymbolTypeAnnotation = isSymbolTypeAnnotation;
     generated$3.isTSAnyKeyword = isTSAnyKeyword;
     generated$3.isTSArrayType = isTSArrayType;
     generated$3.isTSAsExpression = isTSAsExpression;
     generated$3.isTSBaseType = isTSBaseType;
     generated$3.isTSBigIntKeyword = isTSBigIntKeyword;
     generated$3.isTSBooleanKeyword = isTSBooleanKeyword;
     generated$3.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
     generated$3.isTSConditionalType = isTSConditionalType;
     generated$3.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
     generated$3.isTSConstructorType = isTSConstructorType;
     generated$3.isTSDeclareFunction = isTSDeclareFunction;
     generated$3.isTSDeclareMethod = isTSDeclareMethod;
     generated$3.isTSEntityName = isTSEntityName;
     generated$3.isTSEnumDeclaration = isTSEnumDeclaration;
     generated$3.isTSEnumMember = isTSEnumMember;
     generated$3.isTSExportAssignment = isTSExportAssignment;
     generated$3.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
     generated$3.isTSExternalModuleReference = isTSExternalModuleReference;
     generated$3.isTSFunctionType = isTSFunctionType;
     generated$3.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
     generated$3.isTSImportType = isTSImportType;
     generated$3.isTSIndexSignature = isTSIndexSignature;
     generated$3.isTSIndexedAccessType = isTSIndexedAccessType;
     generated$3.isTSInferType = isTSInferType;
     generated$3.isTSInstantiationExpression = isTSInstantiationExpression;
     generated$3.isTSInterfaceBody = isTSInterfaceBody;
     generated$3.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
     generated$3.isTSIntersectionType = isTSIntersectionType;
     generated$3.isTSIntrinsicKeyword = isTSIntrinsicKeyword;
     generated$3.isTSLiteralType = isTSLiteralType;
     generated$3.isTSMappedType = isTSMappedType;
     generated$3.isTSMethodSignature = isTSMethodSignature;
     generated$3.isTSModuleBlock = isTSModuleBlock;
     generated$3.isTSModuleDeclaration = isTSModuleDeclaration;
     generated$3.isTSNamedTupleMember = isTSNamedTupleMember;
     generated$3.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
     generated$3.isTSNeverKeyword = isTSNeverKeyword;
     generated$3.isTSNonNullExpression = isTSNonNullExpression;
     generated$3.isTSNullKeyword = isTSNullKeyword;
     generated$3.isTSNumberKeyword = isTSNumberKeyword;
     generated$3.isTSObjectKeyword = isTSObjectKeyword;
     generated$3.isTSOptionalType = isTSOptionalType;
     generated$3.isTSParameterProperty = isTSParameterProperty;
     generated$3.isTSParenthesizedType = isTSParenthesizedType;
     generated$3.isTSPropertySignature = isTSPropertySignature;
     generated$3.isTSQualifiedName = isTSQualifiedName;
     generated$3.isTSRestType = isTSRestType;
     generated$3.isTSSatisfiesExpression = isTSSatisfiesExpression;
     generated$3.isTSStringKeyword = isTSStringKeyword;
     generated$3.isTSSymbolKeyword = isTSSymbolKeyword;
     generated$3.isTSThisType = isTSThisType;
     generated$3.isTSTupleType = isTSTupleType;
     generated$3.isTSType = isTSType;
     generated$3.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
     generated$3.isTSTypeAnnotation = isTSTypeAnnotation;
     generated$3.isTSTypeAssertion = isTSTypeAssertion;
     generated$3.isTSTypeElement = isTSTypeElement;
     generated$3.isTSTypeLiteral = isTSTypeLiteral;
     generated$3.isTSTypeOperator = isTSTypeOperator;
     generated$3.isTSTypeParameter = isTSTypeParameter;
     generated$3.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
     generated$3.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
     generated$3.isTSTypePredicate = isTSTypePredicate;
     generated$3.isTSTypeQuery = isTSTypeQuery;
     generated$3.isTSTypeReference = isTSTypeReference;
     generated$3.isTSUndefinedKeyword = isTSUndefinedKeyword;
     generated$3.isTSUnionType = isTSUnionType;
     generated$3.isTSUnknownKeyword = isTSUnknownKeyword;
     generated$3.isTSVoidKeyword = isTSVoidKeyword;
     generated$3.isTaggedTemplateExpression = isTaggedTemplateExpression;
     generated$3.isTemplateElement = isTemplateElement;
     generated$3.isTemplateLiteral = isTemplateLiteral;
     generated$3.isTerminatorless = isTerminatorless;
     generated$3.isThisExpression = isThisExpression;
     generated$3.isThisTypeAnnotation = isThisTypeAnnotation;
     generated$3.isThrowStatement = isThrowStatement;
     generated$3.isTopicReference = isTopicReference;
     generated$3.isTryStatement = isTryStatement;
     generated$3.isTupleExpression = isTupleExpression;
     generated$3.isTupleTypeAnnotation = isTupleTypeAnnotation;
     generated$3.isTypeAlias = isTypeAlias;
     generated$3.isTypeAnnotation = isTypeAnnotation;
     generated$3.isTypeCastExpression = isTypeCastExpression;
     generated$3.isTypeParameter = isTypeParameter;
     generated$3.isTypeParameterDeclaration = isTypeParameterDeclaration;
     generated$3.isTypeParameterInstantiation = isTypeParameterInstantiation;
     generated$3.isTypeScript = isTypeScript;
     generated$3.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
     generated$3.isUnaryExpression = isUnaryExpression;
     generated$3.isUnaryLike = isUnaryLike;
     generated$3.isUnionTypeAnnotation = isUnionTypeAnnotation;
     generated$3.isUpdateExpression = isUpdateExpression;
     generated$3.isUserWhitespacable = isUserWhitespacable;
     generated$3.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier;
     generated$3.isVariableDeclaration = isVariableDeclaration;
     generated$3.isVariableDeclarator = isVariableDeclarator;
     generated$3.isVariance = isVariance;
     generated$3.isVoidTypeAnnotation = isVoidTypeAnnotation;
     generated$3.isWhile = isWhile;
     generated$3.isWhileStatement = isWhileStatement;
     generated$3.isWithStatement = isWithStatement;
     generated$3.isYieldExpression = isYieldExpression;
     var _shallowEqual = requireShallowEqual();
     var _deprecationWarning = requireDeprecationWarning();
     function isArrayExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ArrayExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isAssignmentExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "AssignmentExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBinaryExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "BinaryExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isInterpreterDirective(node, opts) {
       if (!node) return false;
       if (node.type !== "InterpreterDirective") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDirective(node, opts) {
       if (!node) return false;
       if (node.type !== "Directive") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDirectiveLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "DirectiveLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBlockStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "BlockStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBreakStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "BreakStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isCallExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "CallExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isCatchClause(node, opts) {
       if (!node) return false;
       if (node.type !== "CatchClause") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isConditionalExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ConditionalExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isContinueStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "ContinueStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDebuggerStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "DebuggerStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDoWhileStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "DoWhileStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEmptyStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "EmptyStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExpressionStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "ExpressionStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isFile(node, opts) {
       if (!node) return false;
       if (node.type !== "File") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isForInStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "ForInStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isForStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "ForStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isFunctionDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "FunctionDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isFunctionExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "FunctionExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isIdentifier(node, opts) {
       if (!node) return false;
       if (node.type !== "Identifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isIfStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "IfStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isLabeledStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "LabeledStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isStringLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "StringLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNumericLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "NumericLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNullLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "NullLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBooleanLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "BooleanLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isRegExpLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "RegExpLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isLogicalExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "LogicalExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isMemberExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "MemberExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNewExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "NewExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isProgram(node, opts) {
       if (!node) return false;
       if (node.type !== "Program") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectMethod(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectMethod") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isRestElement(node, opts) {
       if (!node) return false;
       if (node.type !== "RestElement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isReturnStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "ReturnStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isSequenceExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "SequenceExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isParenthesizedExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ParenthesizedExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isSwitchCase(node, opts) {
       if (!node) return false;
       if (node.type !== "SwitchCase") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isSwitchStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "SwitchStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isThisExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ThisExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isThrowStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "ThrowStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTryStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "TryStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isUnaryExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "UnaryExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isUpdateExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "UpdateExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isVariableDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "VariableDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isVariableDeclarator(node, opts) {
       if (!node) return false;
       if (node.type !== "VariableDeclarator") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isWhileStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "WhileStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isWithStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "WithStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isAssignmentPattern(node, opts) {
       if (!node) return false;
       if (node.type !== "AssignmentPattern") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isArrayPattern(node, opts) {
       if (!node) return false;
       if (node.type !== "ArrayPattern") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isArrowFunctionExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ArrowFunctionExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassBody(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassBody") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExportAllDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "ExportAllDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExportDefaultDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "ExportDefaultDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExportNamedDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "ExportNamedDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExportSpecifier(node, opts) {
       if (!node) return false;
       if (node.type !== "ExportSpecifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isForOfStatement(node, opts) {
       if (!node) return false;
       if (node.type !== "ForOfStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isImportDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "ImportDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isImportDefaultSpecifier(node, opts) {
       if (!node) return false;
       if (node.type !== "ImportDefaultSpecifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isImportNamespaceSpecifier(node, opts) {
       if (!node) return false;
       if (node.type !== "ImportNamespaceSpecifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isImportSpecifier(node, opts) {
       if (!node) return false;
       if (node.type !== "ImportSpecifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isImportExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ImportExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isMetaProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "MetaProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassMethod(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassMethod") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectPattern(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectPattern") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isSpreadElement(node, opts) {
       if (!node) return false;
       if (node.type !== "SpreadElement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isSuper(node, opts) {
       if (!node) return false;
       if (node.type !== "Super") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTaggedTemplateExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "TaggedTemplateExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTemplateElement(node, opts) {
       if (!node) return false;
       if (node.type !== "TemplateElement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTemplateLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "TemplateLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isYieldExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "YieldExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isAwaitExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "AwaitExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isImport(node, opts) {
       if (!node) return false;
       if (node.type !== "Import") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBigIntLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "BigIntLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExportNamespaceSpecifier(node, opts) {
       if (!node) return false;
       if (node.type !== "ExportNamespaceSpecifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isOptionalMemberExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "OptionalMemberExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isOptionalCallExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "OptionalCallExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassAccessorProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassAccessorProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassPrivateProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassPrivateProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassPrivateMethod(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassPrivateMethod") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isPrivateName(node, opts) {
       if (!node) return false;
       if (node.type !== "PrivateName") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isStaticBlock(node, opts) {
       if (!node) return false;
       if (node.type !== "StaticBlock") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isAnyTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "AnyTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isArrayTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "ArrayTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBooleanTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "BooleanTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBooleanLiteralTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "BooleanLiteralTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNullLiteralTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "NullLiteralTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isClassImplements(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassImplements") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareClass(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareClass") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareFunction(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareFunction") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareInterface(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareInterface") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareModule(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareModule") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareModuleExports(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareModuleExports") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareTypeAlias(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareTypeAlias") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareOpaqueType(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareOpaqueType") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareVariable(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareVariable") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareExportDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareExportDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclareExportAllDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclareExportAllDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDeclaredPredicate(node, opts) {
       if (!node) return false;
       if (node.type !== "DeclaredPredicate") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExistsTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "ExistsTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isFunctionTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "FunctionTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isFunctionTypeParam(node, opts) {
       if (!node) return false;
       if (node.type !== "FunctionTypeParam") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isGenericTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "GenericTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isInferredPredicate(node, opts) {
       if (!node) return false;
       if (node.type !== "InferredPredicate") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isInterfaceExtends(node, opts) {
       if (!node) return false;
       if (node.type !== "InterfaceExtends") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isInterfaceDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "InterfaceDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isInterfaceTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "InterfaceTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isIntersectionTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "IntersectionTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isMixedTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "MixedTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEmptyTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "EmptyTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNullableTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "NullableTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNumberLiteralTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "NumberLiteralTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNumberTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "NumberTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectTypeInternalSlot(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectTypeInternalSlot") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectTypeCallProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectTypeCallProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectTypeIndexer(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectTypeIndexer") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectTypeProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectTypeProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isObjectTypeSpreadProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "ObjectTypeSpreadProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isOpaqueType(node, opts) {
       if (!node) return false;
       if (node.type !== "OpaqueType") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isQualifiedTypeIdentifier(node, opts) {
       if (!node) return false;
       if (node.type !== "QualifiedTypeIdentifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isStringLiteralTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "StringLiteralTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isStringTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "StringTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isSymbolTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "SymbolTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isThisTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "ThisTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTupleTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "TupleTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTypeofTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "TypeofTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTypeAlias(node, opts) {
       if (!node) return false;
       if (node.type !== "TypeAlias") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "TypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTypeCastExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "TypeCastExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTypeParameter(node, opts) {
       if (!node) return false;
       if (node.type !== "TypeParameter") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTypeParameterDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "TypeParameterDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTypeParameterInstantiation(node, opts) {
       if (!node) return false;
       if (node.type !== "TypeParameterInstantiation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isUnionTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "UnionTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isVariance(node, opts) {
       if (!node) return false;
       if (node.type !== "Variance") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isVoidTypeAnnotation(node, opts) {
       if (!node) return false;
       if (node.type !== "VoidTypeAnnotation") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumBooleanBody(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumBooleanBody") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumNumberBody(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumNumberBody") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumStringBody(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumStringBody") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumSymbolBody(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumSymbolBody") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumBooleanMember(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumBooleanMember") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumNumberMember(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumNumberMember") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumStringMember(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumStringMember") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isEnumDefaultedMember(node, opts) {
       if (!node) return false;
       if (node.type !== "EnumDefaultedMember") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isIndexedAccessType(node, opts) {
       if (!node) return false;
       if (node.type !== "IndexedAccessType") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isOptionalIndexedAccessType(node, opts) {
       if (!node) return false;
       if (node.type !== "OptionalIndexedAccessType") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXAttribute(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXAttribute") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXClosingElement(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXClosingElement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXElement(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXElement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXEmptyExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXEmptyExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXExpressionContainer(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXExpressionContainer") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXSpreadChild(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXSpreadChild") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXIdentifier(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXIdentifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXMemberExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXMemberExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXNamespacedName(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXNamespacedName") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXOpeningElement(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXOpeningElement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXSpreadAttribute(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXSpreadAttribute") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXText(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXText") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXFragment(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXFragment") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXOpeningFragment(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXOpeningFragment") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isJSXClosingFragment(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXClosingFragment") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isNoop(node, opts) {
       if (!node) return false;
       if (node.type !== "Noop") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isPlaceholder(node, opts) {
       if (!node) return false;
       if (node.type !== "Placeholder") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isV8IntrinsicIdentifier(node, opts) {
       if (!node) return false;
       if (node.type !== "V8IntrinsicIdentifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isArgumentPlaceholder(node, opts) {
       if (!node) return false;
       if (node.type !== "ArgumentPlaceholder") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isBindExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "BindExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isImportAttribute(node, opts) {
       if (!node) return false;
       if (node.type !== "ImportAttribute") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDecorator(node, opts) {
       if (!node) return false;
       if (node.type !== "Decorator") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDoExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "DoExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isExportDefaultSpecifier(node, opts) {
       if (!node) return false;
       if (node.type !== "ExportDefaultSpecifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isRecordExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "RecordExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTupleExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "TupleExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isDecimalLiteral(node, opts) {
       if (!node) return false;
       if (node.type !== "DecimalLiteral") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isModuleExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "ModuleExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTopicReference(node, opts) {
       if (!node) return false;
       if (node.type !== "TopicReference") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isPipelineTopicExpression(node, opts) {
       if (!node) return false;
       if (node.type !== "PipelineTopicExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isPipelineBareFunction(node, opts) {
       if (!node) return false;
       if (node.type !== "PipelineBareFunction") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isPipelinePrimaryTopicReference(node, opts) {
       if (!node) return false;
       if (node.type !== "PipelinePrimaryTopicReference") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSParameterProperty(node, opts) {
       if (!node) return false;
       if (node.type !== "TSParameterProperty") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSDeclareFunction(node, opts) {
       if (!node) return false;
       if (node.type !== "TSDeclareFunction") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSDeclareMethod(node, opts) {
       if (!node) return false;
       if (node.type !== "TSDeclareMethod") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSQualifiedName(node, opts) {
       if (!node) return false;
       if (node.type !== "TSQualifiedName") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSCallSignatureDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "TSCallSignatureDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSConstructSignatureDeclaration(node, opts) {
       if (!node) return false;
       if (node.type !== "TSConstructSignatureDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSPropertySignature(node, opts) {
       if (!node) return false;
       if (node.type !== "TSPropertySignature") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSMethodSignature(node, opts) {
       if (!node) return false;
       if (node.type !== "TSMethodSignature") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSIndexSignature(node, opts) {
       if (!node) return false;
       if (node.type !== "TSIndexSignature") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSAnyKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSAnyKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSBooleanKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSBooleanKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSBigIntKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSBigIntKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSIntrinsicKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSIntrinsicKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSNeverKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSNeverKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSNullKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSNullKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSNumberKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSNumberKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSObjectKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSObjectKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSStringKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSStringKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSSymbolKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSSymbolKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSUndefinedKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSUndefinedKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
     function isTSUnknownKeyword(node, opts) {
       if (!node) return false;
       if (node.type !== "TSUnknownKeyword") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
--> --------------------

--> maximum size reached

--> --------------------

quality90%

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.31Bemerkung: (vorverarbeitet) ¤

*Bot Zugriff

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.