Merge branch 'dev'

# Conflicts:
#	dist/index.js

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

scripts/test-compile

@@ -1,4 +1,5 @@
 #!/bin/bash
 
 $(npm bin)/tsc -p tsconfig-test.json &&
-$(npm bin)/babel test-tmp --out-dir test-tmp --source-maps inline --presets es2015
+$(npm bin)/babel test-tmp --out-dir test-tmp --source-maps inline --presets es2015 &&
+rsync -a --prune-empty-dirs --include '*/' --include '*.js' --exclude '*' test/ test-tmp/test/

src/JavaScriptObfuscator.ts

@@ -6,8 +6,6 @@ if (!(<any>global)._babelPolyfill && parseInt(process.version.split('.')[0], 10)
 
 import { ServiceIdentifiers } from './container/ServiceIdentifiers';
 
-import { Chance } from 'chance';
-
 import { TInputOptions } from './types/options/TInputOptions';
 
 import { IInversifyContainerFacade } from './interfaces/container/IInversifyContainerFacade';
@@ -29,14 +27,15 @@ export class JavaScriptObfuscator {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade(inputOptions);
         const options: IOptions = inversifyContainerFacade.get<IOptions>(ServiceIdentifiers.IOptions);
 
-        if (options.seed !== 0) {
-            RandomGeneratorUtils.setRandomGenerator(new Chance(options.seed));
-        }
+        RandomGeneratorUtils.initializeRandomGenerator(options.seed);
 
         const javaScriptObfuscator: IJavaScriptObfuscator = inversifyContainerFacade
             .get<IJavaScriptObfuscator>(ServiceIdentifiers.IJavaScriptObfuscator);
+        const obfuscationResult: IObfuscationResult = javaScriptObfuscator.obfuscate(sourceCode);
+
+        RandomGeneratorUtils.clearRandomGenerator();
 
-        return javaScriptObfuscator.obfuscate(sourceCode);
+        return obfuscationResult;
     }
 
     /**

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]] // should be latest in the chain of obfuscators
     ]);
 
     /**

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>}
      */

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

@@ -20,11 +20,15 @@ export class StringLiteralReplacer extends AbstractReplacer {
      */
     private static readonly minimumLengthForStringArray: number = 3;
 
+    /**
+     * @type {IStorage<ICustomNodeGroup>}
+     */
+    private readonly customNodeGroupStorage: IStorage<ICustomNodeGroup>;
+
     /**
      * @type {string[]}
      */
-    private static readonly rc4Keys: string[] = RandomGeneratorUtils.getRandomGenerator()
-        .n(() => RandomGeneratorUtils.getRandomGenerator().string({length: 4}), 50);
+    private readonly rc4Keys: string[];
 
     /**
      * @type {Map<string, string>}
@@ -36,11 +40,6 @@ export class StringLiteralReplacer extends AbstractReplacer {
      */
     private readonly stringLiteralHexadecimalIndexCache: Map <string, string> = new Map();
 
-    /**
-     * @type {IStorage<ICustomNodeGroup>}
-     */
-    private readonly customNodeGroupStorage: IStorage<ICustomNodeGroup>;
-
     /**
      * @type {IStorage<string>}
      */
@@ -60,6 +59,9 @@ export class StringLiteralReplacer extends AbstractReplacer {
 
         this.customNodeGroupStorage = customNodeGroupStorage;
         this.stringArrayStorage = stringArrayStorage;
+
+        this.rc4Keys = RandomGeneratorUtils.getRandomGenerator()
+            .n(() => RandomGeneratorUtils.getRandomGenerator().string({length: 4}), 50);
     }
 
     /**
@@ -119,7 +121,7 @@ export class StringLiteralReplacer extends AbstractReplacer {
 
         switch (this.options.stringArrayEncoding) {
             case StringArrayEncoding.rc4:
-                key = RandomGeneratorUtils.getRandomGenerator().pickone(StringLiteralReplacer.rc4Keys);
+                key = RandomGeneratorUtils.getRandomGenerator().pickone(this.rc4Keys);
                 encodedValue = CryptUtils.btoa(CryptUtils.rc4(value, key));
 
                 break;

src/utils/RandomGeneratorUtils.ts

@@ -21,7 +21,22 @@ export class RandomGeneratorUtils {
     /**
      * @type {Chance.Chance | Chance.SeededChance}
      */
-    private static randomGenerator: Chance.Chance | Chance.SeededChance = new Chance();
+    private static randomGenerator: Chance.Chance | Chance.SeededChance;
+
+    /**
+     * @param seed
+     */
+    public static initializeRandomGenerator (seed: number): void {
+        if (seed !== 0) {
+            RandomGeneratorUtils.randomGenerator = new Chance(seed);
+        } else {
+            RandomGeneratorUtils.randomGenerator = new Chance();
+        }
+    }
+
+    public static clearRandomGenerator (): void {
+        RandomGeneratorUtils.randomVariableNameSet.clear();
+    }
 
     /**
      * @param min
@@ -43,7 +58,7 @@ export class RandomGeneratorUtils {
         const randomGenerator: Chance.Chance = RandomGeneratorUtils.randomGenerator;
 
         if (!randomGenerator) {
-            throw new Error(`\`randomGenerator\` static property is undefined`);
+            RandomGeneratorUtils.initializeRandomGenerator(0);
         }
 
         return RandomGeneratorUtils.randomGenerator;
@@ -94,11 +109,4 @@ export class RandomGeneratorUtils {
 
         return randomVariableName;
     }
-
-    /**
-     * @param randomGenerator
-     */
-    public static setRandomGenerator (randomGenerator: Chance.Chance | Chance.SeededChance): void {
-        RandomGeneratorUtils.randomGenerator = randomGenerator;
-    }
 }

test/dev/dev.ts

@@ -82,18 +82,16 @@ if (!(<any>global)._babelPolyfill) {
                 console.log(foo()());
                 
                 if (true) {
-                    console.log(1);
-                    console.log(2);
-                    console.log(3);
-                    console.log(4);
-                    console.log(5);
+                    console.log(\`1\`);
+                    console.log(\`2\`);
+                    console.log(\`3\`);
+                    console.log(\`4\`);
+                    console.log(\`5\`);
                 }
             })();
         `,
         {
             ...NO_CUSTOM_NODES_PRESET,
-            controlFlowFlattening: true,
-            controlFlowFlatteningThreshold: 1,
             compact: false
         }
     ).getObfuscatedCode();

test/functional-tests/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.spec.ts

@@ -4,6 +4,8 @@ import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResul
 
 import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
+import { readFileAsString } from '../../../helpers/readFileAsString';
+
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
 describe('ConsoleOutputDisableExpressionNode', () => {
@@ -11,7 +13,7 @@ describe('ConsoleOutputDisableExpressionNode', () => {
 
     it('should correctly append `ConsoleOutputDisableExpressionNode` custom node into the obfuscated code if `disableConsoleOutput` option is set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 disableConsoleOutput: true
@@ -23,7 +25,7 @@ describe('ConsoleOutputDisableExpressionNode', () => {
 
     it('should\'t append `ConsoleOutputDisableExpressionNode` custom node into the obfuscated code if `disableConsoleOutput` option is not set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 disableConsoleOutput: false,

test/functional-tests/custom-nodes/console-output-nodes/fixtures/simple-input.js

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

test/functional-tests/custom-nodes/domain-lock-nodes/DomainLockNode.spec.ts

@@ -4,12 +4,14 @@ import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResul
 
 import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
+import { readFileAsString } from '../../../helpers/readFileAsString';
+
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
 describe('DomainLockNode', () => {
     it('should correctly append `DomainLockNode` custom node into the obfuscated code if `domainLock` option is set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 domainLock: ['.example.com']
@@ -21,7 +23,7 @@ describe('DomainLockNode', () => {
 
     it('should\'t append `DomainLockNode` custom node into the obfuscated code if `domainLock` option is not set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 domainLock: []

test/functional-tests/custom-nodes/domain-lock-nodes/fixtures/simple-input.js

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

test/functional-tests/custom-nodes/string-array-nodes/StringArrayCallsWrapper.spec.ts

@@ -4,12 +4,14 @@ import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResul
 
 import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
+import { readFileAsString } from '../../../helpers/readFileAsString';
+
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
 describe('StringArrayCallsWrapper', () => {
     it('should correctly append `StringArrayCallsWrapper` custom node into the obfuscated code', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 stringArray: true,

test/functional-tests/custom-nodes/string-array-nodes/StringArrayNode.spec.ts

@@ -4,12 +4,14 @@ import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResul
 
 import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
+import { readFileAsString } from '../../../helpers/readFileAsString';
+
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
 describe('StringArrayNode', () => {
     it('should correctly append `StringArrayNode` custom node into the obfuscated code if `stringArray` option is set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 stringArray: true,
@@ -22,7 +24,7 @@ describe('StringArrayNode', () => {
 
     it('should\'t append `StringArrayNode` custom node into the obfuscated code if `stringArray` option is not set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 stringArray: false

test/functional-tests/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.spec.ts

@@ -4,12 +4,14 @@ import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResul
 
 import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
+import { readFileAsString } from '../../../helpers/readFileAsString';
+
 import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
 
 describe('StringArrayRotateFunctionNode', () => {
     it('should correctly append `StringArrayRotateFunctionNode` custom node into the obfuscated code if `rotateStringArray` option is set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 rotateStringArray: true,
@@ -23,7 +25,7 @@ describe('StringArrayRotateFunctionNode', () => {
 
     it('should\'t append `StringArrayRotateFunctionNode` custom node into the obfuscated code if `rotateStringArray` option is not set', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 'test';`,
+            readFileAsString(__dirname + '/fixtures/simple-input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 rotateStringArray: false,

test/functional-tests/custom-nodes/string-array-nodes/fixtures/simple-input.js

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

test/functional-tests/JavaScriptObfuscatorCLI.spec.ts → test/functional-tests/javascript-obfuscator-cli/JavaScriptObfuscatorCLI.spec.ts

@@ -4,9 +4,9 @@ import * as sinon from 'sinon';
 
 import { assert } from 'chai';
 
-import { StdoutWriteMock } from '../mocks/StdoutWriteMock';
+import { StdoutWriteMock } from '../../mocks/StdoutWriteMock';
 
-import { JavaScriptObfuscator } from '../../src/JavaScriptObfuscator';
+import { JavaScriptObfuscator } from '../../../src/JavaScriptObfuscator';
 
 describe('JavaScriptObfuscatorCLI', function (): void {
     let fixturesDirName: string = 'test/fixtures',

test/functional-tests/JavaScriptObfuscatorInternal.spec.ts → test/functional-tests/javascript-obfuscator-internal/JavaScriptObfuscatorInternal.spec.ts

@@ -1,14 +1,14 @@
-import { ServiceIdentifiers } from '../../src/container/ServiceIdentifiers';
+import { ServiceIdentifiers } from '../../../src/container/ServiceIdentifiers';
 
 import { assert } from 'chai';
 
-import { IInversifyContainerFacade } from '../../src/interfaces/container/IInversifyContainerFacade';
-import { IJavaScriptObfuscator } from '../../src/interfaces/IJavaScriptObfsucator';
-import { IObfuscationResult } from '../../src/interfaces/IObfuscationResult';
+import { IInversifyContainerFacade } from '../../../src/interfaces/container/IInversifyContainerFacade';
+import { IJavaScriptObfuscator } from '../../../src/interfaces/IJavaScriptObfsucator';
+import { IObfuscationResult } from '../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../src/options/presets/NoCustomNodes';
 
-import { InversifyContainerFacade } from '../../src/container/InversifyContainerFacade';
+import { InversifyContainerFacade } from '../../../src/container/InversifyContainerFacade';
 
 describe('JavaScriptObfuscatorInternal', () => {
     describe(`setSourceMapUrl (url: string)`, () => {

test/functional-tests/JavaScriptObfuscator.spec.ts → test/functional-tests/javascript-obfuscator/JavaScriptObfuscator.spec.ts

@@ -1,26 +1,25 @@
 import { assert } from 'chai';
 
-import { Chance } from 'chance';
+import { IObfuscationResult } from '../../../src/interfaces/IObfuscationResult';
 
-import { IObfuscationResult } from '../../src/interfaces/IObfuscationResult';
+import { JavaScriptObfuscator } from '../../../src/JavaScriptObfuscator';
 
-import { JavaScriptObfuscator } from '../../src/JavaScriptObfuscator';
+import { NO_CUSTOM_NODES_PRESET } from '../../../src/options/presets/NoCustomNodes';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../src/options/presets/NoCustomNodes';
+import { readFileAsString } from '../../helpers/readFileAsString';
 
-import { readFileAsString } from '../helpers/readFileAsString';
-import { RandomGeneratorUtils } from '../../src/utils/RandomGeneratorUtils';
+import { RandomGeneratorUtils } from '../../../src/utils/RandomGeneratorUtils';
 
 describe('JavaScriptObfuscator', () => {
     describe('obfuscate (sourceCode: string, customOptions?: IObfuscatorOptions): IObfuscationResult', () => {
         beforeEach(() => {
-            RandomGeneratorUtils.setRandomGenerator(new Chance());
+            RandomGeneratorUtils.initializeRandomGenerator(0);
         });
 
         describe('if `sourceMap` option is `false`', () => {
             it('should returns object with obfuscated code and empty source map', () => {
                 let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                    `var test = 1;`,
+                    readFileAsString(__dirname + '/fixtures/simple-input-1.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET
                     }
@@ -34,7 +33,7 @@ describe('JavaScriptObfuscator', () => {
         describe('if `sourceMap` option is `true`', () => {
             it('should returns object with obfuscated code and source map', () => {
                 let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                    `var test = 1;`,
+                    readFileAsString(__dirname + '/fixtures/simple-input-1.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET,
                         sourceMap: true
@@ -47,7 +46,7 @@ describe('JavaScriptObfuscator', () => {
 
             it('should returns object with obfuscated code with inline source map as Base64 string', () => {
                 let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                    `var test = 1;`,
+                    readFileAsString(__dirname + '/fixtures/simple-input-1.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET,
                         sourceMap: true,
@@ -65,7 +64,7 @@ describe('JavaScriptObfuscator', () => {
 
             it('should returns object with empty obfuscated code and source map with empty data if source code is empty', () => {
                 let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                    '',
+                    readFileAsString(__dirname + '/fixtures/empty-input.js'),
                     {
                         sourceMap: true
                     }
@@ -81,7 +80,7 @@ describe('JavaScriptObfuscator', () => {
         it('should returns an empty string if source code is empty', () => {
             assert.isNotOk(
                 JavaScriptObfuscator.obfuscate(
-                    ''
+                    readFileAsString(__dirname + '/fixtures/empty-input.js'),
                 ).getObfuscatedCode()
             );
         });
@@ -89,7 +88,7 @@ describe('JavaScriptObfuscator', () => {
         it('should returns an empty string if source code contains only comments', () => {
             assert.isNotOk(
                 JavaScriptObfuscator.obfuscate(
-                    '// comment'
+                    readFileAsString(__dirname + '/fixtures/comments-only.js'),
                 ).getObfuscatedCode()
             );
         });
@@ -97,7 +96,7 @@ describe('JavaScriptObfuscator', () => {
         it('should obfuscate simple code with variable inside global scope', () => {
             assert.match(
                 JavaScriptObfuscator.obfuscate(
-                    `var test = 1;`,
+                    readFileAsString(__dirname + '/fixtures/simple-input-1.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET
                     }
@@ -109,7 +108,7 @@ describe('JavaScriptObfuscator', () => {
         it('should obfuscate simple code with variable inside block-scope', () => {
             assert.match(
                 JavaScriptObfuscator.obfuscate(
-                    `(function () {var test = 1;})()`,
+                    readFileAsString(__dirname + '/fixtures/block-scope.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET
                     }
@@ -122,7 +121,7 @@ describe('JavaScriptObfuscator', () => {
             let pattern1: RegExp = /^var _0x(\w){4} *= *\['(\\[x|u]\d+)+'\];/,
                 pattern2: RegExp = /var *test *= *_0x(\w){4}\('0x0'\);$/,
                 obfuscatedCode1: string = JavaScriptObfuscator.obfuscate(
-                    `var test = 'abc';`,
+                    readFileAsString(__dirname + '/fixtures/simple-input-2.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET,
                         stringArray: true,
@@ -130,7 +129,7 @@ describe('JavaScriptObfuscator', () => {
                     }
                 ).getObfuscatedCode(),
                 obfuscatedCode2: string = JavaScriptObfuscator.obfuscate(
-                    `var test = 'абц';`,
+                    readFileAsString(__dirname + '/fixtures/simple-input-cyrillic.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET,
                         stringArray: true,
@@ -145,21 +144,33 @@ describe('JavaScriptObfuscator', () => {
             assert.match(obfuscatedCode2, pattern2);
         });
 
-        it('should returns same code every time with same `seed`', () => {
+        it('should returns same code every time with same `seed`', function () {
+            this.timeout(15000);
+
             const code: string = readFileAsString('./test/fixtures/sample.js');
-            const seed: number = 12345;
+            const samples: number = 100;
 
-            const obfuscationResult1: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                code, { seed: seed }
-            );
-            RandomGeneratorUtils.randomVariableNameSet.clear();
+            let seed: number = 12345,
+                equalsCount: number = 0;
 
-            const obfuscationResult2: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                code, { seed: seed }
-            );
-            RandomGeneratorUtils.randomVariableNameSet.clear();
+            for (let i: number = 0; i < samples; i++) {
+                if (i % 20 === 0) {
+                    seed++;
+                }
+
+                const obfuscationResult1: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code, { seed: seed }
+                );
+                const obfuscationResult2: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code, { seed: seed }
+                );
+
+                if (obfuscationResult1.getObfuscatedCode() === obfuscationResult2.getObfuscatedCode()) {
+                    equalsCount++;
+                }
+            }
 
-            assert.equal(obfuscationResult1.getObfuscatedCode(), obfuscationResult2.getObfuscatedCode());
+            assert.equal(equalsCount, samples);
         });
 
         it('should returns different code with different `seed` option value', () => {
@@ -184,7 +195,7 @@ describe('JavaScriptObfuscator', () => {
         });
 
         afterEach(() => {
-            RandomGeneratorUtils.setRandomGenerator(new Chance());
+            RandomGeneratorUtils.initializeRandomGenerator(0);
         });
     });
 });

test/functional-tests/javascript-obfuscator/fixtures/block-scope.js

@@ -0,0 +1 @@
+(function () {var test = 1;})()

test/functional-tests/javascript-obfuscator/fixtures/comments-only.js

@@ -0,0 +1 @@
+// comment

test/functional-tests/javascript-obfuscator/fixtures/simple-input-1.js

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

test/functional-tests/javascript-obfuscator/fixtures/simple-input-2.js

@@ -0,0 +1 @@
+var test = 'abc';

test/functional-tests/javascript-obfuscator/fixtures/simple-input-cyrillic.js

@@ -0,0 +1 @@
+var test = 'абц';

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

@@ -1,20 +1,18 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
 
 describe('BlockStatementControlFlowTransformer', () => {
     describe('transformNode (blockStatementNode: ESTree.BlockStatement): ESTree.Node', () => {
         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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-1.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -59,9 +57,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-2.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -106,9 +102,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/one-statement.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -126,9 +120,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/const-declaration.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -146,9 +138,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/let-declaration.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -166,9 +156,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/break-statement.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -186,9 +174,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/continue-statement.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -206,9 +192,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/function-declaration.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -229,9 +213,7 @@ describe('BlockStatementControlFlowTransformer', () => {
             const controlFlowFlatteningThreshold: number = 0.5;
             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'
-                ).repeat(samples),
+                readFileAsString(__dirname + '/fixtures/input-1.js').repeat(samples),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,

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/binary-expression-control-flow-replacer/BinaryExpressionControlFlowReplacer.spec.ts

@@ -1,20 +1,18 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
+import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscator';
 
 describe('BinaryExpressionControlFlowReplacer', () => {
     describe('replace (binaryExpressionNode: ESTree.BinaryExpression,parentNode: ESTree.Node,controlFlowStorage: IStorage <ICustomNode>)', () => {
         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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-1.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -31,9 +29,9 @@ describe('BinaryExpressionControlFlowReplacer', () => {
 
         describe('variant #2 - multiple binary expressions with threshold = 1', () => {
             it('should replace binary expression node by call to control flow storage node', function () {
-                this.timeout(4000);
+                this.timeout(15000);
 
-                const samplesCount: number = 200;
+                const samplesCount: number = 1000;
                 const expectedValue: number = 0.5;
                 const delta: number = 0.1;
 
@@ -41,9 +39,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'
-                        ),
+                        readFileAsString(__dirname + '/fixtures/input-2.js'),
                         {
                             ...NO_CUSTOM_NODES_PRESET,
                             controlFlowFlattening: true,

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/call-expression-control-flow-replacer/CallExpressionControlFlowReplacer.spec.ts

@@ -1,20 +1,18 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
+import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscator';
 
 describe('CallExpressionControlFlowReplacer', () => {
     describe('replace (callExpressionNode: ESTree.CallExpression,parentNode: ESTree.Node,controlFlowStorage: IStorage <ICustomNode>)', () => {
         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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-1.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -31,9 +29,9 @@ describe('CallExpressionControlFlowReplacer', () => {
 
         describe('variant #2 - multiple call expressions with threshold = 1', () => {
             it('should replace call expression node by call to control flow storage node', function () {
-                this.timeout(4000);
+                this.timeout(15000);
 
-                const samplesCount: number = 200;
+                const samplesCount: number = 1000;
                 const expectedValue: number = 0.5;
                 const delta: number = 0.1;
 
@@ -41,9 +39,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'
-                        ),
+                        readFileAsString(__dirname + '/fixtures/input-2.js'),
                         {
                             ...NO_CUSTOM_NODES_PRESET,
                             controlFlowFlattening: true,
@@ -76,9 +72,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-3.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,

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/logical-expression-control-flow-replacer/LogicalExpressionControlFlowReplacer.spec.ts

@@ -1,20 +1,18 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
+import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscator';
 
 describe('LogicalExpressionControlFlowReplacer', () => {
     describe('replace (logicalExpressionNode: ESTree.LogicalExpression,parentNode: ESTree.Node,controlFlowStorage: IStorage <ICustomNode>)', () => {
         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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-1.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -31,9 +29,9 @@ describe('LogicalExpressionControlFlowReplacer', () => {
 
         describe('variant #2 - multiple logical expressions with threshold = 1', () => {
             it('should replace logical expression node by call to control flow storage node', function () {
-                this.timeout(4000);
+                this.timeout(15000);
 
-                const samplesCount: number = 200;
+                const samplesCount: number = 1000;
                 const expectedValue: number = 0.5;
                 const delta: number = 0.1;
 
@@ -41,9 +39,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'
-                        ),
+                        readFileAsString(__dirname + '/fixtures/input-2.js'),
                         {
                             ...NO_CUSTOM_NODES_PRESET,
                             controlFlowFlattening: true,
@@ -76,9 +72,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-3.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -95,9 +89,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/prohibited-nodes.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,

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

@@ -1,12 +1,12 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
 
 describe('FunctionControlFlowTransformer', () => {
     const variableMatch: string = '_0x([a-z0-9]){4,6}';
@@ -28,9 +28,7 @@ describe('FunctionControlFlowTransformer', () => {
     describe('transformNode (functionNode: ESTree.Function): ESTree.Node', () => {
         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'
-                ),
+                readFileAsString(__dirname + '/fixtures/input-1.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -46,7 +44,7 @@ describe('FunctionControlFlowTransformer', () => {
         });
 
         describe('variant #2 - two `control flow storage` nodes: root and inner', () => {
-            const samplesCount: number = 200;
+            const samplesCount: number = 1000;
             const delta: number = 0.1;
             const expectedValue: number = 0.5;
             const regExp1: RegExp = new RegExp(
@@ -62,9 +60,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'
-                    ),
+                    readFileAsString(__dirname + '/fixtures/input-2.js'),
                     {
                         ...NO_CUSTOM_NODES_PRESET,
                         controlFlowFlattening: true,
@@ -89,9 +85,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/multiple-items.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -117,9 +111,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/root-block-scope-1.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,
@@ -150,9 +142,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'
-                        ),
+                        readFileAsString(__dirname + '/fixtures/root-block-scope-2.js'),
                         {
                             ...NO_CUSTOM_NODES_PRESET,
                             controlFlowFlattening: true,
@@ -172,9 +162,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'
-                ),
+                readFileAsString(__dirname + '/fixtures/zero-threshold.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     controlFlowFlattening: true,

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

@@ -1,19 +1,17 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+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'
-            ),
+            readFileAsString(__dirname + '/fixtures/input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET
             }
@@ -22,7 +20,7 @@ describe('CatchClauseObfuscator', () => {
         const paramNameRegExp: RegExp = /catch *\((_0x([a-z0-9]){4,6})\) *\{/;
         const bodyParamNameRegExp: RegExp = /console\['\\x6c\\x6f\\x67'\]\((_0x([a-z0-9]){4,6})\);/;
 
-        it('should obfuscate catch clause node', () => {
+        it('should transform catch clause node', () => {
             assert.match(obfuscatedCode, paramNameRegExp);
             assert.match(obfuscatedCode, bodyParamNameRegExp);
         });

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

@@ -1,35 +1,24 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-describe('FunctionDeclarationObfuscator', () => {
-    describe('obfuscation of `functionDeclaration` node names', () => {
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
+
+describe('FunctionDeclarationTransformer', () => {
+    describe('transformation of `functionDeclaration` node names', () => {
         const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `
-                function foo () {
-                    function bar () {
-                    }
-                    
-                    if (true) {
-                        bar();
-                    }
-                }
-                
-                if (true) {
-                    foo();
-                }
-            `,
+            readFileAsString(__dirname + '/fixtures/input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET
             }
         );
         const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
 
-        it('shouldn\'t obfuscate function name if `functionDeclaration` parent block scope is a `ProgramNode`', () => {
+        it('shouldn\'t transform function name if `functionDeclaration` parent block scope is a `ProgramNode`', () => {
             const functionNameIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
                 .match(/function *foo *\(\) *\{/);
             const functionCallIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
@@ -41,7 +30,7 @@ describe('FunctionDeclarationObfuscator', () => {
             assert.equal(functionParamIdentifierName, functionBodyIdentifierName);
         });
 
-        it('should obfuscate function name if `functionDeclaration` parent block scope is not a `ProgramNode`', () => {
+        it('should transform function name if `functionDeclaration` parent block scope is not a `ProgramNode`', () => {
             const functionNameIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
                 .match(/function *_0x[a-z0-9]{4,6} *\(\) *\{/);
             const functionCallIdentifierMatch: RegExpMatchArray|null = obfuscatedCode

test/functional-tests/node-transformers/obfuscation-transformers/function-declaration-transformer/fixtures/input.js

@@ -0,0 +1,12 @@
+function foo () {
+    function bar () {
+    }
+
+    if (true) {
+        bar();
+    }
+}
+
+if (true) {
+    foo();
+}

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

@@ -1,36 +1,24 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-describe('FunctionObfuscator', () => {
-    describe('identifiers obfuscation inside `FunctionDeclaration` and `FunctionExpression` node body', () => {
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
+
+describe('FunctionTransformer', () => {
+    describe('identifiers transformation inside `FunctionDeclaration` and `FunctionExpression` node body', () => {
         const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `
-                (function () {
-                    var test = function (test) {
-                        console.log(test);
-                        
-                        if (true) {
-                            var test = 5
-                        }
-                        
-                        variable = 6;
-                        
-                        return test;
-                    }
-                })();
-            `,
+            readFileAsString(__dirname + '/fixtures/input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET
             }
         );
         const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
 
-        it('should correct obfuscate both function parameter identifier and function body identifier with same name', () => {
+        it('should correct transform both function parameter identifier and function body identifier with same name', () => {
             const functionParamIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
                 .match(/var _0x[a-z0-9]{4,6} *= *function *\((_0x[a-z0-9]{4,6})\) *\{/);
             const functionBodyIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
@@ -42,7 +30,7 @@ describe('FunctionObfuscator', () => {
             assert.equal(functionParamIdentifierName, functionBodyIdentifierName);
         });
 
-        it('shouldn\'t obfuscate other variables in function body', () => {
+        it('shouldn\'t transform other variables in function body', () => {
             assert.equal(/variable *= *0x6;/.test(obfuscatedCode), true);
         });
     });

test/functional-tests/node-transformers/obfuscation-transformers/function-transformer/fixtures/input.js

@@ -0,0 +1,13 @@
+(function () {
+    var test = function (test) {
+        console.log(test);
+
+        if (true) {
+            var test = 5
+        }
+
+        variable = 6;
+
+        return test;
+    }
+})();

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

@@ -1,19 +1,17 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+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'
-            ),
+            readFileAsString(__dirname + '/fixtures/input.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET
             }
@@ -23,15 +21,15 @@ describe('LabeledStatementObfuscator', () => {
         const continueStatementRegExp: RegExp = /continue *(_0x([a-z0-9]){4,6});/;
         const breakStatementRegExp: RegExp = /break *(_0x([a-z0-9]){4,6});/;
 
-        it('should obfuscate `labeledStatement` identifier', () => {
+        it('should transform `labeledStatement` identifier', () => {
             assert.match(obfuscatedCode, labeledStatementRegExp);
         });
 
-        it('should obfuscate `continueStatement` identifier', () => {
+        it('should transform `continueStatement` identifier', () => {
             assert.match(obfuscatedCode, continueStatementRegExp);
         });
 
-        it('should obfuscate `breakStatement` identifier', () => {
+        it('should transform `breakStatement` identifier', () => {
             assert.match(obfuscatedCode, breakStatementRegExp);
         });
 

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

@@ -1,18 +1,18 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
+import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
 
-import { NO_CUSTOM_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
+import { NO_CUSTOM_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
-import { readFileAsString } from '../../../helpers/readFileAsString';
+import { readFileAsString } from '../../../../helpers/readFileAsString';
 
-import { JavaScriptObfuscator } from '../../../../src/JavaScriptObfuscator';
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscator';
 
-describe('LiteralObfuscator', () => {
-    describe('obfuscation of literal node with string value', () => {
+describe('LiteralTransformer', () => {
+    describe('transformation of literal node with string value', () => {
         it('should replace literal node value with unicode escape sequence', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'test';`,
+                readFileAsString(__dirname + '/fixtures/simple-input.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET
                 }
@@ -23,7 +23,7 @@ describe('LiteralObfuscator', () => {
 
         it('should replace literal node value with unicode escape sequence from string array', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'test';`,
+                readFileAsString(__dirname + '/fixtures/simple-input.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -40,11 +40,7 @@ describe('LiteralObfuscator', () => {
 
         it('should create only one item in string array for same literal node values', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `
-                    var test = 'test';
-                    var test = 'test';
-                    object.test();
-                `,
+                readFileAsString(__dirname + '/fixtures/same-literal-values.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -61,7 +57,7 @@ describe('LiteralObfuscator', () => {
 
         it('should replace literal node value with raw value from string array if `unicodeEscapeSequence` is disabled', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'test';`,
+                readFileAsString(__dirname + '/fixtures/simple-input.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -79,7 +75,7 @@ describe('LiteralObfuscator', () => {
 
         it('should replace literal node value with raw value from string array if `unicodeEscapeSequence` and `stringArray` are disabled', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'test';`,
+                readFileAsString(__dirname + '/fixtures/simple-input.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     unicodeEscapeSequence: false
@@ -94,7 +90,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(__dirname + '/fixtures/error-when-non-latin.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -106,7 +102,7 @@ describe('LiteralObfuscator', () => {
 
         it('shouldn\'t replace short literal node value with value from string array', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'te';`,
+                readFileAsString(__dirname + '/fixtures/short-literal-value.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -119,7 +115,7 @@ describe('LiteralObfuscator', () => {
 
         it('should replace literal node value with value from string array encoded using base64', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'test';`,
+                readFileAsString(__dirname + '/fixtures/simple-input.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -137,7 +133,7 @@ describe('LiteralObfuscator', () => {
 
         it('should replace literal node value with value from string array encoded using rc4', () => {
             let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'test';`,
+                readFileAsString(__dirname + '/fixtures/simple-input.js'),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -157,7 +153,7 @@ describe('LiteralObfuscator', () => {
             const stringArrayThreshold: number = 0.5;
             const delta: number = 0.1;
             const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                `var test = 'test';\n`.repeat(samples),
+                `${readFileAsString(__dirname + '/fixtures/simple-input.js')}\n`.repeat(samples),
                 {
                     ...NO_CUSTOM_NODES_PRESET,
                     stringArray: true,
@@ -175,9 +171,9 @@ describe('LiteralObfuscator', () => {
         });
     });
 
-    it('should obfuscate literal node with boolean value', () => {
+    it('should transform literal node with boolean value', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = true;`,
+            readFileAsString(__dirname + '/fixtures/boolean-value.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 stringArray: true,
@@ -188,9 +184,9 @@ describe('LiteralObfuscator', () => {
         assert.match(obfuscationResult.getObfuscatedCode(),  /^var *test *= *!!\[\];$/);
     });
 
-    it('should obfuscate literal node with number value', () => {
+    it('should transform literal node with number value', () => {
         let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-            `var test = 0;`,
+            readFileAsString(__dirname + '/fixtures/number-value.js'),
             {
                 ...NO_CUSTOM_NODES_PRESET,
                 stringArray: true,

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

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

test/functional-tests/node-transformers/obfuscation-transformers/literal-transformer/fixtures/number-value.js

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

test/functional-tests/node-transformers/obfuscation-transformers/literal-transformer/fixtures/same-literal-values.js

@@ -0,0 +1,3 @@
+var test = 'test';
+var test = 'test';
+object.test();

test/functional-tests/node-transformers/obfuscation-transformers/literal-transformer/fixtures/short-literal-value.js

@@ -0,0 +1 @@
+var test = 'te';

test/functional-tests/node-transformers/obfuscation-transformers/literal-transformer/fixtures/simple-input.js

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