javascript-obfuscator 2.18.1 → 3.0.1

package/src/node-transformers/simplifying-transformers/IfStatementSimplifyTransformer.ts

@@ -1,326 +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 { IStatementSimplifyData } from '../../interfaces/node-transformers/simplifying-transformers/IStatementSimplifyData';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractStatementSimplifyTransformer } from './AbstractStatementSimplifyTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeUtils } from '../../node/NodeUtils';
-
-/**
- * Simplifies `IfStatement` node
- */
-@injectable()
-export class IfStatementSimplifyTransformer extends AbstractStatementSimplifyTransformer {
-    /**
-     * @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.Simplifying:
-                return {
-                    leave: (
-                        node: ESTree.Node,
-                        parentNode: ESTree.Node | null
-                    ): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isIfStatementNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {ESTree.IfStatement} ifStatementNode
-     * @param {ESTree.Node} parentNode
-     * @returns {ESTree.IfStatement}
-     */
-    public transformNode (
-        ifStatementNode: ESTree.IfStatement,
-        parentNode: ESTree.Node
-    ): ESTree.Node {
-        const consequentSimplifyData: IStatementSimplifyData | null = this.getStatementSimplifyData(ifStatementNode.consequent);
-
-        // Variant #1: no valid consequent expression data
-        if (!consequentSimplifyData) {
-            return ifStatementNode;
-        }
-
-        let transformedNode: ESTree.Node;
-
-        if (!ifStatementNode.alternate) {
-            // Variant #2: valid data for consequent expression only
-            transformedNode = this.getConsequentNode(ifStatementNode, consequentSimplifyData);
-        } else {
-            const alternateSimplifyData: IStatementSimplifyData | null = this.getStatementSimplifyData(ifStatementNode.alternate);
-
-            if (!alternateSimplifyData) {
-                return ifStatementNode;
-            }
-
-            // Variant #3: valid data for consequent and alternate expressions
-            transformedNode = this.getConsequentAndAlternateNode(ifStatementNode, consequentSimplifyData, alternateSimplifyData);
-        }
-
-        return NodeUtils.parentizeNode(transformedNode, parentNode);
-    }
-
-    /**
-     * @param {ESTree.IfStatement} ifStatementNode
-     * @param {IStatementSimplifyData} consequentSimplifyData
-     * @returns {ESTree.Node}
-     */
-    protected getConsequentNode (
-        ifStatementNode: ESTree.IfStatement,
-        consequentSimplifyData: IStatementSimplifyData
-    ): ESTree.Node {
-        /**
-         * Converts:
-         * if (true) {
-         *     const foo = 1;
-         *     console.log(1);
-         *     return 1;
-         * }
-         *
-         * to:
-         * if (true) {
-         *     const foo = 1;
-         *     return console.log(1), 1;
-         * }
-         */
-        if (
-            consequentSimplifyData.leadingStatements.length
-            || !consequentSimplifyData.trailingStatement
-        ) {
-            return NodeFactory.ifStatementNode(
-                ifStatementNode.test,
-                this.getPartialStatement(consequentSimplifyData)
-            );
-        }
-
-        /**
-         * Converts:
-         * if (true) {
-         *     return 1;
-         * }
-         *
-         * to:
-         * if (true)
-         *     return 1;
-         */
-        if (consequentSimplifyData.hasReturnStatement) {
-            return NodeFactory.ifStatementNode(
-                ifStatementNode.test,
-                consequentSimplifyData.trailingStatement.statement
-            );
-        }
-
-        /**
-         * Converts:
-         * if (true) {
-         *     console.log(1);
-         * }
-         *
-         * to:
-         * true && console.log(1);
-         */
-        return NodeFactory.expressionStatementNode(
-            NodeFactory.logicalExpressionNode(
-                '&&',
-                ifStatementNode.test,
-                consequentSimplifyData.trailingStatement.expression
-            )
-        );
-    }
-
-    /**
-     * @param {ESTree.IfStatement} ifStatementNode
-     * @param {IStatementSimplifyData} consequentSimplifyData
-     * @param {IStatementSimplifyData} alternateSimplifyData
-     * @returns {ESTree.Node}
-     */
-    protected getConsequentAndAlternateNode (
-        ifStatementNode: ESTree.IfStatement,
-        consequentSimplifyData: IStatementSimplifyData,
-        alternateSimplifyData: IStatementSimplifyData
-    ): ESTree.Node {
-        /**
-         * Converts:
-         * if (true) {
-         *     const foo = 1;
-         *     console.log(1);
-         *     return 1;
-         * }
-         *
-         * to:
-         * if (true) {
-         *     const foo = 1;
-         *     return console.log(1), 1;
-         * }
-         */
-        if (
-            consequentSimplifyData.leadingStatements.length
-            || alternateSimplifyData.leadingStatements.length
-            || !consequentSimplifyData.trailingStatement
-            || !alternateSimplifyData.trailingStatement
-        ) {
-            return NodeFactory.ifStatementNode(
-                ifStatementNode.test,
-                this.getPartialStatement(consequentSimplifyData),
-                this.getPartialStatement(alternateSimplifyData)
-            );
-        }
-
-        /**
-         * Converts:
-         * if (true) {
-         *     return 1;
-         * } else {
-         *     return 2;
-         * }
-         *
-         * to:
-         * return true ? 1 : 2;
-         */
-        if (consequentSimplifyData.hasReturnStatement && alternateSimplifyData.hasReturnStatement) {
-            return NodeFactory.returnStatementNode(
-                NodeFactory.conditionalExpressionNode(
-                    ifStatementNode.test,
-                    consequentSimplifyData.trailingStatement.expression,
-                    alternateSimplifyData.trailingStatement.expression
-                )
-            );
-        }
-
-        /**
-         * Converts:
-         * if (true) {
-         *     return 1;
-         * } else {
-         *     console.log(2);
-         * }
-         *
-         * to:
-         * if (true)
-         *     return 1;
-         * else
-         *     console.log(2);
-         */
-        if (consequentSimplifyData.hasReturnStatement || alternateSimplifyData.hasReturnStatement) {
-            return NodeFactory.ifStatementNode(
-                ifStatementNode.test,
-                consequentSimplifyData.trailingStatement.statement,
-                alternateSimplifyData.trailingStatement.statement
-            );
-        }
-
-        /**
-         * Converts:
-         * if (true) {
-         *     console.log(1);
-         * } else {
-         *     console.log(2);
-         * }
-         *
-         * to:
-         * true ? console.log(1) : console.log(2);
-         */
-        return NodeFactory.expressionStatementNode(
-            NodeFactory.conditionalExpressionNode(
-                ifStatementNode.test,
-                consequentSimplifyData.trailingStatement.expression,
-                alternateSimplifyData.trailingStatement.expression
-            )
-        );
-    }
-
-    /**
-     * @param {IStatementSimplifyData} statementSimplifyData
-     * @returns {ESTree.Statement}
-     */
-    protected override getPartialStatement (statementSimplifyData: IStatementSimplifyData): ESTree.Statement {
-        const partialStatement: ESTree.Statement = super.getPartialStatement(statementSimplifyData);
-
-        if (!NodeGuards.isBlockStatementNode(partialStatement)) {
-            return partialStatement;
-        }
-
-        return partialStatement.body.length === 1
-        && !this.isProhibitedSingleStatementForIfStatementBranch(partialStatement.body[0])
-            ? partialStatement.body[0]
-            : partialStatement;
-
-    }
-
-    /**
-     * @param {ESTree.Statement} statement
-     * @returns {boolean}
-     */
-    protected isProhibitedSingleStatementForIfStatementBranch (statement: ESTree.Statement): boolean {
-        /**
-         * Function declaration is not allowed outside of block in `strict` mode
-         */
-        return NodeGuards.isFunctionDeclarationNode(statement)
-            /**
-             * Have to ignore all `IfStatement` nodes
-             * Also have to ignore any nodes with a single statement as a `body`
-             * Without ignore it can break following code:
-             * Input:
-             * if (condition1) {
-             *     if (condition2) {
-             *         var foo = bar();
-             *     }
-             * } else {
-             *     var baz = bark();
-             * }
-             *
-             * Invalid output:
-             * if (condition1)
-             *     if (condition2)
-             *         var foo = bar();
-             *     else
-             *         var baz = bark();
-             *
-             * See issue: https://github.com/javascript-obfuscator/javascript-obfuscator/issues/860
-             */
-            || NodeGuards.isIfStatementNode(statement)
-            || NodeGuards.isNodeWithSingleStatementBody(statement)
-
-            /**
-             * `let` and `const` variable declarations are not allowed outside of `IfStatement` block statement
-             * Input:
-             * if (condition1) {
-             *     const foo = 1;
-             * }
-             *
-             * Invalid output with runtime error:
-             * if (condition1)
-             *     const foo = 1;
-             */
-            || (NodeGuards.isVariableDeclarationNode(statement) && statement.kind !== 'var');
-    }
-}

