javascript-obfuscator 2.18.0 → 3.0.0

package/src/JavaScriptObfuscator.ts

@@ -1,311 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from './container/ServiceIdentifiers';
-
-import * as acorn from 'acorn';
-import * as escodegen from '@javascript-obfuscator/escodegen';
-import * as ESTree from 'estree';
-
-import { TObfuscationResultFactory } from './types/container/source-code/TObfuscationResultFactory';
-
-import { ICodeTransformersRunner } from './interfaces/code-transformers/ICodeTransformersRunner';
-import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
-import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
-import { ILogger } from './interfaces/logger/ILogger';
-import { IObfuscationResult } from './interfaces/source-code/IObfuscationResult';
-import { IOptions } from './interfaces/options/IOptions';
-import { IRandomGenerator } from './interfaces/utils/IRandomGenerator';
-import { INodeTransformersRunner } from './interfaces/node-transformers/INodeTransformersRunner';
-
-import { CodeTransformer } from './enums/code-transformers/CodeTransformer';
-import { CodeTransformationStage } from './enums/code-transformers/CodeTransformationStage';
-import { LoggingMessage } from './enums/logger/LoggingMessage';
-import { NodeTransformer } from './enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from './enums/node-transformers/NodeTransformationStage';
-
-import { ecmaVersion } from './constants/EcmaVersion';
-
-import { ASTParserFacade } from './ASTParserFacade';
-import { NodeGuards } from './node/NodeGuards';
-import { Utils } from './utils/Utils';
-import { SourceMapSourcesMode } from './enums/source-map/SourceMapSourcesMode';
-
-@injectable()
-export class JavaScriptObfuscator implements IJavaScriptObfuscator {
-    /**
-     * @type {Options}
-     */
-    private static readonly parseOptions: acorn.Options = {
-        ecmaVersion,
-        allowHashBang: true,
-        allowImportExportEverywhere: true,
-        allowReturnOutsideFunction: true,
-        locations: true,
-        ranges: true
-    };
-
-    /**
-     * @type {GenerateOptions}
-     */
-    private static readonly escodegenParams: escodegen.GenerateOptions = {
-        comment: true,
-        verbatim: 'x-verbatim-property',
-        sourceMapWithCode: true
-    };
-
-    /**
-     * @type {CodeTransformer[]}
-     */
-    private static readonly codeTransformersList: CodeTransformer[] = [
-        CodeTransformer.HashbangOperatorTransformer
-    ];
-
-    /**
-     * @type {NodeTransformer[]}
-     */
-    private static readonly nodeTransformersList: NodeTransformer[] = [
-        NodeTransformer.BooleanLiteralTransformer,
-        NodeTransformer.BlockStatementControlFlowTransformer,
-        NodeTransformer.BlockStatementSimplifyTransformer,
-        NodeTransformer.ClassFieldTransformer,
-        NodeTransformer.CommentsTransformer,
-        NodeTransformer.CustomCodeHelpersTransformer,
-        NodeTransformer.DeadCodeInjectionTransformer,
-        NodeTransformer.EscapeSequenceTransformer,
-        NodeTransformer.EvalCallExpressionTransformer,
-        NodeTransformer.ExportSpecifierTransformer,
-        NodeTransformer.ExpressionStatementsMergeTransformer,
-        NodeTransformer.FunctionControlFlowTransformer,
-        NodeTransformer.IfStatementSimplifyTransformer,
-        NodeTransformer.LabeledStatementTransformer,
-        NodeTransformer.RenamePropertiesTransformer,
-        NodeTransformer.MemberExpressionTransformer,
-        NodeTransformer.MetadataTransformer,
-        NodeTransformer.NumberLiteralTransformer,
-        NodeTransformer.NumberToNumericalExpressionTransformer,
-        NodeTransformer.ObfuscatingGuardsTransformer,
-        NodeTransformer.ObjectExpressionKeysTransformer,
-        NodeTransformer.ObjectExpressionTransformer,
-        NodeTransformer.ObjectPatternPropertiesTransformer,
-        NodeTransformer.ParentificationTransformer,
-        NodeTransformer.ScopeIdentifiersTransformer,
-        NodeTransformer.ScopeThroughIdentifiersTransformer,
-        NodeTransformer.SplitStringTransformer,
-        NodeTransformer.StringArrayRotateFunctionTransformer,
-        NodeTransformer.StringArrayScopeCallsWrapperTransformer,
-        NodeTransformer.StringArrayTransformer,
-        NodeTransformer.TemplateLiteralTransformer,
-        NodeTransformer.DirectivePlacementTransformer,
-        NodeTransformer.VariableDeclarationsMergeTransformer,
-        NodeTransformer.VariablePreserveTransformer
-    ];
-
-    /**
-     * @type {ICodeTransformersRunner}
-     */
-    private readonly codeTransformersRunner: ICodeTransformersRunner;
-
-    /**
-     * @type {ILogger}
-     */
-    private readonly logger: ILogger;
-
-    /**
-     * @type {TObfuscationResultFactory}
-     */
-    private readonly obfuscationResultFactory: TObfuscationResultFactory;
-
-    /**
-     * @type {IOptions}
-     */
-    private readonly options: IOptions;
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    private readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @type {INodeTransformersRunner}
-     */
-    private readonly nodeTransformersRunner: INodeTransformersRunner;
-
-    /**
-     * @param {ICodeTransformersRunner} codeTransformersRunner
-     * @param {INodeTransformersRunner} nodeTransformersRunner
-     * @param {IRandomGenerator} randomGenerator
-     * @param {TObfuscationResultFactory} obfuscatedCodeFactory
-     * @param {ILogger} logger
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.ICodeTransformersRunner) codeTransformersRunner: ICodeTransformersRunner,
-        @inject(ServiceIdentifiers.INodeTransformersRunner) nodeTransformersRunner: INodeTransformersRunner,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.Factory__IObfuscationResult) obfuscatedCodeFactory: TObfuscationResultFactory,
-        @inject(ServiceIdentifiers.ILogger) logger: ILogger,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.codeTransformersRunner = codeTransformersRunner;
-        this.nodeTransformersRunner = nodeTransformersRunner;
-        this.randomGenerator = randomGenerator;
-        this.obfuscationResultFactory = obfuscatedCodeFactory;
-        this.logger = logger;
-        this.options = options;
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @returns {IObfuscationResult}
-     */
-    public obfuscate (sourceCode: string): IObfuscationResult {
-        if (typeof sourceCode !== 'string') {
-            sourceCode = '';
-        }
-
-        const timeStart: number = Date.now();
-        this.logger.info(LoggingMessage.Version, Utils.buildVersionMessage(process.env.VERSION, process.env.BUILD_TIMESTAMP));
-        this.logger.info(LoggingMessage.ObfuscationStarted);
-        this.logger.info(LoggingMessage.RandomGeneratorSeed, this.randomGenerator.getInputSeed());
-
-        // preparing code transformations
-        sourceCode = this.runCodeTransformationStage(sourceCode, CodeTransformationStage.PreparingTransformers);
-
-        // parse AST tree
-        const astTree: ESTree.Program = this.parseCode(sourceCode);
-
-        // obfuscate AST tree
-        const obfuscatedAstTree: ESTree.Program = this.transformAstTree(astTree);
-
-        // generate code
-        const generatorOutput: IGeneratorOutput = this.generateCode(sourceCode, obfuscatedAstTree);
-
-        // finalizing code transformations
-        generatorOutput.code = this.runCodeTransformationStage(generatorOutput.code, CodeTransformationStage.FinalizingTransformers);
-
-        const obfuscationTime: number = (Date.now() - timeStart) / 1000;
-        this.logger.success(LoggingMessage.ObfuscationCompleted, obfuscationTime);
-
-        return this.getObfuscationResult(generatorOutput);
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @returns {Program}
-     */
-    private parseCode (sourceCode: string): ESTree.Program {
-        return ASTParserFacade.parse(sourceCode, JavaScriptObfuscator.parseOptions);
-    }
-
-    /**
-     * @param {Program} astTree
-     * @returns {Program}
-     */
-    private transformAstTree (astTree: ESTree.Program): ESTree.Program {
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Initializing);
-
-        const isEmptyAstTree: boolean = NodeGuards.isProgramNode(astTree)
-            && !astTree.body.length
-            && !astTree.leadingComments
-            && !astTree.trailingComments;
-
-        if (isEmptyAstTree) {
-            this.logger.warn(LoggingMessage.EmptySourceCode);
-
-            return astTree;
-        }
-
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Preparing);
-
-        if (this.options.deadCodeInjection) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.DeadCodeInjection);
-        }
-
-        if (this.options.controlFlowFlattening) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
-        }
-
-        if (this.options.renameProperties) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameProperties);
-        }
-
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameIdentifiers);
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.StringArray);
-
-        if (this.options.simplify) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Simplifying);
-        }
-
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Finalizing);
-
-        return astTree;
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @param {Program} astTree
-     * @returns {IGeneratorOutput}
-     */
-    private generateCode (sourceCode: string, astTree: ESTree.Program): IGeneratorOutput {
-        const escodegenParams: escodegen.GenerateOptions = {
-            ...JavaScriptObfuscator.escodegenParams,
-            format: {
-                compact: this.options.compact
-            },
-            ...this.options.sourceMap && {
-                ...this.options.sourceMapSourcesMode === SourceMapSourcesMode.SourcesContent
-                    ? {
-                        sourceMap: 'sourceMap',
-                        sourceContent: sourceCode
-                    }
-                    : {
-                        sourceMap: this.options.inputFileName || 'sourceMap'
-                    }
-            }
-        };
-
-        const generatorOutput: IGeneratorOutput = escodegen.generate(astTree, escodegenParams);
-
-        generatorOutput.map = generatorOutput.map ? generatorOutput.map.toString() : '';
-
-        return generatorOutput;
-    }
-
-    /**
-     * @param {IGeneratorOutput} generatorOutput
-     * @returns {IObfuscationResult}
-     */
-    private getObfuscationResult (generatorOutput: IGeneratorOutput): IObfuscationResult {
-        return this.obfuscationResultFactory(generatorOutput.code, generatorOutput.map);
-    }
-
-    /**
-     * @param {string} code
-     * @param {CodeTransformationStage} codeTransformationStage
-     * @returns {string}
-     */
-    private runCodeTransformationStage (code: string, codeTransformationStage: CodeTransformationStage): string {
-        this.logger.info(LoggingMessage.CodeTransformationStage, codeTransformationStage);
-
-        return this.codeTransformersRunner.transform(
-            code,
-            JavaScriptObfuscator.codeTransformersList,
-            codeTransformationStage
-        );
-    }
-
-    /**
-     * @param {Program} astTree
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {Program}
-     */
-    private runNodeTransformationStage (astTree: ESTree.Program, nodeTransformationStage: NodeTransformationStage): ESTree.Program {
-        this.logger.info(LoggingMessage.NodeTransformationStage, nodeTransformationStage);
-
-        return this.nodeTransformersRunner.transform(
-            astTree,
-            JavaScriptObfuscator.nodeTransformersList,
-            nodeTransformationStage
-        );
-    }
-}

