javascript-obfuscator 2.18.1 → 3.0.1

package/src/analyzers/calls-graph-analyzer/CallsGraphAnalyzer.ts

@@ -1,170 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { TCalleeDataExtractorFactory } from '../../types/container/calls-graph-analyzer/TCalleeDataExtractorFactory';
-
-import { ICalleeData } from '../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
-import { ICallsGraphAnalyzer } from '../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphAnalyzer';
-import { ICallsGraphData } from '../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphData';
-
-import { CalleeDataExtractor } from '../../enums/analyzers/calls-graph-analyzer/CalleeDataExtractor';
-
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeStatementUtils } from '../../node/NodeStatementUtils';
-
-/**
- * This class generates a data with a graph of functions calls
- *
- * For example:
- *
- * function Foo () {
- *     var baz = function () {
- *
- *     }
- *
- *     baz();
- * }
- *
- * foo();
- *
- * Will generate a structure like:
- *
- * [
- *      {
- *          callee: FOO_FUNCTION_NODE
- *          name: 'Foo',
- *          trace: [
- *              {
- *                  callee: BAZ_FUNCTION_NODE,
- *                  name: 'baz,
- *                  trace: []
- *              }
- *          ]
- *      }
- * ]
- */
-@injectable()
-export class CallsGraphAnalyzer implements ICallsGraphAnalyzer {
-    /**
-     * @type {CalleeDataExtractor[]}
-     */
-    private static readonly calleeDataExtractorsList: CalleeDataExtractor[] = [
-        CalleeDataExtractor.FunctionDeclarationCalleeDataExtractor,
-        CalleeDataExtractor.FunctionExpressionCalleeDataExtractor,
-        CalleeDataExtractor.ObjectExpressionCalleeDataExtractor
-    ];
-
-    /**
-     * @type {number}
-     */
-    private static readonly limitThresholdActivationLength: number = 25;
-
-    /**
-     * @type {number}
-     */
-    private static readonly limitThreshold: number = 0.002;
-
-    /**
-     * @type {TCalleeDataExtractorFactory}
-     */
-    private readonly calleeDataExtractorFactory: TCalleeDataExtractorFactory;
-
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__ICalleeDataExtractor) calleeDataExtractorFactory: TCalleeDataExtractorFactory
-    ) {
-        this.calleeDataExtractorFactory = calleeDataExtractorFactory;
-    }
-
-    /**
-     * @param {number} blockScopeBodyLength
-     * @returns {number}
-     */
-    public static getLimitIndex (blockScopeBodyLength: number): number {
-        const lastIndex: number = blockScopeBodyLength - 1;
-        const limitThresholdActivationIndex: number = CallsGraphAnalyzer.limitThresholdActivationLength - 1;
-
-        let limitIndex: number = lastIndex;
-
-        if (lastIndex > limitThresholdActivationIndex) {
-            limitIndex = Math.round(
-                limitThresholdActivationIndex + (lastIndex * CallsGraphAnalyzer.limitThreshold)
-            );
-
-            if (limitIndex > lastIndex) {
-                limitIndex = lastIndex;
-            }
-        }
-
-        return limitIndex;
-    }
-
-    /**
-     * @param {Program} astTree
-     * @returns {ICallsGraphData[]}
-     */
-    public analyze (astTree: ESTree.Program): ICallsGraphData[] {
-        return this.analyzeRecursive(astTree.body);
-    }
-
-    /**
-     * @param {NodeGuards[]} blockScopeBody
-     * @returns {ICallsGraphData[]}
-     */
-    private analyzeRecursive (blockScopeBody: ESTree.Node[]): ICallsGraphData[] {
-        const limitIndex: number = CallsGraphAnalyzer.getLimitIndex(blockScopeBody.length);
-        const callsGraphData: ICallsGraphData[] = [];
-        const blockScopeBodyLength: number = blockScopeBody.length;
-
-        for (let index: number = 0; index < blockScopeBodyLength; index++) {
-            if (index > limitIndex) {
-                break;
-            }
-
-            const blockScopeBodyNode: ESTree.Node = blockScopeBody[index];
-
-            estraverse.traverse(blockScopeBodyNode, {
-                enter: (node: ESTree.Node): estraverse.VisitorOption | void => {
-                    if (!NodeGuards.isCallExpressionNode(node)) {
-                        return;
-                    }
-
-                    if (blockScopeBodyNode.parentNode !== NodeStatementUtils.getParentNodeWithStatements(node)) {
-                        return estraverse.VisitorOption.Skip;
-                    }
-
-                    this.analyzeCallExpressionNode(callsGraphData, blockScopeBody, node);
-                }
-            });
-        }
-
-        return callsGraphData;
-    }
-
-    /**
-     * @param {ICallsGraphData[]} callsGraphData
-     * @param {NodeGuards[]} blockScopeBody
-     * @param {CallExpression} callExpressionNode
-     */
-    private analyzeCallExpressionNode (
-        callsGraphData: ICallsGraphData[],
-        blockScopeBody: ESTree.Node[],
-        callExpressionNode: ESTree.CallExpression
-    ): void {
-        CallsGraphAnalyzer.calleeDataExtractorsList.forEach((calleeDataExtractorName: CalleeDataExtractor) => {
-            const calleeData: ICalleeData | null = this.calleeDataExtractorFactory(calleeDataExtractorName)
-                .extract(blockScopeBody, callExpressionNode.callee);
-
-            if (!calleeData) {
-                return;
-            }
-
-            callsGraphData.push({
-                ...calleeData,
-                callsGraph: this.analyzeRecursive(calleeData.callee.body)
-            });
-        });
-    }
-}

package/src/analyzers/calls-graph-analyzer/callee-data-extractors/AbstractCalleeDataExtractor.ts

@@ -1,16 +0,0 @@
-import { injectable } from 'inversify';
-
-import * as ESTree from 'estree';
-
-import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
-import { ICalleeDataExtractor } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeDataExtractor';
-
-@injectable()
-export abstract class AbstractCalleeDataExtractor implements ICalleeDataExtractor {
-    /**
-     * @param {Node[]} blockScopeBody
-     * @param {Node} callee
-     * @returns {ICalleeData}
-     */
-    public abstract extract (blockScopeBody: ESTree.Node[], callee: ESTree.Node): ICalleeData | null;
-}

package/src/analyzers/calls-graph-analyzer/callee-data-extractors/FunctionDeclarationCalleeDataExtractor.ts

@@ -1,59 +0,0 @@
-import { injectable } from 'inversify';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
-
-import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeStatementUtils } from '../../../node/NodeStatementUtils';
-
-@injectable()
-export class FunctionDeclarationCalleeDataExtractor extends AbstractCalleeDataExtractor {
-    /**
-     * @param {NodeGuards[]} blockScopeBody
-     * @param {Identifier} callee
-     * @returns {ICalleeData}
-     */
-    public extract (blockScopeBody: ESTree.Node[], callee: ESTree.Identifier): ICalleeData | null {
-        if (!NodeGuards.isIdentifierNode(callee)) {
-            return null;
-        }
-
-        const calleeBlockStatement: ESTree.BlockStatement | null = this.getCalleeBlockStatement(
-            NodeStatementUtils.getParentNodeWithStatements(blockScopeBody[0]),
-            callee.name
-        );
-
-        if (!calleeBlockStatement) {
-            return null;
-        }
-
-        return {
-            callee: calleeBlockStatement,
-            name: callee.name
-        };
-    }
-
-    /**
-     * @param {NodeGuards} targetNode
-     * @param {string} name
-     * @returns {BlockStatement}
-     */
-    private getCalleeBlockStatement (targetNode: ESTree.Node, name: string): ESTree.BlockStatement | null {
-        let calleeBlockStatement: ESTree.BlockStatement | null = null;
-
-        estraverse.traverse(targetNode, {
-            enter: (node: ESTree.Node): estraverse.VisitorOption | void => {
-                if (NodeGuards.isFunctionDeclarationNode(node) && node.id.name === name) {
-                    calleeBlockStatement = node.body;
-
-                    return estraverse.VisitorOption.Break;
-                }
-            }
-        });
-
-        return calleeBlockStatement;
-    }
-}

