Replaced ObfuscationResult and SourceMapCorrector classes by ObfuscatedCode class

src/JavaScriptObfuscator.ts

@@ -5,13 +5,14 @@ import * as escodegen from 'escodegen-wallaby';
 import * as espree from 'espree';
 import * as ESTree from 'estree';
 
+import { TObfuscatedCodeFactory } from './types/container/source-code/TObfuscatedCodeFactory';
+
 import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
 import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
 import { ILogger } from './interfaces/logger/ILogger';
-import { IObfuscationResult } from './interfaces/IObfuscationResult';
+import { IObfuscatedCode } from './interfaces/source-code/IObfuscatedCode';
 import { IOptions } from './interfaces/options/IOptions';
 import { IRandomGenerator } from './interfaces/utils/IRandomGenerator';
-import { ISourceMapCorrector } from './interfaces/source-map/ISourceMapCorrector';
 import { ITransformersRunner } from './interfaces/node-transformers/ITransformersRunner';
 
 import { LoggingMessage } from './enums/logger/LoggingMessage';
@@ -79,6 +80,11 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      */
     private readonly logger: ILogger;
 
+    /**
+     * @type {TObfuscatedCodeFactory}
+     */
+    private readonly obfuscatedCodeFactory: TObfuscatedCodeFactory;
+
     /**
      * @type {IOptions}
      */
@@ -89,11 +95,6 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      */
     private readonly randomGenerator: IRandomGenerator;
 
-    /**
-     * @type {ISourceMapCorrector}
-     */
-    private readonly sourceMapCorrector: ISourceMapCorrector;
-
     /**
      * @type {ITransformersRunner}
      */
@@ -101,30 +102,30 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
 
     /**
      * @param {ITransformersRunner} transformersRunner
-     * @param {ISourceMapCorrector} sourceMapCorrector
      * @param {IRandomGenerator} randomGenerator
+     * @param {TObfuscatedCodeFactory} obfuscatedCodeFactory
      * @param {ILogger} logger
      * @param {IOptions} options
      */
     constructor (
         @inject(ServiceIdentifiers.ITransformersRunner) transformersRunner: ITransformersRunner,
-        @inject(ServiceIdentifiers.ISourceMapCorrector) sourceMapCorrector: ISourceMapCorrector,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.Factory__IObfuscatedCode) obfuscatedCodeFactory: TObfuscatedCodeFactory,
         @inject(ServiceIdentifiers.ILogger) logger: ILogger,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         this.transformersRunner = transformersRunner;
-        this.sourceMapCorrector = sourceMapCorrector;
         this.randomGenerator = randomGenerator;
+        this.obfuscatedCodeFactory = obfuscatedCodeFactory;
         this.logger = logger;
         this.options = options;
     }
 
     /**
      * @param {string} sourceCode
-     * @returns {IObfuscationResult}
+     * @returns {IObfuscatedCode}
      */
-    public obfuscate (sourceCode: string): IObfuscationResult {
+    public obfuscate (sourceCode: string): IObfuscatedCode {
         const timeStart: number = Date.now();
         this.logger.info(LoggingMessage.Version, process.env.VERSION);
         this.logger.info(LoggingMessage.ObfuscationStarted);
@@ -142,7 +143,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         const obfuscationTime: number = (Date.now() - timeStart) / 1000;
         this.logger.success(LoggingMessage.ObfuscationCompleted, obfuscationTime);
 
-        return this.getObfuscationResult(generatorOutput);
+        return this.getObfuscatedCode(generatorOutput);
     }
 
     /**
@@ -215,13 +216,10 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
 
     /**
      * @param {IGeneratorOutput} generatorOutput
-     * @returns {IObfuscationResult}
+     * @returns {IObfuscatedCode}
      */
-    private getObfuscationResult (generatorOutput: IGeneratorOutput): IObfuscationResult {
-        return this.sourceMapCorrector.correct(
-            generatorOutput.code,
-            generatorOutput.map
-        );
+    private getObfuscatedCode (generatorOutput: IGeneratorOutput): IObfuscatedCode {
+        return this.obfuscatedCodeFactory(generatorOutput.code, generatorOutput.map);
     }
 
     /**

src/JavaScriptObfuscatorFacade.ts

@@ -6,7 +6,7 @@ import { TInputOptions } from './types/options/TInputOptions';
 
 import { IInversifyContainerFacade } from './interfaces/container/IInversifyContainerFacade';
 import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
-import { IObfuscationResult } from './interfaces/IObfuscationResult';
+import { IObfuscatedCode } from './interfaces/source-code/IObfuscatedCode';
 
 import { InversifyContainerFacade } from './container/InversifyContainerFacade';
 
@@ -19,20 +19,20 @@ class JavaScriptObfuscatorFacade {
     /**
      * @param {string} sourceCode
      * @param {TInputOptions} inputOptions
-     * @returns {IObfuscationResult}
+     * @returns {IObfuscatedCode}
      */
-    public static obfuscate (sourceCode: string, inputOptions: TInputOptions = {}): IObfuscationResult {
+    public static obfuscate (sourceCode: string, inputOptions: TInputOptions = {}): IObfuscatedCode {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-        inversifyContainerFacade.load(sourceCode, inputOptions);
+        inversifyContainerFacade.load(sourceCode, '', inputOptions);
 
         const javaScriptObfuscator: IJavaScriptObfuscator = inversifyContainerFacade
             .get<IJavaScriptObfuscator>(ServiceIdentifiers.IJavaScriptObfuscator);
-        const obfuscationResult: IObfuscationResult = javaScriptObfuscator.obfuscate(sourceCode);
+        const obfuscatedCode: IObfuscatedCode = javaScriptObfuscator.obfuscate(sourceCode);
 
         inversifyContainerFacade.unload();
 
-        return obfuscationResult;
+        return obfuscatedCode;
     }
 }
 

src/ObfuscationResult.ts

@@ -1,50 +0,0 @@
-import { injectable } from 'inversify';
-
-import { IObfuscationResult } from './interfaces/IObfuscationResult';
-
-import { initializable } from './decorators/Initializable';
-
-@injectable()
-export class ObfuscationResult implements IObfuscationResult {
-    /**
-     * @type {string}
-     */
-    @initializable()
-    private obfuscatedCode!: string;
-
-    /**
-     * @type {string}
-     */
-    @initializable()
-    private sourceMap!: string;
-
-    /**
-     * @param {string} obfuscatedCode
-     * @param {string} sourceMap
-     */
-    public initialize (obfuscatedCode: string, sourceMap: string): void {
-        this.obfuscatedCode = obfuscatedCode;
-        this.sourceMap = sourceMap;
-    }
-
-    /**
-     * @returns {string}
-     */
-    public getObfuscatedCode (): string {
-        return this.obfuscatedCode;
-    }
-
-    /**
-     * @returns {string}
-     */
-    public getSourceMap (): string {
-        return this.sourceMap;
-    }
-
-    /**
-     * @returns {string}
-     */
-    public toString (): string {
-        return this.obfuscatedCode;
-    }
-}

src/SourceCode.ts

@@ -1,22 +0,0 @@
-import { ISourceCode } from './interfaces/ISourceCode';
-
-export class SourceCode implements ISourceCode {
-    /**
-     * @type {string}
-     */
-    private readonly sourceCode: string;
-
-    /**
-     * @param {string} sourceCode
-     */
-    constructor (sourceCode: string) {
-        this.sourceCode = sourceCode;
-    }
-
-    /**
-     * @returns {string}
-     */
-    public getSourceCode (): string {
-        return this.sourceCode;
-    }
-}

src/cli/JavaScriptObfuscatorCLI.ts

@@ -7,7 +7,7 @@ import { TSourceCodeData } from '../types/cli/TSourceCodeData';
 
 import { IFileData } from '../interfaces/cli/IFileData';
 import { IInitializable } from '../interfaces/IInitializable';
-import { IObfuscationResult } from '../interfaces/IObfuscationResult';
+import { IObfuscatedCode } from '../interfaces/source-code/IObfuscatedCode';
 
 import { initializable } from '../decorators/Initializable';
 
@@ -131,12 +131,12 @@ export class JavaScriptObfuscatorCLI implements IInitializable {
             sourceMapFileName: path.basename(outputSourceMapPath)
         };
 
-        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(sourceCode, options);
+        const obfuscatedCode: IObfuscatedCode = JavaScriptObfuscator.obfuscate(sourceCode, options);
 
-        CLIUtils.writeFile(outputCodePath, obfuscationResult.getObfuscatedCode());
+        CLIUtils.writeFile(outputCodePath, obfuscatedCode.getObfuscatedCode());
 
-        if (options.sourceMapMode === 'separate' && obfuscationResult.getSourceMap()) {
-            CLIUtils.writeFile(outputSourceMapPath, obfuscationResult.getSourceMap());
+        if (options.sourceMapMode === 'separate' && obfuscatedCode.getSourceMap()) {
+            CLIUtils.writeFile(outputSourceMapPath, obfuscatedCode.getSourceMap());
         }
     }
 

src/container/InversifyContainerFacade.ts

@@ -20,17 +20,15 @@ import { IInversifyContainerFacade } from '../interfaces/container/IInversifyCon
 import { IJavaScriptObfuscator } from '../interfaces/IJavaScriptObfsucator';
 import { ILogger } from '../interfaces/logger/ILogger';
 import { IObfuscationEventEmitter } from '../interfaces/event-emitters/IObfuscationEventEmitter';
-import { IObfuscationResult } from '../interfaces/IObfuscationResult';
-import { ISourceCode } from '../interfaces/ISourceCode';
-import { ISourceMapCorrector } from '../interfaces/source-map/ISourceMapCorrector';
+import { IObfuscatedCode } from '../interfaces/source-code/IObfuscatedCode';
+import { ISourceCode } from '../interfaces/source-code/ISourceCode';
 import { ITransformersRunner } from '../interfaces/node-transformers/ITransformersRunner';
 
 import { JavaScriptObfuscator } from '../JavaScriptObfuscator';
 import { Logger } from '../logger/Logger';
 import { ObfuscationEventEmitter } from '../event-emitters/ObfuscationEventEmitter';
-import { ObfuscationResult } from '../ObfuscationResult';
-import { SourceCode } from '../SourceCode';
-import { SourceMapCorrector } from '../source-map/SourceMapCorrector';
+import { ObfuscatedCode } from '../source-code/ObfuscatedCode';
+import { SourceCode } from '../source-code/SourceCode';
 import { TransformersRunner } from '../node-transformers/TransformersRunner';
 
 export class InversifyContainerFacade implements IInversifyContainerFacade {
@@ -140,12 +138,13 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
 
     /**
      * @param {string} sourceCode
+     * @param {string} sourceMap
      * @param {TInputOptions} options
      */
-    public load (sourceCode: string, options: TInputOptions): void {
+    public load (sourceCode: string, sourceMap: string, options: TInputOptions): void {
         this.container
             .bind<ISourceCode>(ServiceIdentifiers.ISourceCode)
-            .toDynamicValue(() => new SourceCode(sourceCode))
+            .toDynamicValue(() => new SourceCode(sourceCode, sourceMap))
             .inSingletonScope();
 
         this.container
@@ -169,28 +168,22 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
             .inSingletonScope();
 
         this.container
-            .bind<IObfuscationResult>(ServiceIdentifiers.IObfuscationResult)
-            .to(ObfuscationResult)
-            .inSingletonScope();
+            .bind<IObfuscatedCode>(ServiceIdentifiers.IObfuscatedCode)
+            .to(ObfuscatedCode);
 
         this.container
-            .bind<IObfuscationResult>(ServiceIdentifiers.Factory__IObfuscationResult)
-            .toFactory<IObfuscationResult>((context: interfaces.Context) => {
-                return (obfuscatedCode: string, sourceMap: string) => {
-                    const obfuscationResult: IObfuscationResult = context.container
-                        .get<IObfuscationResult>(ServiceIdentifiers.IObfuscationResult);
+            .bind<IObfuscatedCode>(ServiceIdentifiers.Factory__IObfuscatedCode)
+            .toFactory<IObfuscatedCode>((context: interfaces.Context) => {
+                return (obfuscatedCodeAsString: string, sourceMapAsString: string) => {
+                    const obfuscatedCode: IObfuscatedCode = context.container
+                        .get<IObfuscatedCode>(ServiceIdentifiers.IObfuscatedCode);
 
-                    obfuscationResult.initialize(obfuscatedCode, sourceMap);
+                    obfuscatedCode.initialize(obfuscatedCodeAsString, sourceMapAsString);
 
-                    return obfuscationResult;
+                    return obfuscatedCode;
                 };
             });
 
-        this.container
-            .bind<ISourceMapCorrector>(ServiceIdentifiers.ISourceMapCorrector)
-            .to(SourceMapCorrector)
-            .inSingletonScope();
-
         this.container
             .bind<IObfuscationEventEmitter>(ServiceIdentifiers.IObfuscationEventEmitter)
             .to(ObfuscationEventEmitter)

src/container/ServiceIdentifiers.ts

@@ -9,7 +9,7 @@ export enum ServiceIdentifiers {
     Factory__IIdentifierObfuscatingReplacer = 'Factory<IIdentifierObfuscatingReplacer>',
     Factory__INodeGuard = 'Factory<INodeGuard>',
     Factory__INodeTransformer = 'Factory<INodeTransformer[]>',
-    Factory__IObfuscationResult = 'Factory<IObfuscationResult>',
+    Factory__IObfuscatedCode = 'Factory<IObfuscatedCode>',
     Factory__IObfuscatingReplacer = 'Factory<IObfuscatingReplacer>',
     Factory__IPropertiesExtractor = 'Factory<IPropertiesExtractor>',
     Factory__TControlFlowStorage = 'Factory<TControlFlowStorage>',
@@ -27,7 +27,7 @@ export enum ServiceIdentifiers {
     INodeGuard = 'INodeGuard',
     INodeTransformer = 'INodeTransformer',
     IObfuscationEventEmitter = 'IObfuscationEventEmitter',
-    IObfuscationResult = 'IObfuscationResult',
+    IObfuscatedCode = 'IObfuscatedCode',
     IOptions = 'IOptions',
     IOptionsNormalizer = 'IOptionsNormalizer',
     IObfuscatingReplacer = 'IObfuscatingReplacer',

src/interfaces/IJavaScriptObfsucator.d.ts

@@ -1,9 +1,9 @@
-import { IObfuscationResult } from './IObfuscationResult';
+import { IObfuscatedCode } from './source-code/IObfuscatedCode';
 
 export interface IJavaScriptObfuscator {
     /**
      * @param sourceCode
-     * @returns IObfuscationResult
+     * @returns IObfuscatedCode
      */
-    obfuscate (sourceCode: string): IObfuscationResult;
+    obfuscate (sourceCode: string): IObfuscatedCode;
 }

src/interfaces/container/IInversifyContainerFacade.d.ts

@@ -15,10 +15,11 @@ export interface IInversifyContainerFacade {
     getNamed <T> (serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
 
     /**
-     * @param sourceCode
-     * @param options
+     * @param {string} sourceCode
+     * @param {string} sourceMap
+     * @param {TInputOptions} options
      */
-    load (sourceCode: string, options: TInputOptions): void;
+    load (sourceCode: string, sourceMap: string, options: TInputOptions): void;
 
     unload (): void;
 }

src/interfaces/IObfuscationResult.d.ts → src/interfaces/source-code/IObfuscatedCode.d.ts

@@ -1,6 +1,6 @@
-import { IInitializable } from './IInitializable';
+import { IInitializable } from '../IInitializable';
 
-export interface IObfuscationResult extends IInitializable {
+export interface IObfuscatedCode extends IInitializable {
     /**
      * @return {string}
      */

src/interfaces/ISourceCode.d.ts → src/interfaces/source-code/ISourceCode.d.ts

@@ -3,4 +3,9 @@ export interface ISourceCode {
      * @returns string
      */
     getSourceCode (): string;
+
+    /**
+     * @returns string
+     */
+    getSourceMap (): string;
 }

src/interfaces/source-map/ISourceMapCorrector.d.ts

@@ -1,10 +0,0 @@
-import { IObfuscationResult } from '../IObfuscationResult';
-
-export interface ISourceMapCorrector {
-    /**
-     * @param {string} obfuscatedCode
-     * @param {string} sourceMap
-     * @returns {IObfuscationResult}
-     */
-    correct (obfuscatedCode: string, sourceMap: string): IObfuscationResult;
-}

src/source-map/SourceMapCorrector.ts → src/source-code/ObfuscatedCode.ts

@@ -1,26 +1,25 @@
 import { inject, injectable } from 'inversify';
 import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
 
-import { TObfuscationResultFactory } from '../types/container/TObfuscationResultFactory';
-
 import { ICryptUtils } from '../interfaces/utils/ICryptUtils';
-import { IObfuscationResult } from '../interfaces/IObfuscationResult';
-import { IOptions } from '../interfaces/options/IOptions';
-import { ISourceMapCorrector } from '../interfaces/source-map/ISourceMapCorrector';
+import { IObfuscatedCode } from '../interfaces/source-code/IObfuscatedCode';
 
+import { initializable } from '../decorators/Initializable';
 import { SourceMapMode } from '../enums/source-map/SourceMapMode';
+import { IOptions } from '../interfaces/options/IOptions';
 
 @injectable()
-export class SourceMapCorrector implements ISourceMapCorrector {
+export class ObfuscatedCode implements IObfuscatedCode {
     /**
      * @type {ICryptUtils}
      */
     private readonly cryptUtils: ICryptUtils;
 
     /**
-     * @type {TObfuscationResultFactory}
+     * @type {string}
      */
-    private readonly obfuscationResultFactory: TObfuscationResultFactory;
+    @initializable()
+    private obfuscatedCode!: string;
 
     /**
      * @type {IOptions}
@@ -28,16 +27,15 @@ export class SourceMapCorrector implements ISourceMapCorrector {
     private readonly options: IOptions;
 
     /**
-     * @param {TObfuscationResultFactory} obfuscationResultFactory
-     * @param {ICryptUtils} cryptUtils
-     * @param {IOptions} options
+     * @type {string}
      */
+    @initializable()
+    private sourceMap!: string;
+
     constructor (
-        @inject(ServiceIdentifiers.Factory__IObfuscationResult) obfuscationResultFactory: TObfuscationResultFactory,
         @inject(ServiceIdentifiers.ICryptUtils) cryptUtils: ICryptUtils,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
-        this.obfuscationResultFactory = obfuscationResultFactory;
         this.cryptUtils = cryptUtils;
         this.options = options;
     }
@@ -45,23 +43,39 @@ export class SourceMapCorrector implements ISourceMapCorrector {
     /**
      * @param {string} obfuscatedCode
      * @param {string} sourceMap
-     * @returns {IObfuscationResult}
      */
-    public correct (obfuscatedCode: string, sourceMap: string): IObfuscationResult {
-        return this.obfuscationResultFactory(
-            this.correctObfuscatedCode(obfuscatedCode, sourceMap),
-            sourceMap
-        );
+    public initialize (obfuscatedCode: string, sourceMap: string): void {
+        this.obfuscatedCode = obfuscatedCode;
+        this.sourceMap = sourceMap;
+    }
+
+    /**
+     * @returns {string}
+     */
+    public getObfuscatedCode (): string {
+        return this.correctObfuscatedCode();
+    }
+
+    /**
+     * @returns {string}
+     */
+    public getSourceMap (): string {
+        return this.sourceMap;
+    }
+
+    /**
+     * @returns {string}
+     */
+    public toString (): string {
+        return this.obfuscatedCode;
     }
 
     /**
-     * @param {string} obfuscatedCode
-     * @param {string} sourceMap
      * @returns {string}
      */
-    private correctObfuscatedCode (obfuscatedCode: string, sourceMap: string): string {
-        if (!sourceMap) {
-            return obfuscatedCode;
+    private correctObfuscatedCode (): string {
+        if (!this.sourceMap) {
+            return this.obfuscatedCode;
         }
 
         const sourceMapUrl: string = this.options.sourceMapBaseUrl + this.options.sourceMapFileName;
@@ -70,19 +84,19 @@ export class SourceMapCorrector implements ISourceMapCorrector {
 
         switch (this.options.sourceMapMode) {
             case SourceMapMode.Inline:
-                sourceMappingUrl += `data:application/json;base64,${this.cryptUtils.btoa(sourceMap)}`;
+                sourceMappingUrl += `data:application/json;base64,${this.cryptUtils.btoa(this.sourceMap)}`;
 
                 break;
 
             case SourceMapMode.Separate:
             default:
                 if (!sourceMapUrl) {
-                    return obfuscatedCode;
+                    return this.obfuscatedCode;
                 }
 
                 sourceMappingUrl += sourceMapUrl;
         }
 
-        return `${obfuscatedCode}\n${sourceMappingUrl}`;
+        return `${this.obfuscatedCode}\n${sourceMappingUrl}`;
     }
 }

src/source-code/SourceCode.ts

@@ -0,0 +1,43 @@
+import { ISourceCode } from '../interfaces/source-code/ISourceCode';
+
+export class SourceCode implements ISourceCode {
+    /**
+     * @type {string}
+     */
+    private readonly sourceCode: string;
+
+    /**
+     * @type {string}
+     */
+    private readonly sourceMap: string;
+
+    /**
+     * @param {string} sourceCode
+     * @param {string} sourceMap
+     */
+    constructor (sourceCode: string, sourceMap: string) {
+        this.sourceCode = sourceCode;
+        this.sourceMap = sourceMap;
+    }
+
+    /**
+     * @returns {string}
+     */
+    public getSourceCode (): string {
+        return this.sourceCode;
+    }
+
+    /**
+     * @returns {string}
+     */
+    public getSourceMap (): string {
+        return this.sourceMap;
+    }
+
+    /**
+     * @returns {string}
+     */
+    public toString (): string {
+        return this.sourceCode;
+    }
+}

src/types/container/TObfuscationResultFactory.d.ts

@@ -1,3 +0,0 @@
-import { IObfuscationResult } from '../../interfaces/IObfuscationResult';
-
-export type TObfuscationResultFactory = (obfuscatedCode: string, sourceMap: string) => IObfuscationResult;

src/types/container/source-code/TObfuscatedCodeFactory.d.ts

@@ -0,0 +1,3 @@
+import { IObfuscatedCode } from '../../../interfaces/source-code/IObfuscatedCode';
+
+export type TObfuscatedCodeFactory = (obfuscatedCode: string, sourceMap: string) => IObfuscatedCode;

src/types/source-map/TSourceMapMode.d.ts

@@ -1 +0,0 @@
-export type TSourceMapMode = 'inline' | 'separate';

src/utils/RandomGenerator.ts

@@ -7,7 +7,7 @@ import { Chance } from 'chance';
 import { IInitializable } from '../interfaces/IInitializable';
 import { IOptions } from '../interfaces/options/IOptions';
 import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
-import { ISourceCode } from '../interfaces/ISourceCode';
+import { ISourceCode } from '../interfaces/source-code/ISourceCode';
 
 import { initializable } from '../decorators/Initializable';
 

test/functional-tests/analyzers/stack-trace-analyzer/StackTraceAnalyzer.spec.ts

@@ -157,7 +157,7 @@ describe('StackTraceAnalyzer', () => {
         before(() => {
             const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-            inversifyContainerFacade.load('', {});
+            inversifyContainerFacade.load('', '', {});
             stackTraceAnalyzer = inversifyContainerFacade
                 .get<IStackTraceAnalyzer>(ServiceIdentifiers.IStackTraceAnalyzer);
         });

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../helpers/readFileAsString';
@@ -18,15 +16,14 @@ describe('ConsoleOutputDisableExpressionNode', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     disableConsoleOutput: true
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('match #1: should correctly append custom node into the obfuscated code', () => {
@@ -47,15 +44,14 @@ describe('ConsoleOutputDisableExpressionNode', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     disableConsoleOutput: false
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('match #1: shouldn\'t append custom node into the obfuscated code', () => {

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../helpers/readFileAsString';
@@ -16,15 +14,14 @@ describe('DomainLockNode', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     domainLock: ['.example.com']
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should correctly append custom node into the obfuscated code', () => {
@@ -37,15 +34,14 @@ describe('DomainLockNode', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     domainLock: []
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t append custom node into the obfuscated code', () => {

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../helpers/readFileAsString';
@@ -17,16 +15,14 @@ describe('StringArrayCallsWrapper', () => {
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
 
-            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should correctly append custom node into the obfuscated code', () => {
@@ -40,15 +36,13 @@ describe('StringArrayCallsWrapper', () => {
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
 
-            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: false
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t append custom node into the obfuscated code', () => {

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../helpers/readFileAsString';
@@ -17,16 +15,14 @@ describe('StringArrayNode', () => {
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
 
-            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should correctly append custom node into the obfuscated code', () => {
@@ -40,15 +36,13 @@ describe('StringArrayNode', () => {
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
 
-            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: false
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t append custom node into the obfuscated code', () => {

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../helpers/readFileAsString';
@@ -17,7 +15,7 @@ describe('StringArrayRotateFunctionNode', () => {
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
 
-            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
@@ -25,9 +23,7 @@ describe('StringArrayRotateFunctionNode', () => {
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should correctly append custom node into the obfuscated code', () => {
@@ -41,7 +37,7 @@ describe('StringArrayRotateFunctionNode', () => {
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
 
-            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
@@ -49,9 +45,7 @@ describe('StringArrayRotateFunctionNode', () => {
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t append custom node into the obfuscated code', () => {

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

@@ -1,6 +1,6 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../src/interfaces/IObfuscationResult';
+import { IObfuscatedCode } from '../../../src/interfaces/source-code/IobfuscatedCode';
 
 import { SourceMapMode } from '../../../src/enums/source-map/SourceMapMode';
 import { StringArrayEncoding } from '../../../src/enums/StringArrayEncoding';
@@ -23,15 +23,15 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                const obfuscatedCodeObject: IObfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
                 );
 
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
-                sourceMap = obfuscationResult.getSourceMap();
+                obfuscatedCode = obfuscatedCodeObject.getObfuscatedCode();
+                sourceMap = obfuscatedCodeObject.getSourceMap();
             });
 
             it('should return correct obfuscated code', () => {
@@ -48,11 +48,10 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/empty-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                    code,
-                );
 
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                ).getObfuscatedCode();
             });
 
             it('should return an empty obfuscated code', () => {
@@ -65,15 +64,14 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/comments-only.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         controlFlowFlattening: true,
                         deadCodeInjection: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should return an empty obfuscated code', () => {
@@ -88,7 +86,7 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    const obfuscatedCodeObject: IObfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -96,8 +94,8 @@ describe('JavaScriptObfuscator', () => {
                         }
                     );
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
-                    sourceMap = JSON.parse(obfuscationResult.getSourceMap()).mappings;
+                    obfuscatedCode = obfuscatedCodeObject.getObfuscatedCode();
+                    sourceMap = JSON.parse(obfuscatedCodeObject.getSourceMap()).mappings;
                 });
 
                 it('should return correct obfuscated code', () => {
@@ -117,7 +115,7 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    const obfuscatedCodeObject: IObfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -126,8 +124,8 @@ describe('JavaScriptObfuscator', () => {
                         }
                     );
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
-                    sourceMap = JSON.parse(obfuscationResult.getSourceMap()).mappings;
+                    obfuscatedCode = obfuscatedCodeObject.getObfuscatedCode();
+                    sourceMap = JSON.parse(obfuscatedCodeObject.getSourceMap()).mappings;
                 });
 
                 it('should return correct obfuscated code', () => {
@@ -151,16 +149,16 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/empty-input.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    const obfuscatedCodeObject: IObfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             sourceMap: true
                         }
                     );
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    obfuscatedCode = obfuscatedCodeObject.getObfuscatedCode();
 
-                    const sourceMapObject: any = JSON.parse(obfuscationResult.getSourceMap());
+                    const sourceMapObject: any = JSON.parse(obfuscatedCodeObject.getSourceMap());
 
                     sourceMapNames = sourceMapObject.names;
                     sourceMapSources = sourceMapObject.sources;
@@ -193,14 +191,13 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should return correct obfuscated code', () => {
@@ -215,15 +212,14 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             renameGlobals: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should return correct obfuscated code', () => {
@@ -238,16 +234,15 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             renameGlobals: true,
                             identifiersPrefix: 'foo'
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should return correct obfuscated code', () => {
@@ -263,7 +258,8 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -272,9 +268,7 @@ describe('JavaScriptObfuscator', () => {
                             stringArray: true,
                             stringArrayThreshold: 1
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('match #1: should return correct obfuscated code', () => {
@@ -294,14 +288,13 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/block-scope.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should return correct obfuscated code', () => {
@@ -320,16 +313,15 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/identifiers-prefix.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             renameGlobals: true,
                             identifiersPrefix: 'foo'
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('match #1: should return correct obfuscated code', () => {
@@ -358,16 +350,15 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should return correct obfuscated code', () => {
@@ -387,16 +378,15 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input-cyrillic.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should return correct obfuscated code', () => {
@@ -426,21 +416,18 @@ describe('JavaScriptObfuscator', () => {
                             seed++;
                         }
 
-                        const obfuscationResult1: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        obfuscatedCode1 = JavaScriptObfuscator.obfuscate(
                             code,
                             {
                                 seed: seed
                             }
-                        );
-                        const obfuscationResult2: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        ).getObfuscatedCode();
+                        obfuscatedCode2 = JavaScriptObfuscator.obfuscate(
                             code,
                             {
                                 seed: seed
                             }
-                        );
-
-                        obfuscatedCode1 = obfuscationResult1.getObfuscatedCode();
-                        obfuscatedCode2 = obfuscationResult2.getObfuscatedCode();
+                        ).getObfuscatedCode();
 
                         if (obfuscatedCode1 === obfuscatedCode2) {
                             equalsCount++;
@@ -460,21 +447,18 @@ describe('JavaScriptObfuscator', () => {
                     obfuscatedCode2: string;
 
                 beforeEach(() => {
-                    const obfuscationResult1: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    obfuscatedCode1 = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             seed: 12345
                         }
-                    );
-                    const obfuscationResult2: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    ).getObfuscatedCode();
+                    obfuscatedCode2 = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             seed: 12346
                         }
-                    );
-
-                    obfuscatedCode1 = obfuscationResult1.getObfuscatedCode();
-                    obfuscatedCode2 = obfuscationResult2.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should return different obfuscated code with different `seed` option value', () => {
@@ -489,21 +473,18 @@ describe('JavaScriptObfuscator', () => {
                     obfuscatedCode2: string;
 
                 beforeEach(() => {
-                    const obfuscationResult1: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    obfuscatedCode1 = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             seed: 0
                         }
-                    );
-                    const obfuscationResult2: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    ).getObfuscatedCode();
+                    obfuscatedCode2 = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             seed: 0
                         }
-                    );
-
-                    obfuscatedCode1 = obfuscationResult1.getObfuscatedCode();
-                    obfuscatedCode2 = obfuscationResult2.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should return different obfuscated code with different `seed` option value', () => {
@@ -521,23 +502,20 @@ describe('JavaScriptObfuscator', () => {
                     match2: string;
 
                 beforeEach(() => {
-                    const obfuscationResult1: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    const obfuscatedCode1: string = JavaScriptObfuscator.obfuscate(
                         code1,
                         {
                             seed: 123,
                             stringArrayThreshold: 1
                         }
-                    );
-                    const obfuscationResult2: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    ).getObfuscatedCode();
+                    const obfuscatedCode2: string = JavaScriptObfuscator.obfuscate(
                         code2,
                         {
                             seed: 123,
                             stringArrayThreshold: 1
                         }
-                    );
-
-                    const obfuscatedCode1: string = obfuscationResult1.getObfuscatedCode();
-                    const obfuscatedCode2: string = obfuscationResult2.getObfuscatedCode();
+                    ).getObfuscatedCode();
 
                     match1 = getRegExpMatch(obfuscatedCode1, regExp);
                     match2 = getRegExpMatch(obfuscatedCode2, regExp);
@@ -556,14 +534,13 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/new-target.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should keep new.target MetaProperty', () => {
@@ -578,14 +555,13 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/mangle.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should mangle obfuscated code', () => {
@@ -602,9 +578,8 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/parse-module-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(code);
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(code).getObfuscatedCode();
                 });
 
                 it('Match #!: should correctly obfuscate a import', () => {
@@ -623,9 +598,8 @@ describe('JavaScriptObfuscator', () => {
 
                 beforeEach(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/parse-module-2.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(code);
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(code).getObfuscatedCode();
                 });
 
                 it('should correctly obfuscate a module', () => {
@@ -643,7 +617,8 @@ describe('JavaScriptObfuscator', () => {
 
             beforeEach(() => {
                 const code: string = buildLargeCode(expectedValue);
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         compact: true,
@@ -659,9 +634,8 @@ describe('JavaScriptObfuscator', () => {
                         transformObjectKeys: true,
                         unicodeEscapeSequence: false
                     }
-                );
+                ).getObfuscatedCode();
 
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
                 result = eval(obfuscatedCode);
             });
 

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
@@ -26,16 +24,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             describe('`console.log` statements', ()=> {
@@ -114,7 +111,8 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -122,9 +120,7 @@ describe('BlockStatementControlFlowTransformer', function () {
                         controlFlowFlatteningThreshold: 1,
                         unicodeEscapeSequence: false
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             describe('`console.log` statements', ()=> {
@@ -205,16 +201,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/one-statement.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -229,16 +224,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/const-declaration.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -253,16 +247,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/let-declaration.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -277,16 +270,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/break-statement-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -301,16 +293,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/break-statement-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -328,16 +319,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/break-statement-inside-while-statement.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 switchCaseLength = obfuscatedCode.match(switchCaseLengthRegExp)!.length;
             });
 
@@ -357,16 +347,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/continue-statement-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -381,16 +370,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/continue-statement-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -408,16 +396,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/continue-statement-inside-while-statement.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 switchCaseLength = obfuscatedCode.match(switchCaseLengthRegExp)!.length;
             });
 
@@ -437,16 +424,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/function-declaration.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -461,16 +447,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/class-declaration.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform block statement', () => {
@@ -492,21 +477,20 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code.repeat(samples),
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: controlFlowFlatteningThreshold,
                     }
-                );
+                ).getObfuscatedCode();
 
-                const transformedStatementMatchesLength: number = obfuscationResult
-                    .getObfuscatedCode()
+                const transformedStatementMatchesLength: number = obfuscatedCode
                     .match(regExp1)!
                     .length;
-                const untouchedStatementMatchesLength: number = obfuscationResult
-                    .getObfuscatedCode()
+                const untouchedStatementMatchesLength: number = obfuscatedCode
                     .match(regExp2)!
                     .length;
 
@@ -534,16 +518,15 @@ describe('BlockStatementControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/no-unreachable-code-warning.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 switchCaseLength = obfuscatedCode.match(switchCaseLengthRegExp)!.length;
             });
 

test/functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/binary-expression-control-flow-replacer/BinaryExpressionControlFlowReplacer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../../helpers/readFileAsString';
@@ -19,16 +17,15 @@ describe('BinaryExpressionControlFlowReplacer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace binary expression node with call to control flow storage node', () => {
@@ -52,8 +49,7 @@ describe('BinaryExpressionControlFlowReplacer', function () {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-2.js');
 
-                let obfuscationResult: IObfuscationResult,
-                    obfuscatedCode: string,
+                let obfuscatedCode: string,
                     firstMatchArray: RegExpMatchArray | null,
                     secondMatchArray: RegExpMatchArray | null,
                     firstMatch: string | undefined,
@@ -61,16 +57,14 @@ describe('BinaryExpressionControlFlowReplacer', function () {
                     equalsValue: number = 0;
 
                 for (let i = 0; i < samplesCount; i++) {
-                    obfuscationResult = JavaScriptObfuscator.obfuscate(
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             controlFlowFlattening: true,
                             controlFlowFlatteningThreshold: 1
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
 
                     firstMatchArray = obfuscatedCode.match(controlFlowStorageCallRegExp1);
                     secondMatchArray = obfuscatedCode.match(controlFlowStorageCallRegExp2);

test/functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/call-expression-control-flow-replacer/CallExpressionControlFlowReplacer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../../helpers/readFileAsString';
@@ -19,16 +17,15 @@ describe('CallExpressionControlFlowReplacer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace call expression node with call to control flow storage node', () => {
@@ -52,8 +49,7 @@ describe('CallExpressionControlFlowReplacer', function () {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-2.js');
 
-                let obfuscationResult: IObfuscationResult,
-                    obfuscatedCode: string,
+                let obfuscatedCode: string,
                     firstMatchArray: RegExpMatchArray | null,
                     secondMatchArray: RegExpMatchArray | null,
                     firstMatch: string | undefined,
@@ -61,16 +57,14 @@ describe('CallExpressionControlFlowReplacer', function () {
                     equalsValue: number = 0;
 
                 for (let i = 0; i < samplesCount; i++) {
-                    obfuscationResult = JavaScriptObfuscator.obfuscate(
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             controlFlowFlattening: true,
                             controlFlowFlatteningThreshold: 1
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
 
                     firstMatchArray = obfuscatedCode.match(controlFlowStorageCallRegExp1);
                     secondMatchArray = obfuscatedCode.match(controlFlowStorageCallRegExp2);
@@ -108,16 +102,15 @@ describe('CallExpressionControlFlowReplacer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-3.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t replace call expression node with call to control flow storage node', () => {

test/functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/logical-expression-control-flow-replacer/LogicalExpressionControlFlowReplacer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../../helpers/readFileAsString';
@@ -19,16 +17,15 @@ describe('LogicalExpressionControlFlowReplacer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace logical expression node with call to control flow storage node', () => {
@@ -52,8 +49,7 @@ describe('LogicalExpressionControlFlowReplacer', function () {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-2.js');
 
-                let obfuscationResult: IObfuscationResult,
-                    obfuscatedCode: string,
+                let obfuscatedCode: string,
                     firstMatchArray: RegExpMatchArray | null,
                     secondMatchArray: RegExpMatchArray | null,
                     firstMatch: string | undefined,
@@ -61,16 +57,14 @@ describe('LogicalExpressionControlFlowReplacer', function () {
                     equalsValue: number = 0;
 
                 for (let i = 0; i < samplesCount; i++) {
-                    obfuscationResult = JavaScriptObfuscator.obfuscate(
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             controlFlowFlattening: true,
                             controlFlowFlatteningThreshold: 1
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
 
                     firstMatchArray = obfuscatedCode.match(controlFlowStorageCallRegExp1);
                     secondMatchArray = obfuscatedCode.match(controlFlowStorageCallRegExp2);
@@ -108,16 +102,15 @@ describe('LogicalExpressionControlFlowReplacer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-3.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace logical unary expression with call to control flow storage node', () => {
@@ -132,16 +125,15 @@ describe('LogicalExpressionControlFlowReplacer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/prohibited-nodes.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: .1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t replace prohibited expression nodes', () => {

test/functional-tests/node-transformers/control-flow-transformers/control-flow-replacers/string-litertal-control-flow-replacer/StringLiteralControlFlowReplacer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../../helpers/readFileAsString';
@@ -17,16 +15,15 @@ describe('StringLiteralControlFlowReplacer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     controlFlowFlattening: true,
                     controlFlowFlatteningThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should add string literal node as property of control flow storage node', () => {

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -35,16 +33,15 @@ describe('FunctionControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should add `control flow storage` node to the obfuscated code', () => {
@@ -72,20 +69,18 @@ describe('FunctionControlFlowTransformer', function () {
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-2.js');
 
-                let obfuscationResult: IObfuscationResult,
-                    obfuscatedCode: string,
+                let obfuscatedCode: string,
                     totalValue: number = 0;
 
                 for (let i = 0; i < samplesCount; i++) {
-                    obfuscationResult = JavaScriptObfuscator.obfuscate(
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             controlFlowFlattening: true,
                             controlFlowFlatteningThreshold: 1
                         }
-                    );
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
 
                     if (regExp1.test(obfuscatedCode)) {
                         totalValue += obfuscatedCode.match(regExp1)!.length;
@@ -120,16 +115,15 @@ describe('FunctionControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/multiple-items.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should add `control flow storage` node with multiple items to the obfuscated code', () => {
@@ -144,16 +138,15 @@ describe('FunctionControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/root-block-scope-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should\'t add control flow storage node', () => {
@@ -179,15 +172,15 @@ describe('FunctionControlFlowTransformer', function () {
 
             before(() => {
                 for (let i = 0; i < samplesCount; i++) {
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             controlFlowFlattening: true,
                             controlFlowFlatteningThreshold: 1
                         }
-                    );
-                    const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
 
                     if (regExp.test(obfuscatedCode)) {
                         totalValue++;
@@ -208,16 +201,15 @@ describe('FunctionControlFlowTransformer', function () {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/zero-threshold.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 0
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t add call to control flow storage node to the obfuscated code', () => {
@@ -237,16 +229,15 @@ describe('FunctionControlFlowTransformer', function () {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/arrow-function-expression-with-body.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             controlFlowFlattening: true,
                             controlFlowFlatteningThreshold: 1
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should add `control flow storage` node to the obfuscated code', () => {
@@ -261,16 +252,15 @@ describe('FunctionControlFlowTransformer', function () {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/arrow-function-expression-without-body.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             controlFlowFlattening: true,
                             controlFlowFlatteningThreshold: 1
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('shouldn\'t add `control flow storage` node to the obfuscated code', () => {

test/functional-tests/node-transformers/converting-transformers/member-expression-transformer/MemberExpressionTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -17,14 +15,13 @@ describe('MemberExpressionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/dot-notation-call.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace member expression dot notation call with literal value', () => {
@@ -40,16 +37,15 @@ describe('MemberExpressionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/dot-notation-call.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should add member expression identifier to string array', () => {
@@ -71,16 +67,15 @@ describe('MemberExpressionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/square-brackets-call.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should add member expression square brackets literal to string array', () => {
@@ -99,14 +94,13 @@ describe('MemberExpressionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/square-brackets-with-identifier-call.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should ignore square brackets call with identifier value', () => {

test/functional-tests/node-transformers/converting-transformers/method-definition-transformer/MethodDefinitionTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -16,14 +14,13 @@ describe('MethodDefinitionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/sample-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should replace method definition node `key` property with square brackets literal', () => {
@@ -39,16 +36,15 @@ describe('MethodDefinitionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/sample-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should add method definition node `key` property to string array', () => {
@@ -67,14 +63,13 @@ describe('MethodDefinitionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/sample-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t transform method definition node with `constructor` key', () => {
@@ -90,14 +85,13 @@ describe('MethodDefinitionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/async-get-method.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should rename class declaration name', () => {

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/ObjectExpressionKeysTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -24,15 +22,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -54,15 +51,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/nested-objects-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -87,15 +83,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/nested-objects-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -117,7 +112,8 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/integration-with-control-flow-flattening.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -125,9 +121,7 @@ describe('ObjectExpressionKeysTransformer', () => {
                         controlFlowFlatteningThreshold: 1,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -148,15 +142,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/variable-declaration-without-initialization.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform object keys', () => {
@@ -178,15 +171,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/member-expression-host-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -206,15 +198,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/member-expression-host-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -237,15 +228,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/placement-inside-if-statement.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -267,15 +257,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/placement-inside-try-statement.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -297,15 +286,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/placement-inside-catch-clause.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly transform object keys', () => {
@@ -327,15 +315,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/placement-inside-switch-case.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         transformObjectKeys: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should transform object keys', () => {
@@ -356,15 +343,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/variable-declarator-with-object-call-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             transformObjectKeys: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should correctly transform object keys', () => {
@@ -385,15 +371,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/variable-declarator-with-object-call-2.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             transformObjectKeys: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should correctly transform object keys', () => {
@@ -414,15 +399,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/variable-declarator-with-object-call-3.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             transformObjectKeys: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should correctly transform first object keys and ignore second object keys', () => {
@@ -446,14 +430,13 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform object keys', () => {
@@ -469,14 +452,13 @@ describe('ObjectExpressionKeysTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/empty-object-expression.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform object keys', () => {
@@ -496,15 +478,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/variable-declarator-with-object-call-ignore-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             transformObjectKeys: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('shouldn\'t transform object keys', () => {
@@ -523,15 +504,14 @@ describe('ObjectExpressionKeysTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/variable-declarator-with-object-call-ignore-2.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             transformObjectKeys: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('shouldn\'t transform object keys', () => {

test/functional-tests/node-transformers/converting-transformers/object-expression-transformer/ObjectExpressionTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -17,15 +15,14 @@ describe('ObjectExpressionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/property-with-identifier-value.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         unicodeEscapeSequence: false
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace object expression node `key` property with identifier value by property with literal value', () => {
@@ -40,15 +37,14 @@ describe('ObjectExpressionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/property-with-identifier-value.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         unicodeEscapeSequence: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace object expression node `key` property with identifier value by property with encoded literal value', () => {
@@ -64,14 +60,13 @@ describe('ObjectExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/shorthand-object-expression.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should correct convert shorthand ES6 object expression to non-shorthand object expression', () => {
@@ -87,14 +82,13 @@ describe('ObjectExpressionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/computed-property-name-identifier.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should ignore computed property identifier', () => {
@@ -110,15 +104,14 @@ describe('ObjectExpressionTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/computed-property-name-literal.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             unicodeEscapeSequence: false
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should ignore computed property literal value', () => {
@@ -133,15 +126,14 @@ describe('ObjectExpressionTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/computed-property-name-literal.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             unicodeEscapeSequence: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('should encode computed property literal value', () => {
@@ -159,14 +151,13 @@ describe('ObjectExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/object-rest.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform object name', () => {
@@ -187,14 +178,13 @@ describe('ObjectExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/object-spread.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform object name', () => {

test/functional-tests/node-transformers/converting-transformers/template-literal-transformer/TemplateLiteralTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -9,131 +7,142 @@ import { readFileAsString } from '../../../../helpers/readFileAsString';
 import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
 
 describe('TemplateLiteralTransformer', () => {
+    let obfuscatedCode: string;
+    
     describe('Variant #1: simple template literal', () => {
         it('should transform es6 template literal to es5', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /^var *test *= *'abc\\x20' *\+ *foo;$/);
+            assert.match(obfuscatedCode,  /^var *test *= *'abc\\x20' *\+ *foo;$/);
         });
     });
 
     describe('Variant #2: multiline template literals', () => {
         it('Variant #1: should transform es6 multiline template literal to es5', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/multiline-template-literal.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /^var *test *= *'foo\\x0abar';$/);
+            assert.match(obfuscatedCode,  /^var *test *= *'foo\\x0abar';$/);
         });
 
         it('Variant #2: should transform es6 multiline template literal inside return statement', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/multiline-template-literal-return-statement-1.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /{ *return *'foo\\x0abar'; *}$/);
+            assert.match(obfuscatedCode,  /{ *return *'foo\\x0abar'; *}$/);
         });
 
         it('Variant #3: should transform es6 multiline template literal inside return statement', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/multiline-template-literal-return-statement-2.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /case *!!\[] *: *return *'foo\\x0abar'; *} *}$/);
+            assert.match(obfuscatedCode,  /case *!!\[] *: *return *'foo\\x0abar'; *} *}$/);
         });
 
         it('Variant #4: should transform es6 multiline template literal inside binary expression inside return statement', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/multiline-template-literal-binary-expression-return-statement-1.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /{ *return *'foo\\x0abar' *\+ *0x1; *}$/);
+            assert.match(obfuscatedCode,  /{ *return *'foo\\x0abar' *\+ *0x1; *}$/);
         });
 
         it('Variant #5: should transform es6 multiline template literal inside binary expression inside return statement', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/multiline-template-literal-binary-expression-return-statement-2.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /case *!!\[] *: *return *'foo\\x0abar' *\+ *0x1; *} *}$/);
+            assert.match(obfuscatedCode,  /case *!!\[] *: *return *'foo\\x0abar' *\+ *0x1; *} *}$/);
         });
     });
 
     describe('Variant #3: simple template literal with expression only', () => {
         it('should transform es6 template literal to es5 and add empty literal node before expression node', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/expression-only.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /^var *test *= *'' *\+ *foo;$/);
+            assert.match(obfuscatedCode,  /^var *test *= *'' *\+ *foo;$/);
         });
     });
 
     describe('Variant #4: literal node inside expression', () => {
         it('should transform es6 template literal to es5', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/literal-inside-expression.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /^var *test *= *'abc';$/);
+            assert.match(obfuscatedCode,  /^var *test *= *'abc';$/);
         });
     });
 
     describe('Variant #5: multiple expressions', () => {
         it('should transform es6 template literal to es5', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/multiple-expressions.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
             assert.match(
-                obfuscationResult.getObfuscatedCode(),
+                obfuscatedCode,
                 /^var *test *= *0x1 *\+ *0x1 *\+ *'\\x20abc\\x20' *\+ *\(0x1 *\+ *0x1\);$/
             );
         });
@@ -142,16 +151,17 @@ describe('TemplateLiteralTransformer', () => {
     describe('Variant #6: tagged template literal', () => {
         it('shouldn\'t transform es6 tagged template literal to es5', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/tagged-template-literal.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
             assert.match(
-                obfuscationResult.getObfuscatedCode(),
+                obfuscatedCode,
                 /tag`foo *\${0x1 *\+ *0x1} *bar`;/
             );
         });
@@ -160,15 +170,16 @@ describe('TemplateLiteralTransformer', () => {
     describe('Variant #7: template literal parentize', () => {
         it('should parentize transformed template literal node', () => {
             const code: string = readFileAsString(__dirname + '/fixtures/template-literal-parentize.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     unicodeEscapeSequence: false
                 }
-            );
+            ).getObfuscatedCode();
 
-            assert.match(obfuscationResult.getObfuscatedCode(),  /^\[]\['map']\(\(\) *=> *'foo'\);$/);
+            assert.match(obfuscatedCode,  /^\[]\['map']\(\(\) *=> *'foo'\);$/);
         });
     });
 });

test/functional-tests/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
 
 import { IdentifierNamesGenerator } from '../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
@@ -33,7 +31,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -42,8 +41,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 const matches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(regExp);
 
                 if (matches) {
@@ -69,7 +67,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/block-statements-min-count.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -78,8 +77,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 const matches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(regexp);
 
                 if (matches) {
@@ -105,7 +103,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -114,8 +113,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 const matches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(regexp);
 
                 if (matches) {
@@ -149,7 +147,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/break-continue-statement.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -158,8 +157,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 const functionMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(functionRegExp);
                 const loopMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(loopRegExp);
 
@@ -200,7 +198,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/await-expression.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -209,8 +208,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 const functionMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(functionRegExp);
                 const awaitExpressionMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(awaitExpressionRegExp);
 
@@ -251,7 +249,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/super-expression.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -260,8 +259,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 const functionMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(functionRegExp);
                 const superExpressionMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(superExpressionRegExp);
 
@@ -339,7 +337,8 @@ describe('DeadCodeInjectionTransformer', () => {
                 let count4: number = 0;
 
                 for (let i = 0; i < samplesCount; i++) {
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -348,8 +347,7 @@ describe('DeadCodeInjectionTransformer', () => {
                             stringArray: true,
                             stringArrayThreshold: 1
                         }
-                    );
-                    const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
 
                     if (regExp1.test(obfuscatedCode)) {
                         count1++;
@@ -396,7 +394,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/block-scope-is-program-node.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -405,9 +404,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         deadCodeInjection: true,
                         deadCodeInjectionThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t add dead code in block statements with `ProgramNode` block scope', () => {
@@ -422,7 +419,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/obfuscation-of-dead-code-block-statements.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -430,9 +428,7 @@ describe('DeadCodeInjectionTransformer', () => {
                         deadCodeInjectionThreshold: 1,
                         debugProtection: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should correctly obfuscate dead-code block statements and prevent any exposing of internal variable names', () => {
@@ -528,7 +524,8 @@ describe('DeadCodeInjectionTransformer', () => {
                     for (let i: number = 0; i < 100; i++) {
                         while (true) {
                             try {
-                                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                                     code,
                                     {
                                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -536,9 +533,7 @@ describe('DeadCodeInjectionTransformer', () => {
                                         deadCodeInjectionThreshold: 1,
                                         identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                                     }
-                                );
-
-                                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                                ).getObfuscatedCode();
                                 functionIdentifierName = getRegExpMatch(obfuscatedCode, functionParameterRegExp, 0);
                                 variableDeclarationIdentifierName = getRegExpMatch(obfuscatedCode, deadCodeRegExp, 0);
                                 returnIdentifierName = getRegExpMatch(obfuscatedCode, deadCodeRegExp, 1);
@@ -593,7 +588,8 @@ describe('DeadCodeInjectionTransformer', () => {
                     for (let i: number = 0; i < 100; i++) {
                         while (true) {
                             try {
-                                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                                     code,
                                     {
                                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -601,9 +597,7 @@ describe('DeadCodeInjectionTransformer', () => {
                                         deadCodeInjectionThreshold: 1,
                                         identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                                     }
-                                );
-
-                                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                                ).getObfuscatedCode();
                                 functionIdentifierName = getRegExpMatch(obfuscatedCode, functionParameterRegExp, 0);
                                 returnIdentifierName = getRegExpMatch(obfuscatedCode, deadCodeRegExp, 0);
                                 variableDeclarationIdentifierName = getRegExpMatch(obfuscatedCode, deadCodeRegExp, 1);
@@ -643,7 +637,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/block-statement-empty-body.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -652,9 +647,8 @@ describe('DeadCodeInjectionTransformer', () => {
                         deadCodeInjection: true,
                         deadCodeInjectionThreshold: 1
                     }
-                );
+                ).getObfuscatedCode();
 
-                const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
                 const functionMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(regExp);
 
                 if (functionMatches) {
@@ -681,7 +675,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/block-statement-with-scope-hoisting-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -690,9 +685,8 @@ describe('DeadCodeInjectionTransformer', () => {
                             deadCodeInjection: true,
                             deadCodeInjectionThreshold: 1
                         }
-                    );
+                    ).getObfuscatedCode();
 
-                    const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
                     const functionMatches: RegExpMatchArray = <RegExpMatchArray>obfuscatedCode.match(regExp);
 
                     if (functionMatches) {
@@ -721,7 +715,8 @@ describe('DeadCodeInjectionTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/block-statement-with-scope-hoisting-2.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -730,9 +725,7 @@ describe('DeadCodeInjectionTransformer', () => {
                             deadCodeInjection: true,
                             deadCodeInjectionThreshold: 1
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('shouldn\'t wrap block statements in dead code conditions', () => {

test/functional-tests/node-transformers/obfuscating-transformers/catch-clause-transformer/CatchClauseTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
@@ -21,14 +19,13 @@ describe('CatchClauseTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
             firstMatch = getRegExpMatch(obfuscatedCode, paramNameRegExp);
             secondMatch = getRegExpMatch(obfuscatedCode, bodyParamNameRegExp);
         });
@@ -52,14 +49,13 @@ describe('CatchClauseTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/object-pattern-as-parameter.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('match #1: shouldn\'t transform function parameter object pattern identifier', () => {

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/ClassDeclarationTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
@@ -22,14 +20,13 @@ describe('ClassDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 classNameIdentifier = getRegExpMatch(obfuscatedCode, classNameIdentifierRegExp);
                 classCallIdentifier = getRegExpMatch(obfuscatedCode, classCallIdentifierRegExp);
             });
@@ -48,14 +45,13 @@ describe('ClassDeclarationTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('match #1: shouldn\'t transform class name', () => {
@@ -76,15 +72,14 @@ describe('ClassDeclarationTransformer', () => {
 
                     before(() => {
                         const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
                             code,
                             {
                                 ...NO_ADDITIONAL_NODES_PRESET,
                                 renameGlobals: true
                             }
-                        );
-
-                        obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                        ).getObfuscatedCode();
                     });
 
                     it('match #1: should transform class name', () => {
@@ -104,15 +99,14 @@ describe('ClassDeclarationTransformer', () => {
 
                     before(() => {
                         const code: string = readFileAsString(__dirname + '/fixtures/rename-globals-identifier-transformation.js');
-                        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
                             code,
                             {
                                 ...NO_ADDITIONAL_NODES_PRESET,
                                 renameGlobals: true
                             }
-                        );
-
-                        obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                        ).getObfuscatedCode();
                     });
 
                     it('match #1: should transform identifier name inside class method', () => {
@@ -134,15 +128,14 @@ describe('ClassDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/prevent-renaming-of-renamed-identifiers.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('Match #1: shouldn\'t rename twice class declaration name', () => {
@@ -161,15 +154,14 @@ describe('ClassDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/named-export.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         renameGlobals: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform identifiers in named export', () => {
@@ -185,15 +177,14 @@ describe('ClassDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/default-export.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         renameGlobals: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('Match #1: should transform identifiers in variable declaration', () => {

test/functional-tests/node-transformers/obfuscating-transformers/function-declaration-transformer/FunctionDeclarationTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
@@ -22,14 +20,13 @@ describe('FunctionDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 functionNameIdentifier = getRegExpMatch(obfuscatedCode, functionNameIdentifierRegExp);
                 functionCallIdentifier = getRegExpMatch(obfuscatedCode, functionCallIdentifierRegExp);
             });
@@ -48,14 +45,13 @@ describe('FunctionDeclarationTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('match #1: shouldn\'t transform function name', () => {
@@ -75,15 +71,14 @@ describe('FunctionDeclarationTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             renameGlobals: true
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('match #1: should transform function name', () => {
@@ -106,14 +101,13 @@ describe('FunctionDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/generator-function.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 functionNameIdentifier = getRegExpMatch(obfuscatedCode, functionNameIdentifierRegExp);
                 functionCallIdentifier = getRegExpMatch(obfuscatedCode, functionCallIdentifierRegExp);
             });
@@ -133,14 +127,13 @@ describe('FunctionDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/async-function.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 functionNameIdentifier = getRegExpMatch(obfuscatedCode, functionNameIdentifierRegExp);
                 functionCallIdentifier = getRegExpMatch(obfuscatedCode, functionCallIdentifierRegExp);
             });
@@ -159,15 +152,14 @@ describe('FunctionDeclarationTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/prevent-renaming-of-renamed-identifiers-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
                             identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('Match #1: shouldn\'t rename twice function declaration name', () => {
@@ -187,15 +179,14 @@ describe('FunctionDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/named-export.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         renameGlobals: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t transform identifiers in named export', () => {
@@ -211,15 +202,14 @@ describe('FunctionDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/default-export.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         renameGlobals: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('Match #1: should transform identifiers in variable declaration', () => {

test/functional-tests/node-transformers/obfuscating-transformers/function-transformer/FunctionTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -21,14 +19,13 @@ describe('FunctionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             const functionParamIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
                 .match(functionParamIdentifierRegExp);
@@ -57,14 +54,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/object-pattern-as-parameter-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: shouldn\'t transform function parameter object pattern identifier', () => {
@@ -86,14 +82,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/object-pattern-as-parameter-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should transform function parameter identifier', () => {
@@ -123,14 +118,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/object-pattern-as-parameter-3.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should transform function parameter object pattern rest identifier', () => {
@@ -160,14 +154,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/assignment-pattern-as-parameter-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should transform function parameter assignment pattern identifier', () => {
@@ -192,14 +185,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/assignment-pattern-as-parameter-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 variableDeclarationIdentifierName = getRegExpMatch(obfuscatedCode, variableDeclarationRegExp);
                 functionParameterIdentifierName = getRegExpMatch(obfuscatedCode, functionParameterRegExp);
                 functionDefaultParameterIdentifierName = getRegExpMatch(obfuscatedCode, functionParameterRegExp, 1);
@@ -242,14 +234,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/assignment-pattern-as-parameter-3.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
 
                 variableDeclarationIdentifierName = getRegExpMatch(obfuscatedCode, variableDeclarationRegExp);
                 functionParameterIdentifierName = getRegExpMatch(obfuscatedCode, functionParameterRegExp);
@@ -309,13 +300,13 @@ describe('FunctionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/array-pattern-as-parameter.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-            const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             arrayPatternIdentifierName1 = getRegExpMatch(obfuscatedCode, functionParameterRegExp);
             arrayPatternIdentifierName2 = getRegExpMatch(obfuscatedCode, functionParameterRegExp, 1);
@@ -340,14 +331,13 @@ describe('FunctionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/rest-parameter.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform function rest parameter', () => {
@@ -367,14 +357,13 @@ describe('FunctionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/array-rest-parameter.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform function rest parameter', () => {
@@ -394,14 +383,13 @@ describe('FunctionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/object-rest-parameter.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform function rest parameter', () => {
@@ -421,14 +409,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/identifier-names-set-object-pattern.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should transform identifiers in function body', () => {
@@ -450,14 +437,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/arrow-function-with-expression-body-block-scope-detection-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should transform identifiers in arrow function expression body', () => {
@@ -477,14 +463,13 @@ describe('FunctionTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/arrow-function-with-expression-body-block-scope-detection-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should transform identifiers in arrow function expression body', () => {

test/functional-tests/node-transformers/obfuscating-transformers/impot-declaration-transformer/ImportDeclarationTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
@@ -21,14 +19,13 @@ describe('ImportDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/default-import.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 importSpecifierIdentifier = getRegExpMatch(obfuscatedCode, importSpecifierRegExp);
                 consoleLogIdentifier = getRegExpMatch(obfuscatedCode, consoleLogRegExp);
             });
@@ -48,14 +45,13 @@ describe('ImportDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/namespace-import.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 importSpecifierIdentifier = getRegExpMatch(obfuscatedCode, importSpecifierRegExp);
                 consoleLogIdentifier = getRegExpMatch(obfuscatedCode, consoleLogRegExp);
             });
@@ -74,14 +70,13 @@ describe('ImportDeclarationTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/named-import-1.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                 });
 
                 it('Match #1: shouldn\'t transform import specifier identifier name', () => {
@@ -103,14 +98,13 @@ describe('ImportDeclarationTransformer', () => {
 
                 before(() => {
                     const code: string = readFileAsString(__dirname + '/fixtures/named-import-2.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET
                         }
-                    );
-
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    ).getObfuscatedCode();
                     importSpecifierIdentifier = getRegExpMatch(obfuscatedCode, importSpecifierRegExp);
                     consoleLogIdentifier = getRegExpMatch(obfuscatedCode, consoleLogRegExp);
                 });
@@ -131,15 +125,14 @@ describe('ImportDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/namespace-import.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         identifiersPrefix: 'bark'
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 importSpecifierIdentifier = getRegExpMatch(obfuscatedCode, importSpecifierRegExp);
                 consoleLogIdentifier = getRegExpMatch(obfuscatedCode, consoleLogRegExp);
             });

test/functional-tests/node-transformers/obfuscating-transformers/labeled-statement-transformer/LabeledStatementTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
@@ -22,14 +20,13 @@ describe('LabeledStatementTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             firstMatch = getRegExpMatch(obfuscatedCode, labeledStatementRegExp);
             secondMatch = getRegExpMatch(obfuscatedCode, continueStatementRegExp);

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

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { IdentifierNamesGenerator } from '../../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
 import { StringArrayEncoding } from '../../../../../src/enums/StringArrayEncoding';
 
@@ -21,16 +19,15 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should replace literal node value with value from string array', () => {
@@ -49,14 +46,13 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t replace literal node value with value from string array', () => {
@@ -93,16 +89,15 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/same-literal-values.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should create only one item in string array for same literal node values', () => {
@@ -121,16 +116,15 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         unicodeEscapeSequence: true
 
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace literal node value with unicode escape sequence', () => {
@@ -146,7 +140,8 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -154,9 +149,7 @@ describe('LiteralTransformer', () => {
                         stringArrayThreshold: 1,
                         unicodeEscapeSequence: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should replace literal node value with unicode escape sequence from string array', () => {
@@ -175,16 +168,15 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/short-literal-value.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t replace short literal node value with value from string array', () => {
@@ -200,7 +192,8 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -208,9 +201,7 @@ describe('LiteralTransformer', () => {
                         stringArrayEncoding: StringArrayEncoding.Base64,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should replace literal node value with value from string array encoded using base64', () => {
@@ -229,7 +220,8 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -237,9 +229,7 @@ describe('LiteralTransformer', () => {
                         stringArrayEncoding: StringArrayEncoding.Rc4,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should replace literal node value with value from string array encoded using rc4', () => {
@@ -260,21 +250,20 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple-input.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                     `${code}\n`.repeat(samples),
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: stringArrayThreshold
                     }
-                );
+                ).getObfuscatedCode();
 
-                const stringArrayMatchesLength: number = obfuscationResult
-                    .getObfuscatedCode()
+                const stringArrayMatchesLength: number = obfuscatedCode
                     .match(regExp1)!
                     .length;
-                const noStringArrayMatchesLength: number = obfuscationResult
-                    .getObfuscatedCode()
+                const noStringArrayMatchesLength: number = obfuscatedCode
                     .match(regExp2)!
                     .length;
 
@@ -298,7 +287,8 @@ describe('LiteralTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/string-array-calls-wrapper-name.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
@@ -306,9 +296,7 @@ describe('LiteralTransformer', () => {
                         stringArrayThreshold: 1,
                         identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should keep identifier with string array calls wrapper name untouched after obfuscation', () => {
@@ -324,16 +312,15 @@ describe('LiteralTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/boolean-value.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should transform literal node', () => {
@@ -348,16 +335,15 @@ describe('LiteralTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/number-value.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should transform literal node', () => {
@@ -372,16 +358,15 @@ describe('LiteralTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/regexp-literal.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should keep safe value of RegExp literal', () => {

test/functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/VariableDeclarationTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
@@ -20,14 +18,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/simple-declaration.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('match #1: should transform `variableDeclaration` node', () => {
@@ -48,14 +45,13 @@ describe('VariableDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: shouldn\'t transform `variableDeclaration` node', () => {
@@ -75,15 +71,14 @@ describe('VariableDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         renameGlobals: true
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should transform `variableDeclaration` node', () => {
@@ -103,14 +98,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/var-kind.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should transform variable call (`identifier` node) outside of block scope of node in which this variable was declared with `var` kind', () => {
@@ -125,14 +119,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/let-kind.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t transform variable call (`identifier` node) outside of block scope of node in which this variable was declared with `let` kind', () => {
@@ -148,14 +141,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/variable-call-before-variable-declaration-1.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should transform variable call (`identifier` node name) before variable declaration if this call is inside function body', () => {
@@ -182,13 +174,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/variable-call-before-variable-declaration-2.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-            const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             outerFunctionParamIdentifierName = getRegExpMatch(obfuscatedCode, functionParamIdentifierRegExp);
             innerFunctionParamIdentifierName = getRegExpMatch(obfuscatedCode, innerFunctionParamIdentifierRegExp);
@@ -237,13 +229,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/variable-call-before-variable-declaration-3.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-            const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             catchClauseParamIdentifierName = getRegExpMatch(obfuscatedCode, catchClauseParamIdentifierRegExp);
             innerFunctionParamIdentifierName = getRegExpMatch(obfuscatedCode, innerFunctionParamIdentifierRegExp);
@@ -285,14 +277,13 @@ describe('VariableDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/property-identifier.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t replace property node identifier', () => {
@@ -307,14 +298,13 @@ describe('VariableDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/member-expression-identifier.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('shouldn\'t replace computed member expression identifier', () => {
@@ -331,14 +321,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/object-pattern.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('match #1: shouldn\'t transform object pattern variable declarator', () => {
@@ -362,14 +351,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/array-pattern.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             objectPatternIdentifierName1 = getRegExpMatch(obfuscatedCode, objectPatternVariableDeclaratorRegExp);
             objectPatternIdentifierName2 = getRegExpMatch(obfuscatedCode, objectPatternVariableDeclaratorRegExp, 1);
@@ -401,14 +389,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/computed-object-expression-identifier.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should transform computed object expression identifier', () => {
@@ -423,14 +410,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/method-definition-identifier.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t transform method definition node key identifier', () => {
@@ -450,15 +436,14 @@ describe('VariableDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/prevent-renaming-of-renamed-identifiers-1.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('Match #1: shouldn\'t rename twice variable declaration name', () => {
@@ -492,15 +477,14 @@ describe('VariableDeclarationTransformer', () => {
 
             before(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/prevent-renaming-of-renamed-identifiers-2.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('Match #1: shouldn\'t rename twice variable declaration name', () => {
@@ -528,15 +512,14 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/named-export.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     renameGlobals: true
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('shouldn\'t transform identifiers in named export', () => {
@@ -552,15 +535,14 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/default-export.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     renameGlobals: true
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform identifiers in variable declaration', () => {
@@ -580,14 +562,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/array-rest.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform object name', () => {
@@ -607,14 +588,13 @@ describe('VariableDeclarationTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/object-rest.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('Match #1: should transform object name', () => {

test/functional-tests/node-transformers/preparing-transformers/comments-transformer/CommentsTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -16,14 +14,13 @@ describe('CommentsTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/no-preserved-words.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should remove comments without preserved words', () => {
@@ -38,14 +35,13 @@ describe('CommentsTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/preserved-words.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should keep comments with preserved words', () => {
@@ -60,14 +56,13 @@ describe('CommentsTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/combined-words-1.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should keep comments with preserved words', () => {
@@ -89,14 +84,13 @@ describe('CommentsTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/combined-words-2.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should keep comments with preserved words', () => {
@@ -109,14 +103,13 @@ describe('CommentsTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/comments-only-1.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should remove comment without preserved words', () => {
@@ -131,14 +124,13 @@ describe('CommentsTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/comments-only-2.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should keep comments with preserved words', () => {

test/functional-tests/node-transformers/preparing-transformers/eval-call-expression-transformer/EvalCallExpressionTransformer.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../src/interfaces/IObfuscationResult';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
 
 import { readFileAsString } from '../../../../helpers/readFileAsString';
@@ -20,14 +18,13 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/identifier-reference.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             functionIdentifierName = getRegExpMatch(obfuscatedCode, functionIdentifierRegExp);
             variableReferenceIdentifierName = getRegExpMatch(obfuscatedCode, evalExpressionRegExp);
@@ -52,14 +49,13 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/call-expression-identifier-reference.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             functionIdentifierName = getRegExpMatch(obfuscatedCode, functionIdentifierRegExp);
             variableReferenceIdentifierName = getRegExpMatch(obfuscatedCode, evalExpressionRegExp);
@@ -81,14 +77,13 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/multiple-statements-eval.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should obfuscate eval string', () => {
@@ -104,16 +99,15 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/string-array-calls-wrapper-call.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     stringArray: true,
                     stringArrayThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('match #1: should add strings from eval expression to the string array', () => {
@@ -135,14 +129,13 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/eval-expression-as-argument.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             functionIdentifierName = getRegExpMatch(obfuscatedCode, functionIdentifierRegExp);
             variableReferenceIdentifierName = getRegExpMatch(obfuscatedCode, evalExpressionRegExp);
@@ -182,14 +175,13 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/nested-eval-expressions.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             functionIdentifierAName = getRegExpMatch(obfuscatedCode, functionIdentifierRegExp, 0);
             functionIdentifierBName = getRegExpMatch(obfuscatedCode, functionIdentifierRegExp, 1);
@@ -240,14 +232,13 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/wrong-eval-string.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should skip obfuscation of eval string', () => {
@@ -265,14 +256,13 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/eval-expression-template-literal.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             functionIdentifierName = getRegExpMatch(obfuscatedCode, functionIdentifierRegExp);
             variableReferenceIdentifierName = getRegExpMatch(obfuscatedCode, evalExpressionRegExp);
@@ -303,16 +293,15 @@ describe('EvalCallExpressionTransformer', () => {
 
         before(() => {
             const code: string = readFileAsString(__dirname + '/fixtures/control-flow-flattening-integration.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     controlFlowFlattening: true,
                     controlFlowFlatteningThreshold: 1
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
         });
 
         it('should add control flow storage node', () => {

test/functional-tests/node-transformers/preparing-transformers/obfuscating-guards/black-list-obfuscating-guard/BlackListObfuscatingGuard.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
-
 import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscatorFacade';
 
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
@@ -19,16 +17,15 @@ describe('BlackListObfuscatingGuard', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/use-strict-operator.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         stringArray: true,
                         stringArrayThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: shouldn\'t obfuscate `use strict` operator', () => {

test/functional-tests/node-transformers/preparing-transformers/obfuscating-guards/conditional-comment-obfuscating-guard/ConditionalCommentObfuscatingGuard.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../../../../../src/interfaces/IObfuscationResult';
-
 import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscatorFacade';
 
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
@@ -19,14 +17,13 @@ describe('ConditionalCommentObfuscatingGuard', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/simple.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should obfuscate variable declaration before `disable` conditional comment', () => {
@@ -51,14 +48,13 @@ describe('ConditionalCommentObfuscatingGuard', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/disable-and-enable-comments.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should obfuscate variable declaration before `disable` conditional comment', () => {
@@ -82,14 +78,13 @@ describe('ConditionalCommentObfuscatingGuard', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/disable-from-beginning.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should ignore variable declaration after `disable` conditional comment', () => {
@@ -120,16 +115,15 @@ describe('ConditionalCommentObfuscatingGuard', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/dead-code-injection.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         deadCodeInjection: true,
                         deadCodeInjectionThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
                 
                 const obfuscatedFunctionExpressionMatches: RegExpMatchArray | null = obfuscatedCode.match(
                     obfuscatedFunctionExpressionRegExp
@@ -180,16 +174,15 @@ describe('ConditionalCommentObfuscatingGuard', () => {
 
             beforeEach(() => {
                 const code: string = readFileAsString(__dirname + '/fixtures/control-flow-flattening.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
                     code,
                     {
                         ...NO_ADDITIONAL_NODES_PRESET,
                         controlFlowFlattening: true,
                         controlFlowFlatteningThreshold: 1
                     }
-                );
-
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('match #1: should obfuscate variable declaration before `disable` conditional comment', () => {

test/functional-tests/options/OptionsNormalizer.spec.ts

@@ -23,7 +23,7 @@ import { InversifyContainerFacade } from '../../../src/container/InversifyContai
 function getNormalizedOptions (optionsPreset: TInputOptions): TInputOptions {
     const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-    inversifyContainerFacade.load('', optionsPreset);
+    inversifyContainerFacade.load('', '', optionsPreset);
 
     const options: IOptions = inversifyContainerFacade
         .get<IOptions>(ServiceIdentifiers.IOptions);

test/functional-tests/templates/debug-protection-nodes/DebugProtectionFunctionCallTemplate.spec.ts

@@ -1,8 +1,6 @@
 import { assert } from 'chai';
 import { spawn } from 'threads';
 
-import { IObfuscationResult } from '../../../../src/interfaces/IObfuscationResult';
-
 import { readFileAsString } from '../../../helpers/readFileAsString';
 
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../../src/options/presets/NoCustomNodes';
@@ -39,15 +37,14 @@ describe('DebugProtectionFunctionCallTemplate', () => {
 
         beforeEach((done) => {
             const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     debugProtection: true
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             spawnThread(
                 () => obfuscatedCode,
@@ -74,16 +71,15 @@ describe('DebugProtectionFunctionCallTemplate', () => {
 
         beforeEach((done) => {
             const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     debugProtection: true,
                     mangle: true
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             spawnThread(
                 () => obfuscatedCode,
@@ -110,16 +106,15 @@ describe('DebugProtectionFunctionCallTemplate', () => {
 
         beforeEach((done) => {
             const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     debugProtection: true,
                     target: ObfuscationTarget.BrowserNoEval
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             spawnThread(
                 () => obfuscatedCode,
@@ -146,15 +141,14 @@ describe('DebugProtectionFunctionCallTemplate', () => {
 
         beforeEach((done) => {
             const code: string = readFileAsString(__dirname + '/fixtures/input.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     debugProtection: true
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
             obfuscatedCode = obfuscatedCode.replace(/\+\+ *_0x([a-f0-9]){4,6}/, '');
 
             spawnThread(
@@ -182,15 +176,14 @@ describe('DebugProtectionFunctionCallTemplate', () => {
 
         beforeEach((done) => {
             const code: string = readFileAsString(__dirname + '/fixtures/single-call.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
                     debugProtection: true
                 }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            ).getObfuscatedCode();
 
             spawnThread(
                 () => obfuscatedCode,

test/functional-tests/templates/domain-lock-nodes/DomainLockNodeTemplate.spec.ts

@@ -91,7 +91,7 @@ describe('DomainLockNodeTemplate', () => {
     before(() => {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-        inversifyContainerFacade.load('', {});
+        inversifyContainerFacade.load('', '', {});
         cryptUtils = inversifyContainerFacade.get<ICryptUtils>(ServiceIdentifiers.ICryptUtils);
     });
 

test/functional-tests/templates/string-array-nodes/StringArrayCallsWrapperNodeTemplate.spec.ts

@@ -29,7 +29,7 @@ describe('StringArrayCallsWrapperNodeTemplate', () => {
     before(() => {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-        inversifyContainerFacade.load('', {});
+        inversifyContainerFacade.load('', '', {});
         cryptUtils = inversifyContainerFacade.get<ICryptUtils>(ServiceIdentifiers.ICryptUtils);
         randomGenerator = inversifyContainerFacade.get<IRandomGenerator>(ServiceIdentifiers.IRandomGenerator);
     });

test/index.spec.ts

@@ -27,9 +27,8 @@ import './unit-tests/node/node-lexical-scope-utils/NodeLexicalScopeUtils.spec';
 import './unit-tests/node/node-statement-utils/NodeStatementUtils.spec';
 import './unit-tests/node/node-utils/NodeUtils.spec';
 import './unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec';
-import './unit-tests/obfuscation-result/ObfuscationResult.spec';
 import './unit-tests/options/ValidationErrorsFormatter.spec';
-import './unit-tests/source-map/SourceMapCorrector.spec';
+import './unit-tests/source-code/ObfuscatedCode.spec';
 import './unit-tests/storages/ArrayStorage.spec';
 import './unit-tests/storages/MapStorage.spec';
 import './unit-tests/utils/ArrayUtils.spec';

test/runtime-tests/JavaScriptObfuscatorRuntime.spec.ts

@@ -1,7 +1,5 @@
 import { assert } from 'chai';
 
-import { IObfuscationResult } from '../../src/interfaces/IObfuscationResult';
-
 import { StringArrayEncoding } from '../../src/enums/StringArrayEncoding';
 
 import { readFileAsString } from '../helpers/readFileAsString';
@@ -15,7 +13,8 @@ describe('JavaScriptObfuscator runtime eval', function () {
 
     before(() => {
         const code: string = readFileAsString(__dirname + '/fixtures/sha256.js');
-        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+
+        obfuscatedCode = JavaScriptObfuscator.obfuscate(
             code,
             {
                 controlFlowFlattening: true,
@@ -25,9 +24,7 @@ describe('JavaScriptObfuscator runtime eval', function () {
                 stringArrayEncoding: StringArrayEncoding.Rc4,
                 transformObjectKeys: true
             }
-        );
-
-        obfuscatedCode = obfuscationResult.getObfuscatedCode();
+        ).getObfuscatedCode();
     });
 
     it('should obfuscate code without any runtime errors after obfuscation: Variant #1 sha256', () => {

test/unit-tests/generators/identifier-names-generators/HexadecimalIdentifierNamesGenerator.spec.ts

@@ -20,7 +20,7 @@ describe('HexadecimalIdentifierNamesGenerator', () => {
         before(() => {
             const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-            inversifyContainerFacade.load('', {});
+            inversifyContainerFacade.load('', '', {});
             identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
                 ServiceIdentifiers.IIdentifierNamesGenerator,
                 IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator
@@ -44,7 +44,7 @@ describe('HexadecimalIdentifierNamesGenerator', () => {
         before(() => {
             const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-            inversifyContainerFacade.load('', {
+            inversifyContainerFacade.load('', '', {
                 identifiersPrefix: 'foo'
             });
             identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(

test/unit-tests/generators/identifier-names-generators/MangledlIdentifierNamesGenerator.spec.ts

@@ -19,7 +19,7 @@ describe('MangledIdentifierNamesGenerator', () => {
         beforeEach(() => {
             const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-            inversifyContainerFacade.load('', {});
+            inversifyContainerFacade.load('', '', {});
             identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
                 ServiceIdentifiers.IIdentifierNamesGenerator,
                 IdentifierNamesGenerator.MangledIdentifierNamesGenerator
@@ -136,7 +136,7 @@ describe('MangledIdentifierNamesGenerator', () => {
         before(() => {
             const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-            inversifyContainerFacade.load('', {
+            inversifyContainerFacade.load('', '', {
                 identifiersPrefix: 'foo'
             });
             identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
@@ -183,7 +183,7 @@ describe('MangledIdentifierNamesGenerator', () => {
             beforeEach(() => {
                 const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-                inversifyContainerFacade.load('', { reservedNames });
+                inversifyContainerFacade.load('', '', { reservedNames });
                 identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
                     ServiceIdentifiers.IIdentifierNamesGenerator,
                     IdentifierNamesGenerator.MangledIdentifierNamesGenerator
@@ -214,7 +214,7 @@ describe('MangledIdentifierNamesGenerator', () => {
             beforeEach(() => {
                 const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-                inversifyContainerFacade.load('', { reservedNames });
+                inversifyContainerFacade.load('', '', { reservedNames });
                 identifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
                     ServiceIdentifiers.IIdentifierNamesGenerator,
                     IdentifierNamesGenerator.MangledIdentifierNamesGenerator

test/unit-tests/javascript-obfuscator/JavaScriptObfuscator.spec.ts

@@ -4,7 +4,7 @@ import { assert } from 'chai';
 
 import { IInversifyContainerFacade } from '../../../src/interfaces/container/IInversifyContainerFacade';
 import { IJavaScriptObfuscator } from '../../../src/interfaces/IJavaScriptObfsucator';
-import { IObfuscationResult } from '../../../src/interfaces/IObfuscationResult';
+import { IObfuscatedCode } from '../../../src/interfaces/source-code/IObfuscatedCode';
 
 import { NO_ADDITIONAL_NODES_PRESET } from '../../../src/options/presets/NoCustomNodes';
 
@@ -28,6 +28,7 @@ describe('JavaScriptObfuscator', () => {
                     const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
                     inversifyContainerFacade.load(
+                        '',
                         '',
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -38,10 +39,11 @@ describe('JavaScriptObfuscator', () => {
                     javaScriptObfuscator = inversifyContainerFacade
                         .get<IJavaScriptObfuscator>(ServiceIdentifiers.IJavaScriptObfuscator);
 
-                    const obfuscationResult: IObfuscationResult = javaScriptObfuscator.obfuscate(code);
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
-                    sourceMapObject = JSON.parse(obfuscationResult.getSourceMap());
+                    const obfuscatedCodeObject: IObfuscatedCode = javaScriptObfuscator.obfuscate(code);
+
+                    obfuscatedCode = obfuscatedCodeObject.getObfuscatedCode();
+                    sourceMapObject = JSON.parse(obfuscatedCodeObject.getSourceMap());
                 });
 
                 it('should link obfuscated code with source map', () => {
@@ -64,6 +66,7 @@ describe('JavaScriptObfuscator', () => {
                     const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
                     inversifyContainerFacade.load(
+                        '',
                         '',
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
@@ -75,10 +78,11 @@ describe('JavaScriptObfuscator', () => {
                     javaScriptObfuscator = inversifyContainerFacade
                         .get<IJavaScriptObfuscator>(ServiceIdentifiers.IJavaScriptObfuscator);
 
-                    const obfuscationResult: IObfuscationResult = javaScriptObfuscator.obfuscate(code);
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
-                    sourceMapObject = JSON.parse(obfuscationResult.getSourceMap());
+                    const obfuscatedCodeObject: IObfuscatedCode = javaScriptObfuscator.obfuscate(code);
+
+                    obfuscatedCode = obfuscatedCodeObject.getObfuscatedCode();
+                    sourceMapObject = JSON.parse(obfuscatedCodeObject.getSourceMap());
                 });
 
                 it('should properly add base url to source map import inside obfuscated code', () => {

test/unit-tests/logger/Logger.spec.ts

@@ -58,7 +58,7 @@ describe('Logger', () => {
 
             before(() => {
                 inversifyContainerFacade = new InversifyContainerFacade();
-                inversifyContainerFacade.load('', {
+                inversifyContainerFacade.load('', '', {
                     log: true
                 });
 
@@ -94,7 +94,7 @@ describe('Logger', () => {
 
             before(() => {
                 inversifyContainerFacade = new InversifyContainerFacade();
-                inversifyContainerFacade.load('', {
+                inversifyContainerFacade.load('', '', {
                     log: false
                 });
 
@@ -129,7 +129,7 @@ describe('Logger', () => {
 
             before(() => {
                 inversifyContainerFacade = new InversifyContainerFacade();
-                inversifyContainerFacade.load('', {
+                inversifyContainerFacade.load('', '', {
                     log: true
                 });
 
@@ -165,7 +165,7 @@ describe('Logger', () => {
 
             before(() => {
                 inversifyContainerFacade = new InversifyContainerFacade();
-                inversifyContainerFacade.load('', {
+                inversifyContainerFacade.load('', '', {
                     log: false
                 });
 
@@ -200,7 +200,7 @@ describe('Logger', () => {
 
             before(() => {
                 inversifyContainerFacade = new InversifyContainerFacade();
-                inversifyContainerFacade.load('', {
+                inversifyContainerFacade.load('', '', {
                     log: true
                 });
 
@@ -236,7 +236,7 @@ describe('Logger', () => {
 
             before(() => {
                 inversifyContainerFacade = new InversifyContainerFacade();
-                inversifyContainerFacade.load('', {
+                inversifyContainerFacade.load('', '', {
                     log: false
                 });
 

test/unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec.ts

@@ -22,7 +22,7 @@ describe('ObfuscatingGuardsTransformer', () => {
 
         before(() => {
             inversifyContainerFacade = new InversifyContainerFacade();
-            inversifyContainerFacade.load('', {});
+            inversifyContainerFacade.load('', '', {});
 
             obfuscatingGuardsTransformer = inversifyContainerFacade
                 .getNamed(ServiceIdentifiers.INodeTransformer, NodeTransformer.ObfuscatingGuardsTransformer);

test/unit-tests/node/node-appender/NodeAppender.spec.ts

@@ -72,7 +72,7 @@ describe('NodeAppender', () => {
         before(() => {
             const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-            inversifyContainerFacade.load('', {});
+            inversifyContainerFacade.load('', '', {});
             stackTraceAnalyzer = inversifyContainerFacade
                 .get<IStackTraceAnalyzer>(ServiceIdentifiers.IStackTraceAnalyzer);
         });

test/unit-tests/obfuscation-result/ObfuscationResult.spec.ts

@@ -1,22 +0,0 @@
-import { assert } from 'chai';
-
-import { IObfuscationResult } from '../../../src/interfaces/IObfuscationResult';
-
-import { ObfuscationResult } from '../../../src/ObfuscationResult';
-
-describe('ObfuscationResult', () => {
-    describe('constructor', () => {
-        let obfuscatedCode: string = 'obfuscatedCode',
-            obfuscationResult: IObfuscationResult,
-            sourceMap: string = 'sourceMap';
-
-        before(() => {
-            obfuscationResult = new ObfuscationResult();
-            obfuscationResult.initialize(obfuscatedCode, sourceMap);
-        });
-
-        it('should return obfuscated code if `.toString()` was called on `ObfuscationResult` object', () => {
-            assert.equal(obfuscationResult.toString(), obfuscatedCode);
-        });
-    });
-});

test/unit-tests/source-map/SourceMapCorrector.spec.ts → test/unit-tests/source-code/ObfuscatedCode.spec.ts

@@ -1,32 +1,34 @@
+import 'reflect-metadata';
+
 import { ServiceIdentifiers } from '../../../src/container/ServiceIdentifiers';
 
 import { assert } from 'chai';
 
 import { IInversifyContainerFacade } from '../../../src/interfaces/container/IInversifyContainerFacade';
-import { IObfuscationResult } from '../../../src/interfaces/IObfuscationResult';
-import { ISourceMapCorrector } from '../../../src/interfaces/source-map/ISourceMapCorrector';
+import { IObfuscatedCode } from '../../../src/interfaces/source-code/IObfuscatedCode';
 
 import { SourceMapMode } from '../../../src/enums/source-map/SourceMapMode';
 
 import { InversifyContainerFacade } from '../../../src/container/InversifyContainerFacade';
 
 /**
- * @param obfuscatedCode
+ * @param rawObfuscatedCode
  * @param sourceMap
  * @param sourceMapBaseUrl
  * @param sourceMapFileName
  * @param sourceMapMode
  */
-function getCorrectedObfuscationResult (
-    obfuscatedCode: string,
+function getObfuscatedCode (
+    rawObfuscatedCode: string,
     sourceMap: string,
     sourceMapBaseUrl: string,
     sourceMapFileName: string,
     sourceMapMode: SourceMapMode
-): IObfuscationResult {
+): IObfuscatedCode {
     const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
     inversifyContainerFacade.load(
+        '',
         '',
         {
             sourceMap: true,
@@ -36,30 +38,48 @@ function getCorrectedObfuscationResult (
         }
     );
 
-    const sourceMapCorrector: ISourceMapCorrector = inversifyContainerFacade
-        .get<ISourceMapCorrector>(ServiceIdentifiers.ISourceMapCorrector);
+    const obfuscatedCode: IObfuscatedCode = inversifyContainerFacade
+        .get<IObfuscatedCode>(ServiceIdentifiers.IObfuscatedCode);
 
-    return sourceMapCorrector.correct(obfuscatedCode, sourceMap);
+    obfuscatedCode.initialize(rawObfuscatedCode, sourceMap);
+
+    return obfuscatedCode;
 }
 
-describe('SourceMapCorrector', () => {
-    describe('correct', () => {
-        const expectedObfuscatedCode: string = 'var test = 1;';
-        const sourceMap: string = 'test';
+describe('ObfuscatedCode', () => {
+    const expectedObfuscatedCode: string = 'var test = 1;';
+    const sourceMap: string = 'test';
+
+    describe('constructor', () => {
+        let obfuscatedCode: IObfuscatedCode;
+
+        before(() => {
+            obfuscatedCode = getObfuscatedCode(
+                expectedObfuscatedCode,
+                sourceMap,
+                '',
+                '',
+                SourceMapMode.Separate
+            );
+        });
+
+        it('should return obfuscated code if `.toString()` was called on `ObfuscatedCode` object', () => {
+            assert.equal(obfuscatedCode.toString(), expectedObfuscatedCode);
+        });
+    });
 
-        let obfuscationResult: IObfuscationResult,
-            obfuscatedCode: string;
+    describe('getObfuscatedCode', () => {
+        let obfuscatedCode: string;
 
         describe('source map doest\'t exist', () => {
             before(() => {
-                obfuscationResult = getCorrectedObfuscationResult(
+                obfuscatedCode = getObfuscatedCode(
                     expectedObfuscatedCode,
                     '',
                     '',
                     '',
                     SourceMapMode.Separate
-                );
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should return untouched obfuscated code', () => {
@@ -71,14 +91,13 @@ describe('SourceMapCorrector', () => {
             const regExp: RegExp = /data:application\/json;base64/;
 
             before(() => {
-                obfuscationResult = getCorrectedObfuscationResult(
+                obfuscatedCode = getObfuscatedCode(
                     expectedObfuscatedCode,
                     sourceMap,
                     '',
                     '',
                     SourceMapMode.Inline
-                );
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should add source map to obfuscated code as base64 encoded string', () => {
@@ -90,14 +109,13 @@ describe('SourceMapCorrector', () => {
             const regExp: RegExp = /sourceMappingURL=http:\/\/example\.com\/output\.js\.map/;
 
             before(() => {
-                obfuscationResult = getCorrectedObfuscationResult(
+                obfuscatedCode = getObfuscatedCode(
                     expectedObfuscatedCode,
                     sourceMap,
                     'http://example.com',
                     'output.js.map',
                     SourceMapMode.Separate
-                );
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should add source map import to obfuscated code', () => {
@@ -107,14 +125,13 @@ describe('SourceMapCorrector', () => {
 
         describe('source map mode is `separate`, `sourceMapUrl` is not set', () => {
             before(() => {
-                obfuscationResult = getCorrectedObfuscationResult(
+                obfuscatedCode = getObfuscatedCode(
                     expectedObfuscatedCode,
                     sourceMap,
                     '',
                     '',
                     SourceMapMode.Separate
-                );
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                ).getObfuscatedCode();
             });
 
             it('should not touch obfuscated code', () => {

test/unit-tests/storages/ArrayStorage.spec.ts

@@ -17,7 +17,7 @@ class ConcreteStorage <V> extends ArrayStorage <V> {
     constructor () {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-        inversifyContainerFacade.load('', {});
+        inversifyContainerFacade.load('', '', {});
 
         super(
             inversifyContainerFacade.get<IRandomGenerator>(ServiceIdentifiers.IRandomGenerator),

test/unit-tests/storages/MapStorage.spec.ts

@@ -16,7 +16,7 @@ class ConcreteStorage <V> extends MapStorage <string, V> {
     constructor () {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-        inversifyContainerFacade.load('', {});
+        inversifyContainerFacade.load('', '', {});
 
         super(
             inversifyContainerFacade.get<IRandomGenerator>(ServiceIdentifiers.IRandomGenerator),

test/unit-tests/utils/ArrayUtils.spec.ts

@@ -13,7 +13,7 @@ describe('ArrayUtils', () => {
     before(() => {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-        inversifyContainerFacade.load('', {});
+        inversifyContainerFacade.load('', '', {});
         arrayUtils = inversifyContainerFacade.get<IArrayUtils>(ServiceIdentifiers.IArrayUtils);
     });
 

test/unit-tests/utils/CryptUtils.spec.ts

@@ -15,7 +15,7 @@ describe('CryptUtils', () => {
     before(() => {
         const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-        inversifyContainerFacade.load('', {});
+        inversifyContainerFacade.load('', '', {});
         cryptUtils = inversifyContainerFacade.get<ICryptUtils>(ServiceIdentifiers.ICryptUtils);
     });
 

test/unit-tests/utils/EscapeSequenceEncoder.spec.ts

@@ -14,7 +14,7 @@ describe('EscapeSequenceEncoder', () => {
         before(() => {
             const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
 
-            inversifyContainerFacade.load('', {});
+            inversifyContainerFacade.load('', '', {});
             escapeSequenceEncoder = inversifyContainerFacade
                 .get<IEscapeSequenceEncoder>(ServiceIdentifiers.IEscapeSequenceEncoder);
         });