javascript-obfuscator 2.18.1 → 3.0.1

package/src/node-transformers/control-flow-transformers/control-flow-replacers/AbstractControlFlowReplacer.ts

@@ -1,123 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
-
-import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
-import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-
-@injectable()
-export abstract class AbstractControlFlowReplacer implements IControlFlowReplacer {
-    /**
-     * @type {TControlFlowCustomNodeFactory}
-     */
-    protected readonly controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory;
-
-    /**
-     * @type {IOptions}
-     */
-    protected readonly options: IOptions;
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    protected readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @type {Map<string, Map<string, string[]>>}
-     */
-    protected readonly replacerDataByControlFlowStorageId: Map <string, Map<string, string[]>> = new Map();
-
-    /**
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.controlFlowCustomNodeFactory = controlFlowCustomNodeFactory;
-        this.randomGenerator = randomGenerator;
-        this.options = options;
-    }
-
-    /**
-     * @param {Map<string, Map<string, string[]>>} identifierDataByControlFlowStorageId
-     * @param {string} controlFlowStorageId
-     * @returns {Map<string, string[]>}
-     */
-    protected static getStorageKeysByIdForCurrentStorage (
-        identifierDataByControlFlowStorageId: Map<string, Map<string, string[]>>,
-        controlFlowStorageId: string
-    ): Map<string, string[]> {
-        let storageKeysById: Map<string, string[]>;
-
-        if (identifierDataByControlFlowStorageId.has(controlFlowStorageId)) {
-            storageKeysById = <Map<string, string[]>>identifierDataByControlFlowStorageId.get(controlFlowStorageId);
-        } else {
-            storageKeysById = new Map <string, string[]>();
-        }
-
-        return storageKeysById;
-    }
-
-    /**
-     * @param {ICustomNode} customNode
-     * @param {TControlFlowStorage} controlFlowStorage
-     * @param {string} replacerId
-     * @param {number} usingExistingIdentifierChance
-     * @returns {string}
-     */
-    protected insertCustomNodeToControlFlowStorage (
-        customNode: ICustomNode,
-        controlFlowStorage: TControlFlowStorage,
-        replacerId: string,
-        usingExistingIdentifierChance: number
-    ): string {
-        const controlFlowStorageId: string = controlFlowStorage.getStorageId();
-        const storageKeysById: Map<string, string[]> = AbstractControlFlowReplacer
-            .getStorageKeysByIdForCurrentStorage(this.replacerDataByControlFlowStorageId, controlFlowStorageId);
-        const storageKeysForCurrentId: string[] | undefined = storageKeysById.get(replacerId);
-
-        if (
-            this.randomGenerator.getMathRandom() < usingExistingIdentifierChance &&
-            storageKeysForCurrentId &&
-            storageKeysForCurrentId.length
-        ) {
-            return this.randomGenerator.getRandomGenerator().pickone(storageKeysForCurrentId);
-        }
-
-        const generateStorageKey: (length: number) => string = (length: number) => {
-            const key: string = this.randomGenerator.getRandomString(length);
-
-            if (controlFlowStorage.getStorage().has(key)) {
-                return generateStorageKey(length);
-            }
-
-            return key;
-        };
-        const storageKey: string = generateStorageKey(5);
-
-        storageKeysById.set(replacerId, [storageKey]);
-        this.replacerDataByControlFlowStorageId.set(controlFlowStorageId, storageKeysById);
-        controlFlowStorage.set(storageKey, customNode);
-
-        return storageKey;
-    }
-
-    /**
-     * @param {Node} node
-     * @param {Node} parentNode
-     * @param {TControlFlowStorage} controlFlowStorage
-     * @returns {Node}
-     */
-    public abstract replace (node: ESTree.Node, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
-}

package/src/node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.ts

@@ -1,71 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
-import { TInitialData } from '../../../types/TInitialData';
-
-import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-
-import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
-
-import { BinaryExpressionFunctionNode } from '../../../custom-nodes/control-flow-flattening-nodes/BinaryExpressionFunctionNode';
-import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
-
-@injectable()
-export class BinaryExpressionControlFlowReplacer extends ExpressionWithOperatorControlFlowReplacer {
-    /**
-     * @type {number}
-     */
-    private static readonly usingExistingIdentifierChance: number = 0.5;
-
-    /**
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(controlFlowCustomNodeFactory, randomGenerator, options);
-    }
-
-    /**
-     * @param {BinaryExpression} binaryExpressionNode
-     * @param {Node} parentNode
-     * @param {TControlFlowStorage} controlFlowStorage
-     * @returns {Node}
-     */
-    public replace (
-        binaryExpressionNode: ESTree.BinaryExpression,
-        parentNode: ESTree.Node,
-        controlFlowStorage: TControlFlowStorage
-    ): ESTree.Node {
-        const operator: ESTree.BinaryOperator = binaryExpressionNode.operator;
-        const binaryExpressionFunctionCustomNode: ICustomNode<TInitialData<BinaryExpressionFunctionNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.BinaryExpressionFunctionNode);
-
-        binaryExpressionFunctionCustomNode.initialize(operator);
-
-        const storageKey: string = this.insertCustomNodeToControlFlowStorage(
-            binaryExpressionFunctionCustomNode,
-            controlFlowStorage,
-            operator,
-            BinaryExpressionControlFlowReplacer.usingExistingIdentifierChance
-        );
-
-        return this.getControlFlowStorageCallNode(
-            controlFlowStorage.getStorageId(),
-            storageKey,
-            binaryExpressionNode.left,
-            binaryExpressionNode.right
-        );
-    }
-}

package/src/node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer.ts

@@ -1,108 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
-import { TInitialData } from '../../../types/TInitialData';
-import { TStatement } from '../../../types/node/TStatement';
-
-import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-
-import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
-
-import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
-import { CallExpressionFunctionNode } from '../../../custom-nodes/control-flow-flattening-nodes/CallExpressionFunctionNode';
-import { CallExpressionControlFlowStorageCallNode } from '../../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/CallExpressionControlFlowStorageCallNode';
-import { NodeGuards } from '../../../node/NodeGuards';
-
-@injectable()
-export class CallExpressionControlFlowReplacer extends AbstractControlFlowReplacer {
-    /**
-     * @type {number}
-     */
-    private static readonly usingExistingIdentifierChance: number = 0.5;
-
-    /**
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(controlFlowCustomNodeFactory, randomGenerator, options);
-    }
-
-    /**
-     * @param {CallExpression} callExpressionNode
-     * @param {NodeGuards} parentNode
-     * @param {TControlFlowStorage} controlFlowStorage
-     * @returns {NodeGuards}
-     */
-    public replace (
-        callExpressionNode: ESTree.CallExpression,
-        parentNode: ESTree.Node,
-        controlFlowStorage: TControlFlowStorage
-    ): ESTree.Node {
-        const callee: ESTree.Expression = <ESTree.Expression>callExpressionNode.callee;
-
-        if (!NodeGuards.isIdentifierNode(callee)) {
-            return callExpressionNode;
-        }
-
-        const replacerId: string = String(callExpressionNode.arguments.length);
-        const callExpressionFunctionCustomNode: ICustomNode<TInitialData<CallExpressionFunctionNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.CallExpressionFunctionNode);
-        const expressionArguments: (ESTree.Expression | ESTree.SpreadElement)[] = callExpressionNode.arguments;
-
-        callExpressionFunctionCustomNode.initialize(expressionArguments);
-
-        const storageKey: string = this.insertCustomNodeToControlFlowStorage(
-            callExpressionFunctionCustomNode,
-            controlFlowStorage,
-            replacerId,
-            CallExpressionControlFlowReplacer.usingExistingIdentifierChance
-        );
-
-        return this.getControlFlowStorageCallNode(
-            controlFlowStorage.getStorageId(),
-            storageKey,
-            callee,
-            expressionArguments
-        );
-    }
-
-    /**
-     * @param {string} controlFlowStorageId
-     * @param {string} storageKey
-     * @param {Expression} callee
-     * @param {(Expression | SpreadElement)[]} expressionArguments
-     * @returns {NodeGuards}
-     */
-    protected getControlFlowStorageCallNode (
-        controlFlowStorageId: string,
-        storageKey: string,
-        callee: ESTree.Expression,
-        expressionArguments: (ESTree.Expression | ESTree.SpreadElement)[]
-    ): ESTree.Node {
-        const controlFlowStorageCallCustomNode: ICustomNode<TInitialData<CallExpressionControlFlowStorageCallNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.CallExpressionControlFlowStorageCallNode);
-
-        controlFlowStorageCallCustomNode.initialize(controlFlowStorageId, storageKey, callee, expressionArguments);
-
-        const statementNode: TStatement = controlFlowStorageCallCustomNode.getNode()[0];
-
-        if (!statementNode || !NodeGuards.isExpressionStatementNode(statementNode)) {
-            throw new Error('`controlFlowStorageCallCustomNode.getNode()[0]` should returns array with `ExpressionStatement` node');
-        }
-
-        return statementNode.expression;
-    }
-}

package/src/node-transformers/control-flow-transformers/control-flow-replacers/ExpressionWithOperatorControlFlowReplacer.ts

@@ -1,62 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-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 { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-
-import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
-
-import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
-import { ExpressionWithOperatorControlFlowStorageCallNode } from '../../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ExpressionWithOperatorControlFlowStorageCallNode';
-import { NodeGuards } from '../../../node/NodeGuards';
-
-@injectable()
-export abstract class ExpressionWithOperatorControlFlowReplacer extends AbstractControlFlowReplacer {
-    /**
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(controlFlowCustomNodeFactory, randomGenerator, options);
-    }
-
-    /**
-     * @param {string} controlFlowStorageId
-     * @param {string} storageKey
-     * @param {Expression} leftExpression
-     * @param {Expression} rightExpression
-     * @returns {NodeGuards}
-     */
-    protected getControlFlowStorageCallNode (
-        controlFlowStorageId: string,
-        storageKey: string,
-        leftExpression: ESTree.Expression,
-        rightExpression: ESTree.Expression
-    ): ESTree.Node {
-        const controlFlowStorageCallCustomNode: ICustomNode<TInitialData<ExpressionWithOperatorControlFlowStorageCallNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.ExpressionWithOperatorControlFlowStorageCallNode);
-
-        controlFlowStorageCallCustomNode.initialize(controlFlowStorageId, storageKey, leftExpression, rightExpression);
-
-        const statementNode: TStatement = controlFlowStorageCallCustomNode.getNode()[0];
-
-        if (!statementNode || !NodeGuards.isExpressionStatementNode(statementNode)) {
-            throw new Error('`controlFlowStorageCallCustomNode.getNode()[0]` should returns array with `ExpressionStatement` node');
-        }
-
-        return statementNode.expression;
-    }
-}

package/src/node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.ts

@@ -1,99 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
-import { TInitialData } from '../../../types/TInitialData';
-
-import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-
-import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
-
-import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
-import { LogicalExpressionFunctionNode } from '../../../custom-nodes/control-flow-flattening-nodes/LogicalExpressionFunctionNode';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeUtils } from '../../../node/NodeUtils';
-
-@injectable()
-export class LogicalExpressionControlFlowReplacer extends ExpressionWithOperatorControlFlowReplacer {
-    /**
-     * @type {number}
-     */
-    private static readonly usingExistingIdentifierChance: number = 0.5;
-
-    /**
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(controlFlowCustomNodeFactory, randomGenerator, options);
-    }
-
-    /**
-     * @param {LogicalExpression} logicalExpressionNode
-     * @param {NodeGuards} parentNode
-     * @param {TControlFlowStorage} controlFlowStorage
-     * @returns {NodeGuards}
-     */
-    public replace (
-        logicalExpressionNode: ESTree.LogicalExpression,
-        parentNode: ESTree.Node,
-        controlFlowStorage: TControlFlowStorage
-    ): ESTree.Node {
-        if (this.checkForProhibitedExpressions(logicalExpressionNode.left, logicalExpressionNode.right)) {
-            return logicalExpressionNode;
-        }
-
-        const operator: ESTree.LogicalOperator = logicalExpressionNode.operator;
-        const logicalExpressionFunctionCustomNode: ICustomNode<TInitialData<LogicalExpressionFunctionNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.LogicalExpressionFunctionNode);
-
-        logicalExpressionFunctionCustomNode.initialize(operator);
-
-        const storageKey: string = this.insertCustomNodeToControlFlowStorage(
-            logicalExpressionFunctionCustomNode,
-            controlFlowStorage,
-            operator,
-            LogicalExpressionControlFlowReplacer.usingExistingIdentifierChance
-        );
-
-        return this.getControlFlowStorageCallNode(
-            controlFlowStorage.getStorageId(),
-            storageKey,
-            logicalExpressionNode.left,
-            logicalExpressionNode.right
-        );
-    }
-
-    /**
-     * @param {Expression} leftExpression
-     * @param {Expression} rightExpression
-     * @returns {boolean}
-     */
-    private checkForProhibitedExpressions (leftExpression: ESTree.Expression, rightExpression: ESTree.Expression): boolean {
-        return [leftExpression, rightExpression].some((expressionNode: ESTree.Node | ESTree.Expression): boolean => {
-            let nodeForCheck: ESTree.Node | ESTree.Expression;
-
-            if (!NodeGuards.isUnaryExpressionNode(expressionNode)) {
-                nodeForCheck = expressionNode;
-            } else {
-                nodeForCheck = NodeUtils.getUnaryExpressionArgumentNode(expressionNode);
-            }
-
-            return !NodeGuards.isLiteralNode(nodeForCheck) &&
-                !NodeGuards.isIdentifierNode(nodeForCheck) &&
-                !NodeGuards.isObjectExpressionNode(nodeForCheck) &&
-                !NodeGuards.isExpressionStatementNode(nodeForCheck);
-        });
-    }
-}

package/src/node-transformers/control-flow-transformers/control-flow-replacers/StringLiteralControlFlowReplacer.ts