package/src/analyzers/calls-graph-analyzer/callee-data-extractors/FunctionExpressionCalleeDataExtractor.ts

@@ -1,70 +0,0 @@
-import { injectable } from 'inversify';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
-
-import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeStatementUtils } from '../../../node/NodeStatementUtils';
-
-@injectable()
-export class FunctionExpressionCalleeDataExtractor extends AbstractCalleeDataExtractor {
-    /**
-     * @param {NodeGuards[]} blockScopeBody
-     * @param {Identifier} callee
-     * @returns {ICalleeData}
-     */
-    public extract (blockScopeBody: ESTree.Node[], callee: ESTree.Identifier | ESTree.FunctionExpression): ICalleeData | null {
-        let calleeName: string | null = null;
-        let calleeBlockStatement: ESTree.BlockStatement | null = null;
-
-        if (NodeGuards.isIdentifierNode(callee)) {
-            calleeName = callee.name;
-            calleeBlockStatement = this.getCalleeBlockStatement(
-                NodeStatementUtils.getParentNodeWithStatements(blockScopeBody[0]),
-                callee.name
-            );
-        } else if (NodeGuards.isFunctionExpressionNode(callee)) {
-            calleeName = null;
-            calleeBlockStatement = callee.body;
-        }
-
-        if (!calleeBlockStatement) {
-            return null;
-        }
-
-        return {
-            callee: calleeBlockStatement,
-            name: calleeName
-        };
-    }
-
-    /**
-     * @param {NodeGuards} targetNode
-     * @param {string} name
-     * @returns {BlockStatement}
-     */
-    private getCalleeBlockStatement (targetNode: ESTree.Node, name: string): ESTree.BlockStatement | null {
-        let calleeBlockStatement: ESTree.BlockStatement | null = null;
-
-        estraverse.traverse(targetNode, {
-            enter: (node: ESTree.Node, parentNode: ESTree.Node | null): estraverse.VisitorOption | void => {
-                if (
-                    NodeGuards.isFunctionExpressionNode(node) &&
-                    parentNode &&
-                    NodeGuards.isVariableDeclaratorNode(parentNode) &&
-                    NodeGuards.isIdentifierNode(parentNode.id) &&
-                    parentNode.id.name === name
-                ) {
-                    calleeBlockStatement = node.body;
-
-                    return estraverse.VisitorOption.Break;
-                }
-            }
-        });
-
-        return calleeBlockStatement;
-    }
-}

package/src/analyzers/calls-graph-analyzer/callee-data-extractors/ObjectExpressionCalleeDataExtractor.ts