package/src/node-transformers/simplifying-transformers/VariableDeclarationsMergeTransformer.ts

@@ -1,91 +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 { TStatement } from '../../types/node/TStatement';
-
-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 { NodeStatementUtils } from '../../node/NodeStatementUtils';
-
-/**
- * replaces:
- *     var foo = 1;
- *     var bar = 2;
- *
- * on:
- *     var foo = 1,
- *         bar = 2;
- */
-@injectable()
-export class VariableDeclarationsMergeTransformer 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.Simplifying:
-                return {
-                    leave: (
-                        node: ESTree.Node,
-                        parentNode: ESTree.Node | null
-                    ): ESTree.Node | estraverse.VisitorOption | undefined => {
-                        if (parentNode && NodeGuards.isVariableDeclarationNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {ESTree.VariableDeclaration} variableDeclarationNode
-     * @param {ESTree.Node} parentNode
-     * @returns {ESTree.VariableDeclaration | estraverse.VisitorOption}
-     */
-    public transformNode (
-        variableDeclarationNode: ESTree.VariableDeclaration,
-        parentNode: ESTree.Node
-    ): ESTree.VariableDeclaration | estraverse.VisitorOption {
-        if (!NodeGuards.isNodeWithStatements(parentNode)) {
-            return variableDeclarationNode;
-        }
-
-        const prevStatement: TStatement | null = NodeStatementUtils.getPreviousSiblingStatement(variableDeclarationNode);
-
-        if (!prevStatement || !NodeGuards.isVariableDeclarationNode(prevStatement)) {
-            return variableDeclarationNode;
-        }
-
-        if (variableDeclarationNode.kind !== prevStatement.kind) {
-            return variableDeclarationNode;
-        }
-
-        prevStatement.declarations.push(...variableDeclarationNode.declarations);
-
-        return estraverse.VisitorOption.Remove;
-    }
-}

package/src/node-transformers/string-array-transformers/StringArrayRotateFunctionTransformer.ts

@@ -1,268 +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 { TCustomCodeHelperFactory } from '../../types/container/custom-code-helpers/TCustomCodeHelperFactory';
-import { TInitialData } from '../../types/TInitialData';
-import { TNumberNumericalExpressionData } from '../../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
-import { TStatement } from '../../types/node/TStatement';
-import { TStringLiteralNode } from '../../types/node/TStringLiteralNode';
-
-import { ICustomCodeHelper } from '../../interfaces/custom-code-helpers/ICustomCodeHelper';
-import { INodeTransformersRunner } from '../../interfaces/node-transformers/INodeTransformersRunner';
-import { INumberNumericalExpressionAnalyzer } from '../../interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
-import { IStringArrayStorageAnalyzer } from '../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { CustomCodeHelper } from '../../enums/custom-code-helpers/CustomCodeHelper';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeAppender } from '../../node/NodeAppender';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeLiteralUtils } from '../../node/NodeLiteralUtils';
-import { NodeMetadata } from '../../node/NodeMetadata';
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-import { NodeUtils } from '../../node/NodeUtils';
-import { NumericalExpressionDataToNodeConverter } from '../../node/NumericalExpressionDataToNodeConverter';
-import { StringArrayRotateFunctionCodeHelper } from '../../custom-code-helpers/string-array/StringArrayRotateFunctionCodeHelper';
-
-@injectable()
-export class StringArrayRotateFunctionTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {NodeTransformer[]}
-     */
-    private static readonly stringArrayRotateFunctionTransformers: NodeTransformer[] = [
-        NodeTransformer.BooleanLiteralTransformer,
-        NodeTransformer.MemberExpressionTransformer,
-        NodeTransformer.NumberLiteralTransformer,
-        NodeTransformer.NumberToNumericalExpressionTransformer,
-        NodeTransformer.ParentificationTransformer,
-        NodeTransformer.ScopeIdentifiersTransformer
-    ];
-
-    /**
-     * @type {number}
-     */
-    private static readonly comparisonExpressionAdditionalPartsCount: number = 7;
-
-    /**
-     * @type {INumberNumericalExpressionAnalyzer}
-     */
-    private readonly numberNumericalExpressionAnalyzer: INumberNumericalExpressionAnalyzer;
-
-    /**
-     * @type {IStringArrayStorage}
-     */
-    private readonly stringArrayStorage: IStringArrayStorage;
-
-    /**
-     * @type {IStringArrayStorageAnalyzer}
-     */
-    private readonly stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer;
-
-    /**
-     * @type {TCustomCodeHelperFactory}
-     */
-    private readonly customCodeHelperFactory: TCustomCodeHelperFactory;
-
-    /**
-     * @type {INodeTransformersRunner}
-     */
-    private readonly transformersRunner: INodeTransformersRunner;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     * @param {INodeTransformersRunner} transformersRunner
-     * @param {IStringArrayStorage} stringArrayStorage
-     * @param {IStringArrayStorageAnalyzer} stringArrayStorageAnalyzer
-     * @param {TCustomCodeHelperFactory} customCodeHelperFactory
-     * @param {INumberNumericalExpressionAnalyzer} numberNumericalExpressionAnalyzer
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions,
-        @inject(ServiceIdentifiers.INodeTransformersRunner) transformersRunner: INodeTransformersRunner,
-        @inject(ServiceIdentifiers.IStringArrayStorage) stringArrayStorage: IStringArrayStorage,
-        @inject(ServiceIdentifiers.IStringArrayStorageAnalyzer) stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer,
-        @inject(ServiceIdentifiers.Factory__ICustomCodeHelper) customCodeHelperFactory: TCustomCodeHelperFactory,
-        @inject(ServiceIdentifiers.INumberNumericalExpressionAnalyzer)
-            numberNumericalExpressionAnalyzer: INumberNumericalExpressionAnalyzer
-    ) {
-        super(randomGenerator, options);
-
-        this.stringArrayStorage = stringArrayStorage;
-        this.stringArrayStorageAnalyzer = stringArrayStorageAnalyzer;
-        this.transformersRunner = transformersRunner;
-        this.customCodeHelperFactory = customCodeHelperFactory;
-        this.numberNumericalExpressionAnalyzer = numberNumericalExpressionAnalyzer;
-    }
-
-    /**
-     * Because this transformer runs BEFORE string array analyzer we can't check string array storage length.
-     * So we have to traverse over program node and check if it has any string literal node.
-     *
-     * @param {Program} programNode
-     * @returns {boolean}
-     */
-    private static isProgramNodeHasStringLiterals (programNode: ESTree.Program): boolean {
-        let hasStringLiterals: boolean = false;
-
-        estraverse.traverse(programNode, {
-            enter: (node: ESTree.Node): estraverse.VisitorOption | void => {
-                if (
-                    NodeGuards.isLiteralNode(node)
-                    && NodeLiteralUtils.isStringLiteralNode(node)
-                ) {
-                    hasStringLiterals = true;
-
-                    return estraverse.VisitorOption.Break;
-                }
-            }
-        });
-
-        return hasStringLiterals;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        if (!this.options.rotateStringArray) {
-            return null;
-        }
-
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.StringArray:
-                return {
-                    enter: (node: ESTree.Node): ESTree.Node | estraverse.VisitorOption => {
-                        if (!NodeGuards.isProgramNode(node)) {
-                            return node;
-                        }
-
-                        if (!StringArrayRotateFunctionTransformer.isProgramNodeHasStringLiterals(node)) {
-                            return estraverse.VisitorOption.Break;
-                        }
-
-                        return this.transformNode(node);
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {Program} programNode
-     * @returns {Node}
-     */
-    public transformNode (programNode: ESTree.Program): ESTree.Node {
-        const stringArrayRotateFunctionNode: TStatement = this.getStringArrayRotateFunctionNode();
-        const wrappedStringArrayRotateFunctionNode: ESTree.Program = NodeFactory.programNode([
-            stringArrayRotateFunctionNode
-        ]);
-
-        NodeUtils.parentizeAst(wrappedStringArrayRotateFunctionNode);
-
-        const transformationStages: NodeTransformationStage[] = [
-            NodeTransformationStage.Preparing,
-            NodeTransformationStage.Converting,
-            NodeTransformationStage.RenameIdentifiers,
-            NodeTransformationStage.Finalizing
-        ];
-
-        // custom transformation of string array rotate function node
-        for (const transformationStage of transformationStages) {
-            this.transformersRunner.transform(
-                wrappedStringArrayRotateFunctionNode,
-                StringArrayRotateFunctionTransformer.stringArrayRotateFunctionTransformers,
-                transformationStage
-            );
-        }
-
-        // mark all child nodes (except literals inside comparison expression)
-        // as ignored to prevent additional transformation of these nodes
-        estraverse.traverse(wrappedStringArrayRotateFunctionNode, {
-            enter: (node: ESTree.Node): void => {
-                if (
-                    !NodeGuards.isLiteralNode(node)
-                    || !NodeLiteralUtils.isStringLiteralNode(node)
-                ) {
-                   return;
-                }
-
-                // force add item data for string literal nodes of comparison expressions
-                // set all other nodes as ignored to prevent them from obfuscation
-                if (this.isComparisonExpressionStringLiteralNode(node)) {
-                    this.stringArrayStorageAnalyzer.addItemDataForLiteralNode(node);
-                } else {
-                    NodeMetadata.set(node, {ignoredNode: true});
-                }
-            }
-        });
-
-        NodeAppender.prepend(programNode, [stringArrayRotateFunctionNode]);
-
-        return programNode;
-    }
-
-    /**
-     * @returns {TStatement}
-     */
-    private getStringArrayRotateFunctionNode (): TStatement {
-        const comparisonValue: number = this.randomGenerator.getRandomInteger(100000, 1_000_000);
-        const comparisonExpressionNumberNumericalExpressionData: TNumberNumericalExpressionData =
-            this.numberNumericalExpressionAnalyzer.analyze(
-                comparisonValue,
-                StringArrayRotateFunctionTransformer.comparisonExpressionAdditionalPartsCount
-            );
-
-        const comparisonExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter.convertIntegerNumberData(
-            comparisonExpressionNumberNumericalExpressionData,
-            ((number: number, isPositiveNumber) => {
-                const literalNode: ESTree.Literal = NodeFactory.literalNode(
-                    `${number}${this.randomGenerator.getRandomString(6)}`
-                );
-                const parseIntCallExpression: ESTree.CallExpression = NodeFactory.callExpressionNode(
-                    NodeFactory.identifierNode('parseInt'),
-                    [literalNode]
-                );
-
-                return isPositiveNumber
-                    ? parseIntCallExpression
-                    : NodeFactory.unaryExpressionNode(
-                        '-',
-                        parseIntCallExpression
-                    );
-            })
-        );
-
-        const stringArrayRotateFunctionCodeHelper: ICustomCodeHelper<TInitialData<StringArrayRotateFunctionCodeHelper>> =
-            this.customCodeHelperFactory(CustomCodeHelper.StringArrayRotateFunction);
-
-        stringArrayRotateFunctionCodeHelper.initialize(
-            this.stringArrayStorage.getStorageName(),
-            comparisonValue,
-            comparisonExpressionNode
-        );
-
-        return stringArrayRotateFunctionCodeHelper.getNode()[0];
-    }
-
-    /**
-     * @param {TStringLiteralNode} stringLiteralNode
-     * @returns {boolean}
-     */
-    private isComparisonExpressionStringLiteralNode (stringLiteralNode: TStringLiteralNode): boolean {
-        return /\d/.test(stringLiteralNode.value);
-    }
-}