javascript-obfuscator 3.1.0 → 3.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "3.1.0",
+  "version": "3.2.3",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -53,45 +53,46 @@
     "@types/eslint-scope": "3.7.3",
     "@types/eslint-visitor-keys": "1.0.0",
     "@types/estraverse": "5.1.1",
-    "@types/estree": "0.0.50",
+    "@types/estree": "0.0.51",
     "@types/js-beautify": "1.13.3",
     "@types/js-string-escape": "1.0.1",
     "@types/md5": "2.3.1",
     "@types/mkdirp": "1.0.2",
     "@types/mocha": "9.1.0",
     "@types/multimatch": "4.0.0",
-    "@types/node": "17.0.13",
+    "@types/node": "17.0.15",
     "@types/rimraf": "3.0.2",
-    "@types/sinon": "10.0.9",
+    "@types/sinon": "10.0.10",
     "@types/string-template": "1.0.2",
     "@types/webpack-env": "1.16.3",
-    "@typescript-eslint/eslint-plugin": "5.10.1",
-    "@typescript-eslint/parser": "5.10.1",
+    "@typescript-eslint/eslint-plugin": "5.10.2",
+    "@typescript-eslint/parser": "5.10.2",
     "chai": "4.3.6",
     "chai-exclude": "2.1.0",
     "cross-env": "7.0.3",
     "eslint": "8.8.0",
     "eslint-plugin-import": "2.25.4",
-    "eslint-plugin-jsdoc": "37.7.0",
+    "eslint-plugin-jsdoc": "37.7.1",
     "eslint-plugin-no-null": "1.0.2",
     "eslint-plugin-prefer-arrow": "1.2.3",
     "eslint-plugin-unicorn": "40.1.0",
+    "eslint-webpack-plugin": "3.1.1",
     "fork-ts-checker-notifier-webpack-plugin": "4.0.0",
-    "fork-ts-checker-webpack-plugin": "6.4.0",
+    "fork-ts-checker-webpack-plugin": "7.0.0",
     "husky": "7.0.4",
     "js-beautify": "1.14.0",
     "mocha": "9.2.0",
     "nyc": "15.1.0",
     "pjson": "1.0.9",
     "rimraf": "3.0.2",
-    "sinon": "13.0.0",
+    "sinon": "13.0.1",
     "source-map-resolve": "0.6.0",
     "terser": "5.10.0",
     "threads": "1.7.0",
     "ts-loader": "9.2.6",
     "ts-node": "10.4.0",
     "typescript": "4.5.5",
-    "webpack": "5.67.0",
+    "webpack": "5.68.0",
     "webpack-cli": "4.9.2",
     "webpack-node-externals": "3.0.0"
   },
@@ -111,9 +112,9 @@
     "test:devRuntimePerformance": "ts-node test/dev/dev-runtime-performance.ts",
     "test:full": "yarn run test:dev && yarn run test:mocha-coverage && yarn run test:mocha-memory-performance",
     "test:mocha": "mocha --require ts-node/register --require source-map-support/register test/index.spec.ts --exit",
-    "test:mocha-coverage": "nyc --reporter text-summary --no-clean yarn run test:mocha",
+    "test:mocha-coverage": "NODE_OPTIONS=--max-old-space-size=4096 nyc --reporter text-summary --no-clean yarn run test:mocha",
     "test:mocha-coverage:report": "nyc report --reporter=lcov",
-    "test:mocha-memory-performance": "cross-env NODE_OPTIONS=--max-old-space-size=230 mocha --require ts-node/register test/performance-tests/JavaScriptObfuscatorMemory.spec.ts",
+    "test:mocha-memory-performance": "cross-env NODE_OPTIONS=--max-old-space-size=240 mocha --require ts-node/register test/performance-tests/JavaScriptObfuscatorMemory.spec.ts",
     "test": "yarn run test:full",
     "eslint": "eslint src/**/*.ts",
     "git:addFiles": "git add .",

package/typings/src/constants/ReservedIdentifierNames.d.ts

@@ -0,0 +1 @@
+export declare const reservedIdentifierNames: string[];

package/typings/src/container/ServiceIdentifiers.d.ts

