19907815758

Committed 03 Dec 2025 08:27PM UTC coverage: 97.319%. Remained the same

Build # 19907815758

Build Type

push

github

Committed by

sanex3339

Commit Message

Adjust precommit hook

Run Details

1770 of 1891 branches covered (93.6%)

Branch coverage included in aggregate %.

5671 of 5755 relevant lines covered (98.54%)

34102965.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.38

/src/node/NodeGuards.ts

/* eslint-disable max-lines */
import * as ESTree from 'estree';

import { TNodeWithLexicalScope } from '../types/node/TNodeWithLexicalScope';
import { TNodeWithLexicalScopeStatements } from '../types/node/TNodeWithLexicalScopeStatements';
import { TNodeWithSingleStatementBody } from '../types/node/TNodeWithSingleStatementBody';
import { TNodeWithStatements } from '../types/node/TNodeWithStatements';

import { NodeType } from '../enums/node/NodeType';

export class NodeGuards {
    /**
     * @type {string[]}
     */
    private static readonly nodesWithLexicalStatements: string[] = [
        NodeType.ArrowFunctionExpression,
        NodeType.FunctionDeclaration,
        NodeType.FunctionExpression,
        NodeType.MethodDefinition
    ];

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isArrayPatternNode(node: ESTree.Node): node is ESTree.ArrayPattern {
        return node.type === NodeType.ArrayPattern;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isArrowFunctionExpressionNode(node: ESTree.Node): node is ESTree.ArrowFunctionExpression {
        return node.type === NodeType.ArrowFunctionExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isAssignmentExpressionNode(node: ESTree.Node): node is ESTree.AssignmentExpression {
        return node.type === NodeType.AssignmentExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isAssignmentPatternNode(node: ESTree.Node): node is ESTree.AssignmentPattern {
        return node.type === NodeType.AssignmentPattern;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isAwaitExpressionNode(node: ESTree.Node): node is ESTree.AwaitExpression {
        return node.type === NodeType.AwaitExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isBigIntLiteralNode(node: ESTree.Node): node is ESTree.BigIntLiteral {
        return NodeGuards.isLiteralNode(node) && !!(<ESTree.BigIntLiteral>node).bigint;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isBlockStatementNode(node: ESTree.Node): node is ESTree.BlockStatement {
        return node.type === NodeType.BlockStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isBreakStatementNode(node: ESTree.Node): node is ESTree.BreakStatement {
        return node.type === NodeType.BreakStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isCallExpressionNode(node: ESTree.Node): node is ESTree.CallExpression {
        return node.type === NodeType.CallExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isChainExpressionNode(node: ESTree.Node): node is ESTree.ChainExpression {
        return node.type === NodeType.ChainExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isClassBodyNode(node: ESTree.Node): node is ESTree.ClassBody {
        return node.type === NodeType.ClassBody;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isClassDeclarationNode(
        node: ESTree.Node
    ): node is ESTree.ClassDeclaration & { id: ESTree.Identifier } {
        return node.type === NodeType.ClassDeclaration && node.id !== null;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isConditionalExpressionNode(node: ESTree.Node): node is ESTree.ConditionalExpression {
        return node.type === NodeType.ConditionalExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isContinueStatementNode(node: ESTree.Node): node is ESTree.ContinueStatement {
        return node.type === NodeType.ContinueStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isDirectiveNode(node: ESTree.Node): node is ESTree.Directive {
        return node.type === NodeType.ExpressionStatement && 'directive' in node;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isDoWhileStatementNode(node: ESTree.Node): node is ESTree.DoWhileStatement {
        return node.type === NodeType.DoWhileStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isExportAllDeclarationNode(node: ESTree.Node): node is ESTree.ExportAllDeclaration {
        return node.type === NodeType.ExportAllDeclaration;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isExportNamedDeclarationNode(node: ESTree.Node): node is ESTree.ExportNamedDeclaration {
        return node.type === NodeType.ExportNamedDeclaration;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isExportSpecifierNode(node: ESTree.Node): node is ESTree.ExportSpecifier {
        return node.type === NodeType.ExportSpecifier;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isExpressionStatementNode(node: ESTree.Node): node is ESTree.ExpressionStatement {
        return node.type === NodeType.ExpressionStatement && !('directive' in node);
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isForStatementNode(node: ESTree.Node): node is ESTree.ForStatement {
        return node.type === NodeType.ForStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isForInStatementNode(node: ESTree.Node): node is ESTree.ForInStatement {
        return node.type === NodeType.ForInStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isForOfStatementNode(node: ESTree.Node): node is ESTree.ForOfStatement {
        return node.type === NodeType.ForOfStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isFunctionNode(node: ESTree.Node): node is ESTree.Function {
        return (
            NodeGuards.isFunctionDeclarationNode(node) ||
            NodeGuards.isFunctionExpressionNode(node) ||
            NodeGuards.isArrowFunctionExpressionNode(node)
        );
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isFunctionDeclarationNode(
        node: ESTree.Node
    ): node is ESTree.FunctionDeclaration & { id: ESTree.Identifier } {
        return node.type === NodeType.FunctionDeclaration && node.id !== null;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isFunctionExpressionNode(node: ESTree.Node): node is ESTree.FunctionExpression {
        return node.type === NodeType.FunctionExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isIdentifierNode(node: ESTree.Node): node is ESTree.Identifier {
        return node.type === NodeType.Identifier;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isIfStatementNode(node: ESTree.Node): node is ESTree.IfStatement {
        return node.type === NodeType.IfStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isIfStatementNodeWithSingleStatementBody(node: ESTree.Node): node is ESTree.IfStatement {
        if (!NodeGuards.isIfStatementNode(node)) {
            return false;
        }

        return (
            !NodeGuards.isBlockStatementNode(node.consequent) ||
            (!!node.alternate && !NodeGuards.isBlockStatementNode(node.alternate))
        );
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isImportDeclarationNode(node: ESTree.Node): node is ESTree.ImportDeclaration {
        return node.type === NodeType.ImportDeclaration;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isImportExpressionNode(node: ESTree.Node): node is ESTree.ImportExpression {
        return node.type === NodeType.ImportExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isImportSpecifierNode(node: ESTree.Node): node is ESTree.ImportSpecifier {
        return node.type === NodeType.ImportSpecifier;
    }

    /**
     * @param {Node} node
     * @param {Node} parentNode
     * @returns {boolean}
     */
    public static isLabelIdentifierNode(node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
        const parentNodeIsLabeledStatementNode: boolean =
            NodeGuards.isLabeledStatementNode(parentNode) && parentNode.label === node;
        const parentNodeIsContinueStatementNode: boolean =
            NodeGuards.isContinueStatementNode(parentNode) && parentNode.label === node;
        const parentNodeIsBreakStatementNode: boolean =
            NodeGuards.isBreakStatementNode(parentNode) && parentNode.label === node;

        return parentNodeIsLabeledStatementNode || parentNodeIsContinueStatementNode || parentNodeIsBreakStatementNode;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isLabeledStatementNode(node: ESTree.Node): node is ESTree.LabeledStatement {
        return node.type === NodeType.LabeledStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isLiteralNode(node: ESTree.Node): node is ESTree.Literal {
        return node.type === NodeType.Literal;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isLogicalExpressionNode(node: ESTree.Node): node is ESTree.LogicalExpression {
        return node.type === NodeType.LogicalExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isMemberExpressionNode(node: ESTree.Node): node is ESTree.MemberExpression {
        return node.type === NodeType.MemberExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isMetaPropertyNode(node: ESTree.Node): node is ESTree.MetaProperty {
        return node.type === NodeType.MetaProperty;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isMethodDefinitionNode(node: ESTree.Node): node is ESTree.MethodDefinition {
        return node.type === NodeType.MethodDefinition;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isNewExpressionNode(node: ESTree.Node): node is ESTree.NewExpression {
        return node.type === NodeType.NewExpression;
    }

    /**
     * @param {Object} object
     * @returns {boolean}
     */
    // eslint-disable-next-line @typescript-eslint/ban-types
    public static isNode(object: Object & { type?: string }): object is ESTree.Node {
        return object && !object.type !== undefined;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isNodeWithLexicalScope(node: ESTree.Node): node is TNodeWithLexicalScope {
        return NodeGuards.isProgramNode(node) || NodeGuards.isFunctionNode(node);
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isNodeWithBlockLexicalScope(node: ESTree.Node): node is TNodeWithLexicalScope {
        return (
            NodeGuards.isNodeWithLexicalScope(node) ||
            NodeGuards.isBlockStatementNode(node) ||
            NodeGuards.isStaticBlockNode(node)
        );
    }

    /**
     * Checks if a node is the node with single statement body, like:
     * while (true)
     *     console.log(1);
     *
     * or:
     *
     *
     * @param {Node} node
     * @returns {boolean}
     */
    public static isNodeWithSingleStatementBody(node: ESTree.Node): node is TNodeWithSingleStatementBody {
        // Different approach for `IfStatement` node because this node hasn't `body` property
        if (NodeGuards.isIfStatementNode(node)) {
            return NodeGuards.isIfStatementNodeWithSingleStatementBody(node);
        }

        // All other nodes with `Statement` node as `body` property
        return (
            (NodeGuards.isForStatementNode(node) ||
                NodeGuards.isForOfStatementNode(node) ||
                NodeGuards.isForInStatementNode(node) ||
                NodeGuards.isWhileStatementNode(node) ||
                NodeGuards.isDoWhileStatementNode(node) ||
                NodeGuards.isWithStatementNode(node) ||
                NodeGuards.isLabeledStatementNode(node)) &&
            !NodeGuards.isBlockStatementNode(node.body)
        );
    }

    /**
     * @param {Node} node
     * @param {Node} parentNode
     * @returns {boolean}
     */
    public static isNodeWithLexicalScopeStatements(
        node: ESTree.Node,
        parentNode: ESTree.Node
    ): node is TNodeWithLexicalScopeStatements {
        return (
            NodeGuards.isProgramNode(node) ||
            (NodeGuards.isBlockStatementNode(node) && NodeGuards.nodesWithLexicalStatements.includes(parentNode.type))
        );
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isNodeWithStatements(node: ESTree.Node): node is TNodeWithStatements {
        return (
            NodeGuards.isProgramNode(node) ||
            NodeGuards.isBlockStatementNode(node) ||
            NodeGuards.isStaticBlockNode(node) ||
            NodeGuards.isSwitchCaseNode(node)
        );
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isNodeWithComments(node: ESTree.Node): node is ESTree.Node {
        return Boolean(node.leadingComments) || Boolean(node.trailingComments);
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isObjectPatternNode(node: ESTree.Node): node is ESTree.ObjectPattern {
        return node.type === NodeType.ObjectPattern;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isObjectExpressionNode(node: ESTree.Node): node is ESTree.ObjectExpression {
        return node.type === NodeType.ObjectExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isPrivateIdentifierNode(node: ESTree.Node): node is ESTree.PrivateIdentifier {
        return node.type === NodeType.PrivateIdentifier;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isProgramNode(node: ESTree.Node): node is ESTree.Program {
        return node.type === NodeType.Program;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isPropertyNode(node: ESTree.Node): node is ESTree.Property {
        return node.type === NodeType.Property;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isPropertyDefinitionNode(node: ESTree.Node): node is ESTree.PropertyDefinition {
        return node.type === NodeType.PropertyDefinition;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isRestElementNode(node: ESTree.Node): node is ESTree.RestElement {
        return node.type === NodeType.RestElement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isReturnStatementNode(node: ESTree.Node): node is ESTree.ReturnStatement {
        return node.type === NodeType.ReturnStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isSequenceExpressionNode(node: ESTree.Node): node is ESTree.SequenceExpression {
        return node.type === NodeType.SequenceExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isSpreadElementNode(node: ESTree.Node): node is ESTree.SpreadElement {
        return node.type === NodeType.SpreadElement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isStaticBlockNode(node: ESTree.Node): node is ESTree.StaticBlock {
        return node.type === NodeType.StaticBlock;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isSuperNode(node: ESTree.Node): node is ESTree.Super {
        return node.type === NodeType.Super;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isSwitchCaseNode(node: ESTree.Node): node is ESTree.SwitchCase {
        return node.type === NodeType.SwitchCase;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isTaggedTemplateExpressionNode(node: ESTree.Node): node is ESTree.TaggedTemplateExpression {
        return node.type === NodeType.TaggedTemplateExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isTemplateLiteralNode(node: ESTree.Node): node is ESTree.TemplateLiteral {
        return node.type === NodeType.TemplateLiteral;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isThisExpressionNode(node: ESTree.Node): node is ESTree.ThisExpression {
        return node.type === NodeType.ThisExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isUnaryExpressionNode(node: ESTree.Node): node is ESTree.UnaryExpression {
        return node.type === NodeType.UnaryExpression;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isVariableDeclarationNode(node: ESTree.Node): node is ESTree.VariableDeclaration {
        return node.type === NodeType.VariableDeclaration;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isVariableDeclaratorNode(node: ESTree.Node): node is ESTree.VariableDeclarator {
        return node.type === NodeType.VariableDeclarator;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isWithStatementNode(node: ESTree.Node): node is ESTree.WithStatement {
        return node.type === NodeType.WithStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isWhileStatementNode(node: ESTree.Node): node is ESTree.WhileStatement {
        return node.type === NodeType.WhileStatement;
    }

    /**
     * @param {Node} node
     * @returns {boolean}
     */
    public static isYieldExpressionNode(node: ESTree.Node): node is ESTree.YieldExpression {
        return node.type === NodeType.YieldExpression;
    }
}

1	/* eslint-disable max-lines */
2	import * as ESTree from 'estree';
3
4	import { TNodeWithLexicalScope } from '../types/node/TNodeWithLexicalScope';
5	import { TNodeWithLexicalScopeStatements } from '../types/node/TNodeWithLexicalScopeStatements';
6	import { TNodeWithSingleStatementBody } from '../types/node/TNodeWithSingleStatementBody';
7	import { TNodeWithStatements } from '../types/node/TNodeWithStatements';
8
9	import { NodeType } from '../enums/node/NodeType';	6✔
10
11	export class NodeGuards {	6✔
12	/**
13	* @type {string[]}
14	*/
15	private static readonly nodesWithLexicalStatements: string[] = [	6✔
16	NodeType.ArrowFunctionExpression,
17	NodeType.FunctionDeclaration,
18	NodeType.FunctionExpression,
19	NodeType.MethodDefinition
20	];
21
22	/**
23	* @param {Node} node
24	* @returns {boolean}
25	*/
26	public static isArrayPatternNode(node: ESTree.Node): node is ESTree.ArrayPattern {
27	return node.type === NodeType.ArrayPattern;	91,821✔
28	}
29
30	/**
31	* @param {Node} node
32	* @returns {boolean}
33	*/
34	public static isArrowFunctionExpressionNode(node: ESTree.Node): node is ESTree.ArrowFunctionExpression {
35	return node.type === NodeType.ArrowFunctionExpression;	371,190,920✔
36	}
37
38	/**
39	* @param {Node} node
40	* @returns {boolean}
41	*/
42	public static isAssignmentExpressionNode(node: ESTree.Node): node is ESTree.AssignmentExpression {
43	return node.type === NodeType.AssignmentExpression;	6,042✔
44	}
45
46	/**
47	* @param {Node} node
48	* @returns {boolean}
49	*/
50	public static isAssignmentPatternNode(node: ESTree.Node): node is ESTree.AssignmentPattern {
51	return node.type === NodeType.AssignmentPattern;	3,549,469✔
52	}
53
54	/**
55	* @param {Node} node
56	* @returns {boolean}
57	*/
58	public static isAwaitExpressionNode(node: ESTree.Node): node is ESTree.AwaitExpression {
59	return node.type === NodeType.AwaitExpression;	5,907,359✔
60	}
61
62	/**
63	* @param {Node} node
64	* @returns {boolean}
65	*/
66	public static isBigIntLiteralNode(node: ESTree.Node): node is ESTree.BigIntLiteral {
67	return NodeGuards.isLiteralNode(node) && !!(<ESTree.BigIntLiteral>node).bigint;	×
68	}
69
70	/**
71	* @param {Node} node
72	* @returns {boolean}
73	*/
74	public static isBlockStatementNode(node: ESTree.Node): node is ESTree.BlockStatement {
75	return node.type === NodeType.BlockStatement;	1,081,662,612✔
76	}
77
78	/**
79	* @param {Node} node
80	* @returns {boolean}
81	*/
82	public static isBreakStatementNode(node: ESTree.Node): node is ESTree.BreakStatement {
83	return node.type === NodeType.BreakStatement;	79,511,759✔
84	}
85
86	/**
87	* @param {Node} node
88	* @returns {boolean}
89	*/
90	public static isCallExpressionNode(node: ESTree.Node): node is ESTree.CallExpression {
91	return node.type === NodeType.CallExpression;	31,671,930✔
92	}
93
94	/**
95	* @param {Node} node
96	* @returns {boolean}
97	*/
98	public static isChainExpressionNode(node: ESTree.Node): node is ESTree.ChainExpression {
99	return node.type === NodeType.ChainExpression;	289,763✔
100	}
101
102	/**
103	* @param {Node} node
104	* @returns {boolean}
105	*/
106	public static isClassBodyNode(node: ESTree.Node): node is ESTree.ClassBody {
107	return node.type === NodeType.ClassBody;	×
108	}
109
110	/**
111	* @param {Node} node
112	* @returns {boolean}
113	*/
114	public static isClassDeclarationNode(
115	node: ESTree.Node
116	): node is ESTree.ClassDeclaration & { id: ESTree.Identifier } {
117	return node.type === NodeType.ClassDeclaration && node.id !== null;	77,058,952✔
118	}
119
120	/**
121	* @param {Node} node
122	* @returns {boolean}
123	*/
124	public static isConditionalExpressionNode(node: ESTree.Node): node is ESTree.ConditionalExpression {
125	return node.type === NodeType.ConditionalExpression;	×
126	}
127
128	/**
129	* @param {Node} node
130	* @returns {boolean}
131	*/
132	public static isContinueStatementNode(node: ESTree.Node): node is ESTree.ContinueStatement {
133	return node.type === NodeType.ContinueStatement;	79,494,731✔
134	}
135
136	/**
137	* @param {Node} node
138	* @returns {boolean}
139	*/
140	public static isDirectiveNode(node: ESTree.Node): node is ESTree.Directive {
141	return node.type === NodeType.ExpressionStatement && 'directive' in node;	17,088,002✔
142	}
143
144	/**
145	* @param {Node} node
146	* @returns {boolean}
147	*/
148	public static isDoWhileStatementNode(node: ESTree.Node): node is ESTree.DoWhileStatement {
149	return node.type === NodeType.DoWhileStatement;	64,709✔
150	}
151
152	/**
153	* @param {Node} node
154	* @returns {boolean}
155	*/
156	public static isExportAllDeclarationNode(node: ESTree.Node): node is ESTree.ExportAllDeclaration {
157	return node.type === NodeType.ExportAllDeclaration;	36,858,984✔
158	}
159
160	/**
161	* @param {Node} node
162	* @returns {boolean}
163	*/
164	public static isExportNamedDeclarationNode(node: ESTree.Node): node is ESTree.ExportNamedDeclaration {
165	return node.type === NodeType.ExportNamedDeclaration;	38,478,507✔
166	}
167
168	/**
169	* @param {Node} node
170	* @returns {boolean}
171	*/
172	public static isExportSpecifierNode(node: ESTree.Node): node is ESTree.ExportSpecifier {
173	return node.type === NodeType.ExportSpecifier;	34,792,232✔
174	}
175
176	/**
177	* @param {Node} node
178	* @returns {boolean}
179	*/
180	public static isExpressionStatementNode(node: ESTree.Node): node is ESTree.ExpressionStatement {
181	return node.type === NodeType.ExpressionStatement && !('directive' in node);	664,777,706✔
182	}
183
184	/**
185	* @param {Node} node
186	* @returns {boolean}
187	*/
188	public static isForStatementNode(node: ESTree.Node): node is ESTree.ForStatement {
189	return node.type === NodeType.ForStatement;	80,561✔
190	}
191
192	/**
193	* @param {Node} node
194	* @returns {boolean}
195	*/
196	public static isForInStatementNode(node: ESTree.Node): node is ESTree.ForInStatement {
197	return node.type === NodeType.ForInStatement;	65,393✔
198	}
199
200	/**
201	* @param {Node} node
202	* @returns {boolean}
203	*/
204	public static isForOfStatementNode(node: ESTree.Node): node is ESTree.ForOfStatement {
205	return node.type === NodeType.ForOfStatement;	5,969,272✔
206	}
207
208	/**
209	* @param {Node} node
210	* @returns {boolean}
211	*/
212	public static isFunctionNode(node: ESTree.Node): node is ESTree.Function {
213	return (	404,124,570✔
214	NodeGuards.isFunctionDeclarationNode(node) \|\|	1,163,118,825✔
215	NodeGuards.isFunctionExpressionNode(node) \|\|
216	NodeGuards.isArrowFunctionExpressionNode(node)
217	);
218	}
219
220	/**
221	* @param {Node} node
222	* @returns {boolean}
223	*/
224	public static isFunctionDeclarationNode(
225	node: ESTree.Node
226	): node is ESTree.FunctionDeclaration & { id: ESTree.Identifier } {
227	return node.type === NodeType.FunctionDeclaration && node.id !== null;	512,365,712✔
228	}
229
230	/**
231	* @param {Node} node
232	* @returns {boolean}
233	*/
234	public static isFunctionExpressionNode(node: ESTree.Node): node is ESTree.FunctionExpression {
235	return node.type === NodeType.FunctionExpression;	397,497,352✔
236	}
237
238	/**
239	* @param {Node} node
240	* @returns {boolean}
241	*/
242	public static isIdentifierNode(node: ESTree.Node): node is ESTree.Identifier {
243	return node.type === NodeType.Identifier;	27,825,683✔
244	}
245
246	/**
247	* @param {Node} node
248	* @returns {boolean}
249	*/
250	public static isIfStatementNode(node: ESTree.Node): node is ESTree.IfStatement {
251	return node.type === NodeType.IfStatement;	350,331,059✔
252	}
253
254	/**
255	* @param {Node} node
256	* @returns {boolean}
257	*/
258	public static isIfStatementNodeWithSingleStatementBody(node: ESTree.Node): node is ESTree.IfStatement {
259	if (!NodeGuards.isIfStatementNode(node)) {	54✔
260	return false;	6✔
261	}
262
263	return (	48✔
264	!NodeGuards.isBlockStatementNode(node.consequent) \|\|	96✔
265	(!!node.alternate && !NodeGuards.isBlockStatementNode(node.alternate))
266	);
267	}
268
269	/**
270	* @param {Node} node
271	* @returns {boolean}
272	*/
273	public static isImportDeclarationNode(node: ESTree.Node): node is ESTree.ImportDeclaration {
274	return node.type === NodeType.ImportDeclaration;	36,859,116✔
275	}
276
277	/**
278	* @param {Node} node
279	* @returns {boolean}
280	*/
281	public static isImportExpressionNode(node: ESTree.Node): node is ESTree.ImportExpression {
282	return node.type === NodeType.ImportExpression;	126✔
283	}
284
285	/**
286	* @param {Node} node
287	* @returns {boolean}
288	*/
289	public static isImportSpecifierNode(node: ESTree.Node): node is ESTree.ImportSpecifier {
290	return node.type === NodeType.ImportSpecifier;	3,456,730✔
291	}
292
293	/**
294	* @param {Node} node
295	* @param {Node} parentNode
296	* @returns {boolean}
297	*/
298	public static isLabelIdentifierNode(node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
299	const parentNodeIsLabeledStatementNode: boolean =
300	NodeGuards.isLabeledStatementNode(parentNode) && parentNode.label === node;	3,456,832✔
301	const parentNodeIsContinueStatementNode: boolean =
302	NodeGuards.isContinueStatementNode(parentNode) && parentNode.label === node;	3,456,832✔
303	const parentNodeIsBreakStatementNode: boolean =
304	NodeGuards.isBreakStatementNode(parentNode) && parentNode.label === node;	3,456,832✔
305
306	return parentNodeIsLabeledStatementNode \|\| parentNodeIsContinueStatementNode \|\| parentNodeIsBreakStatementNode;	3,456,832✔
307	}
308
309	/**
310	* @param {Node} node
311	* @returns {boolean}
312	*/
313	public static isLabeledStatementNode(node: ESTree.Node): node is ESTree.LabeledStatement {
314	return node.type === NodeType.LabeledStatement;	61,542,447✔
315	}
316
317	/**
318	* @param {Node} node
319	* @returns {boolean}
320	*/
321	public static isLiteralNode(node: ESTree.Node): node is ESTree.Literal {
322	return node.type === NodeType.Literal;	757,341,437✔
323	}
324
325	/**
326	* @param {Node} node
327	* @returns {boolean}
328	*/
329	public static isLogicalExpressionNode(node: ESTree.Node): node is ESTree.LogicalExpression {
330	return node.type === NodeType.LogicalExpression;	×
331	}
332
333	/**
334	* @param {Node} node
335	* @returns {boolean}
336	*/
337	public static isMemberExpressionNode(node: ESTree.Node): node is ESTree.MemberExpression {
338	return node.type === NodeType.MemberExpression;	53,588,159✔
339	}
340
341	/**
342	* @param {Node} node
343	* @returns {boolean}
344	*/
345	public static isMetaPropertyNode(node: ESTree.Node): node is ESTree.MetaProperty {
346	return node.type === NodeType.MetaProperty;	32,880,132✔
347	}
348
349	/**
350	* @param {Node} node
351	* @returns {boolean}
352	*/
353	public static isMethodDefinitionNode(node: ESTree.Node): node is ESTree.MethodDefinition {
354	return node.type === NodeType.MethodDefinition;	49,793,492✔
355	}
356
357	/**
358	* @param {Node} node
359	* @returns {boolean}
360	*/
361	public static isNewExpressionNode(node: ESTree.Node): node is ESTree.NewExpression {
362	return node.type === NodeType.NewExpression;	1,356,899✔
363	}
364
365	/**
366	* @param {Object} object
367	* @returns {boolean}
368	*/
369	// eslint-disable-next-line @typescript-eslint/ban-types
370	public static isNode(object: Object & { type?: string }): object is ESTree.Node {
371	return object && !object.type !== undefined;	1,554,746,808✔
372	}
373
374	/**
375	* @param {Node} node
376	* @returns {boolean}
377	*/
378	public static isNodeWithLexicalScope(node: ESTree.Node): node is TNodeWithLexicalScope {
379	return NodeGuards.isProgramNode(node) \|\| NodeGuards.isFunctionNode(node);	50,333,098✔
380	}
381
382	/**
383	* @param {Node} node
384	* @returns {boolean}
385	*/
386	public static isNodeWithBlockLexicalScope(node: ESTree.Node): node is TNodeWithLexicalScope {
387	return (	9,681,616✔
388	NodeGuards.isNodeWithLexicalScope(node) \|\|	9,682,996✔
389	NodeGuards.isBlockStatementNode(node) \|\|
390	NodeGuards.isStaticBlockNode(node)
391	);
392	}
393
394	/**
395	* Checks if a node is the node with single statement body, like:
396	* while (true)
397	* console.log(1);
398	*
399	* or:
400	*
401	*
402	* @param {Node} node
403	* @returns {boolean}
404	*/
405	public static isNodeWithSingleStatementBody(node: ESTree.Node): node is TNodeWithSingleStatementBody {
406	// Different approach for `IfStatement` node because this node hasn't `body` property
407	if (NodeGuards.isIfStatementNode(node)) {	80,585✔
408	return NodeGuards.isIfStatementNodeWithSingleStatementBody(node);	24✔
409	}
410
411	// All other nodes with `Statement` node as `body` property
412	return (	80,561✔
413	(NodeGuards.isForStatementNode(node) \|\|	486,191✔
414	NodeGuards.isForOfStatementNode(node) \|\|
415	NodeGuards.isForInStatementNode(node) \|\|
416	NodeGuards.isWhileStatementNode(node) \|\|
417	NodeGuards.isDoWhileStatementNode(node) \|\|
418	NodeGuards.isWithStatementNode(node) \|\|
419	NodeGuards.isLabeledStatementNode(node)) &&
420	!NodeGuards.isBlockStatementNode(node.body)
421	);
422	}
423
424	/**
425	* @param {Node} node
426	* @param {Node} parentNode
427	* @returns {boolean}
428	*/
429	public static isNodeWithLexicalScopeStatements(
430	node: ESTree.Node,
431	parentNode: ESTree.Node
432	): node is TNodeWithLexicalScopeStatements {
433	return (	633,318,597✔
434	NodeGuards.isProgramNode(node) \|\|	1,284,996,101✔
435	(NodeGuards.isBlockStatementNode(node) && NodeGuards.nodesWithLexicalStatements.includes(parentNode.type))
436	);
437	}
438
439	/**
440	* @param {Node} node
441	* @returns {boolean}
442	*/
443	public static isNodeWithStatements(node: ESTree.Node): node is TNodeWithStatements {
444	return (	6,484,697✔
445	NodeGuards.isProgramNode(node) \|\|	13,907,652✔
446	NodeGuards.isBlockStatementNode(node) \|\|
447	NodeGuards.isStaticBlockNode(node) \|\|
448	NodeGuards.isSwitchCaseNode(node)
449	);
450	}
451
452	/**
453	* @param {Node} node
454	* @returns {boolean}
455	*/
456	public static isNodeWithComments(node: ESTree.Node): node is ESTree.Node {
457	return Boolean(node.leadingComments) \|\| Boolean(node.trailingComments);	16,440,066✔
458	}
459
460	/**
461	* @param {Node} node
462	* @returns {boolean}
463	*/
464	public static isObjectPatternNode(node: ESTree.Node): node is ESTree.ObjectPattern {
465	return node.type === NodeType.ObjectPattern;	120,722,300✔
466	}
467
468	/**
469	* @param {Node} node
470	* @returns {boolean}
471	*/
472	public static isObjectExpressionNode(node: ESTree.Node): node is ESTree.ObjectExpression {
473	return node.type === NodeType.ObjectExpression;	55,846,227✔
474	}
475
476	/**
477	* @param {Node} node
478	* @returns {boolean}
479	*/
480	public static isPrivateIdentifierNode(node: ESTree.Node): node is ESTree.PrivateIdentifier {
481	return node.type === NodeType.PrivateIdentifier;	5,903,735✔
482	}
483
484	/**
485	* @param {Node} node
486	* @returns {boolean}
487	*/
488	public static isProgramNode(node: ESTree.Node): node is ESTree.Program {
489	return node.type === NodeType.Program;	2,451,879,955✔
490	}
491
492	/**
493	* @param {Node} node
494	* @returns {boolean}
495	*/
496	public static isPropertyNode(node: ESTree.Node): node is ESTree.Property {
497	return node.type === NodeType.Property;	109,432,524✔
498	}
499
500	/**
501	* @param {Node} node
502	* @returns {boolean}
503	*/
504	public static isPropertyDefinitionNode(node: ESTree.Node): node is ESTree.PropertyDefinition {
505	return node.type === NodeType.PropertyDefinition;	49,784,434✔
506	}
507
508	/**
509	* @param {Node} node
510	* @returns {boolean}
511	*/
512	public static isRestElementNode(node: ESTree.Node): node is ESTree.RestElement {
513	return node.type === NodeType.RestElement;	91,821✔
514	}
515
516	/**
517	* @param {Node} node
518	* @returns {boolean}
519	*/
520	public static isReturnStatementNode(node: ESTree.Node): node is ESTree.ReturnStatement {
521	return node.type === NodeType.ReturnStatement;	3,269,861✔
522	}
523
524	/**
525	* @param {Node} node
526	* @returns {boolean}
527	*/
528	public static isSequenceExpressionNode(node: ESTree.Node): node is ESTree.SequenceExpression {
529	return node.type === NodeType.SequenceExpression;	484,495✔
530	}
531
532	/**
533	* @param {Node} node
534	* @returns {boolean}
535	*/
536	public static isSpreadElementNode(node: ESTree.Node): node is ESTree.SpreadElement {
537	return node.type === NodeType.SpreadElement;	388,397✔
538	}
539
540	/**
541	* @param {Node} node
542	* @returns {boolean}
543	*/
544	public static isStaticBlockNode(node: ESTree.Node): node is ESTree.StaticBlock {
545	return node.type === NodeType.StaticBlock;	497,929✔
546	}
547
548	/**
549	* @param {Node} node
550	* @returns {boolean}
551	*/
552	public static isSuperNode(node: ESTree.Node): node is ESTree.Super {
553	return node.type === NodeType.Super;	5,941,361✔
554	}
555
556	/**
557	* @param {Node} node
558	* @returns {boolean}
559	*/
560	public static isSwitchCaseNode(node: ESTree.Node): node is ESTree.SwitchCase {
561	return node.type === NodeType.SwitchCase;	14,123,679✔
562	}
563
564	/**
565	* @param {Node} node
566	* @returns {boolean}
567	*/
568	public static isTaggedTemplateExpressionNode(node: ESTree.Node): node is ESTree.TaggedTemplateExpression {
569	return node.type === NodeType.TaggedTemplateExpression;	6,489✔
570	}
571
572	/**
573	* @param {Node} node
574	* @returns {boolean}
575	*/
576	public static isTemplateLiteralNode(node: ESTree.Node): node is ESTree.TemplateLiteral {
577	return node.type === NodeType.TemplateLiteral;	34,792,274✔
578	}
579
580	/**
581	* @param {Node} node
582	* @returns {boolean}
583	*/
584	public static isThisExpressionNode(node: ESTree.Node): node is ESTree.ThisExpression {
585	return node.type === NodeType.ThisExpression;	7,733,713✔
586	}
587
588	/**
589	* @param {Node} node
590	* @returns {boolean}
591	*/
592	public static isUnaryExpressionNode(node: ESTree.Node): node is ESTree.UnaryExpression {
593	return node.type === NodeType.UnaryExpression;	241,611✔
594	}
595
596	/**
597	* @param {Node} node
598	* @returns {boolean}
599	*/
600	public static isVariableDeclarationNode(node: ESTree.Node): node is ESTree.VariableDeclaration {
601	return node.type === NodeType.VariableDeclaration;	2,711,860,925✔
602	}
603
604	/**
605	* @param {Node} node
606	* @returns {boolean}
607	*/
608	public static isVariableDeclaratorNode(node: ESTree.Node): node is ESTree.VariableDeclarator {
609	return node.type === NodeType.VariableDeclarator;	18,434,238✔
610	}
611
612	/**
613	* @param {Node} node
614	* @returns {boolean}
615	*/
616	public static isWithStatementNode(node: ESTree.Node): node is ESTree.WithStatement {
617	return node.type === NodeType.WithStatement;	64,691✔
618	}
619
620	/**
621	* @param {Node} node
622	* @returns {boolean}
623	*/
624	public static isWhileStatementNode(node: ESTree.Node): node is ESTree.WhileStatement {
625	return node.type === NodeType.WhileStatement;	70,272,607✔
626	}
627
628	/**
629	* @param {Node} node
630	* @returns {boolean}
631	*/
632	public static isYieldExpressionNode(node: ESTree.Node): node is ESTree.YieldExpression {
633	return node.type === NodeType.YieldExpression;	5,907,353✔
634	}
635	}

javascript-obfuscator / javascript-obfuscator / 19907815758

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous