javascript-obfuscator 2.18.1 → 3.0.1

package/src/node-transformers/converting-transformers/TemplateLiteralTransformer.ts

@@ -1,137 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeUtils } from '../../node/NodeUtils';
-
-/**
- * Transform ES2015 template literals to ES5
- * Thanks to Babel for algorithm
- */
-@injectable()
-export class TemplateLiteralTransformer extends AbstractNodeTransformer {
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {NodeGuards} node
-     * @returns {boolean}
-     */
-    private static isLiteralNodeWithStringValue (node: ESTree.Node | undefined): boolean {
-        return !!node && NodeGuards.isLiteralNode(node) && typeof node.value === 'string';
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Converting:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isTemplateLiteralNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {ESTree.TemplateLiteral} templateLiteralNode
-     * @param {ESTree.Node} parentNode
-     * @returns {ESTree.Node}
-     */
-    public transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
-        if (NodeGuards.isTaggedTemplateExpressionNode(parentNode)) {
-            return templateLiteralNode;
-        }
-
-        return this.transformTemplateLiteralNode(templateLiteralNode, parentNode);
-    }
-
-    /**
-     * @param {ESTree.TemplateLiteral} templateLiteralNode
-     * @param {ESTree.Node} parentNode
-     * @returns {ESTree.Expression}
-     */
-    private transformTemplateLiteralNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Expression {
-        const templateLiteralExpressions: ESTree.Expression[] = templateLiteralNode.expressions;
-
-        let nodes: ESTree.Expression[] = [];
-
-        templateLiteralNode.quasis.forEach((templateElement: ESTree.TemplateElement) => {
-            if (templateElement.value.cooked === undefined || templateElement.value.cooked === null) {
-                return;
-            }
-
-            nodes.push(NodeFactory.literalNode(templateElement.value.cooked));
-
-            const expression: ESTree.Expression | undefined = templateLiteralExpressions.shift();
-
-            if (!expression) {
-                return;
-            }
-
-            nodes.push(expression);
-        });
-
-        nodes = nodes.filter((node: ESTree.Literal | ESTree.Expression) => {
-            return !(NodeGuards.isLiteralNode(node) && node.value === '');
-        });
-
-        // since `+` is left-to-right associative
-        // ensure the first node is a string if first/second isn't
-        if (
-            !TemplateLiteralTransformer.isLiteralNodeWithStringValue(nodes[0]) &&
-            !TemplateLiteralTransformer.isLiteralNodeWithStringValue(nodes[1])
-        ) {
-            nodes.unshift(NodeFactory.literalNode(''));
-        }
-
-        let transformedNode: ESTree.Node;
-
-        if (nodes.length > 1) {
-            let root: ESTree.BinaryExpression = NodeFactory.binaryExpressionNode(
-                '+',
-                <ESTree.Literal>nodes.shift(),
-                <ESTree.Expression>nodes.shift()
-            );
-
-            nodes.forEach((node: ESTree.Literal | ESTree.Expression) => {
-                root = NodeFactory.binaryExpressionNode('+', root, node);
-            });
-
-            transformedNode = root;
-        } else {
-            transformedNode = nodes[0];
-        }
-
-        NodeUtils.parentizeAst(transformedNode);
-        NodeUtils.parentizeNode(transformedNode, parentNode);
-
-        return transformedNode;
-    }
-}

package/src/node-transformers/converting-transformers/object-expression-extractors/BasePropertiesExtractor.ts