@@ -1,177 +0,0 @@
-import { injectable } from 'inversify';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { TObjectMembersCallsChain } from '../../../types/analyzers/calls-graph-analyzer/TObjectMembersCallsChain';
-
-import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
-
-import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeStatementUtils } from '../../../node/NodeStatementUtils';
-
-@injectable()
-export class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtractor {
-    /**
-     * @param {Property} propertyNode
-     * @param {string | number} nextItemInCallsChain
-     * @returns {boolean}
-     */
-    private static isValidTargetPropertyNode (propertyNode: ESTree.Property, nextItemInCallsChain: string | number): boolean {
-        if (!propertyNode.key) {
-            return false;
-        }
-
-        const isTargetPropertyNodeWithIdentifierKey: boolean =
-            NodeGuards.isIdentifierNode(propertyNode.key) && propertyNode.key.name === nextItemInCallsChain;
-        const isTargetPropertyNodeWithLiteralKey: boolean =
-            NodeGuards.isLiteralNode(propertyNode.key) &&
-            Boolean(propertyNode.key.value) &&
-            propertyNode.key.value === nextItemInCallsChain;
-
-        return isTargetPropertyNodeWithIdentifierKey || isTargetPropertyNodeWithLiteralKey;
-    }
-
-    /**
-     * @param {NodeGuards[]} blockScopeBody
-     * @param {MemberExpression} callee
-     * @returns {ICalleeData}
-     */
-    public extract (blockScopeBody: ESTree.Node[], callee: ESTree.MemberExpression): ICalleeData | null {
-        if (!NodeGuards.isMemberExpressionNode(callee)) {
-            return null;
-        }
-
-        const objectMembersCallsChain: TObjectMembersCallsChain = this.createObjectMembersCallsChain([], callee);
-
-        if (!objectMembersCallsChain.length) {
-            return null;
-        }
-
-        const functionExpressionName: string | number | null = objectMembersCallsChain[objectMembersCallsChain.length - 1];
-        const calleeBlockStatement: ESTree.BlockStatement | null = this.getCalleeBlockStatement(
-            NodeStatementUtils.getParentNodeWithStatements(blockScopeBody[0]),
-            objectMembersCallsChain
-        );
-
-        if (!calleeBlockStatement) {
-            return null;
-        }
-
-        return {
-            callee: calleeBlockStatement,
-            name: functionExpressionName
-        };
-    }
-
-    /**
-     * Creates array with MemberExpression calls chain.
-     *
-     * Example: object.foo.bar(); // ['object', 'foo', 'bar']
-     *
-     * @param {TObjectMembersCallsChain} currentChain
-     * @param {MemberExpression} memberExpression
-     * @returns {TObjectMembersCallsChain}
-     */
-    private createObjectMembersCallsChain (
-        currentChain: TObjectMembersCallsChain,
-        memberExpression: ESTree.MemberExpression
-    ): TObjectMembersCallsChain {
-        // first step: processing memberExpression `property` property
-        if (NodeGuards.isIdentifierNode(memberExpression.property) && !memberExpression.computed) {
-            currentChain.unshift(memberExpression.property.name);
-        } else if (
-            NodeGuards.isLiteralNode(memberExpression.property) &&
-            (
-                typeof memberExpression.property.value === 'string' ||
-                typeof memberExpression.property.value === 'number'
-            )
-        ) {
-            currentChain.unshift(memberExpression.property.value);
-        } else {
-            return currentChain;
-        }
-
-        // second step: processing memberExpression `object` property
-        if (NodeGuards.isMemberExpressionNode(memberExpression.object)) {
-            return this.createObjectMembersCallsChain(currentChain, memberExpression.object);
-        } else if (NodeGuards.isIdentifierNode(memberExpression.object)) {
-            currentChain.unshift(memberExpression.object.name);
-        }
-
-        return currentChain;
-    }
-
-    /**
-     * @param {NodeGuards} targetNode
-     * @param {TObjectMembersCallsChain} objectMembersCallsChain
-     * @returns {BlockStatement}
-     */
-    private getCalleeBlockStatement (
-        targetNode: ESTree.Node,
-        objectMembersCallsChain: TObjectMembersCallsChain
-    ): ESTree.BlockStatement | null {
-        const objectName: string | number | undefined = objectMembersCallsChain.shift();
-
-        if (!objectName) {
-            return null;
-        }
-
-        let calleeBlockStatement: ESTree.BlockStatement | null = null;
-
-        estraverse.traverse(targetNode, {
-            enter: (node: ESTree.Node): estraverse.VisitorOption | void => {
-                if (
-                    NodeGuards.isVariableDeclaratorNode(node) &&
-                    NodeGuards.isIdentifierNode(node.id) &&
-                    node.init &&
-                    NodeGuards.isObjectExpressionNode(node.init) &&
-                    node.id.name === objectName
-                ) {
-                    calleeBlockStatement = this.findCalleeBlockStatement(node.init.properties, objectMembersCallsChain);
-
-                    return estraverse.VisitorOption.Break;
-                }
-            }
-        });
-
-        return calleeBlockStatement;
-    }
-
-    /**
-     * @param {Property[]} objectExpressionProperties
-     * @param {TObjectMembersCallsChain} objectMembersCallsChain
-     * @returns {BlockStatement}
-     */
-    private findCalleeBlockStatement (
-        objectExpressionProperties: (ESTree.Property | ESTree.SpreadElement)[],
-        objectMembersCallsChain: TObjectMembersCallsChain
-    ): ESTree.BlockStatement | null {
-        const nextItemInCallsChain: string | number | undefined = objectMembersCallsChain.shift();
-
-        if (!nextItemInCallsChain) {
-            return null;
-        }
-
-        for (const propertyNode of objectExpressionProperties) {
-            if (!NodeGuards.isPropertyNode(propertyNode)) {
-                continue;
-            }
-
-            if (!ObjectExpressionCalleeDataExtractor.isValidTargetPropertyNode(propertyNode, nextItemInCallsChain)) {
-                continue;
-            }
-
-            if (NodeGuards.isObjectExpressionNode(propertyNode.value)) {
-                return this.findCalleeBlockStatement(propertyNode.value.properties, objectMembersCallsChain);
-            }
-
-            if (NodeGuards.isFunctionExpressionNode(propertyNode.value)) {
-                return propertyNode.value.body;
-            }
-        }
-
-        return null;
-    }
-}

