NodeObfuscators now ObfuscationTransformers

New TemplateLiteralTransformer

README.md

@@ -429,7 +429,7 @@ Allows to enable/disable string conversion to unicode escape sequence.
 
 Unicode escape sequence increases code size greatly. It is recommended to disable this option when using [`stringArrayEncoding`](#stringarrayencoding) (especially with `rc4` encoding).
 
-## Option Presets
+## Preset Options
 ### High obfuscation, low performance
 
 Performance will 50-100% slower then without obfuscation

src/Obfuscator.ts

@@ -39,20 +39,21 @@ export class Obfuscator implements IObfuscator {
      * @type {Map<string, NodeTransformers[]>}
      */
     private static readonly nodeObfuscatorsMap: Map <string, NodeTransformers[]> = new Map([
-        [NodeType.ArrowFunctionExpression, [NodeTransformers.FunctionObfuscator]],
-        [NodeType.ClassDeclaration, [NodeTransformers.FunctionDeclarationObfuscator]],
-        [NodeType.CatchClause, [NodeTransformers.CatchClauseObfuscator]],
+        [NodeType.ArrowFunctionExpression, [NodeTransformers.FunctionTransformer]],
+        [NodeType.ClassDeclaration, [NodeTransformers.FunctionDeclarationTransformer]],
+        [NodeType.CatchClause, [NodeTransformers.CatchClauseTransformer]],
         [NodeType.FunctionDeclaration, [
-            NodeTransformers.FunctionDeclarationObfuscator,
-            NodeTransformers.FunctionObfuscator
+            NodeTransformers.FunctionDeclarationTransformer,
+            NodeTransformers.FunctionTransformer
         ]],
-        [NodeType.FunctionExpression, [NodeTransformers.FunctionObfuscator]],
-        [NodeType.MemberExpression, [NodeTransformers.MemberExpressionObfuscator]],
-        [NodeType.MethodDefinition, [NodeTransformers.MethodDefinitionObfuscator]],
-        [NodeType.ObjectExpression, [NodeTransformers.ObjectExpressionObfuscator]],
-        [NodeType.VariableDeclaration, [NodeTransformers.VariableDeclarationObfuscator]],
-        [NodeType.LabeledStatement, [NodeTransformers.LabeledStatementObfuscator]],
-        [NodeType.Literal, [NodeTransformers.LiteralObfuscator]]
+        [NodeType.FunctionExpression, [NodeTransformers.FunctionTransformer]],
+        [NodeType.MemberExpression, [NodeTransformers.MemberExpressionTransformer]],
+        [NodeType.MethodDefinition, [NodeTransformers.MethodDefinitionTransformer]],
+        [NodeType.ObjectExpression, [NodeTransformers.ObjectExpressionTransformer]],
+        [NodeType.VariableDeclaration, [NodeTransformers.VariableDeclarationTransformer]],
+        [NodeType.LabeledStatement, [NodeTransformers.LabeledStatementTransformer]],
+        [NodeType.TemplateLiteral, [NodeTransformers.TemplateLiteralTransformer]],
+        [NodeType.Literal, [NodeTransformers.LiteralTransformer]]
     ]);
 
     /**

src/container/InversifyContainerFacade.ts

@@ -1,9 +1,9 @@
 import { Container, interfaces } from 'inversify';
 import { ServiceIdentifiers } from './ServiceIdentifiers';
 
+import { controlFlowTransformersModule } from './modules/node-transformers/ControlFlowTransformersModule';
 import { customNodesModule } from './modules/custom-nodes/CustomNodesModule';
-import { nodeControlFlowTransformersModule } from './modules/node-transformers/NodeControlFlowTransformersModule';
-import { nodeObfuscatorsModule } from './modules/node-transformers/NodeObfuscatorsModule';
+import { obfuscationTransformersModule } from './modules/node-transformers/ObfuscationTransformersModule';
 import { nodeTransformersModule } from './modules/node-transformers/NodeTransformersModule';
 import { stackTraceAnalyzerModule } from './modules/stack-trace-analyzer/StackTraceAnalyzerModule';
 import { storagesModule } from './modules/storages/StoragesModule';
@@ -87,8 +87,8 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
         this.container.load(stackTraceAnalyzerModule);
         this.container.load(customNodesModule);
         this.container.load(nodeTransformersModule);
-        this.container.load(nodeControlFlowTransformersModule);
-        this.container.load(nodeObfuscatorsModule);
+        this.container.load(controlFlowTransformersModule);
+        this.container.load(obfuscationTransformersModule);
     }
 
     /**

src/container/ServiceIdentifiers.ts

@@ -5,7 +5,7 @@ export const ServiceIdentifiers: any = {
     Factory__ICustomNodeGroup: Symbol('Factory<ICustomNodeGroup>'),
     Factory__INodeTransformer: Symbol('Factory<INodeTransformer[]>'),
     Factory__IObfuscationResult: Symbol('Factory<IObfuscationResult>'),
-    Factory__IObfuscatorReplacer: Symbol('Factory<IObfuscatorReplacer>'),
+    Factory__IObfuscatorReplacer: Symbol('Factory<IObfuscationReplacer>'),
     Factory__TControlFlowStorage: Symbol('Factory<TControlFlowStorage>'),
     ICalleeDataExtractor: Symbol('ICalleeDataExtractor'),
     ICustomNodeGroup: Symbol('ICustomNodeGroup'),
@@ -16,7 +16,7 @@ export const ServiceIdentifiers: any = {
     IObfuscationResult: Symbol('IObfuscationResult'),
     IObfuscator: Symbol('IObfuscator'),
     IOptions: Symbol('IOptions'),
-    IObfuscatorReplacer: Symbol('IObfuscatorReplacer'),
+    IObfuscatorReplacer: Symbol('IObfuscationReplacer'),
     ISourceMapCorrector: Symbol('ISourceMapCorrector'),
     IStackTraceAnalyzer: Symbol('IStackTraceAnalyzer'),
     Newable__ICustomNode: Symbol('Newable<ICustomNode>'),

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

@@ -5,11 +5,11 @@ import { IControlFlowReplacer } from '../../../interfaces/node-transformers/ICon
 
 import { NodeControlFlowReplacers } from '../../../enums/container/NodeControlFlowReplacers';
 
-import { BinaryExpressionControlFlowReplacer } from '../../../node-transformers/node-control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer';
-import { CallExpressionControlFlowReplacer } from '../../../node-transformers/node-control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer';
-import { LogicalExpressionControlFlowReplacer } from '../../../node-transformers/node-control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer';
+import { BinaryExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer';
+import { CallExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer';
+import { LogicalExpressionControlFlowReplacer } from '../../../node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer';
 
-export const nodeControlFlowTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+export const controlFlowTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     bind<IControlFlowReplacer>(ServiceIdentifiers.IControlFlowReplacer)
         .to(BinaryExpressionControlFlowReplacer)
         .whenTargetNamed(NodeControlFlowReplacers.BinaryExpressionControlFlowReplacer);

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

@@ -5,18 +5,19 @@ import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTra
 
 import { NodeTransformers } from '../../../enums/container/NodeTransformers';
 
-import { FunctionControlFlowTransformer } from '../../../node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer';
-
-import { BlockStatementControlFlowTransformer } from '../../../node-transformers/node-control-flow-transformers/BlockStatementControlFlowTransformer';
-import { CatchClauseObfuscator } from '../../../node-transformers/node-obfuscators/CatchClauseObfuscator';
-import { FunctionDeclarationObfuscator } from '../../../node-transformers/node-obfuscators/FunctionDeclarationObfuscator';
-import { FunctionObfuscator } from '../../../node-transformers/node-obfuscators/FunctionObfuscator';
-import { LabeledStatementObfuscator } from '../../../node-transformers/node-obfuscators/LabeledStatementObfuscator';
-import { LiteralObfuscator } from '../../../node-transformers/node-obfuscators/LiteralObfuscator';
-import { MemberExpressionObfuscator } from '../../../node-transformers/node-obfuscators/MemberExpressionObfuscator';
-import { MethodDefinitionObfuscator } from '../../../node-transformers/node-obfuscators/MethodDefinitionObfuscator';
-import { ObjectExpressionObfuscator } from '../../../node-transformers/node-obfuscators/ObjectExpressionObfuscator';
-import { VariableDeclarationObfuscator } from '../../../node-transformers/node-obfuscators/VariableDeclarationObfuscator';
+import { FunctionControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/FunctionControlFlowTransformer';
+
+import { BlockStatementControlFlowTransformer } from '../../../node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer';
+import { CatchClauseTransformer } from '../../../node-transformers/obfuscation-transformers/CatchClauseTransformer';
+import { FunctionDeclarationTransformer } from '../../../node-transformers/obfuscation-transformers/FunctionDeclarationTransformer';
+import { FunctionTransformer } from '../../../node-transformers/obfuscation-transformers/FunctionTransformer';
+import { LabeledStatementTransformer } from '../../../node-transformers/obfuscation-transformers/LabeledStatementTransformer';
+import { LiteralTransformer } from '../../../node-transformers/obfuscation-transformers/LiteralTransformer';
+import { MemberExpressionTransformer } from '../../../node-transformers/obfuscation-transformers/MemberExpressionTransformer';
+import { MethodDefinitionTransformer } from '../../../node-transformers/obfuscation-transformers/MethodDefinitionTransformer';
+import { ObjectExpressionTransformer } from '../../../node-transformers/obfuscation-transformers/ObjectExpressionTransformer';
+import { TemplateLiteralTransformer } from '../../../node-transformers/obfuscation-transformers/TemplateLiteralTransformer';
+import { VariableDeclarationTransformer } from '../../../node-transformers/obfuscation-transformers/VariableDeclarationTransformer';
 
 export const nodeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // node control flow transformers
@@ -30,40 +31,44 @@ export const nodeTransformersModule: interfaces.ContainerModule = new ContainerM
 
     // node obfuscators
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(CatchClauseObfuscator)
-        .whenTargetNamed(NodeTransformers.CatchClauseObfuscator);
+        .to(CatchClauseTransformer)
+        .whenTargetNamed(NodeTransformers.CatchClauseTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(FunctionDeclarationObfuscator)
-        .whenTargetNamed(NodeTransformers.FunctionDeclarationObfuscator);
+        .to(FunctionDeclarationTransformer)
+        .whenTargetNamed(NodeTransformers.FunctionDeclarationTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(FunctionObfuscator)
-        .whenTargetNamed(NodeTransformers.FunctionObfuscator);
+        .to(FunctionTransformer)
+        .whenTargetNamed(NodeTransformers.FunctionTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(LabeledStatementObfuscator)
-        .whenTargetNamed(NodeTransformers.LabeledStatementObfuscator);
+        .to(LabeledStatementTransformer)
+        .whenTargetNamed(NodeTransformers.LabeledStatementTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(LiteralObfuscator)
-        .whenTargetNamed(NodeTransformers.LiteralObfuscator);
+        .to(LiteralTransformer)
+        .whenTargetNamed(NodeTransformers.LiteralTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(MemberExpressionObfuscator)
-        .whenTargetNamed(NodeTransformers.MemberExpressionObfuscator);
+        .to(MemberExpressionTransformer)
+        .whenTargetNamed(NodeTransformers.MemberExpressionTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(MethodDefinitionObfuscator)
-        .whenTargetNamed(NodeTransformers.MethodDefinitionObfuscator);
+        .to(MethodDefinitionTransformer)
+        .whenTargetNamed(NodeTransformers.MethodDefinitionTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ObjectExpressionObfuscator)
-        .whenTargetNamed(NodeTransformers.ObjectExpressionObfuscator);
+        .to(ObjectExpressionTransformer)
+        .whenTargetNamed(NodeTransformers.ObjectExpressionTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(VariableDeclarationObfuscator)
-        .whenTargetNamed(NodeTransformers.VariableDeclarationObfuscator);
+        .to(TemplateLiteralTransformer)
+        .whenTargetNamed(NodeTransformers.TemplateLiteralTransformer);
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(VariableDeclarationTransformer)
+        .whenTargetNamed(NodeTransformers.VariableDeclarationTransformer);
 
     // node transformers factory
     bind<INodeTransformer[]>(ServiceIdentifiers.Factory__INodeTransformer)

src/container/modules/node-transformers/NodeObfuscatorsModule.ts → src/container/modules/node-transformers/ObfuscationTransformersModule.ts

@@ -1,42 +1,42 @@
 import { ContainerModule, interfaces } from 'inversify';
 import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 
-import { IObfuscatorReplacer } from '../../../interfaces/node-transformers/IObfuscatorReplacer';
+import { IObfuscationReplacer } from '../../../interfaces/node-transformers/IObfuscationReplacer';
 
-import { NodeObfuscatorsReplacers } from '../../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../../enums/container/NodeObfuscationReplacers';
 
-import { BooleanLiteralReplacer } from '../../../node-transformers/node-obfuscators/replacers/BooleanLiteralReplacer';
-import { IdentifierReplacer } from '../../../node-transformers/node-obfuscators/replacers/IdentifierReplacer';
-import { NumberLiteralReplacer } from '../../../node-transformers/node-obfuscators/replacers/NumberLiteralReplacer';
-import { StringLiteralReplacer } from '../../../node-transformers/node-obfuscators/replacers/StringLiteralReplacer';
+import { BooleanLiteralReplacer } from '../../../node-transformers/obfuscation-transformers/replacers/BooleanLiteralReplacer';
+import { IdentifierReplacer } from '../../../node-transformers/obfuscation-transformers/replacers/IdentifierReplacer';
+import { NumberLiteralReplacer } from '../../../node-transformers/obfuscation-transformers/replacers/NumberLiteralReplacer';
+import { StringLiteralReplacer } from '../../../node-transformers/obfuscation-transformers/replacers/StringLiteralReplacer';
 
-export const nodeObfuscatorsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    bind<IObfuscatorReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
+export const obfuscationTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    bind<IObfuscationReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
         .to(BooleanLiteralReplacer)
         .whenTargetNamed(NodeObfuscatorsReplacers.BooleanReplacer);
 
-    bind<IObfuscatorReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
+    bind<IObfuscationReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
         .to(IdentifierReplacer)
         .whenTargetNamed(NodeObfuscatorsReplacers.IdentifierReplacer);
 
-    bind<IObfuscatorReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
+    bind<IObfuscationReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
         .to(NumberLiteralReplacer)
         .whenTargetNamed(NodeObfuscatorsReplacers.NumberLiteralReplacer);
 
-    bind<IObfuscatorReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
+    bind<IObfuscationReplacer>(ServiceIdentifiers.IObfuscatorReplacer)
         .to(StringLiteralReplacer)
         .whenTargetNamed(NodeObfuscatorsReplacers.StringLiteralReplacer);
 
-    bind<IObfuscatorReplacer>(ServiceIdentifiers.Factory__IObfuscatorReplacer)
-        .toFactory<IObfuscatorReplacer>((context: interfaces.Context) => {
-            const cache: Map <NodeObfuscatorsReplacers, IObfuscatorReplacer> = new Map();
+    bind<IObfuscationReplacer>(ServiceIdentifiers.Factory__IObfuscatorReplacer)
+        .toFactory<IObfuscationReplacer>((context: interfaces.Context) => {
+            const cache: Map <NodeObfuscatorsReplacers, IObfuscationReplacer> = new Map();
 
             return (replacerName: NodeObfuscatorsReplacers) => {
                 if (cache.has(replacerName)) {
-                    return <IObfuscatorReplacer>cache.get(replacerName);
+                    return <IObfuscationReplacer>cache.get(replacerName);
                 }
 
-                const obfuscationReplacer: IObfuscatorReplacer = context.container.getNamed<IObfuscatorReplacer>(
+                const obfuscationReplacer: IObfuscationReplacer = context.container.getNamed<IObfuscationReplacer>(
                     ServiceIdentifiers.IObfuscatorReplacer,
                     replacerName
                 );

src/enums/NodeType.ts

@@ -27,6 +27,7 @@ export const NodeType: any = Utils.strEnumify({
     ReturnStatement: 'ReturnStatement',
     SwitchCase: 'SwitchCase',
     SwitchStatement: 'SwitchStatement',
+    TemplateLiteral: 'TemplateLiteral',
     TryStatement: 'TryStatement',
     UnaryExpression: 'UnaryExpression',
     UpdateExpression: 'UpdateExpression',

src/enums/container/NodeTransformers.ts

@@ -1,13 +1,14 @@
 export enum NodeTransformers {
     BlockStatementControlFlowTransformer,
     FunctionControlFlowTransformer,
-    CatchClauseObfuscator,
-    FunctionDeclarationObfuscator,
-    FunctionObfuscator,
-    LabeledStatementObfuscator,
-    LiteralObfuscator,
-    MemberExpressionObfuscator,
-    MethodDefinitionObfuscator,
-    ObjectExpressionObfuscator,
-    VariableDeclarationObfuscator
+    CatchClauseTransformer,
+    FunctionDeclarationTransformer,
+    FunctionTransformer,
+    LabeledStatementTransformer,
+    LiteralTransformer,
+    MemberExpressionTransformer,
+    MethodDefinitionTransformer,
+    ObjectExpressionTransformer,
+    TemplateLiteralTransformer,
+    VariableDeclarationTransformer
 }

src/interfaces/node-transformers/IObfuscatorReplacer.d.ts → src/interfaces/node-transformers/IObfuscationReplacer.d.ts

@@ -1,6 +1,4 @@
-import * as ESTree from 'estree';
-
-export interface IObfuscatorReplacer {
+export interface IObfuscationReplacer {
     /**
      * @param nodeValue
      * @param nodeIdentifier

src/interfaces/node-transformers/IObfuscationReplacerWithStorage.d.ts

@@ -0,0 +1,9 @@
+import { IObfuscationReplacer } from './IObfuscationReplacer';
+
+export interface IObfuscationReplacerWithStorage extends IObfuscationReplacer {
+    /**
+     * @param nodeValue
+     * @param nodeIdentifier
+     */
+    storeNames (nodeValue: any, nodeIdentifier: number): void;
+}

src/interfaces/node-transformers/IObfuscatorReplacerWithStorage.d.ts

@@ -1,11 +0,0 @@
-import * as ESTree from 'estree';
-
-import { IObfuscatorReplacer } from './IObfuscatorReplacer';
-
-export interface IObfuscatorReplacerWithStorage extends IObfuscatorReplacer {
-    /**
-     * @param nodeValue
-     * @param nodeIdentifier
-     */
-    storeNames (nodeValue: any, nodeIdentifier: number): void;
-}

src/node-transformers/node-obfuscators/CatchClauseObfuscator.ts → src/node-transformers/obfuscation-transformers/CatchClauseTransformer.ts

@@ -5,10 +5,10 @@ import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
-import { IObfuscatorReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscatorReplacerWithStorage';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
+import { IObfuscationReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscationReplacerWithStorage';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -24,23 +24,23 @@ import { NodeUtils } from '../../node/NodeUtils';
  *
  */
 @injectable()
-export class CatchClauseObfuscator extends AbstractNodeTransformer {
+export class CatchClauseTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IObfuscatorReplacerWithStorage}
+     * @type {IObfuscationReplacerWithStorage}
      */
-    private readonly identifierReplacer: IObfuscatorReplacerWithStorage;
+    private readonly identifierReplacer: IObfuscationReplacerWithStorage;
 
     /**
      * @param replacersFactory
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
 
-        this.identifierReplacer = <IObfuscatorReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
+        this.identifierReplacer = <IObfuscationReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
     /**

src/node-transformers/node-obfuscators/FunctionDeclarationObfuscator.ts → src/node-transformers/obfuscation-transformers/FunctionDeclarationTransformer.ts

@@ -7,10 +7,10 @@ import * as ESTree from 'estree';
 import { TNodeWithBlockStatement } from '../../types/node/TNodeWithBlockStatement';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
-import { IObfuscatorReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscatorReplacerWithStorage';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
+import { IObfuscationReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscationReplacerWithStorage';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -27,11 +27,11 @@ import { NodeUtils } from '../../node/NodeUtils';
  *     _0x12d45f();
  */
 @injectable()
-export class FunctionDeclarationObfuscator extends AbstractNodeTransformer {
+export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IObfuscatorReplacerWithStorage}
+     * @type {IObfuscationReplacerWithStorage}
      */
-    private readonly identifierReplacer: IObfuscatorReplacerWithStorage;
+    private readonly identifierReplacer: IObfuscationReplacerWithStorage;
 
     /**
      * @type {Map<ESTree.Node, ESTree.Identifier[]>}
@@ -43,12 +43,12 @@ export class FunctionDeclarationObfuscator extends AbstractNodeTransformer {
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) nodeObfuscatorsReplacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) nodeObfuscatorsReplacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
 
-        this.identifierReplacer = <IObfuscatorReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
+        this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
     /**

src/node-transformers/node-obfuscators/FunctionObfuscator.ts → src/node-transformers/obfuscation-transformers/FunctionTransformer.ts

@@ -5,10 +5,10 @@ import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
-import { IObfuscatorReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscatorReplacerWithStorage';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
+import { IObfuscationReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscationReplacerWithStorage';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -24,23 +24,23 @@ import { NodeUtils } from '../../node/NodeUtils';
  *
  */
 @injectable()
-export class FunctionObfuscator extends AbstractNodeTransformer {
+export class FunctionTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IObfuscatorReplacerWithStorage}
+     * @type {IObfuscationReplacerWithStorage}
      */
-    private readonly identifierReplacer: IObfuscatorReplacerWithStorage;
+    private readonly identifierReplacer: IObfuscationReplacerWithStorage;
 
     /**
      * @param nodeObfuscatorsReplacersFactory
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) nodeObfuscatorsReplacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) nodeObfuscatorsReplacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
 
-        this.identifierReplacer = <IObfuscatorReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
+        this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
     /**

src/node-transformers/node-obfuscators/LabeledStatementObfuscator.ts → src/node-transformers/obfuscation-transformers/LabeledStatementTransformer.ts

@@ -5,10 +5,10 @@ import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
-import { IObfuscatorReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscatorReplacerWithStorage';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
+import { IObfuscationReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscationReplacerWithStorage';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -32,23 +32,23 @@ import { NodeUtils } from '../../node/NodeUtils';
  *
  */
 @injectable()
-export class LabeledStatementObfuscator extends AbstractNodeTransformer {
+export class LabeledStatementTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IObfuscatorReplacerWithStorage}
+     * @type {IObfuscationReplacerWithStorage}
      */
-    private readonly identifierReplacer: IObfuscatorReplacerWithStorage;
+    private readonly identifierReplacer: IObfuscationReplacerWithStorage;
 
     /**
      * @param nodeObfuscatorsReplacersFactory
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) nodeObfuscatorsReplacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) nodeObfuscatorsReplacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
 
-        this.identifierReplacer = <IObfuscatorReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
+        this.identifierReplacer = <IObfuscationReplacerWithStorage>nodeObfuscatorsReplacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
     /**

src/node-transformers/node-obfuscators/LiteralObfuscator.ts → src/node-transformers/obfuscation-transformers/LiteralTransformer.ts

@@ -5,26 +5,26 @@ import * as escodegen from 'escodegen';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { Node } from '../../node/Node';
 
 @injectable()
-export class LiteralObfuscator extends AbstractNodeTransformer {
+export class LiteralTransformer extends AbstractNodeTransformer {
     /**
-     * @type {(replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer}
+     * @type {(replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer}
      */
-    private readonly replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer;
+    private readonly replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer;
 
     /**
      * @param replacersFactory
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);

src/node-transformers/node-obfuscators/MemberExpressionObfuscator.ts → src/node-transformers/obfuscation-transformers/MemberExpressionTransformer.ts

@@ -4,27 +4,27 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { Node } from '../../node/Node';
 
 @injectable()
-export class MemberExpressionObfuscator extends AbstractNodeTransformer {
+export class MemberExpressionTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IObfuscatorReplacer}
+     * @type {IObfuscationReplacer}
      */
-    private readonly stringLiteralReplacer: IObfuscatorReplacer;
+    private readonly stringLiteralReplacer: IObfuscationReplacer;
 
     /**
      * @param replacersFactory
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
@@ -33,6 +33,17 @@ export class MemberExpressionObfuscator extends AbstractNodeTransformer {
     }
 
     /**
+     * replaces:
+     *     object.identifier = 1;
+     *
+     * on:
+     *     object['identifier'] = 1;
+     *
+     * and skip:
+     *     object[identifier] = 1;
+     *
+     * Literal node will be obfuscated by LiteralTransformer
+     *
      * @param memberExpressionNode
      * @returns {ESTree.Node}
      */
@@ -43,32 +54,13 @@ export class MemberExpressionObfuscator extends AbstractNodeTransformer {
             }
 
             memberExpressionNode.computed = true;
-            memberExpressionNode.property = this.obfuscateIdentifierProperty(memberExpressionNode.property);
+            memberExpressionNode.property = {
+                type: NodeType.Literal,
+                value: memberExpressionNode.property.name,
+                raw: `'${memberExpressionNode.property.name}'`
+            };
         }
 
         return memberExpressionNode;
     }
-
-    /**
-     * replaces:
-     *     object.identifier = 1;
-     *
-     * on:
-     *     object['identifier'] = 1;
-     *
-     * and skip:
-     *     object[identifier] = 1;
-     *
-     * Literal node will be obfuscated by LiteralObfuscator
-     *
-     * @param node
-     * @returns {ESTree.Literal}
-     */
-    private obfuscateIdentifierProperty (node: ESTree.Identifier): ESTree.Literal {
-        return {
-            type: NodeType.Literal,
-            value: node.name,
-            raw: `'${node.name}'`
-        };
-    }
 }