package/src/JavaScriptObfuscatorCLIFacade.ts

@@ -1,17 +0,0 @@
-import 'reflect-metadata';
-
-import { JavaScriptObfuscatorCLI } from './cli/JavaScriptObfuscatorCLI';
-
-class JavaScriptObfuscatorCLIFacade {
-    /**
-     * @param {string[]} argv
-     */
-    public static obfuscate (argv: string[]): void {
-        const javaScriptObfuscatorCLI: JavaScriptObfuscatorCLI = new JavaScriptObfuscatorCLI(argv);
-
-        javaScriptObfuscatorCLI.initialize();
-        javaScriptObfuscatorCLI.run();
-    }
-}
-
-export { JavaScriptObfuscatorCLIFacade as JavaScriptObfuscatorCLI };

package/src/JavaScriptObfuscatorFacade.ts

@@ -1,93 +0,0 @@
-import 'reflect-metadata';
-
-import { ServiceIdentifiers } from './container/ServiceIdentifiers';
-
-import { TDictionary } from './types/TDictionary';
-import { TInputOptions } from './types/options/TInputOptions';
-import { TObfuscationResultsObject } from './types/TObfuscationResultsObject';
-import { TOptionsPreset } from './types/options/TOptionsPreset';
-
-import { IInversifyContainerFacade } from './interfaces/container/IInversifyContainerFacade';
-import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
-import { IObfuscationResult } from './interfaces/source-code/IObfuscationResult';
-
-import { InversifyContainerFacade } from './container/InversifyContainerFacade';
-import { Options } from './options/Options';
-import { Utils } from './utils/Utils';
-
-class JavaScriptObfuscatorFacade {
-    /**
-     * @type {string | undefined}
-     */
-    public static version: string = process.env.VERSION ?? 'unknown';
-
-    /**
-     * @param {string} sourceCode
-     * @param {TInputOptions} inputOptions
-     * @returns {IObfuscationResult}
-     */
-    public static obfuscate (sourceCode: string, inputOptions: TInputOptions = {}): IObfuscationResult {
-        const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
-
-        inversifyContainerFacade.load(sourceCode, '', inputOptions);
-
-        const javaScriptObfuscator: IJavaScriptObfuscator = inversifyContainerFacade
-            .get<IJavaScriptObfuscator>(ServiceIdentifiers.IJavaScriptObfuscator);
-        const obfuscationResult: IObfuscationResult = javaScriptObfuscator.obfuscate(sourceCode);
-
-        inversifyContainerFacade.unload();
-
-        return obfuscationResult;
-    }
-
-    /**
-     * @param {TSourceCodesObject} sourceCodesObject
-     * @param {TInputOptions} inputOptions
-     * @returns {TObfuscationResultsObject<TSourceCodesObject>}
-     */
-    public static obfuscateMultiple <TSourceCodesObject extends TDictionary<string>> (
-        sourceCodesObject: TSourceCodesObject,
-        inputOptions: TInputOptions = {}
-    ): TObfuscationResultsObject<TSourceCodesObject> {
-        if (typeof sourceCodesObject !== 'object') {
-            throw new Error('Source codes object should be a plain object');
-        }
-
-        return Object
-            .keys(sourceCodesObject)
-            .reduce(
-                (
-                    acc: TObfuscationResultsObject<TSourceCodesObject>,
-                    sourceCodeIdentifier: keyof TSourceCodesObject,
-                    index: number
-                ) => {
-                    const identifiersPrefix: string = Utils.getIdentifiersPrefixForMultipleSources(
-                        inputOptions.identifiersPrefix,
-                        index
-                    );
-
-                    const sourceCode: string = sourceCodesObject[sourceCodeIdentifier];
-                    const sourceCodeOptions: TInputOptions = {
-                        ...inputOptions,
-                        identifiersPrefix
-                    };
-
-                    return {
-                        ...acc,
-                        [sourceCodeIdentifier]: JavaScriptObfuscatorFacade.obfuscate(sourceCode, sourceCodeOptions)
-                    };
-                },
-                <TObfuscationResultsObject<TSourceCodesObject>>{}
-            );
-    }
-
-    /**
-     * @param {TOptionsPreset} optionsPreset
-     * @returns {TInputOptions}
-     */
-    public static getOptionsByPreset (optionsPreset: TOptionsPreset): TInputOptions {
-        return Options.getOptionsByPreset(optionsPreset);
-    }
-}
-
-export { JavaScriptObfuscatorFacade as JavaScriptObfuscator };

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;
-    }
-}