javascript-obfuscator 2.18.0 → 3.0.0

package/src/node-transformers/AbstractNodeTransformer.ts

@@ -1,56 +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 { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
-import { IOptions } from '../interfaces/options/IOptions';
-import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from '../enums/node-transformers/NodeTransformationStage';
-
-@injectable()
-export abstract class AbstractNodeTransformer implements INodeTransformer {
-    /**
-     * @type {NodeTransformer[] | undefined}
-     */
-    public readonly runAfter: NodeTransformer[] | undefined;
-
-    /**
-     * @type {IOptions}
-     */
-    protected readonly options: IOptions;
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    protected readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.randomGenerator = randomGenerator;
-        this.options = options;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public abstract getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null;
-
-    /**
-     * @param {Node} node
-     * @param {Node} parentNode
-     * @returns {Node | VisitorOption}
-     */
-    public abstract transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node | estraverse.VisitorOption;
-}

package/src/node-transformers/NodeTransformersRunner.ts

@@ -1,176 +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 { TNodeTransformerFactory } from '../types/container/node-transformers/TNodeTransformerFactory';
-import { TDictionary } from '../types/TDictionary';
-import { TVisitorDirection } from '../types/node-transformers/TVisitorDirection';
-import { TVisitorFunction } from '../types/node-transformers/TVisitorFunction';
-import { TVisitorResult } from '../types/node-transformers/TVisitorResult';
-
-import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
-import { INodeTransformersRunner } from '../interfaces/node-transformers/INodeTransformersRunner';
-import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
-import { IVisitor } from '../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from '../enums/node-transformers/NodeTransformationStage';
-import { VisitorDirection } from '../enums/node-transformers/VisitorDirection';
-
-import { NodeGuards } from '../node/NodeGuards';
-import { NodeMetadata } from '../node/NodeMetadata';
-
-@injectable()
-export class NodeTransformersRunner implements INodeTransformersRunner {
-    /**
-     * @type {TNodeTransformerFactory}
-     */
-    private readonly nodeTransformerFactory: TNodeTransformerFactory;
-
-    /**
-     * @type {ITransformerNamesGroupsBuilder}
-     */
-    private readonly nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
-        NodeTransformer,
-        INodeTransformer
-    >;
-
-    /**
-     * @param {TNodeTransformerFactory} nodeTransformerFactory
-     * @param {ITransformerNamesGroupsBuilder} nodeTransformerNamesGroupsBuilder
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__INodeTransformer)
-            nodeTransformerFactory: TNodeTransformerFactory,
-        @inject(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
-            nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
-                NodeTransformer,
-                INodeTransformer
-            >,
-    ) {
-        this.nodeTransformerFactory = nodeTransformerFactory;
-        this.nodeTransformerNamesGroupsBuilder = nodeTransformerNamesGroupsBuilder;
-    }
-
-    /**
-     * @param {T} astTree
-     * @param {NodeTransformer[]} nodeTransformerNames
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {T}
-     */
-    public transform <T extends ESTree.Node = ESTree.Program> (
-        astTree: T,
-        nodeTransformerNames: NodeTransformer[],
-        nodeTransformationStage: NodeTransformationStage
-    ): T {
-        if (!nodeTransformerNames.length) {
-            return astTree;
-        }
-
-        const normalizedNodeTransformers: TDictionary<INodeTransformer> =
-            this.buildNormalizedNodeTransformers(nodeTransformerNames, nodeTransformationStage);
-        const nodeTransformerNamesGroups: NodeTransformer[][] =
-            this.nodeTransformerNamesGroupsBuilder.build(normalizedNodeTransformers);
-
-        for (const nodeTransformerNamesGroup of nodeTransformerNamesGroups) {
-            const enterVisitors: IVisitor[] = [];
-            const leaveVisitors: IVisitor[] = [];
-
-            for (const nodeTransformerName of nodeTransformerNamesGroup) {
-                const nodeTransformer: INodeTransformer = normalizedNodeTransformers[nodeTransformerName];
-                const visitor: IVisitor | null = nodeTransformer.getVisitor(nodeTransformationStage);
-
-                if (!visitor) {
-                    continue;
-                }
-
-                if (visitor.enter) {
-                    enterVisitors.push({ enter: visitor.enter });
-                }
-
-                if (visitor.leave) {
-                    leaveVisitors.push({ leave: visitor.leave });
-                }
-            }
-
-            if (!enterVisitors.length && !leaveVisitors.length) {
-                continue;
-            }
-
-            estraverse.replace(astTree, {
-                enter: this.mergeVisitorsForDirection(enterVisitors, VisitorDirection.Enter),
-                leave: this.mergeVisitorsForDirection(leaveVisitors, VisitorDirection.Leave)
-            });
-        }
-
-        return astTree;
-    }
-
-    /**
-     * @param {NodeTransformer[]} nodeTransformerNames
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {TDictionary<INodeTransformer>}
-     */
-    private buildNormalizedNodeTransformers (
-        nodeTransformerNames: NodeTransformer[],
-        nodeTransformationStage: NodeTransformationStage
-    ): TDictionary<INodeTransformer> {
-        return nodeTransformerNames
-            .reduce<TDictionary<INodeTransformer>>(
-                (acc: TDictionary<INodeTransformer>, nodeTransformerName: NodeTransformer) => {
-                    const nodeTransformer: INodeTransformer = this.nodeTransformerFactory(nodeTransformerName);
-
-                    if (!nodeTransformer.getVisitor(nodeTransformationStage)) {
-                        return acc;
-                    }
-
-                    return <TDictionary<INodeTransformer>>{
-                        ...acc,
-                        [nodeTransformerName]: nodeTransformer
-                    };
-                },
-                {}
-            );
-    }
-
-    /**
-     * @param {IVisitor[]} visitors
-     * @param {TVisitorDirection} direction
-     * @returns {TVisitorFunction}
-     */
-    private mergeVisitorsForDirection (visitors: IVisitor[], direction: TVisitorDirection): TVisitorFunction {
-        const visitorsLength: number = visitors.length;
-
-        if (!visitorsLength) {
-            return (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node => node;
-        }
-
-        return (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | estraverse.VisitorOption => {
-            if (NodeMetadata.isIgnoredNode(node)) {
-                return estraverse.VisitorOption.Skip;
-            }
-
-            for (let i: number = 0; i < visitorsLength; i++) {
-                const visitorFunction: TVisitorFunction | undefined = visitors[i][direction];
-
-                if (!visitorFunction) {
-                    continue;
-                }
-
-                const visitorResult: TVisitorResult = visitorFunction(node, parentNode);
-                const isValidVisitorResult = visitorResult && NodeGuards.isNode(visitorResult);
-
-                if (!isValidVisitorResult) {
-                    continue;
-                }
-
-                node = visitorResult;
-            }
-
-            return node;
-        };
-    }
-}

package/src/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.ts

@@ -1,151 +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 { TControlFlowCustomNodeFactory } from '../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TInitialData } from '../../types/TInitialData';
-import { TStatement } from '../../types/node/TStatement';
-
-import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
-import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { ControlFlowCustomNode } from '../../enums/custom-nodes/ControlFlowCustomNode';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { BlockStatementControlFlowFlatteningNode } from '../../custom-nodes/control-flow-flattening-nodes/BlockStatementControlFlowFlatteningNode';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeUtils } from '../../node/NodeUtils';
-
-@injectable()
-export class BlockStatementControlFlowTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {IArrayUtils}
-     */
-    private readonly arrayUtils: IArrayUtils;
-
-    /**
-     * @type {TControlFlowCustomNodeFactory}
-     */
-    private readonly controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory;
-
-    /**
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IArrayUtils} arrayUtils
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IArrayUtils) arrayUtils: IArrayUtils,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-
-        this.controlFlowCustomNodeFactory = controlFlowCustomNodeFactory;
-        this.arrayUtils = arrayUtils;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
-    private static isProhibitedStatementNode (node: ESTree.Node): boolean {
-        const isBreakOrContinueStatement: boolean = NodeGuards.isBreakStatementNode(node)
-            || NodeGuards.isContinueStatementNode(node);
-        const isVariableDeclarationWithLetOrConstKind: boolean = NodeGuards.isVariableDeclarationNode(node)
-            && (node.kind === 'const' || node.kind === 'let');
-        const isClassDeclaration: boolean = NodeGuards.isClassDeclarationNode(node);
-
-        return NodeGuards.isFunctionDeclarationNode(node)
-            || isBreakOrContinueStatement
-            || isVariableDeclarationWithLetOrConstKind
-            || isClassDeclaration;
-    }
-
-    /**
-     * @param {BlockStatement} blockStatementNode
-     * @returns {boolean}
-     */
-    private static canTransformBlockStatementNode (blockStatementNode: ESTree.BlockStatement): boolean {
-        let canTransform: boolean = true;
-
-        estraverse.traverse(blockStatementNode, {
-            enter: (node: ESTree.Node): estraverse.VisitorOption | void => {
-                if (NodeGuards.isWhileStatementNode(node)) {
-                    return estraverse.VisitorOption.Skip;
-                }
-
-                if (BlockStatementControlFlowTransformer.isProhibitedStatementNode(node)) {
-                    canTransform = false;
-                }
-            }
-        });
-
-        if (blockStatementNode.body.length <= 4) {
-            canTransform = false;
-        }
-
-        return canTransform;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.ControlFlowFlattening:
-                return {
-                    leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isBlockStatementNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {BlockStatement} blockStatementNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (blockStatementNode: ESTree.BlockStatement, parentNode: ESTree.Node): ESTree.Node {
-        if (
-            this.randomGenerator.getMathRandom() > this.options.controlFlowFlatteningThreshold ||
-            !BlockStatementControlFlowTransformer.canTransformBlockStatementNode(blockStatementNode)
-        ) {
-            return blockStatementNode;
-        }
-
-        const blockStatementBody: ESTree.Statement[] = blockStatementNode.body;
-        const originalKeys: number[] = this.arrayUtils.createWithRange(blockStatementBody.length);
-        const shuffledKeys: number[] = this.arrayUtils.shuffle(originalKeys);
-        const originalKeysIndexesInShuffledArray: number[] = originalKeys.map((key: number) => shuffledKeys.indexOf(key));
-        const blockStatementControlFlowFlatteningCustomNode: ICustomNode<TInitialData<BlockStatementControlFlowFlatteningNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.BlockStatementControlFlowFlatteningNode);
-
-        blockStatementControlFlowFlatteningCustomNode.initialize(
-            blockStatementBody,
-            shuffledKeys,
-            originalKeysIndexesInShuffledArray
-        );
-
-        const newBlockStatementNode: TStatement = blockStatementControlFlowFlatteningCustomNode.getNode()[0];
-
-        NodeUtils.parentizeNode(newBlockStatementNode, parentNode);
-
-        return newBlockStatementNode;
-    }
-}

package/src/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.ts

@@ -1,265 +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 { TControlFlowCustomNodeFactory } from '../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowReplacerFactory } from '../../types/container/node-transformers/TControlFlowReplacerFactory';
-import { TControlFlowStorage } from '../../types/storages/TControlFlowStorage';
-import { TControlFlowStorageFactory } from '../../types/container/node-transformers/TControlFlowStorageFactory';
-import { TInitialData } from '../../types/TInitialData';
-import { TNodeWithStatements } from '../../types/node/TNodeWithStatements';
-
-import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { ControlFlowCustomNode } from '../../enums/custom-nodes/ControlFlowCustomNode';
-import { ControlFlowReplacer } from '../../enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer';
-import { NodeType } from '../../enums/node/NodeType';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { ControlFlowStorageNode } from '../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ControlFlowStorageNode';
-import { NodeAppender } from '../../node/NodeAppender';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeMetadata } from '../../node/NodeMetadata';
-import { NodeStatementUtils } from '../../node/NodeStatementUtils';
-import { NodeUtils } from '../../node/NodeUtils';
-
-@injectable()
-export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {Map <string, ControlFlowReplacer>}
-     */
-    private static readonly controlFlowReplacersMap: Map <string, ControlFlowReplacer> = new Map([
-        [NodeType.BinaryExpression, ControlFlowReplacer.BinaryExpressionControlFlowReplacer],
-        [NodeType.CallExpression, ControlFlowReplacer.CallExpressionControlFlowReplacer],
-        [NodeType.LogicalExpression, ControlFlowReplacer.LogicalExpressionControlFlowReplacer],
-        [NodeType.Literal, ControlFlowReplacer.StringLiteralControlFlowReplacer]
-    ]);
-
-    /**
-     * @type {number}
-     */
-    private static readonly hostNodeSearchMinDepth: number = 0;
-
-    /**
-     * @type {number}
-     */
-    private static readonly hostNodeSearchMaxDepth: number = 2;
-
-    /**
-     * @type {Map<ESTree.Node, TControlFlowStorage>}
-     */
-    private readonly controlFlowData: Map <ESTree.Node, TControlFlowStorage> = new Map();
-
-    /**
-     * @type {Set<ESTree.Function>}
-     */
-    private readonly visitedFunctionNodes: Set<ESTree.Function> = new Set();
-
-    /**
-     * @type {Set<TNodeWithStatements>}
-     */
-    private readonly hostNodesWithControlFlowNode: Set<TNodeWithStatements> = new Set();
-
-    /**
-     * @type {TControlFlowReplacerFactory}
-     */
-    private readonly controlFlowReplacerFactory: TControlFlowReplacerFactory;
-
-    /**
-     * @type {TControlFlowStorageFactory}
-     */
-    private readonly controlFlowStorageFactory: TControlFlowStorageFactory;
-
-    /**
-     * @type {TControlFlowCustomNodeFactory}
-     */
-    private readonly controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory;
-
-    /**
-     * @param {TControlFlowStorageFactory} controlFlowStorageFactory
-     * @param {TControlFlowReplacerFactory} controlFlowReplacerFactory
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__TControlFlowStorage)
-            controlFlowStorageFactory: TControlFlowStorageFactory,
-        @inject(ServiceIdentifiers.Factory__IControlFlowReplacer)
-            controlFlowReplacerFactory: TControlFlowReplacerFactory,
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-
-        this.controlFlowStorageFactory = controlFlowStorageFactory;
-        this.controlFlowReplacerFactory = controlFlowReplacerFactory;
-        this.controlFlowCustomNodeFactory = controlFlowCustomNodeFactory;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.ControlFlowFlattening:
-                return {
-                    leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (
-                            parentNode && (
-                                NodeGuards.isFunctionDeclarationNode(node) ||
-                                NodeGuards.isFunctionExpressionNode(node) ||
-                                NodeGuards.isArrowFunctionExpressionNode(node)
-                            )
-                        ) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {Function} functionNode
-     * @param {NodeGuards} parentNode
-     * @returns {Function}
-     */
-    public transformNode (functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Function {
-        this.visitedFunctionNodes.add(functionNode);
-
-        if (!NodeGuards.isBlockStatementNode(functionNode.body)) {
-            return functionNode;
-        }
-
-        const hostNode: TNodeWithStatements = this.getHostNode(functionNode.body);
-        const controlFlowStorage: TControlFlowStorage = this.getControlFlowStorage(hostNode);
-
-        this.controlFlowData.set(hostNode, controlFlowStorage);
-        this.transformFunctionBody(functionNode.body, controlFlowStorage);
-
-        if (!controlFlowStorage.getLength()) {
-            return functionNode;
-        }
-
-        const controlFlowStorageCustomNode: ICustomNode<TInitialData<ControlFlowStorageNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.ControlFlowStorageNode);
-
-        controlFlowStorageCustomNode.initialize(controlFlowStorage);
-        NodeAppender.prepend(hostNode, controlFlowStorageCustomNode.getNode());
-        this.hostNodesWithControlFlowNode.add(hostNode);
-
-        NodeUtils.parentizeAst(functionNode);
-
-        return functionNode;
-    }
-
-    /**
-     * @param {TNodeWithStatements} hostNode
-     * @returns {TControlFlowStorage}
-     */
-    private getControlFlowStorage (hostNode: TNodeWithStatements): TControlFlowStorage {
-        const controlFlowStorage: TControlFlowStorage = this.controlFlowStorageFactory();
-
-        if (this.controlFlowData.has(hostNode)) {
-            if (this.hostNodesWithControlFlowNode.has(hostNode)) {
-                if (NodeGuards.isSwitchCaseNode(hostNode)) {
-                    hostNode.consequent.shift();
-                } else {
-                    hostNode.body.shift();
-                }
-            }
-
-            const hostControlFlowStorage: TControlFlowStorage = <TControlFlowStorage>this.controlFlowData.get(hostNode);
-
-            controlFlowStorage.mergeWith(hostControlFlowStorage, true);
-        }
-
-        return controlFlowStorage;
-    }
-
-    /**
-     * @param {BlockStatement} functionNodeBody
-     * @returns {TNodeWithStatements}
-     */
-    private getHostNode (functionNodeBody: ESTree.BlockStatement): TNodeWithStatements {
-        const blockScopesOfNode: TNodeWithStatements[] = NodeStatementUtils.getParentNodesWithStatements(functionNodeBody);
-
-        if (blockScopesOfNode.length === 1) {
-            return functionNodeBody;
-        } else {
-            blockScopesOfNode.pop();
-        }
-
-        if (blockScopesOfNode.length > FunctionControlFlowTransformer.hostNodeSearchMinDepth) {
-            blockScopesOfNode.splice(0, FunctionControlFlowTransformer.hostNodeSearchMinDepth);
-        }
-
-        if (blockScopesOfNode.length > FunctionControlFlowTransformer.hostNodeSearchMaxDepth) {
-            blockScopesOfNode.length = FunctionControlFlowTransformer.hostNodeSearchMaxDepth;
-        }
-
-        return this.randomGenerator.getRandomGenerator().pickone(blockScopesOfNode);
-    }
-
-    /**
-     * @param {NodeGuards} node
-     * @returns {boolean}
-     */
-    private isVisitedFunctionNode (node: ESTree.Node): boolean {
-        return (
-            NodeGuards.isFunctionDeclarationNode(node) ||
-            NodeGuards.isFunctionExpressionNode(node) ||
-            NodeGuards.isArrowFunctionExpressionNode(node)
-        ) && this.visitedFunctionNodes.has(node);
-    }
-
-    /**
-     * @param {BlockStatement} functionNodeBody
-     * @param {TControlFlowStorage} controlFlowStorage
-     */
-    private transformFunctionBody (functionNodeBody: ESTree.BlockStatement, controlFlowStorage: TControlFlowStorage): void {
-        estraverse.replace(functionNodeBody, {
-            enter: (node: ESTree.Node, parentNode: ESTree.Node | null): estraverse.VisitorOption | ESTree.Node => {
-                if (NodeMetadata.isIgnoredNode(node)) {
-                    return estraverse.VisitorOption.Skip;
-                }
-
-                if (this.isVisitedFunctionNode(node) || !parentNode) {
-                    return estraverse.VisitorOption.Skip;
-                }
-
-                if (!FunctionControlFlowTransformer.controlFlowReplacersMap.has(node.type)) {
-                    return node;
-                }
-
-                if (this.randomGenerator.getMathRandom() > this.options.controlFlowFlatteningThreshold) {
-                    return node;
-                }
-
-                const controlFlowReplacerName: ControlFlowReplacer = <ControlFlowReplacer>FunctionControlFlowTransformer
-                    .controlFlowReplacersMap.get(node.type);
-
-                if (controlFlowReplacerName === undefined) {
-                    return node;
-                }
-
-                return {
-                    ...this.controlFlowReplacerFactory(controlFlowReplacerName).replace(node, parentNode, controlFlowStorage),
-                    parentNode
-                };
-            }
-        });
-    }
-}