19907815758

Committed 03 Dec 2025 08:27PM UTC coverage: 97.319%. Remained the same

Build # 19907815758

Build Type

push

github

Committed by

sanex3339

Commit Message

Adjust precommit hook

Run Details

1770 of 1891 branches covered (93.6%)

Branch coverage included in aggregate %.

5671 of 5755 relevant lines covered (98.54%)

34102965.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.96

/src/node-transformers/string-array-transformers/StringArrayTransformer.ts

import { inject, injectable } from 'inversify';
import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';

import * as ESTree from 'estree';

import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
import { TInitialData } from '../../types/TInitialData';
import { TNodeWithLexicalScopeStatements } from '../../types/node/TNodeWithLexicalScopeStatements';
import { TStatement } from '../../types/node/TStatement';
import { TStringArrayScopeCallsWrappersDataByEncoding } from '../../types/node-transformers/string-array-transformers/TStringArrayScopeCallsWrappersDataByEncoding';
import { TStringArrayCustomNodeFactory } from '../../types/container/custom-nodes/TStringArrayCustomNodeFactory';

import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
import { IIdentifierNamesGenerator } from '../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
import { ILiteralNodesCacheStorage } from '../../interfaces/storages/string-array-transformers/ILiteralNodesCacheStorage';
import { IOptions } from '../../interfaces/options/IOptions';
import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
import { IStringArrayScopeCallsWrapperData } from '../../interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperData';
import { IStringArrayScopeCallsWrappersDataStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage';
import { IStringArrayScopeCallsWrapperParameterIndexesData } from '../../interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperParameterIndexesData';
import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
import { IStringArrayStorageAnalyzer } from '../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
import { IStringArrayStorageItemData } from '../../interfaces/storages/string-array-transformers/IStringArrayStorageItem';
import { IVisitedLexicalScopeNodesStackStorage } from '../../interfaces/storages/string-array-transformers/IVisitedLexicalScopeNodesStackStorage';
import { IVisitor } from '../../interfaces/node-transformers/IVisitor';

import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
import { StringArrayCustomNode } from '../../enums/custom-nodes/StringArrayCustomNode';
import { StringArrayWrappersType } from '../../enums/node-transformers/string-array-transformers/StringArrayWrappersType';

import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
import { NodeGuards } from '../../node/NodeGuards';
import { NodeLiteralUtils } from '../../node/NodeLiteralUtils';
import { NodeMetadata } from '../../node/NodeMetadata';
import { NodeUtils } from '../../node/NodeUtils';
import { StringArrayCallNode } from '../../custom-nodes/string-array-nodes/StringArrayCallNode';

@injectable()
export class StringArrayTransformer extends AbstractNodeTransformer {
    /**
     * @type {number}
     */
    private static readonly minShiftedIndexValue: number = -1000;

    /**
     * @type {number}
     */
    private static readonly maxShiftedIndexValue: number = 1000;

    /**
     * @type {NodeTransformer[]}
     */
    public override readonly runAfter: NodeTransformer[] = [NodeTransformer.StringArrayRotateFunctionTransformer];

    /**
     * @type {IIdentifierNamesGenerator}
     */
    private readonly identifierNamesGenerator: IIdentifierNamesGenerator;

    /**
     * @type {ILiteralNodesCacheStorage}
     */
    private readonly literalNodesCacheStorage: ILiteralNodesCacheStorage;

    /**
     * @type {IStringArrayStorage}
     */
    private readonly stringArrayStorage: IStringArrayStorage;

    /**
     * @type {IStringArrayStorageAnalyzer}
     */
    private readonly stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer;

    /**
     * @type {IStringArrayScopeCallsWrappersDataStorage}
     */
    private readonly stringArrayScopeCallsWrappersDataStorage: IStringArrayScopeCallsWrappersDataStorage;

    /**
     * @type {TStringArrayCustomNodeFactory}
     */
    private readonly stringArrayTransformerCustomNodeFactory: TStringArrayCustomNodeFactory;

    /**
     * @type {IVisitedLexicalScopeNodesStackStorage}
     */
    private readonly visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage;

    /**
     * @param {IRandomGenerator} randomGenerator
     * @param {IOptions} options
     * @param {ILiteralNodesCacheStorage} literalNodesCacheStorage
     * @param {IVisitedLexicalScopeNodesStackStorage} visitedLexicalScopeNodesStackStorage
     * @param {IStringArrayStorage} stringArrayStorage
     * @param {IStringArrayScopeCallsWrappersDataStorage} stringArrayScopeCallsWrappersDataStorage
     * @param {IStringArrayStorageAnalyzer} stringArrayStorageAnalyzer
     * @param {TIdentifierNamesGeneratorFactory} identifierNamesGeneratorFactory
     * @param {TStringArrayCustomNodeFactory} stringArrayTransformerCustomNodeFactory
     */
    public constructor(
        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
        @inject(ServiceIdentifiers.IOptions) options: IOptions,
        @inject(ServiceIdentifiers.ILiteralNodesCacheStorage) literalNodesCacheStorage: ILiteralNodesCacheStorage,
        @inject(ServiceIdentifiers.IVisitedLexicalScopeNodesStackStorage)
        visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage,
        @inject(ServiceIdentifiers.IStringArrayStorage) stringArrayStorage: IStringArrayStorage,
        @inject(ServiceIdentifiers.IStringArrayScopeCallsWrappersDataStorage)
        stringArrayScopeCallsWrappersDataStorage: IStringArrayScopeCallsWrappersDataStorage,
        @inject(ServiceIdentifiers.IStringArrayStorageAnalyzer) stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer,
        @inject(ServiceIdentifiers.Factory__IIdentifierNamesGenerator)
        identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory,
        @inject(ServiceIdentifiers.Factory__IStringArrayCustomNode)
        stringArrayTransformerCustomNodeFactory: TStringArrayCustomNodeFactory
    ) {
        super(randomGenerator, options);

        this.literalNodesCacheStorage = literalNodesCacheStorage;
        this.visitedLexicalScopeNodesStackStorage = visitedLexicalScopeNodesStackStorage;
        this.stringArrayStorage = stringArrayStorage;
        this.stringArrayScopeCallsWrappersDataStorage = stringArrayScopeCallsWrappersDataStorage;
        this.stringArrayStorageAnalyzer = stringArrayStorageAnalyzer;
        this.identifierNamesGenerator = identifierNamesGeneratorFactory(options);
        this.stringArrayTransformerCustomNodeFactory = stringArrayTransformerCustomNodeFactory;
    }

    /**
     * @param {NodeTransformationStage} nodeTransformationStage
     * @returns {IVisitor | null}
     */
    public getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null {
        switch (nodeTransformationStage) {
            case NodeTransformationStage.StringArray:
                return {
                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                        if (NodeGuards.isProgramNode(node)) {
                            this.prepareNode(node);
                        }

                        if (
                            parentNode &&
                            NodeGuards.isLiteralNode(node) &&
                            !NodeMetadata.isStringArrayCallLiteralNode(node)
                        ) {
                            return this.transformNode(node, parentNode);
                        }
                    }
                };

            default:
                return null;
        }
    }

    /**
     * @param {Program} programNode
     */
    public prepareNode(programNode: ESTree.Program): void {
        if (this.options.stringArray) {
            this.stringArrayStorageAnalyzer.analyze(programNode);
        }

        if (this.options.stringArrayShuffle) {
            this.stringArrayStorage.shuffleStorage();
        }

        if (this.options.stringArrayRotate) {
            this.stringArrayStorage.rotateStorage();
        }
    }

    /**
     * @param {Literal} literalNode
     * @param {NodeGuards} parentNode
     * @returns {NodeGuards}
     */
    public transformNode(literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
        if (
            !NodeLiteralUtils.isStringLiteralNode(literalNode) ||
            NodeLiteralUtils.isProhibitedLiteralNode(literalNode, parentNode)
        ) {
            return literalNode;
        }

        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;

        const stringArrayStorageItemData: IStringArrayStorageItemData | undefined =
            this.stringArrayStorageAnalyzer.getItemDataForLiteralNode(literalNode);
        const cacheKey: string = this.literalNodesCacheStorage.buildKey(literalValue, stringArrayStorageItemData);
        const useCachedValue: boolean = this.literalNodesCacheStorage.shouldUseCachedValue(
            cacheKey,
            stringArrayStorageItemData
        );

        let resultNode: ESTree.Node;

        if (useCachedValue) {
            const nodeFromCache: ESTree.Node = <ESTree.Node>this.literalNodesCacheStorage.get(cacheKey);

            resultNode = NodeUtils.clone(nodeFromCache);
        } else {
            resultNode = stringArrayStorageItemData
                ? this.getStringArrayCallNode(stringArrayStorageItemData)
                : literalNode;
            this.literalNodesCacheStorage.set(cacheKey, resultNode);
        }

        NodeUtils.parentizeNode(resultNode, parentNode);

        return resultNode;
    }

    /**
     * @param {IStringArrayStorageItemData} stringArrayStorageItemData
     * @returns {Expression}
     */
    private getStringArrayCallNode(stringArrayStorageItemData: IStringArrayStorageItemData): ESTree.Expression {
        const stringArrayScopeCallsWrapperData: IStringArrayScopeCallsWrapperData =
            this.getStringArrayScopeCallsWrapperData(stringArrayStorageItemData);
        const { decodeKey, index } = stringArrayStorageItemData;

        const stringArrayCallCustomNode: ICustomNode<TInitialData<StringArrayCallNode>> =
            this.stringArrayTransformerCustomNodeFactory(StringArrayCustomNode.StringArrayCallNode);

        stringArrayCallCustomNode.initialize(
            index,
            this.stringArrayStorage.getIndexShiftAmount(),
            stringArrayScopeCallsWrapperData,
            decodeKey
        );

        const statementNode: TStatement = stringArrayCallCustomNode.getNode()[0];

        if (!NodeGuards.isExpressionStatementNode(statementNode)) {
            throw new Error(
                '`stringArrayCallCustomNode.getNode()[0]` should returns array with `ExpressionStatement` node'
            );
        }

        return statementNode.expression;
    }

    /**
     * @param {IStringArrayStorageItemData} stringArrayStorageItemData
     * @returns {IStringArrayScopeCallsWrapperData}
     */
    private getStringArrayScopeCallsWrapperData(
        stringArrayStorageItemData: IStringArrayStorageItemData
    ): IStringArrayScopeCallsWrapperData {
        return !this.options.stringArrayWrappersCount
            ? this.getRootStringArrayScopeCallsWrapperData(stringArrayStorageItemData)
            : this.getUpperStringArrayScopeCallsWrapperData(stringArrayStorageItemData);
    }

    /**
     * @param {IStringArrayStorageItemData} stringArrayStorageItemData
     * @returns {IStringArrayScopeCallsWrapperData}
     */
    private getRootStringArrayScopeCallsWrapperData(
        stringArrayStorageItemData: IStringArrayStorageItemData
    ): IStringArrayScopeCallsWrapperData {
        const { encoding } = stringArrayStorageItemData;

        const rootStringArrayCallsWrapperName: string = this.stringArrayStorage.getStorageCallsWrapperName(encoding);

        return {
            name: rootStringArrayCallsWrapperName,
            index: 0,
            parameterIndexesData: null
        };
    }

    /**
     * @param {IStringArrayStorageItemData} stringArrayStorageItemData
     * @returns {IStringArrayScopeCallsWrapperData}
     */
    private getUpperStringArrayScopeCallsWrapperData(
        stringArrayStorageItemData: IStringArrayStorageItemData
    ): IStringArrayScopeCallsWrapperData {
        const { encoding } = stringArrayStorageItemData;
        const currentLexicalScopeBodyNode: TNodeWithLexicalScopeStatements | null =
            this.visitedLexicalScopeNodesStackStorage.getLastElement() ?? null;

        if (!currentLexicalScopeBodyNode) {
            throw new Error('Cannot find current lexical scope body node');
        }

        const stringArrayScopeCallsWrappersDataByEncoding: TStringArrayScopeCallsWrappersDataByEncoding =
            this.getAndUpdateStringArrayScopeCallsWrappersDataByEncoding(
                currentLexicalScopeBodyNode,
                stringArrayStorageItemData
            );

        const stringArrayScopeCallsWrappersData: IStringArrayScopeCallsWrapperData[] =
            stringArrayScopeCallsWrappersDataByEncoding[encoding]?.scopeCallsWrappersData ?? [];

        return this.randomGenerator.getRandomGenerator().pickone(stringArrayScopeCallsWrappersData);
    }

    /**
     * @param {TNodeWithLexicalScopeStatements} currentLexicalScopeBodyNode
     * @param {IStringArrayStorageItemData} stringArrayStorageItemData
     * @returns {TStringArrayScopeCallsWrappersDataByEncoding}
     */
    private getAndUpdateStringArrayScopeCallsWrappersDataByEncoding(
        currentLexicalScopeBodyNode: TNodeWithLexicalScopeStatements,
        stringArrayStorageItemData: IStringArrayStorageItemData
    ): TStringArrayScopeCallsWrappersDataByEncoding {
        const { encoding } = stringArrayStorageItemData;
        const stringArrayScopeCallsWrappersDataByEncoding: TStringArrayScopeCallsWrappersDataByEncoding =
            this.stringArrayScopeCallsWrappersDataStorage.get(currentLexicalScopeBodyNode) ?? {};

        const stringArrayScopeCallsWrappersData: IStringArrayScopeCallsWrapperData[] =
            stringArrayScopeCallsWrappersDataByEncoding[encoding]?.scopeCallsWrappersData ?? [];
        const isFilledScopeCallsWrapperNamesList: boolean =
            stringArrayScopeCallsWrappersData.length === this.options.stringArrayWrappersCount;

        if (isFilledScopeCallsWrapperNamesList) {
            return stringArrayScopeCallsWrappersDataByEncoding;
        }

        // have to use `generateForGlobalScope` for program node for correct attach prefix to the calls wrapper name
        const nextScopeCallsWrapperName: string = NodeGuards.isProgramNode(currentLexicalScopeBodyNode)
            ? this.identifierNamesGenerator.generateForGlobalScope()
            : this.identifierNamesGenerator.generateNext();
        const nextScopeCallsWrapperShiftedIndex: number = this.getStringArrayCallsWrapperShiftedIndex();
        const nextScopeCallsWrapperParameterIndexesData: IStringArrayScopeCallsWrapperParameterIndexesData | null =
            this.getStringArrayCallsWrapperParameterIndexesData();

        stringArrayScopeCallsWrappersDataByEncoding[encoding] = {
            encoding,
            scopeCallsWrappersData: [
                ...stringArrayScopeCallsWrappersData,
                {
                    name: nextScopeCallsWrapperName,
                    index: nextScopeCallsWrapperShiftedIndex,
                    parameterIndexesData: nextScopeCallsWrapperParameterIndexesData
                }
            ]
        };

        this.stringArrayScopeCallsWrappersDataStorage.set(
            currentLexicalScopeBodyNode,
            stringArrayScopeCallsWrappersDataByEncoding
        );

        return stringArrayScopeCallsWrappersDataByEncoding;
    }

    /**
     * @returns {number}
     */
    private getStringArrayCallsWrapperShiftedIndex(): number {
        return this.options.stringArrayWrappersType === StringArrayWrappersType.Function
            ? this.randomGenerator.getRandomInteger(
                  StringArrayTransformer.minShiftedIndexValue,
                  StringArrayTransformer.maxShiftedIndexValue
              )
            : 0;
    }

    /**
     * @returns {IStringArrayScopeCallsWrapperParameterIndexesData | null}
     */
    private getStringArrayCallsWrapperParameterIndexesData(): IStringArrayScopeCallsWrapperParameterIndexesData | null {
        if (this.options.stringArrayWrappersType !== StringArrayWrappersType.Function) {
            return null;
        }

        const minIndexValue: number = 0;
        const maxIndexValue: number = this.options.stringArrayWrappersParametersMaxCount - 1;

        const valueIndexParameterIndex: number = this.randomGenerator.getRandomInteger(minIndexValue, maxIndexValue);
        const decodeKeyParameterIndex: number = this.randomGenerator.getRandomIntegerExcluding(
            minIndexValue,
            maxIndexValue,
            [valueIndexParameterIndex]
        );

        return {
            valueIndexParameterIndex,
            decodeKeyParameterIndex
        };
    }
}

