javascript-obfuscator 3.0.0 → 3.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "3.0.0",
+  "version": "3.2.1",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -21,76 +21,78 @@
   },
   "types": "typings/index.d.ts",
   "dependencies": {
-    "@javascript-obfuscator/escodegen": "2.2.2",
-    "@javascript-obfuscator/estraverse": "5.3.0",
+    "@javascript-obfuscator/escodegen": "2.3.0",
+    "@javascript-obfuscator/estraverse": "5.4.0",
     "@nuxtjs/opencollective": "0.3.2",
-    "acorn": "8.5.0",
+    "acorn": "8.7.0",
     "assert": "2.0.0",
     "chalk": "4.1.2",
     "chance": "1.1.8",
-    "class-validator": "0.13.1",
-    "commander": "8.2.0",
-    "eslint-scope": "6.0.0",
+    "class-validator": "0.13.2",
+    "commander": "9.0.0",
+    "eslint-scope": "7.1.0",
+    "eslint-visitor-keys": "3.2.0",
     "fast-deep-equal": "3.1.3",
-    "inversify": "5.1.1",
+    "inversify": "6.0.1",
     "js-string-escape": "1.0.1",
     "md5": "2.3.0",
     "mkdirp": "1.0.4",
     "multimatch": "5.0.0",
     "process": "0.11.10",
     "reflect-metadata": "0.1.13",
-    "source-map-support": "0.5.20",
+    "source-map-support": "0.5.21",
     "string-template": "1.0.0",
     "stringz": "2.1.0",
     "tslib": "2.3.1"
   },
   "devDependencies": {
-    "@istanbuljs/nyc-config-typescript": "1.0.1",
-    "@types/chai": "4.2.22",
+    "@istanbuljs/nyc-config-typescript": "1.0.2",
+    "@types/chai": "4.3.0",
     "@types/chance": "1.1.3",
     "@types/escodegen": "0.0.7",
-    "@types/eslint-scope": "3.7.1",
+    "@types/eslint-scope": "3.7.3",
+    "@types/eslint-visitor-keys": "1.0.0",
     "@types/estraverse": "5.1.1",
     "@types/estree": "0.0.50",
     "@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.0.0",
+    "@types/mocha": "9.1.0",
     "@types/multimatch": "4.0.0",
-    "@types/node": "16.11.0",
+    "@types/node": "17.0.13",
     "@types/rimraf": "3.0.2",
-    "@types/sinon": "10.0.4",
+    "@types/sinon": "10.0.9",
     "@types/string-template": "1.0.2",
     "@types/webpack-env": "1.16.3",
-    "@typescript-eslint/eslint-plugin": "5.0.0",
-    "@typescript-eslint/parser": "5.0.0",
-    "chai": "4.3.4",
+    "@typescript-eslint/eslint-plugin": "5.10.1",
+    "@typescript-eslint/parser": "5.10.1",
+    "chai": "4.3.6",
     "chai-exclude": "2.1.0",
     "cross-env": "7.0.3",
-    "eslint": "7.31.0",
-    "eslint-plugin-import": "2.23.4",
-    "eslint-plugin-jsdoc": "35.5.1",
+    "eslint": "8.8.0",
+    "eslint-plugin-import": "2.25.4",
+    "eslint-plugin-jsdoc": "37.7.0",
     "eslint-plugin-no-null": "1.0.2",
     "eslint-plugin-prefer-arrow": "1.2.3",
-    "eslint-plugin-unicorn": "34.0.1",
+    "eslint-plugin-unicorn": "40.1.0",
     "fork-ts-checker-notifier-webpack-plugin": "4.0.0",
-    "fork-ts-checker-webpack-plugin": "6.3.4",
-    "husky": "^7.0.2",
+    "fork-ts-checker-webpack-plugin": "6.4.0",
+    "husky": "7.0.4",
     "js-beautify": "1.14.0",
-    "mocha": "9.1.3",
+    "mocha": "9.2.0",
     "nyc": "15.1.0",
     "pjson": "1.0.9",
     "rimraf": "3.0.2",
-    "sinon": "11.1.2",
+    "sinon": "13.0.0",
     "source-map-resolve": "0.6.0",
-    "terser": "^5.9.0",
+    "terser": "5.10.0",
     "threads": "1.7.0",
     "ts-loader": "9.2.6",
-    "ts-node": "10.3.0",
-    "typescript": "4.4.4",
-    "webpack": "5.58.2",
-    "webpack-cli": "4.9.0",
+    "ts-node": "10.4.0",
+    "typescript": "4.5.5",
+    "webpack": "5.67.0",
+    "webpack-cli": "4.9.2",
     "webpack-node-externals": "3.0.0"
   },
   "repository": {
@@ -109,9 +111,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=220 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/code-transformers/AbstractCodeTransformer.d.ts

@@ -7,6 +7,6 @@ export declare abstract class AbstractCodeTransformer implements ICodeTransforme
     readonly runAfter: CodeTransformer[] | undefined;
     protected readonly options: IOptions;
     protected readonly randomGenerator: IRandomGenerator;
-    protected constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
     abstract transformCode(code: string, codeTransformationStage: CodeTransformationStage): string;
 }

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

@@ -1,4 +1,5 @@
 import { interfaces } from 'inversify';
+import { TConstructor } from '../types/TConstructor';
 import { TInputOptions } from '../types/options/TInputOptions';
 import { IInversifyContainerFacade } from '../interfaces/container/IInversifyContainerFacade';
 export declare class InversifyContainerFacade implements IInversifyContainerFacade {
@@ -6,7 +7,7 @@ export declare class InversifyContainerFacade implements IInversifyContainerFaca
     constructor();
     static getFactory<T extends string, U>(serviceIdentifier: interfaces.ServiceIdentifier<U>): (context: interfaces.Context) => (bindingName: T) => U;
     static getCacheFactory<T extends string, U>(serviceIdentifier: interfaces.ServiceIdentifier<U>): (context: interfaces.Context) => (bindingName: T) => U;
-    static getConstructorFactory<T extends string, U>(serviceIdentifier: interfaces.ServiceIdentifier<interfaces.Newable<U>>, ...dependencies: interfaces.ServiceIdentifier<interfaces.Newable<Record<string, any>>>[]): (context: interfaces.Context) => (bindingName: T) => U;
+    static getConstructorFactory<T extends string, U>(serviceIdentifier: interfaces.ServiceIdentifier<TConstructor<Record<string, any>[], U>>, ...dependencies: interfaces.ServiceIdentifier<TConstructor<Record<string, any>[], U>>[]): (context: interfaces.Context) => (bindingName: T) => U;
     get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
     getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
     load(sourceCode: string, sourceMap: string, options: TInputOptions): void;

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-code-helpers/AbstractCustomCodeHelper.d.ts

@@ -14,7 +14,7 @@ export declare abstract class AbstractCustomCodeHelper<TInitialData extends unkn
     protected readonly identifierNamesGenerator: IIdentifierNamesGenerator;
     protected readonly options: IOptions;
     protected readonly randomGenerator: IRandomGenerator;
-    protected constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, customCodeHelperObfuscator: ICustomCodeHelperObfuscator, randomGenerator: IRandomGenerator, options: IOptions);
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, customCodeHelperObfuscator: ICustomCodeHelperObfuscator, randomGenerator: IRandomGenerator, options: IOptions);
     getNode(): TStatement[];
     protected getGlobalVariableTemplate(): string;
     protected getCodeHelperTemplate(): string;

package/typings/src/custom-nodes/AbstractCustomNode.d.ts

@@ -11,7 +11,7 @@ export declare abstract class AbstractCustomNode<TInitialData extends unknown[]
     protected readonly identifierNamesGenerator: IIdentifierNamesGenerator;
     protected readonly options: IOptions;
     protected readonly randomGenerator: IRandomGenerator;
-    protected constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
     getNode(): TStatement[];
     abstract initialize(...args: TInitialData): void;
     protected abstract getNodeStructure(): TStatement[];

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/custom-nodes/string-array-nodes/AbstractStringArrayCallNode.d.ts

@@ -13,7 +13,7 @@ export declare abstract class AbstractStringArrayCallNode extends AbstractCustom
     protected readonly arrayUtils: IArrayUtils;
     protected readonly stringArrayStorage: IStringArrayStorage;
     private readonly stringArrayIndexNodeFactory;
-    protected constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, stringArrayIndexNodeFactory: TStringArrayIndexNodeFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, stringArrayStorage: IStringArrayStorage, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, stringArrayIndexNodeFactory: TStringArrayIndexNodeFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, stringArrayStorage: IStringArrayStorage, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
     protected getStringArrayIndexNode(index: number): ESTree.Expression;
     protected getRc4KeyLiteralNode(decodeKey: string): ESTree.Literal;
 }

package/typings/src/custom-nodes/string-array-nodes/string-array-index-nodes/AbstractStringArrayIndexNode.d.ts

@@ -5,6 +5,6 @@ import { IStringArrayIndexNode } from '../../../interfaces/custom-nodes/string-a
 export declare abstract class AbstractStringArrayIndexNode implements IStringArrayIndexNode {
     protected readonly options: IOptions;
     protected readonly randomGenerator: IRandomGenerator;
-    protected constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
     abstract getNode(index: number): ESTree.Expression;
 }

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/NodeType.d.ts

@@ -47,6 +47,7 @@ export declare enum NodeType {
     ReturnStatement = "ReturnStatement",
     SequenceExpression = "SequenceExpression",
     SpreadElement = "SpreadElement",
+    StaticBlock = "StaticBlock",
     Super = "Super",
     SwitchCase = "SwitchCase",
     SwitchStatement = "SwitchStatement",

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,7 +6,7 @@ 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;
@@ -16,5 +16,6 @@ export declare abstract class AbstractIdentifierNamesGenerator implements IIdent
     private notReservedName;
     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/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/NodeFactory.d.ts

@@ -33,6 +33,7 @@ export declare class NodeFactory {
     static returnStatementNode(argument: ESTree.Expression): ESTree.ReturnStatement;
     static sequenceExpressionNode(expressions: ESTree.Expression[]): ESTree.SequenceExpression;
     static spreadElementNode(argument: ESTree.Expression): ESTree.SpreadElement;
+    static staticBlockNode(body?: ESTree.Statement[]): ESTree.StaticBlock;
     static switchStatementNode(discriminant: ESTree.Expression, cases: ESTree.SwitchCase[]): ESTree.SwitchStatement;
     static switchCaseNode(test: ESTree.Expression, consequent: ESTree.Statement[]): ESTree.SwitchCase;
     static unaryExpressionNode(operator: ESTree.UnaryOperator, argument: ESTree.Expression, prefix?: true): ESTree.UnaryExpression;

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

@@ -65,6 +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 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,25 @@
+/// <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 { 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';
+import { IControlFlowStorage } from '../../interfaces/storages/control-flow-transformers/IControlFlowStorage';
+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 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;
 }