src/node-transformers/node-obfuscators/MethodDefinitionObfuscator.ts → src/node-transformers/obfuscation-transformers/MethodDefinitionTransformer.ts

@@ -4,9 +4,9 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 import * as ESTree from 'estree';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -19,26 +19,26 @@ import { Node } from '../../node/Node';
  * on:
  *     ['foo'] { //... };
  *
- * Literal node will be obfuscated by LiteralObfuscator
+ * Literal node will be obfuscated by LiteralTransformer
  */
 @injectable()
-export class MethodDefinitionObfuscator extends AbstractNodeTransformer {
+export class MethodDefinitionTransformer extends AbstractNodeTransformer {
     /**
      * @type {string[]}
      */
     private static readonly ignoredNames: string[] = ['constructor'];
 
     /**
-     * @type {IObfuscatorReplacer}
+     * @type {IObfuscationReplacer}
      */
-    private readonly stringLiteralReplacer: IObfuscatorReplacer;
+    private readonly stringLiteralReplacer: IObfuscationReplacer;
 
     /**
      * @param replacersFactory
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
@@ -46,17 +46,6 @@ export class MethodDefinitionObfuscator extends AbstractNodeTransformer {
         this.stringLiteralReplacer = replacersFactory(NodeObfuscatorsReplacers.StringLiteralReplacer);
     }
 
-    /**
-     * @param methodDefinitionNode
-     * @param parentNode
-     * @returns {ESTree.Node}
-     */
-    public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
-        this.replaceMethodName(methodDefinitionNode);
-
-        return methodDefinitionNode;
-    }
-
     /**
      * replaces:
      *     object.identifier = 1;
@@ -66,14 +55,16 @@ export class MethodDefinitionObfuscator extends AbstractNodeTransformer {
      *
      * and skip:
      *     object[identifier] = 1;
-     * Literal node will be obfuscated by LiteralObfuscator
+     * Literal node will be obfuscated by LiteralTransformer
      *
      * @param methodDefinitionNode
+     * @param parentNode
+     * @returns {ESTree.Node}
      */
-    private replaceMethodName (methodDefinitionNode: ESTree.MethodDefinition): void {
+    public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
         if (
             Node.isIdentifierNode(methodDefinitionNode.key) &&
-            !MethodDefinitionObfuscator.ignoredNames.includes(methodDefinitionNode.key.name) &&
+            !MethodDefinitionTransformer.ignoredNames.includes(methodDefinitionNode.key.name) &&
             methodDefinitionNode.computed === false
         ) {
             methodDefinitionNode.computed = true;
@@ -83,5 +74,7 @@ export class MethodDefinitionObfuscator extends AbstractNodeTransformer {
                 raw: `'${methodDefinitionNode.key.name}'`
             };
         }
+
+        return methodDefinitionNode;
     }
 }

src/node-transformers/node-obfuscators/ObjectExpressionObfuscator.ts → src/node-transformers/obfuscation-transformers/ObjectExpressionTransformer.ts

@@ -23,7 +23,7 @@ import { Utils } from '../../utils/Utils';
  *     var object = { '\u0050\u0053\u0045\u0055\u0044\u004f': 1 };
  */
 @injectable()
-export class ObjectExpressionObfuscator extends AbstractNodeTransformer {
+export class ObjectExpressionTransformer extends AbstractNodeTransformer {
     /**
      * @param options
      */
@@ -76,9 +76,9 @@ export class ObjectExpressionObfuscator extends AbstractNodeTransformer {
                 }
 
                 if (Node.isLiteralNode(property.key)) {
-                    property.key = ObjectExpressionObfuscator.obfuscateLiteralPropertyKey(property.key);
+                    property.key = ObjectExpressionTransformer.obfuscateLiteralPropertyKey(property.key);
                 } else if (Node.isIdentifierNode(property.key)) {
-                    property.key = ObjectExpressionObfuscator.obfuscateIdentifierPropertyKey(property.key);
+                    property.key = ObjectExpressionTransformer.obfuscateIdentifierPropertyKey(property.key);
                 }
             });
 

src/node-transformers/obfuscation-transformers/TemplateLiteralTransformer.ts

@@ -0,0 +1,98 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
+
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
+
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { Node } from '../../node/Node';
+import { Nodes } from '../../node/Nodes';
+
+/**
+ * Transform ES2015 template literals to ES5
+ * Thanks to Babel for algorithm
+ */
+@injectable()
+export class TemplateLiteralTransformer extends AbstractNodeTransformer {
+    /**
+     * @type {(replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer}
+     */
+    private readonly replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer;
+
+    /**
+     * @param replacersFactory
+     * @param options
+     */
+    constructor(
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(options);
+
+        this.replacersFactory = replacersFactory;
+    }
+
+    /**
+     * @param node
+     * @return {boolean}
+     */
+    private static isLiteralNodeWithStringValue (node: ESTree.Node): boolean {
+        return node && Node.isLiteralNode(node) && typeof node.value === 'string';
+    }
+
+    /**
+     * @param templateLiteralNode
+     * @param parentNode
+     * @returns {ESTree.Node}
+     */
+    public transformNode (templateLiteralNode: ESTree.TemplateLiteral, parentNode: ESTree.Node): ESTree.Node {
+        const templateLiteralExpressions: ESTree.Expression[] = templateLiteralNode.expressions;
+
+        let nodes: (ESTree.Literal | ESTree.Expression)[] = [];
+
+        for (const templateElement of templateLiteralNode.quasis) {
+            nodes.push(Nodes.getLiteralNode(templateElement.value.cooked));
+
+            const expression: ESTree.Expression | undefined = templateLiteralExpressions.shift();
+
+            if (!expression) {
+                continue;
+            }
+
+            nodes.push(expression);
+        }
+
+        nodes = nodes.filter((node: ESTree.Literal | ESTree.Expression) => {
+            return !(Node.isLiteralNode(node) && node.value === '');
+        });
+
+        // since `+` is left-to-right associative
+        // ensure the first node is a string if first/second isn't
+        if (
+            !TemplateLiteralTransformer.isLiteralNodeWithStringValue(nodes[0]) &&
+            !TemplateLiteralTransformer.isLiteralNodeWithStringValue(nodes[1])
+        ) {
+            nodes.unshift(Nodes.getLiteralNode(''));
+        }
+
+        if (nodes.length > 1) {
+            let root: ESTree.BinaryExpression = Nodes.getBinaryExpressionNode(
+                '+',
+                <ESTree.Literal>nodes.shift(),
+                <ESTree.Expression>nodes.shift()
+            );
+
+            for (const node of nodes) {
+                root = Nodes.getBinaryExpressionNode('+', root, <ESTree.Literal | ESTree.Expression>node);
+            }
+
+            return root;
+        }
+
+        return nodes[0];
+    }
+}

src/node-transformers/node-obfuscators/VariableDeclarationObfuscator.ts → src/node-transformers/obfuscation-transformers/VariableDeclarationTransformer.ts

@@ -7,10 +7,10 @@ import * as ESTree from 'estree';
 import { TNodeWithBlockStatement } from '../../types/node/TNodeWithBlockStatement';
 
 import { IOptions } from '../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';
-import { IObfuscatorReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscatorReplacerWithStorage';
+import { IObfuscationReplacer } from '../../interfaces/node-transformers/IObfuscationReplacer';
+import { IObfuscationReplacerWithStorage } from '../../interfaces/node-transformers/IObfuscationReplacerWithStorage';
 
-import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
+import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscationReplacers';
 import { NodeType } from '../../enums/NodeType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -28,11 +28,11 @@ import { NodeUtils } from '../../node/NodeUtils';
  *
  */
 @injectable()
-export class VariableDeclarationObfuscator extends AbstractNodeTransformer {
+export class VariableDeclarationTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IObfuscatorReplacerWithStorage}
+     * @type {IObfuscationReplacerWithStorage}
      */
-    private readonly identifierReplacer: IObfuscatorReplacerWithStorage;
+    private readonly identifierReplacer: IObfuscationReplacerWithStorage;
 
     /**
      * @type {Map<ESTree.Node, ESTree.Identifier[]>}
@@ -44,12 +44,12 @@ export class VariableDeclarationObfuscator extends AbstractNodeTransformer {
      * @param options
      */
     constructor(
-        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
+        @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscationReplacer,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
 
-        this.identifierReplacer = <IObfuscatorReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
+        this.identifierReplacer = <IObfuscationReplacerWithStorage>replacersFactory(NodeObfuscatorsReplacers.IdentifierReplacer);
     }
 
     /**

src/node-transformers/node-obfuscators/replacers/AbstractReplacer.ts → src/node-transformers/obfuscation-transformers/replacers/AbstractReplacer.ts

@@ -2,10 +2,10 @@ import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 
 import { IOptions } from '../../../interfaces/options/IOptions';
-import { IObfuscatorReplacer } from '../../../interfaces/node-transformers/IObfuscatorReplacer';
+import { IObfuscationReplacer } from '../../../interfaces/node-transformers/IObfuscationReplacer';
 
 @injectable()
-export abstract class AbstractReplacer implements IObfuscatorReplacer {
+export abstract class AbstractReplacer implements IObfuscationReplacer {
     /**
      * @type {IOptions}
      */

src/node-transformers/node-obfuscators/replacers/IdentifierReplacer.ts → src/node-transformers/obfuscation-transformers/replacers/IdentifierReplacer.ts

@@ -1,14 +1,14 @@
 import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 
-import { IObfuscatorReplacerWithStorage } from '../../../interfaces/node-transformers/IObfuscatorReplacerWithStorage';
+import { IObfuscationReplacerWithStorage } from '../../../interfaces/node-transformers/IObfuscationReplacerWithStorage';
 import { IOptions } from '../../../interfaces/options/IOptions';
 
 import { AbstractReplacer } from './AbstractReplacer';
 import { RandomGeneratorUtils } from '../../../utils/RandomGeneratorUtils';
 
 @injectable()
-export class IdentifierReplacer extends AbstractReplacer implements IObfuscatorReplacerWithStorage {
+export class IdentifierReplacer extends AbstractReplacer implements IObfuscationReplacerWithStorage {
     /**
      * @type {Map<string, string>}
      */

test/dev/dev.ts

@@ -9,91 +9,9 @@ if (!(<any>global)._babelPolyfill) {
     const JavaScriptObfuscator: any = require("../../index");
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
-        `
-            (function(){
-                var result = 1,
-                    term1 = 0,
-                    term2 = 1,
-                    i = 1;
-                while(i < 10)
-                {
-                    var test = 10;
-                    result = term1 + term2;
-                    console.log(result);
-                    term1 = term2;
-                    term2 = result;
-                    i++;
-                }
-        
-                console.log(test);
-                
-                var test = function (test) {
-                    console.log(test);
-                    
-                    if (true) {
-                        var test = 5
-                    }
-                    
-                    return test;
-                }
-                
-                console.log(test(1));
-                
-                function test2 (abc) {
-                    function test1 () {
-                      console.log('inside', abc.item);
-                    }
-                    
-                    console.log('тест', abc);
-                    
-                    var abc = {};
-                    
-                    return abc.item = 15, test1();
-                };
-                
-                var regexptest = /version\\/(\\d+)/i;
-                console.log(regexptest);
-                
-                test2(22);
-                console.log(105.4);
-                console.log(true, false);
-                
-                var sA = 'shorthand1';
-                var sB = 'shorthand2';
-                
-                console.log({sA, sB});
-                
-                try {
-                } catch (error) {
-                    console.log(error);
-                }
-                
-                function foo () {
-                    return function () {
-                        var sum1 = 10 + 20;
-                        var sum2 = 20 + 30;
-                        var sum3 = 30 + 50;
-                        var sub = sum3 - sum2;
-                        
-                        return sum1 + sub;
-                    }
-                }
-                
-                console.log(foo()());
-                
-                if (true) {
-                    console.log(1);
-                    console.log(2);
-                    console.log(3);
-                    console.log(4);
-                    console.log(5);
-                }
-            })();
-        `,
+        'var variable = `abc`;',
         {
             ...NO_CUSTOM_NODES_PRESET,
-            controlFlowFlattening: true,
-            controlFlowFlatteningThreshold: 1,
             compact: false
         }
     ).getObfuscatedCode();

test/functional-tests/node-transformers/node-control-flow-transformers/BlockStatementControlFlowTransformer.spec.ts → test/functional-tests/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.spec.ts

@@ -13,7 +13,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #1: 5 simple statements', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -60,7 +60,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #2: 5 simple statements inside while loop without break or continue statement', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-2.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-2.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -107,7 +107,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #3: less then 5 statements', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-one-statement.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-one-statement.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -127,7 +127,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #4: const declaration inside block statement', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-const-declaration.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-const-declaration.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -147,7 +147,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #5: let declaration inside block statement', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-let-declaration.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-let-declaration.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -167,7 +167,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #6: break statement inside block statement', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-break-statement.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-break-statement.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -187,7 +187,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #7: continue statement inside block statement', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-continue-statement.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-continue-statement.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -207,7 +207,7 @@ describe('BlockStatementControlFlowTransformer', () => {
         describe('variant #8: function declaration inside block statement', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-function-declaration.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-function-declaration.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -230,7 +230,7 @@ describe('BlockStatementControlFlowTransformer', () => {
             const delta: number = 0.1;
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/block-statement-control-flow-transformer-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/block-statement-control-flow-transformer-1.js'
                 ).repeat(samples),
                 {
                     ...NO_CUSTOM_NODES_PRESET,

test/functional-tests/node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer.spec.ts → test/functional-tests/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.spec.ts

@@ -29,7 +29,7 @@ describe('FunctionControlFlowTransformer', () => {
         describe('variant #1 - single `control flow storage` node with single item', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/function-control-flow-transformer-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -63,7 +63,7 @@ describe('FunctionControlFlowTransformer', () => {
             for (let i = 0; i < samplesCount; i++) {
                 const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                     readFileAsString(
-                        './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-2.js'
+                        './test/fixtures/node-transformers/control-flow-transformers/function-control-flow-transformer-2.js'
                     ),
                     {
                         ...NO_CUSTOM_NODES_PRESET,
@@ -90,7 +90,7 @@ describe('FunctionControlFlowTransformer', () => {
         describe('variant #3 - single `control flow storage` node with multiple items', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-multiple-items-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/function-control-flow-transformer-multiple-items-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -118,7 +118,7 @@ describe('FunctionControlFlowTransformer', () => {
         describe('variant #4 - no `control flow storage` node to the root block scope', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-root-block-scope-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/function-control-flow-transformer-root-block-scope-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -151,7 +151,7 @@ describe('FunctionControlFlowTransformer', () => {
                 for (let i = 0; i < samplesCount; i++) {
                     const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                         readFileAsString(
-                            './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-root-block-scope-2.js'
+                            './test/fixtures/node-transformers/control-flow-transformers/function-control-flow-transformer-root-block-scope-2.js'
                         ),
                         {
                             ...NO_CUSTOM_NODES_PRESET,
@@ -173,7 +173,7 @@ describe('FunctionControlFlowTransformer', () => {
         describe('variant #6 - no single `control flow storage` node when threshold is 0', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/function-control-flow-transformer-zero-threshold.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/function-control-flow-transformer-zero-threshold.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,

test/functional-tests/node-transformers/node-control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.spec.ts → test/functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.spec.ts

@@ -13,7 +13,7 @@ describe('BinaryExpressionControlFlowReplacer', () => {
         describe('variant #1 - single binary expression', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/binary-expression-control-flow-replacer-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/binary-expression-control-flow-replacer-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -42,7 +42,7 @@ describe('BinaryExpressionControlFlowReplacer', () => {
                 for (let i = 0; i < samplesCount; i++) {
                     const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                         readFileAsString(
-                            './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/binary-expression-control-flow-replacer-2.js'
+                            './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/binary-expression-control-flow-replacer-2.js'
                         ),
                         {
                             ...NO_CUSTOM_NODES_PRESET,

test/functional-tests/node-transformers/node-control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer.spec.ts → test/functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer.spec.ts

@@ -13,7 +13,7 @@ describe('CallExpressionControlFlowReplacer', () => {
         describe('variant #1 - single call expression', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/call-expression-control-flow-replacer-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/call-expression-control-flow-replacer-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -42,7 +42,7 @@ describe('CallExpressionControlFlowReplacer', () => {
                 for (let i = 0; i < samplesCount; i++) {
                     const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                         readFileAsString(
-                            './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/call-expression-control-flow-replacer-2.js'
+                            './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/call-expression-control-flow-replacer-2.js'
                         ),
                         {
                             ...NO_CUSTOM_NODES_PRESET,
@@ -77,7 +77,7 @@ describe('CallExpressionControlFlowReplacer', () => {
         describe('variant #3 - callee - member expression', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/call-expression-control-flow-replacer-3.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/call-expression-control-flow-replacer-3.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,

test/functional-tests/node-transformers/node-control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.spec.ts → test/functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.spec.ts

@@ -13,7 +13,7 @@ describe('LogicalExpressionControlFlowReplacer', () => {
         describe('variant #1 - single logical expression', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -42,7 +42,7 @@ describe('LogicalExpressionControlFlowReplacer', () => {
                 for (let i = 0; i < samplesCount; i++) {
                     const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                         readFileAsString(
-                            './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-2.js'
+                            './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-2.js'
                         ),
                         {
                             ...NO_CUSTOM_NODES_PRESET,
@@ -77,7 +77,7 @@ describe('LogicalExpressionControlFlowReplacer', () => {
         describe('variant #3 - single logical expression with unary expression', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-3.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-3.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
@@ -96,7 +96,7 @@ describe('LogicalExpressionControlFlowReplacer', () => {
         describe('prohibited nodes variant #1', () => {
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
                 readFileAsString(
-                    './test/fixtures/node-transformers/node-control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-prohibited-nodes-1.js'
+                    './test/fixtures/node-transformers/control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer-prohibited-nodes-1.js'
                 ),
                 {
                     ...NO_CUSTOM_NODES_PRESET,

test/functional-tests/node-transformers/node-obfuscators/CatchClauseObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/CatchClauseTransformer.spec.ts

@@ -8,11 +8,11 @@ import { readFileAsString } from '../../../helpers/readFileAsString';
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('CatchClauseObfuscator', () => {
+describe('CatchClauseTransformer', () => {
     describe('changeControlFlow (catchClauseNode: ESTree.CatchClause): void', () => {
         const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
             readFileAsString(
-                './test/fixtures/node-transformers/node-obfuscators/catch-clause-obfuscator/catch-clause-obfuscator.js'
+                './test/fixtures/node-transformers/obfuscation-transformers/catch-clause-transformer.js'
             ),
             {
                 ...NO_CUSTOM_NODES_PRESET

test/functional-tests/node-transformers/node-obfuscators/FunctionDeclarationObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/FunctionDeclarationTransformer.spec.ts

@@ -6,7 +6,7 @@ import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustom
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('FunctionDeclarationObfuscator', () => {
+describe('FunctionDeclarationTransformer', () => {
     describe('obfuscation of `functionDeclaration` node names', () => {
         const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
             `

test/functional-tests/node-transformers/node-obfuscators/FunctionObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/FunctionTransformer.spec.ts

@@ -6,7 +6,7 @@ import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustom
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('FunctionObfuscator', () => {
+describe('FunctionTransformer', () => {
     describe('identifiers obfuscation inside `FunctionDeclaration` and `FunctionExpression` node body', () => {
         const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
             `

test/functional-tests/node-transformers/node-obfuscators/LabeledStatementObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/LabeledStatementTransformer.spec.ts

@@ -8,11 +8,11 @@ import { readFileAsString } from '../../../helpers/readFileAsString';
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('LabeledStatementObfuscator', () => {
+describe('LabeledStatementTransformer', () => {
     describe('changeControlFlow (labeledStatementNode: ESTree.LabeledStatement): void', () => {
         const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
             readFileAsString(
-                './test/fixtures/node-transformers/node-obfuscators/labeled-statement-obfuscator/labeled-statement-obfuscator.js'
+                './test/fixtures/node-transformers/obfuscation-transformers/labeled-statement-transformer.js'
             ),
             {
                 ...NO_CUSTOM_NODES_PRESET

test/functional-tests/node-transformers/node-obfuscators/LiteralObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/LiteralTransformer.spec.ts

@@ -8,7 +8,7 @@ import { readFileAsString } from '../../../helpers/readFileAsString';
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('LiteralObfuscator', () => {
+describe('LiteralTransformer', () => {
     describe('obfuscation of literal node with string value', () => {
         it('should replace literal node value with unicode escape sequence', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
@@ -94,7 +94,7 @@ describe('LiteralObfuscator', () => {
 
         it('should\'t throw an error when string contains non-latin and non-digit characters and `unicodeEscapeSequence` is disabled', () => {
             assert.doesNotThrow(() => JavaScriptObfuscator.obfuscate(
-                readFileAsString('./test/fixtures/node-transformers/node-obfuscators/literal-obfuscator/literal-obfuscator-unicode-sequence.js'),
+                readFileAsString('./test/fixtures/node-transformers/obfuscation-transformers/literal-transformer-unicode-sequence.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,

test/functional-tests/node-transformers/node-obfuscators/MemberExpressionObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/MemberExpressionTransformer.spec.ts

@@ -6,7 +6,7 @@ import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustom
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('MemberExpressionObfuscator', () => {
+describe('MemberExpressionTransformer', () => {
     describe('obfuscation of member expression node with dot notation', () => {
         it('should replace member expression dot notation call by square brackets call with unicode literal value', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(

test/functional-tests/node-transformers/node-obfuscators/MethodDefinitionObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/MethodDefinitionTransformer.spec.ts

@@ -6,7 +6,7 @@ import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustom
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('MethodDefinitionObfuscator', () => {
+describe('MethodDefinitionTransformer', () => {
     let code: string = `
         class Foo {
             constructor () {}

test/functional-tests/node-transformers/node-obfuscators/ObjectExpressionObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/ObjectExpressionTransformer.spec.ts

@@ -6,7 +6,7 @@ import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustom
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('ObjectExpressionObfuscator', () => {
+describe('ObjectExpressionTransformer', () => {
     it('should replace object expression node `key` property with literal value by unicode value', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
             `var test = { 'foo': 0 };`,

test/functional-tests/node-transformers/node-obfuscators/VariableDeclarationObfuscator.spec.ts → test/functional-tests/node-transformers/obfuscation-transformers/VariableDeclarationTransformer.spec.ts

@@ -6,7 +6,7 @@ import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustom
 
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
-describe('VariableDeclarationObfuscator', () => {
+describe('VariableDeclarationTransformer', () => {
     it('should obfuscate `variableDeclaration` node', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
             `

test/index.spec.ts

@@ -30,20 +30,20 @@ import './functional-tests/custom-nodes/domain-lock-nodes/DomainLockNode.spec';
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayCallsWrapper.spec';
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.spec';
 import './functional-tests/custom-nodes/string-array-nodes/StringArrayNode.spec';
-import './functional-tests/node-transformers/node-control-flow-transformers/BlockStatementControlFlowTransformer.spec';
-import './functional-tests/node-transformers/node-control-flow-transformers/FunctionControlFlowTransformer.spec';
-import './functional-tests/node-transformers/node-control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.spec';
-import './functional-tests/node-transformers/node-control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer.spec';
-import './functional-tests/node-transformers/node-control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.spec';
-import './functional-tests/node-transformers/node-obfuscators/CatchClauseObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/FunctionDeclarationObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/FunctionObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/LabeledStatementObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/LiteralObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/MemberExpressionObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/MethodDefinitionObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/ObjectExpressionObfuscator.spec';
-import './functional-tests/node-transformers/node-obfuscators/VariableDeclarationObfuscator.spec';
+import './functional-tests/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.spec';
+import './functional-tests/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.spec';
+import './functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.spec';
+import './functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer.spec';
+import './functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/CatchClauseTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/FunctionDeclarationTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/FunctionTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/LabeledStatementTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/LiteralTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/MemberExpressionTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/MethodDefinitionTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/ObjectExpressionTransformer.spec';
+import './functional-tests/node-transformers/obfuscation-transformers/VariableDeclarationTransformer.spec';
 import './functional-tests/stack-trace-analyzer/StackTraceAnalyzer.spec';
 import './functional-tests/templates/custom-nodes/domain-lock-nodes/DomainLockNodeTemplate.spec';
 import './functional-tests/templates/custom-nodes/string-array-nodes/StringArrayCallsWrapperNodeTemplate.spec';