1	import { inject, injectable } from 'inversify';	6✔
2	import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';	6✔
3
4	import * as ESTree from 'estree';
5
6	import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
7	import { TInitialData } from '../../types/TInitialData';
8	import { TNodeWithLexicalScopeStatements } from '../../types/node/TNodeWithLexicalScopeStatements';
9	import { TStatement } from '../../types/node/TStatement';
10	import { TStringArrayScopeCallsWrappersDataByEncoding } from '../../types/node-transformers/string-array-transformers/TStringArrayScopeCallsWrappersDataByEncoding';
11	import { TStringArrayCustomNodeFactory } from '../../types/container/custom-nodes/TStringArrayCustomNodeFactory';
12
13	import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
14	import { IIdentifierNamesGenerator } from '../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
15	import { ILiteralNodesCacheStorage } from '../../interfaces/storages/string-array-transformers/ILiteralNodesCacheStorage';
16	import { IOptions } from '../../interfaces/options/IOptions';
17	import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
18	import { IStringArrayScopeCallsWrapperData } from '../../interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperData';
19	import { IStringArrayScopeCallsWrappersDataStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage';
20	import { IStringArrayScopeCallsWrapperParameterIndexesData } from '../../interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperParameterIndexesData';
21	import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
22	import { IStringArrayStorageAnalyzer } from '../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
23	import { IStringArrayStorageItemData } from '../../interfaces/storages/string-array-transformers/IStringArrayStorageItem';
24	import { IVisitedLexicalScopeNodesStackStorage } from '../../interfaces/storages/string-array-transformers/IVisitedLexicalScopeNodesStackStorage';
25	import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
26
27	import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';	6✔
28	import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';	6✔
29	import { StringArrayCustomNode } from '../../enums/custom-nodes/StringArrayCustomNode';	6✔
30	import { StringArrayWrappersType } from '../../enums/node-transformers/string-array-transformers/StringArrayWrappersType';	6✔
31
32	import { AbstractNodeTransformer } from '../AbstractNodeTransformer';	6✔
33	import { NodeGuards } from '../../node/NodeGuards';	6✔
34	import { NodeLiteralUtils } from '../../node/NodeLiteralUtils';	6✔
35	import { NodeMetadata } from '../../node/NodeMetadata';	6✔
36	import { NodeUtils } from '../../node/NodeUtils';	6✔
37	import { StringArrayCallNode } from '../../custom-nodes/string-array-nodes/StringArrayCallNode';
38
39	@injectable()
40	export class StringArrayTransformer extends AbstractNodeTransformer {	6✔
41	/**
42	* @type {number}
43	*/
44	private static readonly minShiftedIndexValue: number = -1000;	6✔
45
46	/**
47	* @type {number}
48	*/
49	private static readonly maxShiftedIndexValue: number = 1000;	6✔
50
51	/**
52	* @type {NodeTransformer[]}
53	*/
54	public override readonly runAfter: NodeTransformer[] = [NodeTransformer.StringArrayRotateFunctionTransformer];	197,808✔
55
56	/**
57	* @type {IIdentifierNamesGenerator}
58	*/
59	private readonly identifierNamesGenerator: IIdentifierNamesGenerator;
60
61	/**
62	* @type {ILiteralNodesCacheStorage}
63	*/
64	private readonly literalNodesCacheStorage: ILiteralNodesCacheStorage;
65
66	/**
67	* @type {IStringArrayStorage}
68	*/
69	private readonly stringArrayStorage: IStringArrayStorage;
70
71	/**
72	* @type {IStringArrayStorageAnalyzer}
73	*/
74	private readonly stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer;
75
76	/**
77	* @type {IStringArrayScopeCallsWrappersDataStorage}
78	*/
79	private readonly stringArrayScopeCallsWrappersDataStorage: IStringArrayScopeCallsWrappersDataStorage;
80
81	/**
82	* @type {TStringArrayCustomNodeFactory}
83	*/
84	private readonly stringArrayTransformerCustomNodeFactory: TStringArrayCustomNodeFactory;
85
86	/**
87	* @type {IVisitedLexicalScopeNodesStackStorage}
88	*/
89	private readonly visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage;
90
91	/**
92	* @param {IRandomGenerator} randomGenerator
93	* @param {IOptions} options
94	* @param {ILiteralNodesCacheStorage} literalNodesCacheStorage
95	* @param {IVisitedLexicalScopeNodesStackStorage} visitedLexicalScopeNodesStackStorage
96	* @param {IStringArrayStorage} stringArrayStorage
97	* @param {IStringArrayScopeCallsWrappersDataStorage} stringArrayScopeCallsWrappersDataStorage
98	* @param {IStringArrayStorageAnalyzer} stringArrayStorageAnalyzer
99	* @param {TIdentifierNamesGeneratorFactory} identifierNamesGeneratorFactory
100	* @param {TStringArrayCustomNodeFactory} stringArrayTransformerCustomNodeFactory
101	*/
102	public constructor(
103	@inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
104	@inject(ServiceIdentifiers.IOptions) options: IOptions,
105	@inject(ServiceIdentifiers.ILiteralNodesCacheStorage) literalNodesCacheStorage: ILiteralNodesCacheStorage,
106	@inject(ServiceIdentifiers.IVisitedLexicalScopeNodesStackStorage)
107	visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage,
108	@inject(ServiceIdentifiers.IStringArrayStorage) stringArrayStorage: IStringArrayStorage,
109	@inject(ServiceIdentifiers.IStringArrayScopeCallsWrappersDataStorage)
110	stringArrayScopeCallsWrappersDataStorage: IStringArrayScopeCallsWrappersDataStorage,
111	@inject(ServiceIdentifiers.IStringArrayStorageAnalyzer) stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer,
112	@inject(ServiceIdentifiers.Factory__IIdentifierNamesGenerator)
113	identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory,
114	@inject(ServiceIdentifiers.Factory__IStringArrayCustomNode)
115	stringArrayTransformerCustomNodeFactory: TStringArrayCustomNodeFactory
116	) {
117	super(randomGenerator, options);	197,808✔
118
119	this.literalNodesCacheStorage = literalNodesCacheStorage;	197,808✔
120	this.visitedLexicalScopeNodesStackStorage = visitedLexicalScopeNodesStackStorage;	197,808✔
121	this.stringArrayStorage = stringArrayStorage;	197,808✔
122	this.stringArrayScopeCallsWrappersDataStorage = stringArrayScopeCallsWrappersDataStorage;	197,808✔
123	this.stringArrayStorageAnalyzer = stringArrayStorageAnalyzer;	197,808✔
124	this.identifierNamesGenerator = identifierNamesGeneratorFactory(options);	197,808✔
125	this.stringArrayTransformerCustomNodeFactory = stringArrayTransformerCustomNodeFactory;	197,808✔
126	}
127
128	/**
129	* @param {NodeTransformationStage} nodeTransformationStage
130	* @returns {IVisitor \| null}
131	*/
132	public getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor \| null {
133	switch (nodeTransformationStage) {	1,612,710✔
134	case NodeTransformationStage.StringArray:	1,612,710✔
135	return {	395,352✔
136	enter: (node: ESTree.Node, parentNode: ESTree.Node \| null): ESTree.Node \| undefined => {
137	if (NodeGuards.isProgramNode(node)) {	107,498,701✔
138	this.prepareNode(node);	197,676✔
139	}
140
141	if (	107,498,701✔
142	parentNode &&	270,249,192✔
143	NodeGuards.isLiteralNode(node) &&
144	!NodeMetadata.isStringArrayCallLiteralNode(node)
145	) {
146	return this.transformNode(node, parentNode);	15,256,994✔
147	}
148	}
149	};
150
151	default:
152	return null;	1,217,358✔
153	}
154	}
155
156	/**
157	* @param {Program} programNode
158	*/
159	public prepareNode(programNode: ESTree.Program): void {
160	if (this.options.stringArray) {	197,676✔
161	this.stringArrayStorageAnalyzer.analyze(programNode);	77,394✔
162	}
163
164	if (this.options.stringArrayShuffle) {	197,676✔
165	this.stringArrayStorage.shuffleStorage();	18,030✔
166	}
167
168	if (this.options.stringArrayRotate) {	197,676✔
169	this.stringArrayStorage.rotateStorage();	18,162✔
170	}
171	}
172
173	/**
174	* @param {Literal} literalNode
175	* @param {NodeGuards} parentNode
176	* @returns {NodeGuards}
177	*/
178	public transformNode(literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
179	if (	15,256,994✔
180	!NodeLiteralUtils.isStringLiteralNode(literalNode) \|\|	27,905,550✔
181	NodeLiteralUtils.isProhibitedLiteralNode(literalNode, parentNode)
182	) {
183	return literalNode;	3,577,899✔
184	}
185
186	const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;	11,679,095✔
187
188	const stringArrayStorageItemData: IStringArrayStorageItemData \| undefined =
189	this.stringArrayStorageAnalyzer.getItemDataForLiteralNode(literalNode);	11,679,095✔
190	const cacheKey: string = this.literalNodesCacheStorage.buildKey(literalValue, stringArrayStorageItemData);	11,679,095✔
191	const useCachedValue: boolean = this.literalNodesCacheStorage.shouldUseCachedValue(	11,679,095✔
192	cacheKey,
193	stringArrayStorageItemData
194	);
195
196	let resultNode: ESTree.Node;
197
198	if (useCachedValue) {	11,679,095✔
199	const nodeFromCache: ESTree.Node = <ESTree.Node>this.literalNodesCacheStorage.get(cacheKey);	332,647✔
200
201	resultNode = NodeUtils.clone(nodeFromCache);	332,647✔
202	} else {
203	resultNode = stringArrayStorageItemData	11,346,448✔
204	? this.getStringArrayCallNode(stringArrayStorageItemData)	11,346,448✔
205	: literalNode;
206	this.literalNodesCacheStorage.set(cacheKey, resultNode);	11,346,448✔
207	}
208
209	NodeUtils.parentizeNode(resultNode, parentNode);	11,679,095✔
210
211	return resultNode;	11,679,095✔
212	}
213
214	/**
215	* @param {IStringArrayStorageItemData} stringArrayStorageItemData
216	* @returns {Expression}
217	*/
218	private getStringArrayCallNode(stringArrayStorageItemData: IStringArrayStorageItemData): ESTree.Expression {
219	const stringArrayScopeCallsWrapperData: IStringArrayScopeCallsWrapperData =
220	this.getStringArrayScopeCallsWrapperData(stringArrayStorageItemData);	8,574,890✔
221	const { decodeKey, index } = stringArrayStorageItemData;	8,574,890✔
222
223	const stringArrayCallCustomNode: ICustomNode<TInitialData<StringArrayCallNode>> =
224	this.stringArrayTransformerCustomNodeFactory(StringArrayCustomNode.StringArrayCallNode);	8,574,890✔
225
226	stringArrayCallCustomNode.initialize(	8,574,890✔
227	index,
228	this.stringArrayStorage.getIndexShiftAmount(),
229	stringArrayScopeCallsWrapperData,
230	decodeKey
231	);
232
233	const statementNode: TStatement = stringArrayCallCustomNode.getNode()[0];	8,574,890✔
234
235	if (!NodeGuards.isExpressionStatementNode(statementNode)) {	8,574,890!
236	throw new Error(	×
237	'`stringArrayCallCustomNode.getNode()[0]` should returns array with `ExpressionStatement` node'
238	);
239	}
240
241	return statementNode.expression;	8,574,890✔
242	}
243
244	/**
245	* @param {IStringArrayStorageItemData} stringArrayStorageItemData
246	* @returns {IStringArrayScopeCallsWrapperData}
247	*/
248	private getStringArrayScopeCallsWrapperData(
249	stringArrayStorageItemData: IStringArrayStorageItemData
250	): IStringArrayScopeCallsWrapperData {
251	return !this.options.stringArrayWrappersCount	8,574,890✔
252	? this.getRootStringArrayScopeCallsWrapperData(stringArrayStorageItemData)	8,574,890✔
253	: this.getUpperStringArrayScopeCallsWrapperData(stringArrayStorageItemData);
254	}
255
256	/**
257	* @param {IStringArrayStorageItemData} stringArrayStorageItemData
258	* @returns {IStringArrayScopeCallsWrapperData}
259	*/
260	private getRootStringArrayScopeCallsWrapperData(
261	stringArrayStorageItemData: IStringArrayStorageItemData
262	): IStringArrayScopeCallsWrapperData {
263	const { encoding } = stringArrayStorageItemData;	313,216✔
264
265	const rootStringArrayCallsWrapperName: string = this.stringArrayStorage.getStorageCallsWrapperName(encoding);	313,216✔
266
267	return {	313,216✔
268	name: rootStringArrayCallsWrapperName,
269	index: 0,
270	parameterIndexesData: null
271	};
272	}
273
274	/**
275	* @param {IStringArrayStorageItemData} stringArrayStorageItemData
276	* @returns {IStringArrayScopeCallsWrapperData}
277	*/
278	private getUpperStringArrayScopeCallsWrapperData(
279	stringArrayStorageItemData: IStringArrayStorageItemData
280	): IStringArrayScopeCallsWrapperData {
281	const { encoding } = stringArrayStorageItemData;	8,261,674✔
282	const currentLexicalScopeBodyNode: TNodeWithLexicalScopeStatements \| null =
283	this.visitedLexicalScopeNodesStackStorage.getLastElement() ?? null;	8,261,674!
284
285	if (!currentLexicalScopeBodyNode) {	8,261,674!
286	throw new Error('Cannot find current lexical scope body node');	×
287	}
288
289	const stringArrayScopeCallsWrappersDataByEncoding: TStringArrayScopeCallsWrappersDataByEncoding =
290	this.getAndUpdateStringArrayScopeCallsWrappersDataByEncoding(	8,261,674✔
291	currentLexicalScopeBodyNode,
292	stringArrayStorageItemData
293	);
294
295	const stringArrayScopeCallsWrappersData: IStringArrayScopeCallsWrapperData[] =
296	stringArrayScopeCallsWrappersDataByEncoding[encoding]?.scopeCallsWrappersData ?? [];	8,261,674!
297
298	return this.randomGenerator.getRandomGenerator().pickone(stringArrayScopeCallsWrappersData);	8,261,674✔
299	}
300
301	/**
302	* @param {TNodeWithLexicalScopeStatements} currentLexicalScopeBodyNode
303	* @param {IStringArrayStorageItemData} stringArrayStorageItemData
304	* @returns {TStringArrayScopeCallsWrappersDataByEncoding}
305	*/
306	private getAndUpdateStringArrayScopeCallsWrappersDataByEncoding(
307	currentLexicalScopeBodyNode: TNodeWithLexicalScopeStatements,
308	stringArrayStorageItemData: IStringArrayStorageItemData
309	): TStringArrayScopeCallsWrappersDataByEncoding {
310	const { encoding } = stringArrayStorageItemData;	8,261,674✔
311	const stringArrayScopeCallsWrappersDataByEncoding: TStringArrayScopeCallsWrappersDataByEncoding =
312	this.stringArrayScopeCallsWrappersDataStorage.get(currentLexicalScopeBodyNode) ?? {};	8,261,674✔
313
314	const stringArrayScopeCallsWrappersData: IStringArrayScopeCallsWrapperData[] =
315	stringArrayScopeCallsWrappersDataByEncoding[encoding]?.scopeCallsWrappersData ?? [];	8,261,674✔
316	const isFilledScopeCallsWrapperNamesList: boolean =
317	stringArrayScopeCallsWrappersData.length === this.options.stringArrayWrappersCount;	8,261,674✔
318
319	if (isFilledScopeCallsWrapperNamesList) {	8,261,674✔
320	return stringArrayScopeCallsWrappersDataByEncoding;	6,584,165✔
321	}
322
323	// have to use `generateForGlobalScope` for program node for correct attach prefix to the calls wrapper name
324	const nextScopeCallsWrapperName: string = NodeGuards.isProgramNode(currentLexicalScopeBodyNode)	1,677,509✔
325	? this.identifierNamesGenerator.generateForGlobalScope()	1,677,509✔
326	: this.identifierNamesGenerator.generateNext();
327	const nextScopeCallsWrapperShiftedIndex: number = this.getStringArrayCallsWrapperShiftedIndex();	1,677,509✔
328	const nextScopeCallsWrapperParameterIndexesData: IStringArrayScopeCallsWrapperParameterIndexesData \| null =
329	this.getStringArrayCallsWrapperParameterIndexesData();	1,677,509✔
330
331	stringArrayScopeCallsWrappersDataByEncoding[encoding] = {	1,677,509✔
332	encoding,
333	scopeCallsWrappersData: [
334	...stringArrayScopeCallsWrappersData,
335	{
336	name: nextScopeCallsWrapperName,
337	index: nextScopeCallsWrapperShiftedIndex,
338	parameterIndexesData: nextScopeCallsWrapperParameterIndexesData
339	}
340	]
341	};
342
343	this.stringArrayScopeCallsWrappersDataStorage.set(	1,677,509✔
344	currentLexicalScopeBodyNode,
345	stringArrayScopeCallsWrappersDataByEncoding
346	);
347
348	return stringArrayScopeCallsWrappersDataByEncoding;	1,677,509✔
349	}
350
351	/**
352	* @returns {number}
353	*/
354	private getStringArrayCallsWrapperShiftedIndex(): number {
355	return this.options.stringArrayWrappersType === StringArrayWrappersType.Function	1,677,509✔
356	? this.randomGenerator.getRandomInteger(	1,677,509✔
357	StringArrayTransformer.minShiftedIndexValue,
358	StringArrayTransformer.maxShiftedIndexValue
359	)
360	: 0;
361	}
362
363	/**
364	* @returns {IStringArrayScopeCallsWrapperParameterIndexesData \| null}
365	*/
366	private getStringArrayCallsWrapperParameterIndexesData(): IStringArrayScopeCallsWrapperParameterIndexesData \| null {
367	if (this.options.stringArrayWrappersType !== StringArrayWrappersType.Function) {	1,677,509✔
368	return null;	71,010✔
369	}
370
371	const minIndexValue: number = 0;	1,606,499✔
372	const maxIndexValue: number = this.options.stringArrayWrappersParametersMaxCount - 1;	1,606,499✔
373
374	const valueIndexParameterIndex: number = this.randomGenerator.getRandomInteger(minIndexValue, maxIndexValue);	1,606,499✔
375	const decodeKeyParameterIndex: number = this.randomGenerator.getRandomIntegerExcluding(	1,606,499✔
376	minIndexValue,
377	maxIndexValue,
378	[valueIndexParameterIndex]
379	);
380
381	return {	1,606,499✔
382	valueIndexParameterIndex,
383	decodeKeyParameterIndex
384	};
385	}
386	}

javascript-obfuscator / javascript-obfuscator / 19907815758

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous