Merge pull request #721 from javascript-obfuscator/transformers-reorganize

Reorganized transformers structure and order

package.json

@@ -25,13 +25,13 @@
     "@nuxtjs/opencollective": "0.2.2",
     "acorn": "8.0.1",
     "chalk": "4.1.0",
-    "chance": "1.1.6",
+    "chance": "1.1.7",
     "class-validator": "0.12.2",
     "commander": "6.0.0",
     "escodegen": "2.0.0",
     "eslint-scope": "5.1.0",
     "estraverse": "5.2.0",
-    "eventemitter3": "4.0.4",
+    "eventemitter3": "4.0.5",
     "fast-deep-equal": "3.1.3",
     "inversify": "5.0.1",
     "js-string-escape": "1.0.1",
@@ -62,8 +62,8 @@
     "@types/sinon": "9.0.5",
     "@types/string-template": "1.0.2",
     "@types/webpack-env": "1.15.2",
-    "@typescript-eslint/eslint-plugin": "3.9.1",
-    "@typescript-eslint/parser": "3.9.1",
+    "@typescript-eslint/eslint-plugin": "3.10.0",
+    "@typescript-eslint/parser": "3.10.0",
     "chai": "4.2.0",
     "coveralls": "3.1.0",
     "eslint": "7.7.0",
@@ -81,12 +81,12 @@
     "rimraf": "3.0.2",
     "sinon": "9.0.3",
     "threads": "1.6.3",
-    "ts-loader": "8.0.2",
+    "ts-loader": "8.0.3",
     "ts-node": "9.0.0",
     "typescript": "4.0.2",
     "webpack": "4.44.1",
     "webpack-cli": "3.3.12",
-    "webpack-node-externals": "2.5.1"
+    "webpack-node-externals": "2.5.2"
   },
   "repository": {
     "type": "git",

src/JavaScriptObfuscator.ts

@@ -62,6 +62,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @type {NodeTransformer[]}
      */
     private static readonly nodeTransformersList: NodeTransformer[] = [
+        NodeTransformer.BooleanLiteralTransformer,
         NodeTransformer.BlockStatementControlFlowTransformer,
         NodeTransformer.BlockStatementSimplifyTransformer,
         NodeTransformer.CommentsTransformer,
@@ -72,11 +73,11 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.FunctionControlFlowTransformer,
         NodeTransformer.IfStatementSimplifyTransformer,
         NodeTransformer.LabeledStatementTransformer,
-        NodeTransformer.LiteralTransformer,
         NodeTransformer.RenamePropertiesTransformer,
         NodeTransformer.MemberExpressionTransformer,
         NodeTransformer.MetadataTransformer,
         NodeTransformer.MethodDefinitionTransformer,
+        NodeTransformer.NumberLiteralTransformer,
         NodeTransformer.NumberToNumericalExpressionTransformer,
         NodeTransformer.ObfuscatingGuardsTransformer,
         NodeTransformer.ObjectExpressionKeysTransformer,
@@ -85,6 +86,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.ParentificationTransformer,
         NodeTransformer.ScopeIdentifiersTransformer,
         NodeTransformer.SplitStringTransformer,
+        NodeTransformer.StringArrayTransformer,
         NodeTransformer.TemplateLiteralTransformer,
         NodeTransformer.VariableDeclarationsMergeTransformer,
         NodeTransformer.VariablePreserveTransformer
@@ -215,12 +217,14 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
             astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
         }
 
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);
+
         if (this.options.renameProperties) {
             astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameProperties);
         }
 
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Obfuscating);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameIdentifiers);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.StringArray);
 
         if (this.options.simplify) {
             astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Simplifying);

src/container/InversifyContainerFacade.ts

@@ -13,12 +13,13 @@ import { generatorsModule } from './modules/generators/GeneratorsModule';
 import { initializingTransformersModule } from './modules/node-transformers/InitializingTransformersModule';
 import { nodeModule } from './modules/node/NodeModule';
 import { nodeTransformersModule } from './modules/node-transformers/NodeTransformersModule';
-import { obfuscatingTransformersModule } from './modules/node-transformers/ObfuscatingTransformersModule';
 import { optionsModule } from './modules/options/OptionsModule';
 import { preparingTransformersModule } from './modules/node-transformers/PreparingTransformersModule';
+import { renameIdentifiersTransformersModule } from './modules/node-transformers/RenameIdentifiersTransformersModule';
 import { renamePropertiesTransformersModule } from './modules/node-transformers/RenamePropertiesTransformersModule';
 import { simplifyingTransformersModule } from './modules/node-transformers/SimplifyingTransformersModule';
 import { storagesModule } from './modules/storages/StoragesModule';
+import { stringArrayTransformersModule } from './modules/node-transformers/StringArrayTransformersModule';
 import { utilsModule } from './modules/utils/UtilsModule';
 
 import { TInputOptions } from '../types/options/TInputOptions';
@@ -216,12 +217,13 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
         this.container.load(initializingTransformersModule);
         this.container.load(nodeModule);
         this.container.load(nodeTransformersModule);
-        this.container.load(obfuscatingTransformersModule);
         this.container.load(optionsModule);
         this.container.load(preparingTransformersModule);
+        this.container.load(renameIdentifiersTransformersModule);
         this.container.load(renamePropertiesTransformersModule);
         this.container.load(simplifyingTransformersModule);
         this.container.load(storagesModule);
+        this.container.load(stringArrayTransformersModule);
         this.container.load(utilsModule);
     }
 

src/container/ServiceIdentifiers.ts