@@ -1,227 +0,0 @@
-import { injectable } from 'inversify';
-
-import * as ESTree from 'estree';
-
-import { TNodeWithStatements } from '../../../types/node/TNodeWithStatements';
-import { IObjectExpressionExtractorResult } from '../../../interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractorResult';
-
-import { IObjectExpressionExtractor } from '../../../interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractor';
-
-import { NodeAppender } from '../../../node/NodeAppender';
-import { NodeFactory } from '../../../node/NodeFactory';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeStatementUtils } from '../../../node/NodeStatementUtils';
-import { NodeUtils } from '../../../node/NodeUtils';
-
-@injectable()
-export class BasePropertiesExtractor implements IObjectExpressionExtractor {
-    /**
-     * @param {Property} propertyNode
-     * @returns {string | null}
-     */
-    private static getPropertyNodeKeyName (propertyNode: ESTree.Property): string | null {
-        const propertyKeyNode: ESTree.Expression | ESTree.PrivateIdentifier = propertyNode.key;
-
-        if (
-            NodeGuards.isLiteralNode(propertyKeyNode)
-            && (
-                typeof propertyKeyNode.value === 'string'
-                || typeof propertyKeyNode.value === 'number'
-            )
-        ) {
-            return propertyKeyNode.value.toString();
-        }
-
-        if (NodeGuards.isIdentifierNode(propertyKeyNode)) {
-            return propertyKeyNode.name;
-        }
-
-        return null;
-    }
-
-    /**
-     * @param {Property} node
-     * @returns {boolean}
-     */
-    private static isProhibitedPropertyNode (node: ESTree.Property): boolean {
-        return node.kind !== 'init';
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {propertyValueNode is Pattern}
-     */
-    private static isProhibitedPattern (node: ESTree.Node): node is ESTree.Pattern {
-        return !node
-            || NodeGuards.isObjectPatternNode(node)
-            || NodeGuards.isArrayPatternNode(node)
-            || NodeGuards.isAssignmentPatternNode(node)
-            || NodeGuards.isRestElementNode(node);
-    }
-
-    /**
-     * @param {Property} property
-     * @returns {boolean}
-     */
-    private static shouldCreateLiteralNode (property: ESTree.Property): boolean {
-        return !property.computed
-            || (property.computed && !!property.key && NodeGuards.isLiteralNode(property.key));
-    }
-
-    /**
-     * extracts object expression properties:
-     *     var _0xabc123 = {
-     *          foo: 1,
-     *          bar: 2
-     *     };
-     *
-     * to:
-     *     var _0xabc123 = {};
-     *     _0xabc123['foo'] = 1;
-     *     _0xabc123['bar'] = 2;
-     *
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Statement} hostStatement
-     * @returns {IObjectExpressionExtractorResult}
-     */
-    public extract (
-        objectExpressionNode: ESTree.ObjectExpression,
-        hostStatement: ESTree.Statement
-    ): IObjectExpressionExtractorResult {
-        const hostNode: ESTree.Node | undefined = objectExpressionNode.parentNode;
-
-        if (
-            hostNode
-            && NodeGuards.isVariableDeclaratorNode(hostNode)
-            && NodeGuards.isIdentifierNode(hostNode.id)
-        ) {
-            return this.transformObjectExpressionNode(objectExpressionNode, hostStatement, hostNode.id);
-        }
-
-        return {
-            nodeToReplace: objectExpressionNode,
-            objectExpressionHostStatement: hostStatement,
-            objectExpressionNode: objectExpressionNode
-        };
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Statement} hostStatement
-     * @param {Expression} memberExpressionHostNode
-     * @returns {IObjectExpressionExtractorResult}
-     */
-    private transformObjectExpressionNode (
-        objectExpressionNode: ESTree.ObjectExpression,
-        hostStatement: ESTree.Statement,
-        memberExpressionHostNode: ESTree.Expression
-    ): IObjectExpressionExtractorResult {
-        const properties: (ESTree.Property | ESTree.SpreadElement)[] = objectExpressionNode.properties;
-        const [expressionStatements, removablePropertyIds]: [ESTree.ExpressionStatement[], number[]] = this
-            .extractPropertiesToExpressionStatements(
-                properties,
-                hostStatement,
-                memberExpressionHostNode
-            );
-
-        const hostNodeWithStatements: TNodeWithStatements = NodeStatementUtils.getScopeOfNode(hostStatement);
-
-        this.filterExtractedObjectExpressionProperties(objectExpressionNode, removablePropertyIds);
-        NodeAppender.insertAfter(hostNodeWithStatements, expressionStatements, hostStatement);
-        NodeUtils.parentizeAst(hostNodeWithStatements);
-
-        return {
-            nodeToReplace: objectExpressionNode,
-            objectExpressionHostStatement: hostStatement,
-            objectExpressionNode: objectExpressionNode
-        };
-    }
-
-    /**
-     * @param {(Property | SpreadElement)[]} properties
-     * @param {Statement} hostStatement
-     * @param {Expression} memberExpressionHostNode
-     * @returns {[ExpressionStatement[], number[]]}
-     */
-    private extractPropertiesToExpressionStatements (
-        properties: (ESTree.Property | ESTree.SpreadElement)[],
-        hostStatement: ESTree.Statement,
-        memberExpressionHostNode: ESTree.Expression
-    ): [ESTree.ExpressionStatement[], number[]] {
-        const propertiesLength: number = properties.length;
-        const expressionStatements: ESTree.ExpressionStatement[] = [];
-        const removablePropertyIds: number[] = [];
-
-        // have to iterate in the reversed order to fast check spread elements and break iteration on them
-        for (let i: number = propertiesLength - 1; i >= 0; i--) {
-            const property: (ESTree.Property | ESTree.SpreadElement) = properties[i];
-
-            // spread element
-            if (NodeGuards.isSpreadElementNode(property)) {
-                break;
-            }
-
-            if (BasePropertiesExtractor.isProhibitedPropertyNode(property)) {
-                continue;
-            }
-
-            const propertyValue: ESTree.Expression | ESTree.Pattern = property.value;
-
-            // invalid property node value
-            if (BasePropertiesExtractor.isProhibitedPattern(propertyValue)) {
-                continue;
-            }
-
-            /**
-             * Stage 1: extract property node key names
-             */
-            const propertyKeyName: string | null = BasePropertiesExtractor.getPropertyNodeKeyName(property);
-
-            if (!propertyKeyName) {
-                continue;
-            }
-
-            /**
-             * Stage 2: creating new expression statement node with member expression based on removed property
-             */
-            const shouldCreateLiteralNode: boolean = BasePropertiesExtractor.shouldCreateLiteralNode(property);
-            const memberExpressionProperty: ESTree.Expression = shouldCreateLiteralNode
-                ? NodeFactory.literalNode(propertyKeyName)
-                : NodeFactory.identifierNode(propertyKeyName);
-            const memberExpressionNode: ESTree.MemberExpression = NodeFactory
-                .memberExpressionNode(memberExpressionHostNode, memberExpressionProperty, true);
-            const expressionStatementNode: ESTree.ExpressionStatement = NodeFactory.expressionStatementNode(
-                NodeFactory.assignmentExpressionNode('=', memberExpressionNode, propertyValue)
-            );
-
-            /**
-             * Stage 3: recursively processing nested object expressions
-             */
-            if (NodeGuards.isObjectExpressionNode(property.value)) {
-                this.transformObjectExpressionNode(property.value, hostStatement, memberExpressionNode);
-            }
-
-            /**
-             * Stage 4: filling arrays
-             */
-            expressionStatements.unshift(expressionStatementNode);
-            removablePropertyIds.unshift(i);
-        }
-
-        return [expressionStatements, removablePropertyIds];
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {number[]} removablePropertyIds
-     */
-    private filterExtractedObjectExpressionProperties (
-        objectExpressionNode: ESTree.ObjectExpression,
-        removablePropertyIds: number[]
-    ): void {
-        objectExpressionNode.properties = objectExpressionNode.properties
-            .filter((property: ESTree.Property | ESTree.SpreadElement, index: number) =>
-                !removablePropertyIds.includes(index)
-            );
-    }
-}

package/src/node-transformers/converting-transformers/object-expression-extractors/ObjectExpressionToVariableDeclarationExtractor.ts

@@ -1,165 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TNodeWithStatements } from '../../../types/node/TNodeWithStatements';
-import { TObjectExpressionKeysTransformerCustomNodeFactory } from '../../../types/container/custom-nodes/TObjectExpressionKeysTransformerCustomNodeFactory';
-import { IObjectExpressionExtractorResult } from '../../../interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractorResult';
-import { TStatement } from '../../../types/node/TStatement';
-
-import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { TInitialData } from '../../../types/TInitialData';
-import { IObjectExpressionExtractor } from '../../../interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractor';
-
-import { ObjectExpressionKeysTransformerCustomNode } from '../../../enums/custom-nodes/ObjectExpressionKeysTransformerCustomNode';
-
-import { ObjectExpressionVariableDeclarationHostNode } from '../../../custom-nodes/object-expression-keys-transformer-nodes/ObjectExpressionVariableDeclarationHostNode';
-import { NodeAppender } from '../../../node/NodeAppender';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeStatementUtils } from '../../../node/NodeStatementUtils';
-import { NodeUtils } from '../../../node/NodeUtils';
-import { TNodeWithLexicalScope } from '../../../types/node/TNodeWithLexicalScope';
-import { NodeLexicalScopeUtils } from '../../../node/NodeLexicalScopeUtils';
-
-@injectable()
-export class ObjectExpressionToVariableDeclarationExtractor implements IObjectExpressionExtractor {
-    /**
-     * @type {TObjectExpressionKeysTransformerCustomNodeFactory}
-     */
-    private readonly objectExpressionKeysTransformerCustomNodeFactory: TObjectExpressionKeysTransformerCustomNodeFactory;
-
-    /**
-     * @param {TObjectExpressionKeysTransformerCustomNodeFactory} objectExpressionKeysTransformerCustomNodeFactory
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IObjectExpressionKeysTransformerCustomNode)
-            objectExpressionKeysTransformerCustomNodeFactory: TObjectExpressionKeysTransformerCustomNodeFactory,
-    ) {
-        this.objectExpressionKeysTransformerCustomNodeFactory = objectExpressionKeysTransformerCustomNodeFactory;
-    }
-
-    /**
-     * extracts object expression:
-     *     var object = {
-     *          foo: 1,
-     *          bar: 2
-     *     };
-     *
-     * to:
-     *     var _0xabc123 = {
-     *          foo: 1,
-     *          bar: 2
-     *     };
-     *     var object = _0xabc123;
-     *
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Statement} hostStatement
-     * @returns {IObjectExpressionExtractorResult}
-     */
-    public extract (
-        objectExpressionNode: ESTree.ObjectExpression,
-        hostStatement: ESTree.Statement
-    ): IObjectExpressionExtractorResult {
-        return this.transformObjectExpressionToVariableDeclaration(
-            objectExpressionNode,
-            hostStatement
-        );
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Statement} hostStatement
-     * @returns {Node}
-     */
-    private transformObjectExpressionToVariableDeclaration (
-        objectExpressionNode: ESTree.ObjectExpression,
-        hostStatement: ESTree.Statement
-    ): IObjectExpressionExtractorResult {
-        const hostNodeWithStatements: TNodeWithStatements = NodeStatementUtils.getScopeOfNode(hostStatement);
-        const lexicalScopeNode: TNodeWithLexicalScope | null = NodeGuards.isNodeWithLexicalScope(hostNodeWithStatements)
-            ? hostNodeWithStatements
-            : NodeLexicalScopeUtils.getLexicalScope(hostNodeWithStatements) ?? null;
-
-        if (!lexicalScopeNode) {
-            throw new Error('Cannot find lexical scope node for the host statement node');
-        }
-
-        const properties: (ESTree.Property | ESTree.SpreadElement)[] = objectExpressionNode.properties;
-
-        const newObjectExpressionHostStatement: ESTree.VariableDeclaration = this.getObjectExpressionHostNode(
-            lexicalScopeNode,
-            properties
-        );
-        const statementsToInsert: TStatement[] = [newObjectExpressionHostStatement];
-
-        NodeAppender.insertBefore(hostNodeWithStatements, statementsToInsert, hostStatement);
-        NodeUtils.parentizeAst(newObjectExpressionHostStatement);
-        NodeUtils.parentizeNode(newObjectExpressionHostStatement, hostNodeWithStatements);
-
-        const newObjectExpressionIdentifier: ESTree.Identifier = this.getObjectExpressionIdentifierNode(newObjectExpressionHostStatement);
-        const newObjectExpressionNode: ESTree.ObjectExpression = this.getObjectExpressionNode(newObjectExpressionHostStatement);
-
-        return {
-            nodeToReplace: newObjectExpressionIdentifier,
-            objectExpressionHostStatement: newObjectExpressionHostStatement,
-            objectExpressionNode: newObjectExpressionNode
-        };
-    }
-
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @param {(Property | SpreadElement)[]} properties
-     * @returns {VariableDeclaration}
-     */
-    private getObjectExpressionHostNode (
-        lexicalScopeNode: TNodeWithLexicalScope,
-        properties: (ESTree.Property | ESTree.SpreadElement)[]
-    ): ESTree.VariableDeclaration {
-        const variableDeclarationHostNodeCustomNode: ICustomNode<TInitialData<ObjectExpressionVariableDeclarationHostNode>> =
-            this.objectExpressionKeysTransformerCustomNodeFactory(
-                ObjectExpressionKeysTransformerCustomNode.ObjectExpressionVariableDeclarationHostNode
-            );
-
-        variableDeclarationHostNodeCustomNode.initialize(lexicalScopeNode, properties);
-
-        const statementNode: TStatement = variableDeclarationHostNodeCustomNode.getNode()[0];
-
-        if (
-            !statementNode
-            || !NodeGuards.isVariableDeclarationNode(statementNode)
-        ) {
-            throw new Error('`objectExpressionHostCustomNode.getNode()[0]` should returns array with `VariableDeclaration` node');
-        }
-
-        return statementNode;
-    }
-
-    /**
-     * @param {VariableDeclaration} objectExpressionHostNode
-     * @returns {Identifier}
-     */
-    private getObjectExpressionIdentifierNode (objectExpressionHostNode: ESTree.VariableDeclaration): ESTree.Identifier {
-        const newObjectExpressionIdentifierNode: ESTree.Pattern = objectExpressionHostNode.declarations[0].id;
-
-        if (!NodeGuards.isIdentifierNode(newObjectExpressionIdentifierNode)) {
-            throw new Error('`objectExpressionHostNode` should contain `VariableDeclarator` node with `Identifier` id property');
-        }
-
-        return newObjectExpressionIdentifierNode;
-    }
-
-    /**
-     * @param {VariableDeclaration} objectExpressionHostNode
-     * @returns {Identifier}
-     */
-    private getObjectExpressionNode (objectExpressionHostNode: ESTree.VariableDeclaration): ESTree.ObjectExpression {
-        const newObjectExpressionNode: ESTree.Expression | null = objectExpressionHostNode.declarations[0].init ?? null;
-
-        if (!newObjectExpressionNode || !NodeGuards.isObjectExpressionNode(newObjectExpressionNode)) {
-            throw new Error('`objectExpressionHostNode` should contain `VariableDeclarator` node with `ObjectExpression` init property');
-        }
-
-        return newObjectExpressionNode;
-    }
-}