@@ -1,101 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
-import { TInitialData } from '../../../types/TInitialData';
-import { TStatement } from '../../../types/node/TStatement';
-
-import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-
-import { ControlFlowCustomNode } from '../../../enums/custom-nodes/ControlFlowCustomNode';
-
-import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeLiteralUtils } from '../../../node/NodeLiteralUtils';
-import { StringLiteralControlFlowStorageCallNode } from '../../../custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/StringLiteralControlFlowStorageCallNode';
-import { StringLiteralNode } from '../../../custom-nodes/control-flow-flattening-nodes/StringLiteralNode';
-
-@injectable()
-export class StringLiteralControlFlowReplacer extends AbstractControlFlowReplacer {
-    /**
-     * @type {number}
-     */
-    private static readonly usingExistingIdentifierChance: number = 1;
-
-    /**
-     * @param {TControlFlowCustomNodeFactory} controlFlowCustomNodeFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IControlFlowCustomNode)
-            controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(controlFlowCustomNodeFactory, randomGenerator, options);
-    }
-
-    /**
-     * @param {Literal} literalNode
-     * @param {NodeGuards} parentNode
-     * @param {TControlFlowStorage} controlFlowStorage
-     * @returns {NodeGuards}
-     */
-    public replace (
-        literalNode: ESTree.Literal,
-        parentNode: ESTree.Node,
-        controlFlowStorage: TControlFlowStorage
-    ): ESTree.Node {
-        if (NodeGuards.isPropertyNode(parentNode) && parentNode.key === literalNode) {
-            return literalNode;
-        }
-
-        if (!NodeLiteralUtils.isStringLiteralNode(literalNode) || literalNode.value.length < 3) {
-            return literalNode;
-        }
-
-        const replacerId: string = String(literalNode.value);
-        const literalFunctionCustomNode: ICustomNode<TInitialData<StringLiteralNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.StringLiteralNode);
-
-        literalFunctionCustomNode.initialize(literalNode.value);
-
-        const storageKey: string = this.insertCustomNodeToControlFlowStorage(
-            literalFunctionCustomNode,
-            controlFlowStorage,
-            replacerId,
-            StringLiteralControlFlowReplacer.usingExistingIdentifierChance
-        );
-
-        return this.getControlFlowStorageCallNode(controlFlowStorage.getStorageId(), storageKey);
-    }
-
-    /**
-     * @param {string} controlFlowStorageId
-     * @param {string} storageKey
-     * @returns {NodeGuards}
-     */
-    protected getControlFlowStorageCallNode (
-        controlFlowStorageId: string,
-        storageKey: string
-    ): ESTree.Node {
-        const controlFlowStorageCallCustomNode: ICustomNode<TInitialData<StringLiteralControlFlowStorageCallNode>> =
-            this.controlFlowCustomNodeFactory(ControlFlowCustomNode.StringLiteralControlFlowStorageCallNode);
-
-        controlFlowStorageCallCustomNode.initialize(controlFlowStorageId, storageKey);
-
-        const statementNode: TStatement = controlFlowStorageCallCustomNode.getNode()[0];
-
-        if (!statementNode || !NodeGuards.isExpressionStatementNode(statementNode)) {
-            throw new Error('`controlFlowStorageCallCustomNode.getNode()[0]` should returns array with `ExpressionStatement` node');
-        }
-
-        return statementNode.expression;
-    }
-}

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

@@ -1,98 +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 { NodeGuards } from '../../node/NodeGuards';
-import { NodeUtils } from '../../node/NodeUtils';
-import { NodeFactory } from '../../node/NodeFactory';
-
-@injectable()
-export class BooleanLiteralTransformer extends AbstractNodeTransformer {
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @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.isLiteralNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * Replaces:
-     *     var foo = true;
-     *     var bar = false;
-     *
-     * on:
-     *     var foo = !![];
-     *     var bar = ![];
-     *
-     * @param {Literal} literalNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
-        if (typeof literalNode.value !== 'boolean') {
-            return literalNode;
-        }
-
-        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;
-
-        const unaryExpressionNode: ESTree.UnaryExpression = literalValue
-            ? this.getTrueUnaryExpressionNode()
-            : this.getFalseUnaryExpressionNode();
-
-        NodeUtils.parentizeNode(unaryExpressionNode, parentNode);
-
-        return unaryExpressionNode;
-    }
-
-    /**
-     * @return {ESTree.UnaryExpression}
-     */
-    private getTrueUnaryExpressionNode (): ESTree.UnaryExpression {
-        return NodeFactory.unaryExpressionNode(
-            '!',
-            this.getFalseUnaryExpressionNode()
-        );
-    }
-
-    /**
-     * @return {ESTree.UnaryExpression}
-     */
-    private getFalseUnaryExpressionNode (): ESTree.UnaryExpression {
-        return NodeFactory.unaryExpressionNode(
-            '!',
-            NodeFactory.arrayExpressionNode()
-        );
-    }
-}