@@ -21,6 +21,7 @@ export declare enum ServiceIdentifiers {
     ICodeTransformer = "ICodeTransformer",
     ICodeTransformerNamesGroupsBuilder = "ICodeTransformerNamesGroupsBuilder",
     ICodeTransformersRunner = "ICodeTransformersRunner",
+    IControlFlowStorage = "IControlFlowStorage",
     ICryptUtils = "ICryptUtils",
     ICryptUtilsStringArray = "ICryptUtilsStringArray",
     ICustomCodeHelper = "ICustomCodeHelper",
@@ -50,6 +51,7 @@ export declare enum ServiceIdentifiers {
     IRandomGenerator = "IRandomGenerator",
     IRenamePropertiesReplacer = "IRenamePropertiesReplacer",
     IScopeIdentifiersTraverser = "IScopeIdentifiersTraverser",
+    ISetUtils = "ISetUtils",
     ISourceCode = "ISourceCode",
     IScopeAnalyzer = "IScopeAnalyzer",
     IStringArrayIndexNode = "IStringArrayIndexNode",
@@ -59,7 +61,6 @@ export declare enum ServiceIdentifiers {
     IThroughIdentifierReplacer = "IThroughIdentifierReplacer",
     IVisitedLexicalScopeNodesStackStorage = "IVisitedLexicalScopeNodesStackStorage",
     Newable__ICustomNode = "Newable<ICustomNode>",
-    Newable__TControlFlowStorage = "Newable<TControlFlowStorage>",
     TCustomNodeGroupStorage = "TCustomNodeGroupStorage",
     TInputOptions = "TInputOptions"
 }

package/typings/src/custom-nodes/control-flow-flattening-nodes/{StringLiteralNode.d.ts → LiteralNode.d.ts}

@@ -1,12 +1,13 @@
+import type * as ESTree from 'estree';
 import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
 import { TStatement } from '../../types/node/TStatement';
 import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { AbstractCustomNode } from '../AbstractCustomNode';
-export declare class StringLiteralNode extends AbstractCustomNode {
-    private literalValue;
+export declare class LiteralNode extends AbstractCustomNode {
+    private literalNode;
     constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
-    initialize(literalValue: string): void;
+    initialize(literalNode: ESTree.Literal): void;
     protected getNodeStructure(): TStatement[];
 }

package/typings/src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ControlFlowStorageNode.d.ts

@@ -1,6 +1,6 @@
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
 import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
 import { TStatement } from '../../../types/node/TStatement';
+import { IControlFlowStorage } from '../../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
 import { ICustomCodeHelperFormatter } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
@@ -8,6 +8,6 @@ import { AbstractCustomNode } from '../../AbstractCustomNode';
 export declare class ControlFlowStorageNode extends AbstractCustomNode {
     private controlFlowStorage;
     constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
-    initialize(controlFlowStorage: TControlFlowStorage): void;
+    initialize(controlFlowStorage: IControlFlowStorage): void;
     protected getNodeStructure(): TStatement[];
 }

package/typings/src/enums/custom-nodes/ControlFlowCustomNode.d.ts

@@ -5,7 +5,7 @@ export declare enum ControlFlowCustomNode {
     CallExpressionFunctionNode = "CallExpressionFunctionNode",
     ControlFlowStorageNode = "ControlFlowStorageNode",
     ExpressionWithOperatorControlFlowStorageCallNode = "ExpressionWithOperatorControlFlowStorageCallNode",
+    LiteralNode = "LiteralNode",
     LogicalExpressionFunctionNode = "LogicalExpressionFunctionNode",
-    StringLiteralControlFlowStorageCallNode = "StringLiteralControlFlowStorageCallNode",
-    StringLiteralNode = "StringLiteralNode"
+    StringLiteralControlFlowStorageCallNode = "StringLiteralControlFlowStorageCallNode"
 }

package/typings/src/enums/node-transformers/NodeTransformer.d.ts

@@ -28,6 +28,7 @@ export declare enum NodeTransformer {
     ScopeIdentifiersTransformer = "ScopeIdentifiersTransformer",
     ScopeThroughIdentifiersTransformer = "ScopeThroughIdentifiersTransformer",
     SplitStringTransformer = "SplitStringTransformer",
+    StringArrayControlFlowTransformer = "StringArrayControlFlowTransformer",
     StringArrayTransformer = "StringArrayTransformer",
     StringArrayRotateFunctionTransformer = "StringArrayRotateFunctionTransformer",
     StringArrayScopeCallsWrapperTransformer = "StringArrayScopeCallsWrapperTransformer",

package/typings/src/enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer.d.ts

@@ -2,5 +2,6 @@ export declare enum ControlFlowReplacer {
     BinaryExpressionControlFlowReplacer = "BinaryExpressionControlFlowReplacer",
     CallExpressionControlFlowReplacer = "CallExpressionControlFlowReplacer",
     LogicalExpressionControlFlowReplacer = "LogicalExpressionControlFlowReplacer",
+    StringArrayCallControlFlowReplacer = "StringArrayCallControlFlowReplacer",
     StringLiteralControlFlowReplacer = "StringLiteralControlFlowReplacer"
 }

package/typings/src/enums/storages/ControlFlowStorage.d.ts

@@ -0,0 +1,4 @@
+export declare enum ControlFlowStorage {
+    FunctionControlFlowStorage = "function-control-flow-storage",
+    StringControlFlowStorage = "string-control-flow-storage"
+}

package/typings/src/generators/identifier-names-generators/AbstractIdentifierNamesGenerator.d.ts

@@ -6,15 +6,16 @@ export declare abstract class AbstractIdentifierNamesGenerator implements IIdent
     protected readonly options: IOptions;
     protected readonly randomGenerator: IRandomGenerator;
     protected readonly preservedNamesSet: Set<string>;
-    protected readonly lexicalScopesPreservedNamesMap: Map<TNodeWithLexicalScope, Set<string>>;
+    protected readonly lexicalScopesPreservedNamesMap: WeakMap<TNodeWithLexicalScope, Set<string>>;
     constructor(randomGenerator: IRandomGenerator, options: IOptions);
     generate(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
     preserveName(name: string): void;
     preserveNameForLexicalScope(name: string, lexicalScopeNode: TNodeWithLexicalScope): void;
     isValidIdentifierName(name: string): boolean;
     isValidIdentifierNameInLexicalScopes(name: string, lexicalScopeNodes: TNodeWithLexicalScope[]): boolean;
-    private notReservedName;
+    private isReservedName;
     abstract generateForGlobalScope(nameLength?: number): string;
     abstract generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    abstract generateForLabel(label: string, nameLength?: number): string;
     abstract generateNext(nameLength?: number): string;
 }

package/typings/src/generators/identifier-names-generators/DictionaryIdentifierNamesGenerator.d.ts

@@ -12,6 +12,7 @@ export declare class DictionaryIdentifierNamesGenerator extends AbstractIdentifi
     generateNext(): string;
     generateForGlobalScope(): string;
     generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope): string;
+    generateForLabel(label: string): string;
     private generateNewDictionaryName;
     private getInitialIdentifierNames;
     private getIncrementedIdentifierNames;

package/typings/src/generators/identifier-names-generators/HexadecimalIdentifierNamesGenerator.d.ts

@@ -8,4 +8,5 @@ export declare class HexadecimalIdentifierNamesGenerator extends AbstractIdentif
     generateNext(nameLength?: number): string;
     generateForGlobalScope(nameLength?: number): string;
     generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    generateForLabel(label: string, nameLength?: number): string;
 }

package/typings/src/generators/identifier-names-generators/MangledIdentifierNamesGenerator.d.ts

@@ -1,21 +1,28 @@
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { ISetUtils } from '../../interfaces/utils/ISetUtils';
 import { AbstractIdentifierNamesGenerator } from './AbstractIdentifierNamesGenerator';
 export declare class MangledIdentifierNamesGenerator extends AbstractIdentifierNamesGenerator {
+    private static readonly maxRegenerationAttempts;
     private static readonly initMangledNameCharacter;
     private static readonly lastMangledNameInScopeMap;
     private static readonly nameSequence;
     private static readonly reservedNamesSet;
+    private readonly lastMangledNameForLabelMap;
     private previousMangledName;
-    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    private readonly setUtils;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions, setUtils: ISetUtils);
     generateNext(nameLength?: number): string;
     generateForGlobalScope(nameLength?: number): string;
     generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    generateForLabel(label: string, nameLength?: number): string;
     isIncrementedMangledName(nextName: string, prevName: string): boolean;
     isValidIdentifierName(mangledName: string): boolean;
     protected getNameSequence(): string[];
     protected updatePreviousMangledName(name: string): void;
-    protected generateNewMangledName(previousMangledName: string): string;
+    protected updatePreviousMangledNameForLabel(name: string, label: string, lastMangledNameForLabel: string): void;
+    protected generateNewMangledName(previousMangledName: string, validationFunction?: (newIdentifierName: string) => boolean): string;
     private getLastMangledNameForScopes;
+    private getLastMangledNameForLabel;
 }

package/typings/src/generators/identifier-names-generators/MangledShuffledIdentifierNamesGenerator.d.ts

@@ -1,13 +1,13 @@
 import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { ISetUtils } from '../../interfaces/utils/ISetUtils';
 import { MangledIdentifierNamesGenerator } from './MangledIdentifierNamesGenerator';
 export declare class MangledShuffledIdentifierNamesGenerator extends MangledIdentifierNamesGenerator {
     protected static shuffledNameSequence: string[];
     private readonly arrayUtils;
-    constructor(arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    constructor(arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions, setUtils: ISetUtils);
     initialize(): void;
     protected initializeNameSequence(nameSequence: string[]): void;
     protected getNameSequence(): string[];
-    protected generateNewMangledName(previousMangledName: string): string;
 }

package/typings/src/interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator.d.ts

@@ -3,6 +3,7 @@ export interface IIdentifierNamesGenerator {
     generate(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
     generateForGlobalScope(nameLength?: number): string;
     generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    generateForLabel(label: string, nameLength?: number): string;
     generateNext(nameLength?: number): string;
     isValidIdentifierName(identifierName: string): boolean;
     isValidIdentifierNameInLexicalScopes(identifierName: string, lexicalScopeNodes: TNodeWithLexicalScope[]): boolean;

package/typings/src/interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer.d.ts

@@ -1,5 +1,6 @@
 import * as ESTree from 'estree';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { IControlFlowStorage } from '../../storages/control-flow-transformers/IControlFlowStorage';
 export interface IControlFlowReplacer {
-    replace(node: ESTree.Node, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    replace(node: ESTree.Node, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
+    generateStorageKey(controlFlowStorage: IControlFlowStorage): string;
 }

package/typings/src/interfaces/node-transformers/simplifying-transformers/IIteratedStatementsSimplifyData.d.ts

@@ -3,4 +3,5 @@ export interface IIteratedStatementsSimplifyData {
     startIndex: number | null;
     unwrappedExpressions: ESTree.Expression[];
     hasReturnStatement: boolean;
+    hasStatementsAfterReturnStatement: boolean;
 }

package/typings/src/interfaces/options/IOptions.d.ts

@@ -46,6 +46,8 @@ export interface IOptions {
     readonly splitStrings: boolean;
     readonly splitStringsChunkLength: number;
     readonly stringArray: boolean;
+    readonly stringArrayCallsTransform: boolean;
+    readonly stringArrayCallsTransformThreshold: number;
     readonly stringArrayEncoding: TStringArrayEncoding[];
     readonly stringArrayIndexesType: TStringArrayIndexesType[];
     readonly stringArrayIndexShift: boolean;

package/typings/src/interfaces/storages/IWeakMapStorage.d.ts

@@ -0,0 +1,9 @@
+import { IInitializable } from '../IInitializable';
+export interface IWeakMapStorage<K extends object, V> extends IInitializable {
+    get(key: K): V | undefined;
+    getOrThrow(key: K): V;
+    getStorage(): WeakMap<K, V>;
+    getStorageId(): string;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+}

package/typings/src/interfaces/storages/control-flow-transformers/IControlFlowStorage.d.ts

@@ -0,0 +1,4 @@
+import { IMapStorage } from '../IMapStorage';
+import { ICustomNode } from '../../custom-nodes/ICustomNode';
+export interface IControlFlowStorage extends IMapStorage<string, ICustomNode> {
+}

package/typings/src/interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage.d.ts

@@ -1,5 +1,5 @@
 import { TNodeWithLexicalScopeStatements } from '../../../types/node/TNodeWithLexicalScopeStatements';
 import { TStringArrayScopeCallsWrappersDataByEncoding } from '../../../types/node-transformers/string-array-transformers/TStringArrayScopeCallsWrappersDataByEncoding';
-import { IMapStorage } from '../IMapStorage';
-export interface IStringArrayScopeCallsWrappersDataStorage extends IMapStorage<TNodeWithLexicalScopeStatements, TStringArrayScopeCallsWrappersDataByEncoding> {
+import { IWeakMapStorage } from '../IWeakMapStorage';
+export interface IStringArrayScopeCallsWrappersDataStorage extends IWeakMapStorage<TNodeWithLexicalScopeStatements, TStringArrayScopeCallsWrappersDataByEncoding> {
 }

package/typings/src/interfaces/utils/ISetUtils.d.ts

@@ -0,0 +1,3 @@
+export interface ISetUtils {
+    getLastElement<T>(set: Set<T>): T | undefined;
+}

package/typings/src/node/NodeGuards.d.ts

@@ -65,7 +65,7 @@ export declare class NodeGuards {
     static isReturnStatementNode(node: ESTree.Node): node is ESTree.ReturnStatement;
     static isSequenceExpressionNode(node: ESTree.Node): node is ESTree.SequenceExpression;
     static isSpreadElementNode(node: ESTree.Node): node is ESTree.SpreadElement;
-    static isStaticBlockNode(node: ESTree.Node): boolean;
+    static isStaticBlockNode(node: ESTree.Node): node is ESTree.StaticBlock;
     static isSuperNode(node: ESTree.Node): node is ESTree.Super;
     static isSwitchCaseNode(node: ESTree.Node): node is ESTree.SwitchCase;
     static isTaggedTemplateExpressionNode(node: ESTree.Node): node is ESTree.TaggedTemplateExpression;

package/typings/src/node/NodeLiteralUtils.d.ts

@@ -1,6 +1,8 @@
 import * as ESTree from 'estree';
+import { TNumberLiteralNode } from '../types/node/TNumberLiteralNode';
 import { TStringLiteralNode } from '../types/node/TStringLiteralNode';
 export declare class NodeLiteralUtils {
+    static isNumberLiteralNode(literalNode: ESTree.Literal): literalNode is TNumberLiteralNode;
     static isStringLiteralNode(literalNode: ESTree.Literal): literalNode is TStringLiteralNode;
     static isProhibitedLiteralNode(literalNode: ESTree.Literal, parentNode: ESTree.Node): boolean;
 }

package/typings/src/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.d.ts

@@ -1,28 +1,37 @@
+/// <reference types="estraverse" />
+import * as estraverse from '@javascript-obfuscator/estraverse';
 import * as ESTree from 'estree';
 import { TControlFlowCustomNodeFactory } from '../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
 import { TControlFlowReplacerFactory } from '../../types/container/node-transformers/TControlFlowReplacerFactory';
 import { TControlFlowStorageFactory } from '../../types/container/node-transformers/TControlFlowStorageFactory';
+import { TControlFlowStorageFactoryCreator } from '../../types/container/node-transformers/TControlFlowStorageFactoryCreator';
+import { TNodeWithStatements } from '../../types/node/TNodeWithStatements';
+import { IControlFlowStorage } from '../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { ControlFlowReplacer } from '../../enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 export declare class FunctionControlFlowTransformer extends AbstractNodeTransformer {
-    private static readonly controlFlowReplacersMap;
     private static readonly hostNodeSearchMinDepth;
     private static readonly hostNodeSearchMaxDepth;
-    private readonly controlFlowData;
-    private readonly visitedFunctionNodes;
-    private readonly hostNodesWithControlFlowNode;
-    private readonly controlFlowReplacerFactory;
-    private readonly controlFlowStorageFactory;
-    private readonly controlFlowCustomNodeFactory;
-    constructor(controlFlowStorageFactory: TControlFlowStorageFactory, controlFlowReplacerFactory: TControlFlowReplacerFactory, controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    protected readonly controlFlowReplacersMap: Map<string, ControlFlowReplacer>;
+    protected readonly controlFlowData: WeakMap<TNodeWithStatements, IControlFlowStorage>;
+    protected readonly hostNodesWithControlFlowNode: WeakMap<TNodeWithStatements, ESTree.VariableDeclaration>;
+    protected readonly controlFlowReplacerFactory: TControlFlowReplacerFactory;
+    protected controlFlowStorageFactory: TControlFlowStorageFactory;
+    protected readonly controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory;
+    protected readonly visitedFunctionNodes: WeakSet<ESTree.Function>;
+    constructor(controlFlowStorageFactoryCreator: TControlFlowStorageFactoryCreator, controlFlowReplacerFactory: TControlFlowReplacerFactory, controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
     transformNode(functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Function;
-    private getControlFlowStorage;
-    private getControlFlowStorageNode;
-    private getHostNode;
-    private isVisitedFunctionNode;
-    private transformFunctionBody;
+    protected transformFunctionBody(functionNode: ESTree.Function, controlFlowStorage: IControlFlowStorage): void;
+    protected transformFunctionBodyNode(node: ESTree.Node, parentNode: ESTree.Node | null, functionNode: ESTree.Function, controlFlowStorage: IControlFlowStorage): estraverse.VisitorOption | ESTree.Node;
+    protected getHostNode(functionNodeBody: ESTree.BlockStatement): TNodeWithStatements;
+    protected getControlFlowStorage(hostNode: TNodeWithStatements): IControlFlowStorage;
+    protected getControlFlowStorageNode(controlFlowStorage: IControlFlowStorage): ESTree.VariableDeclaration;
+    protected appendControlFlowStorageNode(hostNode: TNodeWithStatements, controlFlowStorageNode: ESTree.VariableDeclaration): void;
+    protected isVisitedFunctionNode(node: ESTree.Node): boolean;
+    protected isAllowedTransformationByThreshold(): boolean;
 }

package/typings/src/node-transformers/control-flow-transformers/StringArrayControlFlowTransformer.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="estraverse" />
+import * as estraverse from '@javascript-obfuscator/estraverse';
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TControlFlowReplacerFactory } from '../../types/container/node-transformers/TControlFlowReplacerFactory';
+import { TControlFlowStorageFactoryCreator } from '../../types/container/node-transformers/TControlFlowStorageFactoryCreator';
+import { TNodeWithStatements } from '../../types/node/TNodeWithStatements';
+import { IControlFlowStorage } from '../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { ControlFlowReplacer } from '../../enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
+import { FunctionControlFlowTransformer } from './FunctionControlFlowTransformer';
+export declare class StringArrayControlFlowTransformer extends FunctionControlFlowTransformer {
+    readonly runAfter: NodeTransformer[];
+    protected readonly controlFlowReplacersMap: Map<string, ControlFlowReplacer>;
+    protected readonly controlFlowStorageNodes: WeakSet<ESTree.VariableDeclaration>;
+    constructor(controlFlowStorageFactoryCreator: TControlFlowStorageFactoryCreator, controlFlowReplacerFactory: TControlFlowReplacerFactory, controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    protected transformFunctionBodyNode(node: ESTree.Node, parentNode: ESTree.Node | null, functionNode: ESTree.Function, controlFlowStorage: IControlFlowStorage): estraverse.VisitorOption | ESTree.Node;
+    protected getControlFlowStorage(hostNode: TNodeWithStatements): IControlFlowStorage;
+    protected appendControlFlowStorageNode(hostNode: TNodeWithStatements, controlFlowStorageNode: ESTree.VariableDeclaration): void;
+    protected isAllowedTransformationByThreshold(): boolean;
+}

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

@@ -1,17 +1,20 @@
 import * as ESTree from 'estree';
 import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
 import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
+import { IControlFlowStorage } from '../../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
+import { IIdentifierNamesGenerator } from '../../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 export declare abstract class AbstractControlFlowReplacer implements IControlFlowReplacer {
     protected readonly controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory;
+    protected readonly identifierNamesGenerator: IIdentifierNamesGenerator;
     protected readonly options: IOptions;
     protected readonly randomGenerator: IRandomGenerator;
     protected readonly replacerDataByControlFlowStorageId: Map<string, Map<string, string[]>>;
-    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
-    protected static getStorageKeysByIdForCurrentStorage(identifierDataByControlFlowStorageId: Map<string, Map<string, string[]>>, controlFlowStorageId: string): Map<string, string[]>;
-    protected insertCustomNodeToControlFlowStorage(customNode: ICustomNode, controlFlowStorage: TControlFlowStorage, replacerId: string, usingExistingIdentifierChance: number): string;
-    abstract replace(node: ESTree.Node, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    generateStorageKey(controlFlowStorage: IControlFlowStorage): string;
+    protected insertCustomNodeToControlFlowStorage(customNode: ICustomNode, controlFlowStorage: IControlFlowStorage, replacerId: string, usingExistingIdentifierChance: number): string;
+    abstract replace(node: ESTree.Node, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
 }

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

@@ -1,11 +1,12 @@
 import * as ESTree from 'estree';
 import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { IControlFlowStorage } from '../../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
 export declare class BinaryExpressionControlFlowReplacer extends ExpressionWithOperatorControlFlowReplacer {
     private static readonly usingExistingIdentifierChance;
-    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
-    replace(binaryExpressionNode: ESTree.BinaryExpression, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(binaryExpressionNode: ESTree.BinaryExpression, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
 }

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

@@ -1,12 +1,13 @@
 import * as ESTree from 'estree';
 import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { IControlFlowStorage } from '../../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
 export declare class CallExpressionControlFlowReplacer extends AbstractControlFlowReplacer {
     private static readonly usingExistingIdentifierChance;
-    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
-    replace(callExpressionNode: ESTree.CallExpression, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(callExpressionNode: ESTree.CallExpression, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
     protected getControlFlowStorageCallNode(controlFlowStorageId: string, storageKey: string, callee: ESTree.Expression, expressionArguments: (ESTree.Expression | ESTree.SpreadElement)[]): ESTree.Node;
 }

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

@@ -1,9 +1,10 @@
 import * as ESTree from 'estree';
 import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
 export declare abstract class ExpressionWithOperatorControlFlowReplacer extends AbstractControlFlowReplacer {
-    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
     protected getControlFlowStorageCallNode(controlFlowStorageId: string, storageKey: string, leftExpression: ESTree.Expression, rightExpression: ESTree.Expression): ESTree.Node;
 }

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

@@ -1,12 +1,13 @@
 import * as ESTree from 'estree';
 import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { IControlFlowStorage } from '../../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
 export declare class LogicalExpressionControlFlowReplacer extends ExpressionWithOperatorControlFlowReplacer {
     private static readonly usingExistingIdentifierChance;
-    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
-    replace(logicalExpressionNode: ESTree.LogicalExpression, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(logicalExpressionNode: ESTree.LogicalExpression, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
     private checkForProhibitedExpressions;
 }

package/typings/src/node-transformers/control-flow-transformers/control-flow-replacers/StringArrayCallControlFlowReplacer.d.ts

@@ -0,0 +1,14 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { IControlFlowStorage } from '../../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
+export declare class StringArrayCallControlFlowReplacer extends AbstractControlFlowReplacer {
+    private static readonly usingExistingIdentifierChance;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(literalNode: ESTree.Literal, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
+    generateStorageKey(controlFlowStorage: IControlFlowStorage): string;
+    protected getControlFlowStorageCallNode(controlFlowStorageId: string, storageKey: string): ESTree.Node;
+}

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

@@ -1,12 +1,13 @@
 import * as ESTree from 'estree';
 import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
-import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { IControlFlowStorage } from '../../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
 export declare class StringLiteralControlFlowReplacer extends AbstractControlFlowReplacer {
-    private static readonly usingExistingIdentifierChance;
-    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
-    replace(literalNode: ESTree.Literal, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    protected static readonly usingExistingIdentifierChance: number;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(literalNode: ESTree.Literal, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
     protected getControlFlowStorageCallNode(controlFlowStorageId: string, storageKey: string): ESTree.Node;
 }

package/typings/src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.d.ts

@@ -6,7 +6,6 @@ import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { INodeTransformersRunner } from '../../interfaces/node-transformers/INodeTransformersRunner';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 export declare class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
@@ -14,7 +13,6 @@ export declare class DeadCodeInjectionTransformer extends AbstractNodeTransforme
     private static readonly maxNestedBlockStatementsCount;
     private static readonly minCollectedBlockStatementsCount;
     private static readonly transformersToRenameBlockScopeIdentifiers;
-    readonly runAfter: NodeTransformer[];
     private readonly deadCodeInjectionRootAstHostNodeSet;
     private readonly collectedBlockStatements;
     private collectedBlockStatementsTotalLength;

package/typings/src/options/Options.d.ts

@@ -50,6 +50,8 @@ export declare class Options implements IOptions {
     readonly splitStrings: boolean;
     readonly splitStringsChunkLength: number;
     readonly stringArray: boolean;
+    readonly stringArrayCallsTransform: boolean;
+    readonly stringArrayCallsTransformThreshold: number;
     readonly stringArrayEncoding: TStringArrayEncoding[];
     readonly stringArrayIndexesType: TStringArrayIndexesType[];
     readonly stringArrayIndexShift: boolean;

package/typings/src/options/normalizer-rules/StringArrayCallsTransformThresholdRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const StringArrayCallsTransformThresholdRule: TOptionsNormalizerRule;