package/src/analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer.ts

@@ -1,140 +0,0 @@
-import { injectable, inject } from 'inversify';
-
-import { TNumberNumericalExpressionData } from '../../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
-
-import { INumberNumericalExpressionAnalyzer } from '../../interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import { NumberUtils } from '../../utils/NumberUtils';
-
-/**
- * Based on https://gist.github.com/da411d/0e59f79dcf4603cdabf0024a10eeb6fe
- */
-@injectable()
-export class NumberNumericalExpressionAnalyzer implements INumberNumericalExpressionAnalyzer {
-    /**
-     * @type {number}
-     */
-    public static readonly defaultAdditionalPartsCount: number = 3;
-
-    /**
-     * @type {number}
-     */
-    private static readonly delta: number = 10000;
-
-    /**
-     * @type {Map<number, number[]>}
-     */
-    private readonly numberFactorsMap: Map<number, number[]> = new Map();
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    private readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator
-    ) {
-        this.randomGenerator = randomGenerator;
-    }
-
-    /**
-     * @param {number} number
-     * @param {number} additionalPartsCount
-     * @returns {TNumberNumericalExpressionData}
-     */
-    public analyze (
-        number: number,
-        additionalPartsCount: number
-    ): TNumberNumericalExpressionData {
-        if (isNaN(number)) {
-            throw new Error('Given value is NaN');
-        }
-
-        if (NumberUtils.isUnsafeNumber(number)) {
-            return [number];
-        }
-
-        const additionParts: number[] = this.generateAdditionParts(number, additionalPartsCount);
-
-        return additionParts.map((addition: number) => this.mixWithMultiplyParts(addition));
-    }
-
-    /**
-     * @param {number} number
-     * @param {number} additionalPartsCount
-     * @returns {number[]}
-     */
-    private generateAdditionParts (number: number, additionalPartsCount: number): number[] {
-        const additionParts = [];
-
-        const upperNumberLimit: number = Math.min(Math.abs(number * 2), Number.MAX_SAFE_INTEGER);
-
-        const from: number = Math.min(-NumberNumericalExpressionAnalyzer.delta, -upperNumberLimit);
-        const to: number = Math.max(NumberNumericalExpressionAnalyzer.delta, upperNumberLimit);
-
-        let temporarySum = 0;
-
-        for (let i = 0; i < additionalPartsCount; i++) {
-            if (i < additionalPartsCount - 1) {
-                // trailing parts
-
-                let addition: number = this.randomGenerator.getRandomInteger(from, to);
-                const isUnsafeCombination: boolean = NumberUtils.isUnsafeNumber(temporarySum + addition);
-
-                // we have to flip sign if total expression sum overflows over safe integer limits
-                if (isUnsafeCombination) {
-                    addition = -addition;
-                }
-
-                additionParts.push(addition);
-                temporarySum += addition;
-            } else {
-                const combination: number = number - temporarySum;
-                const isUnsafeCombination: boolean = NumberUtils.isUnsafeNumber(combination);
-
-                // last part
-                if (isUnsafeCombination) {
-                    additionParts.push(0 - temporarySum);
-                    additionParts.push(number);
-                } else {
-                    additionParts.push(combination);
-                }
-            }
-        }
-
-        return additionParts;
-    }
-
-    /**
-     * @param {number} number
-     * @returns {number | number[]}
-     */
-    private mixWithMultiplyParts (number: number): number | number[] {
-        const shouldMixWithMultiplyParts: boolean = this.randomGenerator.getMathRandom() > 0.5;
-
-        if (!shouldMixWithMultiplyParts || number === 0) {
-            return number;
-        }
-
-        let factors: number[] | null = this.numberFactorsMap.get(number) ?? null;
-
-        if (!factors) {
-           factors = NumberUtils.getFactors(number);
-           this.numberFactorsMap.set(number, factors);
-        }
-
-        if (!factors.length) {
-            return number;
-        }
-
-        const factor: number = factors[this.randomGenerator.getRandomInteger(0, factors.length - 1)];
-
-        return [factor, number / factor];
-    }
-}

package/src/analyzers/prevailing-kind-of-variables-analyzer/PrevailingKindOfVariablesAnalyzer.ts

@@ -1,61 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
-import { IPrevailingKindOfVariablesAnalyzer } from '../../interfaces/analyzers/calls-graph-analyzer/IPrevailingKindOfVariablesAnalyzer';
-
-import { NodeGuards } from '../../node/NodeGuards';
-
-@injectable()
-export class PrevailingKindOfVariablesAnalyzer implements IPrevailingKindOfVariablesAnalyzer {
-    /**
-     * @type {ESTree.VariableDeclaration['kind']}
-     */
-    private static readonly defaultKindOfVariables: ESTree.VariableDeclaration['kind'] = 'var';
-
-    /**
-     * @type {IArrayUtils}
-     */
-    private readonly arrayUtils: IArrayUtils;
-
-    /**
-     * @type {ESTree.VariableDeclaration['kind']}
-     */
-    private prevailingKindOfVariables: ESTree.VariableDeclaration['kind'] = PrevailingKindOfVariablesAnalyzer.defaultKindOfVariables;
-
-    public constructor (
-        @inject(ServiceIdentifiers.IArrayUtils) arrayUtils: IArrayUtils
-    ) {
-        this.arrayUtils = arrayUtils;
-    }
-
-    /**
-     * @param {Program} astTree
-     */
-    public analyze (astTree: ESTree.Program): void {
-        const variableKinds: ESTree.VariableDeclaration['kind'][] = [];
-
-        estraverse.traverse(astTree, {
-            enter: (node: ESTree.Node): estraverse.VisitorOption | void => {
-                if (!NodeGuards.isVariableDeclarationNode(node)) {
-                    return;
-                }
-
-                variableKinds.push(node.kind);
-            }
-        });
-
-        this.prevailingKindOfVariables = this.arrayUtils.findMostOccurringElement(variableKinds)
-            ?? PrevailingKindOfVariablesAnalyzer.defaultKindOfVariables;
-    }
-
-    /**
-     * @returns {VariableDeclaration["kind"]}
-     */
-    public getPrevailingKind (): ESTree.VariableDeclaration['kind'] {
-        return this.prevailingKindOfVariables;
-    }
-}