@@ -7,11 +7,9 @@ export enum ServiceIdentifiers {
     Factory__ICustomCodeHelperGroup = 'Factory<ICustomCodeHelperGroup>',
     Factory__IDeadCodeInjectionCustomNode = 'Factory<IDeadCodeInjectionCustomNode>',
     Factory__IIdentifierNamesGenerator = 'Factory<IIdentifierNamesGenerator>',
-    Factory__IIdentifierObfuscatingReplacer = 'Factory<IIdentifierObfuscatingReplacer>',
     Factory__INodeGuard = 'Factory<INodeGuard>',
     Factory__INodeTransformer = 'Factory<INodeTransformer[]>',
     Factory__IObfuscatedCode = 'Factory<IObfuscatedCode>',
-    Factory__IObfuscatingReplacer = 'Factory<IObfuscatingReplacer>',
     Factory__IObjectExpressionKeysTransformerCustomNode = 'Factory<IObjectExpressionKeysTransformerCustomNode>',
     Factory__IObjectExpressionExtractor = 'Factory<IObjectExpressionExtractor>',
     Factory__TControlFlowStorage = 'Factory<TControlFlowStorage>',
@@ -30,7 +28,7 @@ export enum ServiceIdentifiers {
     ICustomCodeHelperObfuscator = 'ICustomCodeHelperObfuscator',
     IEscapeSequenceEncoder = 'IEscapeSequenceEncoder',
     IIdentifierNamesGenerator = 'IIdentifierNamesGenerator',
-    IIdentifierObfuscatingReplacer = 'IIdentifierObfuscatingReplacer',
+    IIdentifierReplacer = 'IIdentifierReplacer',
     IJavaScriptObfuscator = 'IJavaScriptObfuscator',
     ILevelledTopologicalSorter = 'ILevelledTopologicalSorter',
     ILogger = 'ILogger',
@@ -42,7 +40,6 @@ export enum ServiceIdentifiers {
     IObfuscatedCode = 'IObfuscatedCode',
     IOptions = 'IOptions',
     IOptionsNormalizer = 'IOptionsNormalizer',
-    IObfuscatingReplacer = 'IObfuscatingReplacer',
     IPrevailingKindOfVariablesAnalyzer = 'IPrevailingKindOfVariablesAnalyzer',
     IObjectExpressionExtractor = 'IObjectExpressionExtractor',
     IRandomGenerator = 'IRandomGenerator',

src/container/modules/node-transformers/ControlFlowTransformersModule.ts

@@ -5,7 +5,7 @@ import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
 import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
 
-import { ControlFlowReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/ControlFlowReplacer';
+import { ControlFlowReplacer } from '../../../enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer';
 import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
 import { BinaryExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer';

src/container/modules/node-transformers/ConvertingTransformersModule.ts

@@ -9,11 +9,13 @@ import { NodeTransformer } from '../../../enums/node-transformers/NodeTransforme
 import { ObjectExpressionExtractor } from '../../../enums/node-transformers/converting-transformers/properties-extractors/ObjectExpressionExtractor';
 
 import { BasePropertiesExtractor } from '../../../node-transformers/converting-transformers/object-expression-extractors/BasePropertiesExtractor';
-import { ObjectExpressionToVariableDeclarationExtractor } from '../../../node-transformers/converting-transformers/object-expression-extractors/ObjectExpressionToVariableDeclarationExtractor';
+import { BooleanLiteralTransformer } from '../../../node-transformers/converting-transformers/BooleanLiteralTransformer';
 import { MemberExpressionTransformer } from '../../../node-transformers/converting-transformers/MemberExpressionTransformer';
 import { MethodDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodDefinitionTransformer';
+import { NumberLiteralTransformer } from '../../../node-transformers/converting-transformers/NumberLiteralTransformer';
 import { NumberToNumericalExpressionTransformer } from '../../../node-transformers/converting-transformers/NumberToNumericalExpressionTransformer';
 import { ObjectExpressionKeysTransformer } from '../../../node-transformers/converting-transformers/ObjectExpressionKeysTransformer';
+import { ObjectExpressionToVariableDeclarationExtractor } from '../../../node-transformers/converting-transformers/object-expression-extractors/ObjectExpressionToVariableDeclarationExtractor';
 import { ObjectExpressionTransformer } from '../../../node-transformers/converting-transformers/ObjectExpressionTransformer';
 import { ObjectPatternPropertiesTransformer } from '../../../node-transformers/converting-transformers/ObjectPatternPropertiesTransformer';
 import { SplitStringTransformer } from '../../../node-transformers/converting-transformers/SplitStringTransformer';
@@ -21,6 +23,10 @@ import { TemplateLiteralTransformer } from '../../../node-transformers/convertin
 
 export const convertingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // converting transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(BooleanLiteralTransformer)
+        .whenTargetNamed(NodeTransformer.BooleanLiteralTransformer);
+
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(MemberExpressionTransformer)
         .whenTargetNamed(NodeTransformer.MemberExpressionTransformer);
@@ -29,6 +35,9 @@ export const convertingTransformersModule: interfaces.ContainerModule = new Cont
         .to(MethodDefinitionTransformer)
         .whenTargetNamed(NodeTransformer.MethodDefinitionTransformer);
 
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(NumberLiteralTransformer)
+        .whenTargetNamed(NodeTransformer.NumberLiteralTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(NumberToNumericalExpressionTransformer)

src/container/modules/node-transformers/FinalizingTransformersModule.ts

@@ -2,5 +2,4 @@ import { ContainerModule, interfaces } from 'inversify';
 
 export const finalizingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // finalizing transformers
-
 });

src/container/modules/node-transformers/ObfuscatingTransformersModule.ts

@@ -1,71 +0,0 @@
-import { InversifyContainerFacade } from '../../InversifyContainerFacade';
-import { ContainerModule, interfaces } from 'inversify';
-import { ServiceIdentifiers } from '../../ServiceIdentifiers';
-
-import { IIdentifierObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
-import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
-import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IObfuscatingReplacer';
-
-import { IdentifierObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
-import { LiteralObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/LiteralObfuscatingReplacer';
-import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
-
-import { BaseIdentifierObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/identifier-obfuscating-replacers/BaseIdentifierObfuscatingReplacer';
-import { BooleanLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/BooleanLiteralObfuscatingReplacer';
-import { LabeledStatementTransformer } from '../../../node-transformers/obfuscating-transformers/LabeledStatementTransformer';
-import { LiteralTransformer } from '../../../node-transformers/obfuscating-transformers/LiteralTransformer';
-import { NumberLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/NumberLiteralObfuscatingReplacer';
-import { StringLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer';
-import { ScopeIdentifiersTransformer } from '../../../node-transformers/obfuscating-transformers/ScopeIdentifiersTransformer';
-import { ScopeThroughIdentifiersTransformer } from '../../../node-transformers/obfuscating-transformers/ScopeThroughIdentifiersTransformer';
-
-export const obfuscatingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    // obfuscating transformers
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(LabeledStatementTransformer)
-        .whenTargetNamed(NodeTransformer.LabeledStatementTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(LiteralTransformer)
-        .whenTargetNamed(NodeTransformer.LiteralTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ScopeIdentifiersTransformer)
-        .whenTargetNamed(NodeTransformer.ScopeIdentifiersTransformer);
-
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ScopeThroughIdentifiersTransformer)
-        .whenTargetNamed(NodeTransformer.ScopeThroughIdentifiersTransformer);
-
-    // literal obfuscating replacers
-    bind<IObfuscatingReplacer>(ServiceIdentifiers.IObfuscatingReplacer)
-        .to(BooleanLiteralObfuscatingReplacer)
-        .whenTargetNamed(LiteralObfuscatingReplacer.BooleanLiteralObfuscatingReplacer);
-
-    bind<IObfuscatingReplacer>(ServiceIdentifiers.IObfuscatingReplacer)
-        .to(NumberLiteralObfuscatingReplacer)
-        .whenTargetNamed(LiteralObfuscatingReplacer.NumberLiteralObfuscatingReplacer);
-
-    bind<IObfuscatingReplacer>(ServiceIdentifiers.IObfuscatingReplacer)
-        .to(StringLiteralObfuscatingReplacer)
-        .whenTargetNamed(LiteralObfuscatingReplacer.StringLiteralObfuscatingReplacer);
-
-    // identifier obfuscating replacer
-    bind<IIdentifierObfuscatingReplacer>(ServiceIdentifiers.IIdentifierObfuscatingReplacer)
-        .to(BaseIdentifierObfuscatingReplacer)
-        .whenTargetNamed(IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer);
-
-    // literal obfuscating replacer factory
-    bind<IObfuscatingReplacer>(ServiceIdentifiers.Factory__IObfuscatingReplacer)
-        .toFactory<IObfuscatingReplacer>(InversifyContainerFacade
-            .getCacheFactory<LiteralObfuscatingReplacer, IObfuscatingReplacer>(
-                ServiceIdentifiers.IObfuscatingReplacer
-            ));
-
-    // identifier obfuscating replacer factory
-    bind<IIdentifierObfuscatingReplacer>(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
-        .toFactory<IIdentifierObfuscatingReplacer>(InversifyContainerFacade
-            .getCacheFactory<IdentifierObfuscatingReplacer, IIdentifierObfuscatingReplacer>(
-                ServiceIdentifiers.IIdentifierObfuscatingReplacer
-            ));
-});

src/container/modules/node-transformers/RenameIdentifiersTransformersModule.ts

@@ -0,0 +1,32 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IIdentifierReplacer } from '../../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { IdentifierReplacer } from '../../../node-transformers/rename-identifiers-transformers/replacer/IdentifierReplacer';
+import { LabeledStatementTransformer } from '../../../node-transformers/rename-identifiers-transformers/LabeledStatementTransformer';
+import { ScopeIdentifiersTransformer } from '../../../node-transformers/rename-identifiers-transformers/ScopeIdentifiersTransformer';
+import { ScopeThroughIdentifiersTransformer } from '../../../node-transformers/rename-identifiers-transformers/ScopeThroughIdentifiersTransformer';
+
+export const renameIdentifiersTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // rename identifiers transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(LabeledStatementTransformer)
+        .whenTargetNamed(NodeTransformer.LabeledStatementTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ScopeIdentifiersTransformer)
+        .whenTargetNamed(NodeTransformer.ScopeIdentifiersTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ScopeThroughIdentifiersTransformer)
+        .whenTargetNamed(NodeTransformer.ScopeThroughIdentifiersTransformer);
+
+    // identifier replacer
+    bind<IIdentifierReplacer>(ServiceIdentifiers.IIdentifierReplacer)
+        .to(IdentifierReplacer)
+        .inSingletonScope();
+});

src/container/modules/node-transformers/StringArrayTransformersModule.ts

@@ -0,0 +1,15 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { StringArrayTransformer } from '../../../node-transformers/string-array-transformers/StringArrayTransformer';
+
+export const stringArrayTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // string array transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(StringArrayTransformer)
+        .whenTargetNamed(NodeTransformer.StringArrayTransformer);
+});

src/enums/node-transformers/NodeTransformationStage.ts

@@ -1,11 +1,12 @@
 export enum NodeTransformationStage {
+    ControlFlowFlattening = 'ControlFlowFlattening',
+    Converting = 'Converting',
+    DeadCodeInjection = 'DeadCodeInjection',
+    Finalizing = 'Finalizing',
     Initializing = 'Initializing',
     Preparing = 'Preparing',
-    DeadCodeInjection = 'DeadCodeInjection',
-    ControlFlowFlattening = 'ControlFlowFlattening',
+    RenameIdentifiers = 'RenameIdentifiers',
     RenameProperties = 'RenameProperties',
-    Converting = 'Converting',
-    Obfuscating = 'Obfuscating',
     Simplifying = 'Simplifying',
-    Finalizing = 'Finalizing'
+    StringArray = 'StringArray'
 }

src/enums/node-transformers/NodeTransformer.ts

@@ -1,4 +1,5 @@
 export enum NodeTransformer {
+    BooleanLiteralTransformer = 'BooleanLiteralTransformer',
     BlockStatementControlFlowTransformer = 'BlockStatementControlFlowTransformer',
     BlockStatementSimplifyTransformer = 'BlockStatementSimplifyTransformer',
     CommentsTransformer = 'CommentsTransformer',
@@ -9,10 +10,10 @@ export enum NodeTransformer {
     FunctionControlFlowTransformer = 'FunctionControlFlowTransformer',
     IfStatementSimplifyTransformer = 'IfStatementSimplifyTransformer',
     LabeledStatementTransformer = 'LabeledStatementTransformer',
-    LiteralTransformer = 'LiteralTransformer',
     MemberExpressionTransformer = 'MemberExpressionTransformer',
     MetadataTransformer = 'MetadataTransformer',
     MethodDefinitionTransformer = 'MethodDefinitionTransformer',
+    NumberLiteralTransformer = 'NumberLiteralTransformer',
     NumberToNumericalExpressionTransformer = 'NumberToNumericalExpressionTransformer',
     ObfuscatingGuardsTransformer = 'ObfuscatingGuardsTransformer',
     ObjectExpressionKeysTransformer = 'ObjectExpressionKeysTransformer',
@@ -23,6 +24,7 @@ export enum NodeTransformer {
     ScopeIdentifiersTransformer = 'ScopeIdentifiersTransformer',
     ScopeThroughIdentifiersTransformer = 'ScopeThroughIdentifiersTransformer',
     SplitStringTransformer = 'SplitStringTransformer',
+    StringArrayTransformer = 'StringArrayTransformer',
     TemplateLiteralTransformer = 'TemplateLiteralTransformer',
     VariableDeclarationsMergeTransformer = 'VariableDeclarationsMergeTransformer',
     VariablePreserveTransformer = 'VariablePreserveTransformer'

src/enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer.ts

@@ -1,3 +0,0 @@
-export enum IdentifierObfuscatingReplacer {
-    BaseIdentifierObfuscatingReplacer = 'BaseIdentifierObfuscatingReplacer'
-}

src/enums/node-transformers/obfuscating-transformers/obfuscating-replacers/LiteralObfuscatingReplacer.ts

@@ -1,5 +0,0 @@
-export enum LiteralObfuscatingReplacer {
-    BooleanLiteralObfuscatingReplacer = 'BooleanLiteralObfuscatingReplacer',
-    NumberLiteralObfuscatingReplacer = 'NumberLiteralObfuscatingReplacer',
-    StringLiteralObfuscatingReplacer = 'StringLiteralObfuscatingReplacer'
-}

src/interfaces/node-transformers/INodeTransformer.ts

@@ -18,7 +18,7 @@ export interface INodeTransformer extends ITransformer <NodeTransformer> {
      * @param {Node} node
      * @param {Node | null} parentNode
      */
-    analyzeNode ? (node: ESTree.Node, parentNode: ESTree.Node | null): void;
+    prepareNode ? (node: ESTree.Node, parentNode: ESTree.Node | null): void;
 
     /**
      * @param {Node} node

src/interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IObfuscatingReplacer.ts

@@ -1,17 +0,0 @@
-import * as ESTree from 'estree';
-
-import { TNodeWithLexicalScope } from '../../../../types/node/TNodeWithLexicalScope';
-
-export interface IObfuscatingReplacer <T = ESTree.Node> {
-    /**
-     * @param {Node} node
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @param {number} nodeIdentifier
-     * @returns {T}
-     */
-    replace (
-        node: ESTree.Node,
-        lexicalScopeNode?: TNodeWithLexicalScope,
-        nodeIdentifier?: number
-    ): T;
-}

src/interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer.ts → src/interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer.ts

@@ -2,9 +2,7 @@ import * as ESTree from 'estree';
 
 import { TNodeWithLexicalScope } from '../../../../types/node/TNodeWithLexicalScope';
 
-import { IObfuscatingReplacer } from './IObfuscatingReplacer';
-
-export interface IIdentifierObfuscatingReplacer extends IObfuscatingReplacer <ESTree.Identifier> {
+export interface IIdentifierReplacer {
     /**
      * @param {Identifier} identifierNode
      * @param {TNodeWithLexicalScope} lexicalScopeNode
@@ -17,6 +15,18 @@ export interface IIdentifierObfuscatingReplacer extends IObfuscatingReplacer <ES
      */
     storeLocalName (identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): void;
 
+    /**
+     * @param {Node} node
+     * @param {TNodeWithLexicalScope} lexicalScopeNode
+     * @param {number} nodeIdentifier
+     * @returns {ESTree.Identifier}
+     */
+    replace (
+        node: ESTree.Node,
+        lexicalScopeNode?: TNodeWithLexicalScope,
+        nodeIdentifier?: number
+    ): ESTree.Identifier;
+
     /**
      * @param {Identifier} identifierNode
      */

src/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.ts

@@ -17,7 +17,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { ControlFlowCustomNode } from '../../enums/custom-nodes/ControlFlowCustomNode';
-import { ControlFlowReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/ControlFlowReplacer';
+import { ControlFlowReplacer } from '../../enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer';
 import { NodeType } from '../../enums/node/NodeType';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 

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

@@ -0,0 +1,98 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeGuards } from '../../node/NodeGuards';
+import { NodeUtils } from '../../node/NodeUtils';
+import { NodeFactory } from '../../node/NodeFactory';
+
+@injectable()
+export class BooleanLiteralTransformer extends AbstractNodeTransformer {
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    public constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(randomGenerator, options);
+    }
+
+    /**
+     * @param {NodeTransformationStage} nodeTransformationStage
+     * @returns {IVisitor | null}
+     */
+    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
+        switch (nodeTransformationStage) {
+            case NodeTransformationStage.Converting:
+                return {
+                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
+                        if (parentNode && NodeGuards.isLiteralNode(node)) {
+                            return this.transformNode(node, parentNode);
+                        }
+                    }
+                };
+
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Replaces:
+     *     var foo = true;
+     *     var bar = false;
+     *
+     * on:
+     *     var foo = !![];
+     *     var bar = ![];
+     *
+     * @param {Literal} literalNode
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
+     */
+    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
+        if (typeof literalNode.value !== 'boolean') {
+            return literalNode;
+        }
+
+        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;
+
+        const unaryExpressionNode: ESTree.UnaryExpression = literalValue
+            ? this.getTrueUnaryExpressionNode()
+            : this.getFalseUnaryExpressionNode();
+
+        NodeUtils.parentizeNode(unaryExpressionNode, parentNode);
+
+        return unaryExpressionNode;
+    }
+
+    /**
+     * @return {ESTree.UnaryExpression}
+     */
+    private getTrueUnaryExpressionNode (): ESTree.UnaryExpression {
+        return NodeFactory.unaryExpressionNode(
+            '!',
+            this.getFalseUnaryExpressionNode()
+        );
+    }
+
+    /**
+     * @return {ESTree.UnaryExpression}
+     */
+    private getFalseUnaryExpressionNode (): ESTree.UnaryExpression {
+        return NodeFactory.unaryExpressionNode(
+            '!',
+            NodeFactory.arrayExpressionNode()
+        );
+    }
+}

src/node-transformers/converting-transformers/MemberExpressionTransformer.ts

@@ -56,7 +56,7 @@ export class MemberExpressionTransformer extends AbstractNodeTransformer {
      * and skip:
      *     object[identifier] = 1;
      *
-     * Literal node will be obfuscated by LiteralTransformer
+     * Literal node will be obfuscated by StringArrayTransformer
      *
      * @param {MemberExpression} memberExpressionNode
      * @param {NodeGuards} parentNode

src/node-transformers/converting-transformers/NumberLiteralTransformer.ts

@@ -0,0 +1,99 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeFactory } from '../../node/NodeFactory';
+import { NodeGuards } from '../../node/NodeGuards';
+import { NumberUtils } from '../../utils/NumberUtils';
+
+@injectable()
+export class NumberLiteralTransformer extends AbstractNodeTransformer {
+    /**
+     * Have to run it after NumberToNumericalExpressionTransformer to keep logic simple
+     *
+     * @type {NodeTransformer[]}
+     */
+    public readonly runAfter: NodeTransformer[] = [
+        NodeTransformer.NumberToNumericalExpressionTransformer
+    ];
+
+    /**
+     * @type {Map<string, string>}
+     */
+    private readonly numberLiteralCache: Map <number, string> = new Map();
+
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    public constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(randomGenerator, options);
+    }
+
+    /**
+     * @param {NodeTransformationStage} nodeTransformationStage
+     * @returns {IVisitor | null}
+     */
+    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
+        switch (nodeTransformationStage) {
+            case NodeTransformationStage.Converting:
+                return {
+                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
+                        if (parentNode && NodeGuards.isLiteralNode(node)) {
+                            return this.transformNode(node, parentNode);
+                        }
+                    }
+                };
+
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Replaces:
+     *     var foo = 1;
+     *
+     * on:
+     *     var foo = 0x1;
+     *
+     * @param {Literal} literalNode
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
+     */
+    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
+        if (typeof literalNode.value !== 'number' && typeof literalNode.value !== 'bigint') {
+            return literalNode;
+        }
+
+        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;
+
+        let rawValue: string;
+
+        if (this.numberLiteralCache.has(literalValue)) {
+            rawValue = <string>this.numberLiteralCache.get(literalValue);
+        } else {
+            if (NumberUtils.isCeil(literalValue)) {
+                rawValue = NumberUtils.toHex(literalValue);
+            } else {
+                rawValue = String(literalValue);
+            }
+
+            this.numberLiteralCache.set(literalValue, rawValue);
+        }
+
+        return NodeFactory.literalNode(literalValue, rawValue);
+    }
+}

src/node-transformers/converting-transformers/ObjectExpressionKeysTransformer.ts

@@ -11,11 +11,11 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { ObjectExpressionExtractor } from '../../enums/node-transformers/converting-transformers/properties-extractors/ObjectExpressionExtractor';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
 import { NodeStatementUtils } from '../../node/NodeStatementUtils';
-import { ObjectExpressionExtractor } from '../../enums/node-transformers/converting-transformers/properties-extractors/ObjectExpressionExtractor';
 
 @injectable()
 export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {

src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.ts

@@ -221,7 +221,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (parentNode && NodeGuards.isProgramNode(node)) {
-                            this.analyzeNode(node, parentNode);
+                            this.prepareNode(node, parentNode);
 
                             return node;
                         }
@@ -261,7 +261,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
      * @param {NodeGuards} programNode
      * @param {NodeGuards} parentNode
      */
-    public analyzeNode (programNode: ESTree.Node, parentNode: ESTree.Node): void {
+    public prepareNode (programNode: ESTree.Node, parentNode: ESTree.Node): void {
         estraverse.traverse(programNode, {
             enter: (node: ESTree.Node): void => {
                 if (!NodeGuards.isBlockStatementNode(node)) {
@@ -366,7 +366,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
         this.transformersRunner.transform(
             hostNode,
             DeadCodeInjectionTransformer.transformersToRenameBlockScopeIdentifiers,
-            NodeTransformationStage.Obfuscating
+            NodeTransformationStage.RenameIdentifiers
         );
 
         return clonedBlockStatementNode;

src/node-transformers/obfuscating-transformers/obfuscating-replacers/AbstractObfuscatingReplacer.ts

@@ -1,33 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TNodeWithLexicalScope } from '../../../types/node/TNodeWithLexicalScope';
-
-import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IObfuscatingReplacer';
-import { IOptions } from '../../../interfaces/options/IOptions';
-
-@injectable()
-export abstract class AbstractObfuscatingReplacer implements IObfuscatingReplacer {
-    /**
-     * @type {IOptions}
-     */
-    protected readonly options: IOptions;
-
-    /**
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.options = options;
-    }
-
-    /**
-     * @param {Node} node
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @returns {Node}
-     */
-    public abstract replace (node: ESTree.Node, lexicalScopeNode?: TNodeWithLexicalScope): ESTree.Node;
-}

src/node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/BooleanLiteralObfuscatingReplacer.ts

@@ -1,57 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { IOptions } from '../../../../interfaces/options/IOptions';
-
-import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { NodeFactory } from '../../../../node/NodeFactory';
-
-@injectable()
-export class BooleanLiteralObfuscatingReplacer extends AbstractObfuscatingReplacer {
-    /**
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(options);
-    }
-
-    /**
-     * @return {ESTree.UnaryExpression}
-     */
-    private static getTrueUnaryExpressionNode (): ESTree.UnaryExpression {
-        return NodeFactory.unaryExpressionNode(
-            '!',
-            BooleanLiteralObfuscatingReplacer.getFalseUnaryExpressionNode()
-        );
-    }
-
-    /**
-     * @return {ESTree.UnaryExpression}
-     */
-    private static getFalseUnaryExpressionNode (): ESTree.UnaryExpression {
-        return NodeFactory.unaryExpressionNode(
-            '!',
-            NodeFactory.arrayExpressionNode()
-        );
-    }
-
-    /**
-     * @param {SimpleLiteral} literalNode
-     * @returns {Node}
-     */
-    public replace (literalNode: ESTree.SimpleLiteral): ESTree.Node {
-        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;
-
-        if (typeof literalValue !== 'boolean') {
-            throw new Error('`BooleanLiteralObfuscatingReplacer` should accept only literals with `boolean` value');
-        }
-
-        return literalValue
-            ? BooleanLiteralObfuscatingReplacer.getTrueUnaryExpressionNode()
-            : BooleanLiteralObfuscatingReplacer.getFalseUnaryExpressionNode();
-    }
-}

src/node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/NumberLiteralObfuscatingReplacer.ts

@@ -1,55 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { IOptions } from '../../../../interfaces/options/IOptions';
-
-import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { NodeFactory } from '../../../../node/NodeFactory';
-import { NumberUtils } from '../../../../utils/NumberUtils';
-
-@injectable()
-export class NumberLiteralObfuscatingReplacer extends AbstractObfuscatingReplacer {
-    /**
-     * @type {Map<string, string>}
-     */
-    private readonly numberLiteralCache: Map <number, string> = new Map();
-
-    /**
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(options);
-    }
-
-    /**
-     * @param {SimpleLiteral} literalNode
-     * @returns {Node}
-     */
-    public replace (literalNode: ESTree.SimpleLiteral): ESTree.Node {
-        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;
-
-        if (typeof literalValue !== 'number' && typeof literalValue !== 'bigint') {
-            throw new Error('`NumberLiteralObfuscatingReplacer` should accept only literals with `number` and `bigint` value');
-        }
-
-        let rawValue: string;
-
-        if (this.numberLiteralCache.has(literalValue)) {
-            rawValue = <string>this.numberLiteralCache.get(literalValue);
-        } else {
-            if (NumberUtils.isCeil(literalValue)) {
-                rawValue = NumberUtils.toHex(literalValue);
-            } else {
-                rawValue = String(literalValue);
-            }
-
-            this.numberLiteralCache.set(literalValue, rawValue);
-        }
-
-        return NodeFactory.literalNode(literalValue, rawValue);
-    }
-}

src/node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer.ts

@@ -1,149 +0,0 @@
-import { inject, injectable, postConstruct } from 'inversify';
-import { ServiceIdentifiers } from '../../../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { IInitializable } from '../../../../interfaces/IInitializable';
-import { IOptions } from '../../../../interfaces/options/IOptions';
-import { IStringArrayStorage } from '../../../../interfaces/storages/string-array-storage/IStringArrayStorage';
-import { IStringArrayStorageAnalyzer } from '../../../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
-import { IStringArrayStorageItemData } from '../../../../interfaces/storages/string-array-storage/IStringArrayStorageItem';
-
-import { StringArrayEncoding } from '../../../../enums/StringArrayEncoding';
-
-import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { NodeMetadata } from '../../../../node/NodeMetadata';
-import { NodeFactory } from '../../../../node/NodeFactory';
-import { NumberUtils } from '../../../../utils/NumberUtils';
-
-@injectable()
-export class StringLiteralObfuscatingReplacer extends AbstractObfuscatingReplacer implements IInitializable {
-    /**
-     * @type {Map<string, ESTree.Node>}
-     */
-    private readonly nodesCache: Map <string, ESTree.Node> = new Map();
-
-    /**
-     * @type {IStringArrayStorage}
-     */
-    private readonly stringArrayStorage: IStringArrayStorage;
-
-    /**
-     * @type {IStringArrayStorageAnalyzer}
-     */
-    private readonly stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer;
-
-    /**
-     * @param {IStringArrayStorage} stringArrayStorage
-     * @param {IStringArrayStorageAnalyzer} stringArrayStorageAnalyzer
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IStringArrayStorage) stringArrayStorage: IStringArrayStorage,
-        @inject(ServiceIdentifiers.IStringArrayStorageAnalyzer) stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(options);
-
-        this.stringArrayStorage = stringArrayStorage;
-        this.stringArrayStorageAnalyzer = stringArrayStorageAnalyzer;
-    }
-
-    /**
-     * @param {string} hexadecimalIndex
-     * @returns {Literal}
-     */
-    private static getHexadecimalLiteralNode (hexadecimalIndex: string): ESTree.Literal {
-        const hexadecimalLiteralNode: ESTree.Literal = NodeFactory.literalNode(hexadecimalIndex);
-
-        NodeMetadata.set(hexadecimalLiteralNode, { replacedLiteral: true });
-
-        return hexadecimalLiteralNode;
-    }
-
-    /**
-     * @param {string} literalValue
-     * @returns {Literal}
-     */
-    private static getRc4KeyLiteralNode (literalValue: string): ESTree.Literal {
-        const rc4KeyLiteralNode: ESTree.Literal = NodeFactory.literalNode(literalValue);
-
-        NodeMetadata.set(rc4KeyLiteralNode, { replacedLiteral: true });
-
-        return rc4KeyLiteralNode;
-    }
-
-    @postConstruct()
-    public initialize (): void {
-        if (this.options.shuffleStringArray) {
-            this.stringArrayStorage.shuffleStorage();
-        }
-
-        if (this.options.rotateStringArray) {
-            this.stringArrayStorage.rotateStorage();
-        }
-    }
-
-    /**
-     * @param {SimpleLiteral} literalNode
-     * @returns {Node}
-     */
-    public replace (literalNode: ESTree.SimpleLiteral): ESTree.Node {
-        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;
-
-        if (typeof literalValue !== 'string') {
-            throw new Error('`StringLiteralObfuscatingReplacer` should accept only literals with `string` value');
-        }
-
-        const stringArrayStorageItemData: IStringArrayStorageItemData | undefined = this.stringArrayStorageAnalyzer
-            .getItemDataForLiteralNode(literalNode);
-        const cacheKey: string = `${literalValue}-${Boolean(stringArrayStorageItemData)}`;
-        const useCachedValue: boolean = this.nodesCache.has(cacheKey) && this.options.stringArrayEncoding !== StringArrayEncoding.Rc4;
-
-        if (useCachedValue) {
-            return <ESTree.Node>this.nodesCache.get(cacheKey);
-        }
-
-        const resultNode: ESTree.Node = stringArrayStorageItemData
-            ? this.replaceWithStringArrayCallNode(stringArrayStorageItemData)
-            : this.replaceWithLiteralNode(literalValue);
-
-        this.nodesCache.set(cacheKey, resultNode);
-
-        return resultNode;
-    }
-
-    /**
-     * @param {string} value
-     * @returns {Node}
-     */
-    private replaceWithLiteralNode (value: string): ESTree.Node {
-        return NodeFactory.literalNode(value);
-    }
-
-    /**
-     * @param {IStringArrayStorageItemData} stringArrayStorageItemData
-     * @returns {Node}
-     */
-    private replaceWithStringArrayCallNode (stringArrayStorageItemData: IStringArrayStorageItemData): ESTree.Node {
-        const { index, decodeKey } = stringArrayStorageItemData;
-
-        const hexadecimalIndex: string = NumberUtils.toHex(index);
-        const callExpressionArgs: (ESTree.Expression | ESTree.SpreadElement)[] = [
-            StringLiteralObfuscatingReplacer.getHexadecimalLiteralNode(hexadecimalIndex)
-        ];
-
-        if (decodeKey) {
-            callExpressionArgs.push(StringLiteralObfuscatingReplacer.getRc4KeyLiteralNode(decodeKey));
-        }
-
-        const stringArrayIdentifierNode: ESTree.Identifier = NodeFactory.identifierNode(
-            this.stringArrayStorage.getStorageCallsWrapperName()
-        );
-
-        return NodeFactory.callExpressionNode(
-            stringArrayIdentifierNode,
-            callExpressionArgs
-        );
-    }
-}

src/node-transformers/preparing-transformers/CustomCodeHelpersTransformer.ts

@@ -94,7 +94,7 @@ export class CustomCodeHelpersTransformer extends AbstractNodeTransformer {
                 return {
                     leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (NodeGuards.isProgramNode(node)) {
-                            this.analyzeNode(node, parentNode);
+                            this.prepareNode(node, parentNode);
                             this.appendCustomNodesBeforeObfuscation(node, parentNode);
 
                             return this.transformNode(node, parentNode);
@@ -120,7 +120,7 @@ export class CustomCodeHelpersTransformer extends AbstractNodeTransformer {
      * @param {Program} node
      * @param {Node | null} parentNode
      */
-    public analyzeNode (node: ESTree.Program, parentNode: ESTree.Node | null): void {
+    public prepareNode (node: ESTree.Program, parentNode: ESTree.Node | null): void {
         this.callsGraphData = this.callsGraphAnalyzer.analyze(node);
         this.prevailingKindOfVariablesAnalyzer.analyze(node);
     }

src/node-transformers/preparing-transformers/VariablePreserveTransformer.ts

@@ -2,10 +2,9 @@ import { inject, injectable, } from 'inversify';
 import * as ESTree from 'estree';
 import * as eslintScope from 'eslint-scope';
 
-import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
+import { IIdentifierReplacer } from '../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
@@ -17,7 +16,6 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 import { NodeGuards } from '../../node/NodeGuards';
 
 /**
@@ -33,9 +31,9 @@ export class VariablePreserveTransformer extends AbstractNodeTransformer {
     ];
 
     /**
-     * @type {IIdentifierObfuscatingReplacer}
+     * @type {IIdentifierReplacer}
      */
-    private readonly identifierObfuscatingReplacer: IIdentifierObfuscatingReplacer;
+    private readonly identifierReplacer: IIdentifierReplacer;
 
     /**
      * @type {IScopeIdentifiersTraverser}
@@ -43,23 +41,20 @@ export class VariablePreserveTransformer extends AbstractNodeTransformer {
     private readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
 
     /**
-     * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
+     * @param {IIdentifierReplacer} identifierReplacer
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      * @param {IScopeIdentifiersTraverser} scopeIdentifiersTraverser
      */
     public constructor (
-        @inject(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
-            identifierObfuscatingReplacerFactory: TIdentifierObfuscatingReplacerFactory,
+        @inject(ServiceIdentifiers.IIdentifierReplacer) identifierReplacer: IIdentifierReplacer,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions,
         @inject(ServiceIdentifiers.IScopeIdentifiersTraverser) scopeIdentifiersTraverser: IScopeIdentifiersTraverser
     ) {
         super(randomGenerator, options);
 
-        this.identifierObfuscatingReplacer = identifierObfuscatingReplacerFactory(
-            IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer
-        );
+        this.identifierReplacer = identifierReplacer;
         this.scopeIdentifiersTraverser = scopeIdentifiersTraverser;
 
         this.preserveScopeVariableIdentifiers = this.preserveScopeVariableIdentifiers.bind(this);
@@ -73,7 +68,7 @@ export class VariablePreserveTransformer extends AbstractNodeTransformer {
         switch (nodeTransformationStage) {
             case NodeTransformationStage.Preparing:
             case NodeTransformationStage.Converting:
-            case NodeTransformationStage.Obfuscating:
+            case NodeTransformationStage.RenameIdentifiers:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (parentNode && NodeGuards.isProgramNode(node)) {
@@ -126,7 +121,7 @@ export class VariablePreserveTransformer extends AbstractNodeTransformer {
      * @param {Identifier} identifierNode
      */
     private preserveIdentifierNameForRootLexicalScope (identifierNode: ESTree.Identifier): void {
-        this.identifierObfuscatingReplacer.preserveName(identifierNode);
+        this.identifierReplacer.preserveName(identifierNode);
     }
 
     /**
@@ -145,6 +140,6 @@ export class VariablePreserveTransformer extends AbstractNodeTransformer {
             return;
         }
 
-        this.identifierObfuscatingReplacer.preserveNameForLexicalScope(identifierNode, lexicalScopeNode);
+        this.identifierReplacer.preserveNameForLexicalScope(identifierNode, lexicalScopeNode);
     }
 }

src/node-transformers/obfuscating-transformers/LabeledStatementTransformer.ts → src/node-transformers/rename-identifiers-transformers/LabeledStatementTransformer.ts

@@ -4,15 +4,13 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
-import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
+import { IIdentifierReplacer } from '../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -38,26 +36,23 @@ import { NodeLexicalScopeUtils } from '../../node/NodeLexicalScopeUtils';
 @injectable()
 export class LabeledStatementTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IIdentifierObfuscatingReplacer}
+     * @type {IIdentifierReplacer}
      */
-    private readonly identifierObfuscatingReplacer: IIdentifierObfuscatingReplacer;
+    private readonly identifierReplacer: IIdentifierReplacer;
 
     /**
-     * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
+     * @param {IIdentifierReplacer} identifierReplacer
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      */
     public constructor (
-        @inject(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
-            identifierObfuscatingReplacerFactory: TIdentifierObfuscatingReplacerFactory,
+        @inject(ServiceIdentifiers.IIdentifierReplacer) identifierReplacer: IIdentifierReplacer,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(randomGenerator, options);
 
-        this.identifierObfuscatingReplacer = identifierObfuscatingReplacerFactory(
-            IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer
-        );
+        this.identifierReplacer = identifierReplacer;
     }
 
     /**
@@ -66,7 +61,7 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
      */
     public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.Obfuscating:
+            case NodeTransformationStage.RenameIdentifiers:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (parentNode && NodeGuards.isLabeledStatementNode(node)) {
@@ -106,7 +101,7 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
         labeledStatementNode: ESTree.LabeledStatement,
         lexicalScopeNode: TNodeWithLexicalScope
     ): void {
-        this.identifierObfuscatingReplacer.storeLocalName(labeledStatementNode.label, lexicalScopeNode);
+        this.identifierReplacer.storeLocalName(labeledStatementNode.label, lexicalScopeNode);
     }
 
     /**
@@ -120,7 +115,7 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
         estraverse.replace(labeledStatementNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
                 if (parentNode && NodeGuards.isLabelIdentifierNode(node, parentNode)) {
-                    const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
+                    const newIdentifier: ESTree.Identifier = this.identifierReplacer
                         .replace(node, lexicalScopeNode);
 
                     node.name = newIdentifier.name;

src/node-transformers/obfuscating-transformers/ScopeIdentifiersTransformer.ts → src/node-transformers/rename-identifiers-transformers/ScopeIdentifiersTransformer.ts

@@ -5,17 +5,15 @@ import * as eslintScope from 'eslint-scope';
 import * as ESTree from 'estree';
 import * as estraverse from 'estraverse';
 
-import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
+import { IIdentifierReplacer } from '../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
 import { IScopeIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeIdentifiersTraverserCallbackData';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -28,9 +26,9 @@ import { NodeMetadata } from '../../node/NodeMetadata';
 @injectable()
 export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IIdentifierObfuscatingReplacer}
+     * @type {IIdentifierReplacer}
      */
-    private readonly identifierObfuscatingReplacer: IIdentifierObfuscatingReplacer;
+    private readonly identifierReplacer: IIdentifierReplacer;
 
     /**
      * @type {Map<TNodeWithLexicalScope, boolean>}
@@ -43,23 +41,20 @@ export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
     private readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
 
     /**
-     * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
+     * @param {IIdentifierReplacer} identifierReplacer
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      * @param {IScopeIdentifiersTraverser} scopeIdentifiersTraverser
      */
     public constructor (
-        @inject(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
-            identifierObfuscatingReplacerFactory: TIdentifierObfuscatingReplacerFactory,
+        @inject(ServiceIdentifiers.IIdentifierReplacer) identifierReplacer: IIdentifierReplacer,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions,
         @inject(ServiceIdentifiers.IScopeIdentifiersTraverser) scopeIdentifiersTraverser: IScopeIdentifiersTraverser
     ) {
         super(randomGenerator, options);
 
-        this.identifierObfuscatingReplacer = identifierObfuscatingReplacerFactory(
-            IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer
-        );
+        this.identifierReplacer = identifierReplacer;
         this.scopeIdentifiersTraverser = scopeIdentifiersTraverser;
     }
 
@@ -69,7 +64,7 @@ export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
      */
     public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.Obfuscating:
+            case NodeTransformationStage.RenameIdentifiers:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (parentNode && NodeGuards.isProgramNode(node)) {
@@ -158,9 +153,9 @@ export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
         isGlobalDeclaration: boolean
     ): void {
         if (isGlobalDeclaration) {
-            this.identifierObfuscatingReplacer.storeGlobalName(identifierNode, lexicalScopeNode);
+            this.identifierReplacer.storeGlobalName(identifierNode, lexicalScopeNode);
         } else {
-            this.identifierObfuscatingReplacer.storeLocalName(identifierNode, lexicalScopeNode);
+            this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
         }
     }
 
@@ -174,7 +169,7 @@ export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
         lexicalScopeNode: TNodeWithLexicalScope,
         variable: eslintScope.Variable
     ): void {
-        const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
+        const newIdentifier: ESTree.Identifier = this.identifierReplacer
             .replace(identifierNode, lexicalScopeNode);
 
         // rename of identifiers

src/node-transformers/obfuscating-transformers/ScopeThroughIdentifiersTransformer.ts → src/node-transformers/rename-identifiers-transformers/ScopeThroughIdentifiersTransformer.ts

@@ -4,17 +4,15 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 import * as eslintScope from 'eslint-scope';
 import * as ESTree from 'estree';
 
-import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
 
-import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
+import { IIdentifierReplacer } from '../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
 import { IScopeThroughIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeThroughIdentifiersTraverserCallbackData';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -26,9 +24,9 @@ import { NodeGuards } from '../../node/NodeGuards';
 @injectable()
 export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IIdentifierObfuscatingReplacer}
+     * @type {IIdentifierReplacer}
      */
-    private readonly identifierObfuscatingReplacer: IIdentifierObfuscatingReplacer;
+    private readonly identifierReplacer: IIdentifierReplacer;
 
     /**
      * @type {IScopeIdentifiersTraverser}
@@ -36,23 +34,20 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
     private readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
 
     /**
-     * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
+     * @param {IIdentifierReplacer} identifierReplacer
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      * @param {IScopeIdentifiersTraverser} scopeIdentifiersTraverser
      */
     public constructor (
-        @inject(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
-            identifierObfuscatingReplacerFactory: TIdentifierObfuscatingReplacerFactory,
+        @inject(ServiceIdentifiers.IIdentifierReplacer) identifierReplacer: IIdentifierReplacer,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions,
         @inject(ServiceIdentifiers.IScopeIdentifiersTraverser) scopeIdentifiersTraverser: IScopeIdentifiersTraverser
     ) {
         super(randomGenerator, options);
 
-        this.identifierObfuscatingReplacer = identifierObfuscatingReplacerFactory(
-            IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer
-        );
+        this.identifierReplacer = identifierReplacer;
         this.scopeIdentifiersTraverser = scopeIdentifiersTraverser;
     }
 
@@ -62,7 +57,7 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
      */
     public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.Obfuscating:
+            case NodeTransformationStage.RenameIdentifiers:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (parentNode && NodeGuards.isProgramNode(node)) {
@@ -124,7 +119,7 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
         identifierNode: ESTree.Identifier,
         lexicalScopeNode: TNodeWithLexicalScope
     ): void {
-        this.identifierObfuscatingReplacer.storeLocalName(identifierNode, lexicalScopeNode);
+        this.identifierReplacer.storeLocalName(identifierNode, lexicalScopeNode);
     }
 
     /**
@@ -137,7 +132,7 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
         lexicalScopeNode: TNodeWithLexicalScope,
         reference: eslintScope.Reference
     ): void {
-        const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
+        const newIdentifier: ESTree.Identifier = this.identifierReplacer
             .replace(identifierNode, lexicalScopeNode);
 
         // rename of identifier

src/node-transformers/obfuscating-transformers/obfuscating-replacers/identifier-obfuscating-replacers/BaseIdentifierObfuscatingReplacer.ts → src/node-transformers/rename-identifiers-transformers/replacer/IdentifierReplacer.ts

@@ -1,20 +1,19 @@
 import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../../container/ServiceIdentifiers';
+import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 
 import * as ESTree from 'estree';
 
-import { TIdentifierNamesGeneratorFactory } from '../../../../types/container/generators/TIdentifierNamesGeneratorFactory';
-import { TNodeWithLexicalScope } from '../../../../types/node/TNodeWithLexicalScope';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TNodeWithLexicalScope } from '../../../types/node/TNodeWithLexicalScope';
 
-import { IIdentifierNamesGenerator } from '../../../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
-import { IIdentifierObfuscatingReplacer } from '../../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
-import { IOptions } from '../../../../interfaces/options/IOptions';
+import { IIdentifierNamesGenerator } from '../../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
+import { IIdentifierReplacer } from '../../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
+import { IOptions } from '../../../interfaces/options/IOptions';
 
-import { AbstractObfuscatingReplacer } from '../AbstractObfuscatingReplacer';
-import { NodeFactory } from '../../../../node/NodeFactory';
+import { NodeFactory } from '../../../node/NodeFactory';
 
 @injectable()
-export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplacer implements IIdentifierObfuscatingReplacer {
+export class IdentifierReplacer implements IIdentifierReplacer {
     /**
      * @type {IIdentifierNamesGenerator}
      */
@@ -25,6 +24,11 @@ export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplac
      */
     private readonly blockScopesMap: Map<TNodeWithLexicalScope, Map<string, string>> = new Map();
 
+    /**
+     * @type {IOptions}
+     */
+    private readonly options: IOptions;
+
     /**
      * @param {TIdentifierNamesGeneratorFactory} identifierNamesGeneratorFactory
      * @param {IOptions} options
@@ -34,30 +38,10 @@ export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplac
             identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
-        super(options);
-
+        this.options = options;
         this.identifierNamesGenerator = identifierNamesGeneratorFactory(options);
     }
 
-    /**
-     * @param {Identifier} identifierNode
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @returns {Identifier}
-     */
-    public replace (identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): ESTree.Identifier {
-        let identifierName: string = identifierNode.name;
-
-        if (this.blockScopesMap.has(lexicalScopeNode)) {
-            const namesMap: Map<string, string> = <Map<string, string>>this.blockScopesMap.get(lexicalScopeNode);
-
-            if (namesMap.has(identifierName)) {
-                identifierName = <string>namesMap.get(identifierName);
-            }
-        }
-
-        return NodeFactory.identifierNode(identifierName);
-    }
-
     /**
      * Store `nodeName` of global identifiers as key in map with random name as value.
      * Reserved name will be ignored.
@@ -108,6 +92,25 @@ export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplac
         namesMap.set(identifierName, newIdentifierName);
     }
 
+    /**
+     * @param {Identifier} identifierNode
+     * @param {TNodeWithLexicalScope} lexicalScopeNode
+     * @returns {Identifier}
+     */
+    public replace (identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): ESTree.Identifier {
+        let identifierName: string = identifierNode.name;
+
+        if (this.blockScopesMap.has(lexicalScopeNode)) {
+            const namesMap: Map<string, string> = <Map<string, string>>this.blockScopesMap.get(lexicalScopeNode);
+
+            if (namesMap.has(identifierName)) {
+                identifierName = <string>namesMap.get(identifierName);
+            }
+        }
+
+        return NodeFactory.identifierNode(identifierName);
+    }
+
     /**
      * Preserve `name` to protect it from further using
      *

src/node-transformers/obfuscating-transformers/LiteralTransformer.ts → src/node-transformers/string-array-transformers/StringArrayTransformer.ts

@@ -3,16 +3,16 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
 import * as ESTree from 'estree';
 
-import { TLiteralObfuscatingReplacerFactory } from '../../types/container/node-transformers/TLiteralObfuscatingReplacerFactory';
-
 import { IEscapeSequenceEncoder } from '../../interfaces/utils/IEscapeSequenceEncoder';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-storage/IStringArrayStorage';
 import { IStringArrayStorageAnalyzer } from '../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
+import { IStringArrayStorageItemData } from '../../interfaces/storages/string-array-storage/IStringArrayStorageItem';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
-import { LiteralObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/LiteralObfuscatingReplacer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { StringArrayEncoding } from '../../enums/StringArrayEncoding';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeFactory } from '../../node/NodeFactory';
@@ -20,18 +20,24 @@ import { NodeGuards } from '../../node/NodeGuards';
 import { NodeLiteralUtils } from '../../node/NodeLiteralUtils';
 import { NodeMetadata } from '../../node/NodeMetadata';
 import { NodeUtils } from '../../node/NodeUtils';
+import { NumberUtils } from '../../utils/NumberUtils';
 
 @injectable()
-export class LiteralTransformer extends AbstractNodeTransformer {
+export class StringArrayTransformer extends AbstractNodeTransformer {
     /**
      * @type {IEscapeSequenceEncoder}
      */
     private readonly escapeSequenceEncoder: IEscapeSequenceEncoder;
 
     /**
-     * @type {TLiteralObfuscatingReplacerFactory}
+     * @type {Map<string, ESTree.Node>}
      */
-    private readonly literalObfuscatingReplacerFactory: TLiteralObfuscatingReplacerFactory;
+    private readonly nodesCache: Map <string, ESTree.Node> = new Map();
+
+    /**
+     * @type {IStringArrayStorage}
+     */
+    private readonly stringArrayStorage: IStringArrayStorage;
 
     /**
      * @type {IStringArrayStorageAnalyzer}
@@ -39,38 +45,61 @@ export class LiteralTransformer extends AbstractNodeTransformer {
     private readonly stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer;
 
     /**
-     * @param {TLiteralObfuscatingReplacerFactory} literalObfuscatingReplacerFactory
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
+     * @param {IStringArrayStorage} stringArrayStorage
      * @param {IStringArrayStorageAnalyzer} stringArrayStorageAnalyzer
      * @param {IEscapeSequenceEncoder} escapeSequenceEncoder
      */
     public constructor (
-        @inject(ServiceIdentifiers.Factory__IObfuscatingReplacer)
-            literalObfuscatingReplacerFactory: TLiteralObfuscatingReplacerFactory,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions,
+        @inject(ServiceIdentifiers.IStringArrayStorage) stringArrayStorage: IStringArrayStorage,
         @inject(ServiceIdentifiers.IStringArrayStorageAnalyzer) stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer,
         @inject(ServiceIdentifiers.IEscapeSequenceEncoder) escapeSequenceEncoder: IEscapeSequenceEncoder
     ) {
         super(randomGenerator, options);
 
-        this.literalObfuscatingReplacerFactory = literalObfuscatingReplacerFactory;
+        this.stringArrayStorage = stringArrayStorage;
         this.stringArrayStorageAnalyzer = stringArrayStorageAnalyzer;
         this.escapeSequenceEncoder = escapeSequenceEncoder;
     }
 
+    /**
+     * @param {string} hexadecimalIndex
+     * @returns {Literal}
+     */
+    private static getHexadecimalLiteralNode (hexadecimalIndex: string): ESTree.Literal {
+        const hexadecimalLiteralNode: ESTree.Literal = NodeFactory.literalNode(hexadecimalIndex);
+
+        NodeMetadata.set(hexadecimalLiteralNode, { replacedLiteral: true });
+
+        return hexadecimalLiteralNode;
+    }
+
+    /**
+     * @param {string} literalValue
+     * @returns {Literal}
+     */
+    private static getRc4KeyLiteralNode (literalValue: string): ESTree.Literal {
+        const rc4KeyLiteralNode: ESTree.Literal = NodeFactory.literalNode(literalValue);
+
+        NodeMetadata.set(rc4KeyLiteralNode, { replacedLiteral: true });
+
+        return rc4KeyLiteralNode;
+    }
+
     /**
      * @param {NodeTransformationStage} nodeTransformationStage
      * @returns {IVisitor | null}
      */
     public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.Obfuscating:
+            case NodeTransformationStage.StringArray:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (NodeGuards.isProgramNode(node)) {
-                            this.analyzeNode(node);
+                            this.prepareNode(node);
                         }
 
                         if (parentNode && NodeGuards.isLiteralNode(node) && !NodeMetadata.isReplacedLiteral(node)) {
@@ -93,8 +122,19 @@ export class LiteralTransformer extends AbstractNodeTransformer {
         }
     }
 
-    public analyzeNode (programNode: ESTree.Program): void {
+    /**
+     * @param {Program} programNode
+     */
+    public prepareNode (programNode: ESTree.Program): void {
         this.stringArrayStorageAnalyzer.analyze(programNode);
+
+        if (this.options.shuffleStringArray) {
+            this.stringArrayStorage.shuffleStorage();
+        }
+
+        if (this.options.rotateStringArray) {
+            this.stringArrayStorage.rotateStorage();
+        }
     }
 
     /**
@@ -103,42 +143,64 @@ export class LiteralTransformer extends AbstractNodeTransformer {
      * @returns {NodeGuards}
      */
     public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
-        if (NodeLiteralUtils.isProhibitedLiteralNode(literalNode, parentNode)) {
+        if (typeof literalNode.value !== 'string' || NodeLiteralUtils.isProhibitedLiteralNode(literalNode, parentNode)) {
             return literalNode;
         }
 
-        let newLiteralNode: ESTree.Node;
+        const literalValue: ESTree.SimpleLiteral['value'] = literalNode.value;
 
-        switch (typeof literalNode.value) {
-            case 'boolean':
-                newLiteralNode = this.literalObfuscatingReplacerFactory(
-                    LiteralObfuscatingReplacer.BooleanLiteralObfuscatingReplacer
-                ).replace(literalNode);
+        const stringArrayStorageItemData: IStringArrayStorageItemData | undefined = this.stringArrayStorageAnalyzer
+            .getItemDataForLiteralNode(literalNode);
+        const cacheKey: string = `${literalValue}-${Boolean(stringArrayStorageItemData)}`;
+        const useCachedValue: boolean = this.nodesCache.has(cacheKey) && this.options.stringArrayEncoding !== StringArrayEncoding.Rc4;
 
-                break;
+        if (useCachedValue) {
+            return <ESTree.Node>this.nodesCache.get(cacheKey);
+        }
 
-            case 'number':
-            case 'bigint':
-                newLiteralNode = this.literalObfuscatingReplacerFactory(
-                    LiteralObfuscatingReplacer.NumberLiteralObfuscatingReplacer
-                ).replace(literalNode);
+        const resultNode: ESTree.Node = stringArrayStorageItemData
+            ? this.getStringArrayCallNode(stringArrayStorageItemData)
+            : this.getLiteralNode(literalValue);
 
-                break;
+        this.nodesCache.set(cacheKey, resultNode);
 
-            case 'string':
-                newLiteralNode = this.literalObfuscatingReplacerFactory(
-                    LiteralObfuscatingReplacer.StringLiteralObfuscatingReplacer
-                ).replace(literalNode);
+        NodeUtils.parentizeNode(resultNode, parentNode);
 
-                break;
+        return resultNode;
+    }
 
-            default:
-                newLiteralNode = literalNode;
+    /**
+     * @param {string} value
+     * @returns {Node}
+     */
+    private getLiteralNode (value: string): ESTree.Node {
+        return NodeFactory.literalNode(value);
+    }
+
+    /**
+     * @param {IStringArrayStorageItemData} stringArrayStorageItemData
+     * @returns {Node}
+     */
+    private getStringArrayCallNode (stringArrayStorageItemData: IStringArrayStorageItemData): ESTree.Node {
+        const { index, decodeKey } = stringArrayStorageItemData;
+
+        const hexadecimalIndex: string = NumberUtils.toHex(index);
+        const callExpressionArgs: (ESTree.Expression | ESTree.SpreadElement)[] = [
+            StringArrayTransformer.getHexadecimalLiteralNode(hexadecimalIndex)
+        ];
+
+        if (decodeKey) {
+            callExpressionArgs.push(StringArrayTransformer.getRc4KeyLiteralNode(decodeKey));
         }
 
-        NodeUtils.parentizeNode(newLiteralNode, parentNode);
+        const stringArrayIdentifierNode: ESTree.Identifier = NodeFactory.identifierNode(
+            this.stringArrayStorage.getStorageCallsWrapperName()
+        );
 
-        return newLiteralNode;
+        return NodeFactory.callExpressionNode(
+            stringArrayIdentifierNode,
+            callExpressionArgs
+        );
     }
 
     /**

src/types/container/node-transformers/TControlFlowReplacerFactory.ts

@@ -1,5 +1,5 @@
 import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
 
-import { ControlFlowReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/ControlFlowReplacer';
+import { ControlFlowReplacer } from '../../../enums/node-transformers/control-flow-transformers/control-flow-replacers/ControlFlowReplacer';
 
 export type TControlFlowReplacerFactory = (replacer: ControlFlowReplacer) => IControlFlowReplacer;

src/types/container/node-transformers/TIdentifierObfuscatingReplacerFactory.ts

@@ -1,5 +0,0 @@
-import { IIdentifierObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
-
-import { IdentifierObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
-
-export type TIdentifierObfuscatingReplacerFactory = (replacer: IdentifierObfuscatingReplacer) => IIdentifierObfuscatingReplacer;

src/types/container/node-transformers/TLiteralObfuscatingReplacerFactory.ts

@@ -1,5 +0,0 @@
-import { IObfuscatingReplacer } from '../../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IObfuscatingReplacer';
-
-import { LiteralObfuscatingReplacer } from '../../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/LiteralObfuscatingReplacer';
-
-export type TLiteralObfuscatingReplacerFactory = (replacer: LiteralObfuscatingReplacer) => IObfuscatingReplacer;

test/dev/dev.ts

@@ -7,38 +7,20 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-            function foo () {
-                function bar () {
-                    const a = [];
-                    const b = [];
-                    while (true) {
-                        for (const a of b) {}
-                    }
-                    return a;
-                }
-            
-                function baz () {
-                    const a = 1;
-                }
-            
-                function bark () {
-                    const a = 1;
-                    
-                    if (true) {
-                        console.log(a);
-                    }
-                }
-            
-                function hawk () {
-                    const a = 1;
-                }
+            function func () {
+                var obj = {foo: 'bar'};
+                
+                console.log(obj.foo);
             }
+            
+            func();
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
-            deadCodeInjection: true,
-            deadCodeInjectionThreshold: 1
+            transformObjectKeys: true,
+            controlFlowFlattening: true,
+            controlFlowFlatteningThreshold: 1
         }
     ).getObfuscatedCode();
 

test/functional-tests/node-transformers/converting-transformers/boolean-literal-transformer/BooleanLiteralTransformer.spec.ts

@@ -0,0 +1,55 @@
+import { assert } from 'chai';
+
+import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
+
+import { readFileAsString } from '../../../../helpers/readFileAsString';
+
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
+
+describe('BooleanLiteralTransformer', () => {
+    describe('transformation `true` boolean literal', () => {
+        const regExp: RegExp = /^var test *= *!!\[\];$/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/true-value.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    stringArray: true,
+                    stringArrayThreshold: 1
+                }
+            ).getObfuscatedCode();
+        });
+
+        it('should transform boolean literal node', () => {
+            assert.match(obfuscatedCode, regExp);
+        });
+    });
+
+    describe('transformation `false` boolean literal', () => {
+        const regExp: RegExp = /^var test *= *!\[\];$/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/false-value.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    stringArray: true,
+                    stringArrayThreshold: 1
+                }
+            ).getObfuscatedCode();
+        });
+
+        it('should transform boolean literal node', () => {
+            assert.match(obfuscatedCode, regExp);
+        });
+    });
+});

test/functional-tests/node-transformers/converting-transformers/boolean-literal-transformer/fixtures/false-value.js

@@ -0,0 +1 @@
+var test = false;

test/functional-tests/node-transformers/converting-transformers/number-literal-transformer/NumberLiteralTransformer.spec.ts

@@ -0,0 +1,55 @@
+import { assert } from 'chai';
+
+import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
+
+import { readFileAsString } from '../../../../helpers/readFileAsString';
+
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
+
+describe('NumberLiteralTransformer', () => {
+    describe('transformation of literal node with number value', () => {
+        const regExp: RegExp = /^var test *= *0x0;$/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/number-value.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    stringArray: true,
+                    stringArrayThreshold: 1
+                }
+            ).getObfuscatedCode();
+        });
+
+        it('should transform literal node', () => {
+            assert.match(obfuscatedCode, regExp);
+        });
+    });
+
+    describe('transformation of literal node with bigint value', () => {
+        const regExp: RegExp = /^var test *= *0xan;$/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/bigint-value.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    stringArray: true,
+                    stringArrayThreshold: 1
+                }
+            ).getObfuscatedCode();
+        });
+
+        it('should transform literal node', () => {
+            assert.match(obfuscatedCode, regExp);
+        });
+    });
+});

test/functional-tests/node-transformers/converting-transformers/numbers-to-numerical-expressions-transformer/NumbersToNumericalExpressionsTransformer.spec.ts

@@ -174,7 +174,7 @@ describe('NumbersToNumericalExpressionsTransformer', function () {
     });
 
     describe('Variant #4: parent node is non-computed object property', () => {
-        const regExp: RegExp = /const foo *= *{1: *'bar'};/;
+        const regExp: RegExp = /const foo *= *{0x1: *'bar'};/;
 
         let obfuscatedCode: string;
 

test/functional-tests/node-transformers/obfuscating-transformers/literal-transformer/LiteralTransformer.spec.ts

@@ -1,742 +0,0 @@
-import { assert } from 'chai';
-
-import { IdentifierNamesGenerator } from '../../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
-import { StringArrayEncoding } from '../../../../../src/enums/StringArrayEncoding';
-
-import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
-
-import { readFileAsString } from '../../../../helpers/readFileAsString';
-import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
-import { swapLettersCase } from '../../../../helpers/swapLettersCase';
-
-import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
-
-describe('LiteralTransformer', () => {
-    describe('transformation of literal node with string value', () => {
-        describe('Variant #1: default behaviour', () => {
-            const stringArrayRegExp: RegExp = /^var _0x([a-f0-9]){4} *= *\['test'\];/;
-            const stringArrayCallRegExp: RegExp = /var test *= *_0x([a-f0-9]){4}\('0x0'\);/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('match #1: should replace literal node value with value from string array', () => {
-                assert.match(obfuscatedCode, stringArrayRegExp);
-            });
-
-            it('match #2: should replace literal node value with value from string array', () => {
-                assert.match(obfuscatedCode, stringArrayCallRegExp);
-            });
-        });
-
-        describe('Variant #2: `stringArray` option is disabled', () => {
-            const regExp: RegExp = /^var test *= *'test';/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('shouldn\'t replace literal node value with value from string array', () => {
-                assert.match(obfuscatedCode, regExp);
-            });
-        });
-
-        describe('Variant #3: string contains non-latin and non-digit characters and `unicodeEscapeSequence` is disabled', () => {
-            let testFunc: () => void;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/error-when-non-latin.js');
-
-                testFunc = () => JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1
-                    }
-                );
-            });
-
-            it('should\'t throw an error', () => {
-                assert.doesNotThrow(testFunc);
-            });
-        });
-
-        describe('Variant #4: same literal node values', () => {
-            const stringArrayRegExp: RegExp = /^var _0x([a-f0-9]){4} *= *\['test'\];/;
-            const stringArrayCallRegExp: RegExp = /var test *= *_0x([a-f0-9]){4}\('0x0'\);/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/same-literal-values.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('match #1: should create only one item in string array for same literal node values', () => {
-                assert.match(obfuscatedCode, stringArrayRegExp);
-            });
-
-            it('match #2: should create only one item in string array for same literal node values', () => {
-                assert.match(obfuscatedCode, stringArrayCallRegExp);
-            });
-        });
-
-        describe('Variant #5: `unicodeEscapeSequence` option is enabled', () => {
-            const regExp: RegExp = /^var test *= *'\\x74\\x65\\x73\\x74';$/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        unicodeEscapeSequence: true
-
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('should replace literal node value with unicode escape sequence', () => {
-                assert.match(obfuscatedCode, regExp);
-            });
-        });
-
-        describe('Variant #6: `unicodeEscapeSequence` and `stringArray` options are enabled', () => {
-            const stringArrayRegExp: RegExp = /^var _0x([a-f0-9]){4} *= *\['\\x74\\x65\\x73\\x74'\];/;
-            const stringArrayCallRegExp: RegExp = /var test *= *_0x([a-f0-9]){4}\('\\x30\\x78\\x30'\);/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1,
-                        unicodeEscapeSequence: true
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('match #1: should replace literal node value with unicode escape sequence from string array', () => {
-                assert.match(obfuscatedCode, stringArrayRegExp);
-            });
-
-            it('match #2: should replace literal node value with unicode escape sequence from string array', () => {
-                assert.match(obfuscatedCode, stringArrayCallRegExp);
-            });
-        });
-
-        describe('Variant #7: short literal node value', () => {
-            const regExp: RegExp = /var test *= *'te';/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/short-literal-value.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('shouldn\'t replace short literal node value with value from string array', () => {
-                assert.match(obfuscatedCode, regExp);
-            });
-        });
-
-        describe('Variant #8: base64 encoding', () => {
-            const stringArrayRegExp: RegExp = new RegExp(`^var _0x([a-f0-9]){4} *= *\\['${swapLettersCase('dGVzdA==')}'];`);
-            const stringArrayCallRegExp: RegExp = /var test *= *_0x([a-f0-9]){4}\('0x0'\);/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayEncoding: StringArrayEncoding.Base64,
-                        stringArrayThreshold: 1
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('match #1: should replace literal node value with value from string array encoded using base64', () => {
-                assert.match(obfuscatedCode, stringArrayRegExp);
-            });
-
-            it('match #2: should replace literal node value with value from string array encoded using base64', () => {
-                assert.match(obfuscatedCode, stringArrayCallRegExp);
-            });
-        });
-
-        describe('Variant #9: rc4 encoding', () => {
-            describe('Variant #1: single string literal', () => {
-                const regExp: RegExp = /var test *= *_0x([a-f0-9]){4}\('0x0', *'.{4}'\);/;
-
-                let obfuscatedCode: string;
-
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-
-                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            stringArray: true,
-                            stringArrayEncoding: StringArrayEncoding.Rc4,
-                            stringArrayThreshold: 1
-                        }
-                    ).getObfuscatedCode();
-                });
-
-                it('should replace literal node value with value from string array encoded using rc4', () => {
-                    assert.match(obfuscatedCode, regExp);
-                });
-            });
-
-            describe('Variant #2: multiple string literals', () => {
-                const variableRegExp1: RegExp = /var test *= *_0x(?:[a-f0-9]){4}\('0x0', *'(.{4})'\);/;
-                const variableRegExp2: RegExp = /var test *= *_0x(?:[a-f0-9]){4}\('0x1', *'(.{4})'\);/;
-
-                let encodedLiteralValue1: string;
-                let encodedLiteralValue2: string;
-
-                let obfuscatedCode: string;
-
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/same-literal-values.js');
-
-                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            seed: 1, // set seed to prevent rare case when all encoded values are the same
-                            stringArray: true,
-                            stringArrayEncoding: StringArrayEncoding.Rc4,
-                            stringArrayThreshold: 1
-                        }
-                    ).getObfuscatedCode();
-
-                    encodedLiteralValue1 = getRegExpMatch(obfuscatedCode, variableRegExp1);
-                    encodedLiteralValue2 = getRegExpMatch(obfuscatedCode, variableRegExp2);
-                });
-
-                it('Match #1: should replace literal node value with value from string array encoded using rc4', () => {
-                    assert.match(obfuscatedCode, variableRegExp1);
-                });
-
-                it('Match #2: should replace literal node value with value from string array encoded using rc4', () => {
-                    assert.match(obfuscatedCode, variableRegExp2);
-                });
-
-                it('Should encode same values as two different encoded string array items', () => {
-                    assert.notEqual(encodedLiteralValue1, encodedLiteralValue2);
-                });
-            });
-        });
-
-        describe('Variant #10: `stringArrayThreshold` option value', () => {
-            const samples: number = 1000;
-            const stringArrayThreshold: number = 0.5;
-            const delta: number = 0.1;
-
-            const regExp1: RegExp = /var test *= *_0x([a-f0-9]){4}\('0x0'\);/g;
-            const regExp2: RegExp = /var test *= *'test';/g;
-
-            let stringArrayProbability: number,
-                noStringArrayProbability: number;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-
-                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
-                    `${code}\n`.repeat(samples),
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: stringArrayThreshold
-                    }
-                ).getObfuscatedCode();
-
-                const stringArrayMatchesLength: number = obfuscatedCode
-                    .match(regExp1)!
-                    .length;
-                const noStringArrayMatchesLength: number = obfuscatedCode
-                    .match(regExp2)!
-                    .length;
-
-                stringArrayProbability = stringArrayMatchesLength / samples;
-                noStringArrayProbability = noStringArrayMatchesLength / samples;
-            });
-
-            it('Variant #1: should replace literal node value with value from string array with `stringArrayThreshold` chance', () => {
-                assert.closeTo(stringArrayProbability, stringArrayThreshold, delta);
-            });
-
-            it('Variant #2: shouldn\'t replace literal node value with value from string array with `(1 - stringArrayThreshold)` chance', () => {
-                assert.closeTo(noStringArrayProbability, stringArrayThreshold, delta);
-            });
-        });
-
-        describe('Variant #11: string array calls wrapper name', () => {
-            const regExp: RegExp = /console\[b\('0x0'\)]\('a'\);/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/string-array-calls-wrapper-name.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1,
-                        identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('match #1: should keep identifier with string array calls wrapper name untouched after obfuscation', () => {
-                assert.match(obfuscatedCode, regExp);
-            });
-        });
-
-        describe('Variant #12: `reservedStrings` option is enabled', () => {
-            describe('Variant #1: base `reservedStrings` values', () => {
-                describe('Variant #1: single reserved string value', () => {
-                    const stringLiteralRegExp1: RegExp = /const foo *= *'foo';/;
-                    const stringLiteralRegExp2: RegExp = /const bar *= *_0x([a-f0-9]){4}\('0x0'\);/;
-
-                    let obfuscatedCode: string;
-
-                    before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
-
-                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                            code,
-                            {
-                                ...NO_ADDITIONAL_NODES_PRESET,
-                                stringArray: true,
-                                stringArrayThreshold: 1,
-                                reservedStrings: ['foo']
-                            }
-                        ).getObfuscatedCode();
-                    });
-
-                    it('match #1: should ignore reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp1);
-                    });
-
-                    it('match #2: should transform non-reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp2);
-                    });
-                });
-
-                describe('Variant #2: two reserved string values', () => {
-                    const stringLiteralRegExp1: RegExp = /const foo *= *'foo';/;
-                    const stringLiteralRegExp2: RegExp = /const bar *= *'bar';/;
-
-                    let obfuscatedCode: string;
-
-                    before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
-
-                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                            code,
-                            {
-                                ...NO_ADDITIONAL_NODES_PRESET,
-                                stringArray: true,
-                                stringArrayThreshold: 1,
-                                reservedStrings: ['foo', 'bar']
-                            }
-                        ).getObfuscatedCode();
-                    });
-
-                    it('match #1: should ignore reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp1);
-                    });
-
-                    it('match #2: should ignore reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp2);
-                    });
-                });
-            });
-
-            describe('Variant #2: RegExp `reservedStrings` values', () => {
-                describe('Variant #1: single reserved string value', () => {
-                    const stringLiteralRegExp1: RegExp = /const foo *= *_0x([a-f0-9]){4}\('0x0'\);/;
-                    const stringLiteralRegExp2: RegExp = /const bar *= *'bar';/;
-
-                    let obfuscatedCode: string;
-
-                    before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
-
-                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                            code,
-                            {
-                                ...NO_ADDITIONAL_NODES_PRESET,
-                                stringArray: true,
-                                stringArrayThreshold: 1,
-                                reservedStrings: ['ar$']
-                            }
-                        ).getObfuscatedCode();
-                    });
-
-                    it('match #1: should transform non-reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp1);
-                    });
-
-                    it('match #2: should ignore reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp2);
-                    });
-                });
-
-                describe('Variant #2: two reserved string values', () => {
-                    const stringLiteralRegExp1: RegExp = /const foo *= *'foo';/;
-                    const stringLiteralRegExp2: RegExp = /const bar *= *'bar';/;
-
-                    let obfuscatedCode: string;
-
-                    before(() => {
-                        const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
-
-                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                            code,
-                            {
-                                ...NO_ADDITIONAL_NODES_PRESET,
-                                stringArray: true,
-                                stringArrayThreshold: 1,
-                                reservedStrings: ['^fo', '.ar']
-                            }
-                        ).getObfuscatedCode();
-                    });
-
-                    it('match #1: should ignore reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp1);
-                    });
-
-                    it('match #2: should ignore reserved strings', () => {
-                        assert.match(obfuscatedCode, stringLiteralRegExp2);
-                    });
-                });
-            });
-
-            describe('Variant #3: `unicodeEscapeSequence` option is enabled', () => {
-                const stringLiteralRegExp1: RegExp = /const foo *= *'foo';/;
-                const stringLiteralRegExp2: RegExp = /const bar *= *'\\x62\\x61\\x72';/;
-
-                let obfuscatedCode: string;
-
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-1.js');
-
-                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            reservedStrings: ['foo'],
-                            unicodeEscapeSequence: true
-                        }
-                    ).getObfuscatedCode();
-                });
-
-                it('match #1: should ignore reserved strings', () => {
-                    assert.match(obfuscatedCode, stringLiteralRegExp1);
-                });
-
-                it('match #2: should transform non-reserved strings', () => {
-                    assert.match(obfuscatedCode, stringLiteralRegExp2);
-                });
-            });
-
-            describe('Variant #4: correct escape of special characters', () => {
-                const stringLiteralRegExp: RegExp = /var baz *= *'Cannot find module \\'' *\+ *foo *\+ *'\\x27';/;
-
-                let obfuscatedCode: string;
-
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/reserved-strings-option-2.js');
-
-                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            reservedStrings: ['a']
-                        }
-                    ).getObfuscatedCode();
-                });
-
-                it('match #1: should ignore reserved strings', () => {
-                    assert.match(obfuscatedCode, stringLiteralRegExp);
-                });
-            });
-        });
-
-        describe('Variant #13: object expression key literal', () => {
-            describe('Variant #1: base key literal', () => {
-                const stringArrayRegExp: RegExp = /^var _0x([a-f0-9]){4} *= *\['bar'];/;
-                const objectExpressionRegExp: RegExp = /var test *= *{'foo' *: *_0x([a-f0-9]){4}\('0x0'\)};/;
-
-                let obfuscatedCode: string;
-
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/object-expression-key-literal.js');
-
-                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            stringArray: true,
-                            stringArrayThreshold: 1
-                        }
-                    ).getObfuscatedCode();
-                });
-
-                it('match #1: should not add object expression key literal to the string array', () => {
-                    assert.match(obfuscatedCode, stringArrayRegExp);
-                });
-
-                it('match #2: should keep object expression key literal', () => {
-                    assert.match(obfuscatedCode, objectExpressionRegExp);
-                });
-            });
-
-            describe('Variant #2: computed key literal', () => {
-                const stringArrayRegExp: RegExp = /^var _0x([a-f0-9]){4} *= *\['foo', *'bar'];/;
-                const objectExpressionRegExp: RegExp = /var test *= *{\[_0x([a-f0-9]){4}\('0x0'\)] *: *_0x([a-f0-9]){4}\('0x1'\)};/;
-
-                let obfuscatedCode: string;
-
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/object-expression-computed-key-literal.js');
-
-                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            stringArray: true,
-                            stringArrayThreshold: 1
-                        }
-                    ).getObfuscatedCode();
-                });
-
-                it('match #1: should add object expression computed key literal to the string array', () => {
-                    assert.match(obfuscatedCode, stringArrayRegExp);
-                });
-
-                it('match #2: should replace object expression computed key literal on call to the string array', () => {
-                    assert.match(obfuscatedCode, objectExpressionRegExp);
-                });
-            });
-        });
-
-        describe('Variant #14: import declaration source literal', () => {
-            const importDeclarationRegExp: RegExp = /import *{ *bar *} *from *'foo';/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/import-declaration-source.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('Should not add `ImportDeclaration` source literal to the string array', () => {
-                assert.match(obfuscatedCode, importDeclarationRegExp);
-            });
-        });
-
-        describe('Variant #15: export all declaration source literal', () => {
-            const exportAllDeclarationRegExp: RegExp = /export *\* *from *'foo';/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/export-all-declaration-source.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('Should not add `ExportAllDeclaration` source literal to the string array', () => {
-                assert.match(obfuscatedCode, exportAllDeclarationRegExp);
-            });
-        });
-
-        describe('Variant #16: export named declaration source literal', () => {
-            const exportNamedDeclarationRegExp: RegExp = /export *{ *bar *} *from *'foo';/;
-
-            let obfuscatedCode: string;
-
-            before(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/export-named-declaration-source.js');
-
-                obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                    code,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        stringArray: true,
-                        stringArrayThreshold: 1
-                    }
-                ).getObfuscatedCode();
-            });
-
-            it('Should not add `ExportNamedDeclaration` source literal to the string array', () => {
-                assert.match(obfuscatedCode, exportNamedDeclarationRegExp);
-            });
-        });
-    });
-
-    describe('transformation of literal node with boolean value', () => {
-        const regExp: RegExp = /^var test *= *!!\[\];$/;
-
-        let obfuscatedCode: string;
-
-        before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/boolean-value.js');
-
-            obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                code,
-                {
-                    ...NO_ADDITIONAL_NODES_PRESET,
-                    stringArray: true,
-                    stringArrayThreshold: 1
-                }
-            ).getObfuscatedCode();
-        });
-
-        it('should transform literal node', () => {
-            assert.match(obfuscatedCode, regExp);
-        });
-    });
-
-    describe('transformation of literal node with number value', () => {
-        const regExp: RegExp = /^var test *= *0x0;$/;
-
-        let obfuscatedCode: string;
-
-        before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/number-value.js');
-
-            obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                code,
-                {
-                    ...NO_ADDITIONAL_NODES_PRESET,
-                    stringArray: true,
-                    stringArrayThreshold: 1
-                }
-            ).getObfuscatedCode();
-        });
-
-        it('should transform literal node', () => {
-            assert.match(obfuscatedCode, regExp);
-        });
-    });
-
-    describe('transformation of literal node with bigint value', () => {
-        const regExp: RegExp = /^var test *= *0xan;$/;
-
-        let obfuscatedCode: string;
-
-        before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/bigint-value.js');
-
-            obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                code,
-                {
-                    ...NO_ADDITIONAL_NODES_PRESET,
-                    stringArray: true,
-                    stringArrayThreshold: 1
-                }
-            ).getObfuscatedCode();
-        });
-
-        it('should transform literal node', () => {
-            assert.match(obfuscatedCode, regExp);
-        });
-    });
-
-    describe('RegExp literal', () => {
-        const regExp: RegExp = /^var regExp *= *\/\(\\d\+\)\/;$/;
-
-        let obfuscatedCode: string;
-
-        before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/regexp-literal.js');
-
-            obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                code,
-                {
-                    ...NO_ADDITIONAL_NODES_PRESET,
-                    stringArray: true,
-                    stringArrayThreshold: 1
-                }
-            ).getObfuscatedCode();
-        });
-
-        it('should keep safe value of RegExp literal', () => {
-            assert.match(obfuscatedCode, regExp);
-        });
-    });
-});

test/functional-tests/node-transformers/obfuscating-transformers/literal-transformer/fixtures/regexp-literal.js

@@ -1 +0,0 @@
-var regExp = /(\d+)/;

test/functional-tests/node-transformers/obfuscating-transformers/obfuscating-replacers/identifier-obfuscating-replacers/BaseIdentifierObfuscatingReplacer.spec.ts → test/functional-tests/node-transformers/rename-identifiers-transformers/identifier-replacer/IdentifierReplacer.spec.ts

@@ -1,12 +1,12 @@
 import { assert } from 'chai';
 
-import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
+import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscatorFacade';
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
 
-describe('BaseIdentifierObfuscatingReplacer', () => {
+describe('IdentifierReplacer', () => {
     describe('Reserved names', () => {
         describe('Variant #1: ignore local reserved names', () => {
             let obfuscatedCode: string;