package/src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionIdentifiersTransformer.ts

@@ -1,141 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as eslintScope from 'eslint-scope';
-import * as ESTree from 'estree';
-
-import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
-import { IIdentifierReplacer } from '../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
-import { IScopeThroughIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeThroughIdentifiersTraverserCallbackData';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-
-/**
- * Renames all scope through identifiers for Dead Code Injection
- */
-@injectable()
-export class DeadCodeInjectionIdentifiersTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {IIdentifierReplacer}
-     */
-    private readonly identifierReplacer: IIdentifierReplacer;
-
-    /**
-     * @type {IScopeIdentifiersTraverser}
-     */
-    private readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
-
-    /**
-     * @param {IIdentifierReplacer} identifierReplacer
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     * @param {IScopeIdentifiersTraverser} scopeIdentifiersTraverser
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IIdentifierReplacer) identifierReplacer: IIdentifierReplacer,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions,
-        @inject(ServiceIdentifiers.IScopeIdentifiersTraverser) scopeIdentifiersTraverser: IScopeIdentifiersTraverser
-    ) {
-        super(randomGenerator, options);
-
-        this.identifierReplacer = identifierReplacer;
-        this.scopeIdentifiersTraverser = scopeIdentifiersTraverser;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.RenameIdentifiers:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isProgramNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {VariableDeclaration} programNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node {
-        this.scopeIdentifiersTraverser.traverseScopeThroughIdentifiers(
-            programNode,
-            parentNode,
-            (data: IScopeThroughIdentifiersTraverserCallbackData) => {
-                const {
-                    reference,
-                    variableLexicalScopeNode
-                } = data;
-
-                this.transformScopeThroughIdentifiers(reference, variableLexicalScopeNode);
-            }
-        );
-
-        return programNode;
-    }
-
-    /**
-     * @param {Reference} reference
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     */
-    private transformScopeThroughIdentifiers (
-        reference: eslintScope.Reference,
-        lexicalScopeNode: TNodeWithLexicalScope,
-    ): void {
-        if (reference.resolved) {
-            return;
-        }
-
-        const identifier: ESTree.Identifier = reference.identifier;
-
-        this.storeIdentifierName(identifier, lexicalScopeNode);
-        this.replaceIdentifierName(identifier, lexicalScopeNode, reference);
-    }
-
-    /**
-     * @param {Identifier} identifierNode
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     */
-    private storeIdentifierName (
-        identifierNode: ESTree.Identifier,
-        lexicalScopeNode: TNodeWithLexicalScope
-    ): void {
-        this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
-    }
-
-    /**
-     * @param {Identifier} identifierNode
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @param {Variable} reference
-     */
-    private replaceIdentifierName (
-        identifierNode: ESTree.Identifier,
-        lexicalScopeNode: TNodeWithLexicalScope,
-        reference: eslintScope.Reference
-    ): void {
-        const newIdentifier: ESTree.Identifier = this.identifierReplacer
-            .replace(identifierNode, lexicalScopeNode);
-
-        // rename of identifier
-        reference.identifier.name = newIdentifier.name;
-    }
-}