Merge pull request #580 from javascript-obfuscator/string-transformer

Code transformers. HashbangOperatorTransformer

src/JavaScriptObfuscator.ts

@@ -7,6 +7,7 @@ import * as ESTree from 'estree';
 
 import { TObfuscatedCodeFactory } from './types/container/source-code/TObfuscatedCodeFactory';
 
+import { ICodeTransformersRunner } from './interfaces/code-transformers/ICodeTransformersRunner';
 import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
 import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
 import { ILogger } from './interfaces/logger/ILogger';
@@ -15,6 +16,8 @@ import { IOptions } from './interfaces/options/IOptions';
 import { IRandomGenerator } from './interfaces/utils/IRandomGenerator';
 import { INodeTransformersRunner } from './interfaces/node-transformers/INodeTransformersRunner';
 
+import { CodeTransformer } from './enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from './enums/code-transformers/CodeTransformationStage';
 import { LoggingMessage } from './enums/logger/LoggingMessage';
 import { NodeTransformer } from './enums/node-transformers/NodeTransformer';
 import { NodeTransformationStage } from './enums/node-transformers/NodeTransformationStage';
@@ -48,10 +51,17 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         sourceMapWithCode: true
     };
 
+    /**
+     * @type {CodeTransformer[]}
+     */
+    private static readonly codeTransformersList: CodeTransformer[] = [
+        CodeTransformer.HashbangOperatorTransformer
+    ];
+
     /**
      * @type {NodeTransformer[]}
      */
-    private static readonly transformersList: NodeTransformer[] = [
+    private static readonly nodeTransformersList: NodeTransformer[] = [
         NodeTransformer.BlockStatementControlFlowTransformer,
         NodeTransformer.CommentsTransformer,
         NodeTransformer.CustomCodeHelpersTransformer,
@@ -73,6 +83,11 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.VariablePreserveTransformer
     ];
 
+    /**
+     * @type {ICodeTransformersRunner}
+     */
+    private readonly codeTransformersRunner: ICodeTransformersRunner;
+
     /**
      * @type {ILogger}
      */
@@ -96,23 +111,26 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
     /**
      * @type {INodeTransformersRunner}
      */
-    private readonly transformersRunner: INodeTransformersRunner;
+    private readonly nodeTransformersRunner: INodeTransformersRunner;
 
     /**
-     * @param {INodeTransformersRunner} transformersRunner
+     * @param {ICodeTransformersRunner} codeTransformersRunner
+     * @param {INodeTransformersRunner} nodeTransformersRunner
      * @param {IRandomGenerator} randomGenerator
      * @param {TObfuscatedCodeFactory} obfuscatedCodeFactory
      * @param {ILogger} logger
      * @param {IOptions} options
      */
     public constructor (
-        @inject(ServiceIdentifiers.ITransformersRunner) transformersRunner: INodeTransformersRunner,
+        @inject(ServiceIdentifiers.ICodeTransformersRunner) codeTransformersRunner: ICodeTransformersRunner,
+        @inject(ServiceIdentifiers.INodeTransformersRunner) nodeTransformersRunner: INodeTransformersRunner,
         @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.codeTransformersRunner = codeTransformersRunner;
+        this.nodeTransformersRunner = nodeTransformersRunner;
         this.randomGenerator = randomGenerator;
         this.obfuscatedCodeFactory = obfuscatedCodeFactory;
         this.logger = logger;
@@ -129,6 +147,9 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         this.logger.info(LoggingMessage.ObfuscationStarted);
         this.logger.info(LoggingMessage.RandomGeneratorSeed, this.randomGenerator.getInputSeed());
 
+        // preparing code transformations
+        sourceCode = this.runCodeTransformationStage(sourceCode, CodeTransformationStage.PreparingTransformers);
+
         // parse AST tree
         const astTree: ESTree.Program = this.parseCode(sourceCode);
 
@@ -138,6 +159,9 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         // generate code
         const generatorOutput: IGeneratorOutput = this.generateCode(sourceCode, obfuscatedAstTree);
 
+        // finalizing code transformations
+        generatorOutput.code = this.runCodeTransformationStage(generatorOutput.code, CodeTransformationStage.FinalizingTransformers);
+
         const obfuscationTime: number = (Date.now() - timeStart) / 1000;
         this.logger.success(LoggingMessage.ObfuscationCompleted, obfuscationTime);
 
@@ -157,7 +181,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @returns {Program}
      */
     private transformAstTree (astTree: ESTree.Program): ESTree.Program {
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Initializing);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Initializing);
 
         const isEmptyAstTree: boolean = NodeGuards.isProgramNode(astTree)
             && !astTree.body.length
@@ -170,19 +194,19 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
             return astTree;
         }
 
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Preparing);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Preparing);
 
         if (this.options.deadCodeInjection) {
-            astTree = this.runTransformationStage(astTree, NodeTransformationStage.DeadCodeInjection);
+            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.DeadCodeInjection);
         }
 
         if (this.options.controlFlowFlattening) {
-            astTree = this.runTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
+            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
         }
 
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Converting);
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Obfuscating);
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Finalizing);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Obfuscating);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Finalizing);
 
         return astTree;
     }
@@ -222,17 +246,32 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         return this.obfuscatedCodeFactory(generatorOutput.code, generatorOutput.map);
     }
 
+    /**
+     * @param {string} code
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    private runCodeTransformationStage (code: string, codeTransformationStage: CodeTransformationStage): string {
+        this.logger.info(LoggingMessage.CodeTransformationStage, codeTransformationStage);
+
+        return this.codeTransformersRunner.transform(
+            code,
+            JavaScriptObfuscator.codeTransformersList,
+            codeTransformationStage
+        );
+    }
+
     /**
      * @param {Program} astTree
      * @param {NodeTransformationStage} nodeTransformationStage
      * @returns {Program}
      */
-    private runTransformationStage (astTree: ESTree.Program, nodeTransformationStage: NodeTransformationStage): ESTree.Program {
-        this.logger.info(LoggingMessage.TransformationStage, nodeTransformationStage);
+    private runNodeTransformationStage (astTree: ESTree.Program, nodeTransformationStage: NodeTransformationStage): ESTree.Program {
+        this.logger.info(LoggingMessage.NodeTransformationStage, nodeTransformationStage);
 
-        return this.transformersRunner.transform(
+        return this.nodeTransformersRunner.transform(
             astTree,
-            JavaScriptObfuscator.transformersList,
+            JavaScriptObfuscator.nodeTransformersList,
             nodeTransformationStage
         );
     }

src/code-transformers/AbstractCodeTransformer.ts

@@ -0,0 +1,46 @@
+import { inject, injectable } from 'inversify';
+import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
+
+import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
+import { IOptions } from '../interfaces/options/IOptions';
+import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
+
+import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../enums/code-transformers/CodeTransformationStage';
+
+@injectable()
+export abstract class AbstractCodeTransformer implements ICodeTransformer {
+    /**
+     * @type {CodeTransformer[]}
+     */
+    public readonly runAfter: CodeTransformer[] | undefined;
+
+    /**
+     * @type {IOptions}
+     */
+    protected readonly options: IOptions;
+
+    /**
+     * @type {IRandomGenerator}
+     */
+    protected readonly randomGenerator: IRandomGenerator;
+
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    protected constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        this.randomGenerator = randomGenerator;
+        this.options = options;
+    }
+
+    /**
+     * @param {string} code
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    public abstract transformCode (code: string, codeTransformationStage: CodeTransformationStage): string;
+}

src/code-transformers/CodeTransformerNamesGroupsBuilder.ts

@@ -0,0 +1,13 @@
+import { injectable } from 'inversify';
+
+import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
+
+import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
+
+import { AbstractTransformerNamesGroupsBuilder } from '../utils/AbstractTransformerNamesGroupsBuilder';
+
+@injectable()
+export class CodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<
+    CodeTransformer,
+    ICodeTransformer
+> {}

src/code-transformers/CodeTransformersRunner.ts

@@ -0,0 +1,100 @@
+import { inject, injectable } from 'inversify';
+
+import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
+
+import { TCodeTransformerFactory } from '../types/container/code-transformers/TCodeTransformerFactory';
+import { TObject } from '../types/TObject';
+
+import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
+import { ICodeTransformersRunner } from '../interfaces/code-transformers/ICodeTransformersRunner';
+import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
+
+import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../enums/code-transformers/CodeTransformationStage';
+
+@injectable()
+export class CodeTransformersRunner implements ICodeTransformersRunner {
+    /**
+     * @type {TCodeTransformerFactory}
+     */
+    private readonly codeTransformerFactory: TCodeTransformerFactory;
+
+    /**
+     * @type {ITransformerNamesGroupsBuilder}
+     */
+    private readonly codeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
+        CodeTransformer,
+        ICodeTransformer
+    >;
+
+    /**
+     * @param {TNodeTransformerFactory} codeTransformerFactory
+     * @param {ITransformerNamesGroupsBuilder} codeTransformerNamesGroupsBuilder
+     */
+    public constructor (
+        @inject(ServiceIdentifiers.Factory__ICodeTransformer)
+            codeTransformerFactory: TCodeTransformerFactory,
+        @inject(ServiceIdentifiers.ICodeTransformerNamesGroupsBuilder)
+            codeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
+                CodeTransformer,
+                ICodeTransformer
+            >,
+    ) {
+        this.codeTransformerFactory = codeTransformerFactory;
+        this.codeTransformerNamesGroupsBuilder = codeTransformerNamesGroupsBuilder;
+    }
+
+    /**
+     * @param {string} code
+     * @param {CodeTransformer[]} codeTransformerNames
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    public transform (
+        code: string,
+        codeTransformerNames: CodeTransformer[],
+        codeTransformationStage: CodeTransformationStage
+    ): string {
+        if (!codeTransformerNames.length) {
+            return code;
+        }
+
+        const normalizedCodeTransformers: TObject<ICodeTransformer> =
+            this.buildNormalizedCodeTransformers(codeTransformerNames, codeTransformationStage);
+        const codeTransformerNamesGroups: CodeTransformer[][] =
+            this.codeTransformerNamesGroupsBuilder.build(normalizedCodeTransformers);
+
+        for (const nodeTransformerNamesGroup of codeTransformerNamesGroups) {
+            for (const nodeTransformerName of nodeTransformerNamesGroup) {
+                const codeTransformer: ICodeTransformer = normalizedCodeTransformers[nodeTransformerName];
+
+                code = codeTransformer.transformCode(code, codeTransformationStage);
+            }
+        }
+
+        return code;
+    }
+
+    /**
+     * @param {NodeTransformer[]} codeTransformerNames
+     * @param {NodeTransformationStage} codeTransformationStage
+     * @returns {TObject<INodeTransformer>}
+     */
+    private buildNormalizedCodeTransformers (
+        codeTransformerNames: CodeTransformer[],
+        codeTransformationStage: CodeTransformationStage
+    ): TObject<ICodeTransformer> {
+        return codeTransformerNames
+            .reduce<TObject<ICodeTransformer>>(
+                (acc: TObject<ICodeTransformer>, codeTransformerName: CodeTransformer) => {
+                    const codeTransformer: ICodeTransformer = this.codeTransformerFactory(codeTransformerName);
+
+                    return {
+                        ...acc,
+                        [codeTransformerName]: codeTransformer
+                    };
+                },
+                {}
+            );
+    }
+}

src/code-transformers/preparing-transformers/HashbangOperatorTransformer.ts

@@ -0,0 +1,72 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+
+import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
+
+import { AbstractCodeTransformer } from '../AbstractCodeTransformer';
+
+@injectable()
+export class HashbangOperatorTransformer extends AbstractCodeTransformer {
+    /**
+     * @type {string | null}
+     */
+    private hashbangOperatorLine: string | null = null;
+
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    public constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(randomGenerator, options);
+    }
+
+    /**
+     * Removes hashbang operator before AST transformation and appends it back after
+     *
+     * @param {string} code
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    public transformCode (code: string, codeTransformationStage: CodeTransformationStage): string {
+        switch (codeTransformationStage) {
+            case CodeTransformationStage.PreparingTransformers:
+                return this.removeAndSaveHashbangOperatorLine(code);
+
+            case CodeTransformationStage.FinalizingTransformers:
+                return this.appendSavedHashbangOperatorLine(code);
+
+            default:
+                return code;
+        }
+    }
+
+    /**
+     * @param {string} code
+     * @returns {string}
+     */
+    private removeAndSaveHashbangOperatorLine (code: string): string {
+        return code
+            .replace(/^#!.*$(\r?\n)*/m, (substring: string) => {
+                if (substring) {
+                    this.hashbangOperatorLine = substring;
+                }
+
+                return '';
+            })
+            .trim();
+    }
+
+    /**
+     * @param {string} code
+     * @returns {string}
+     */
+    private appendSavedHashbangOperatorLine (code: string): string {
+        return `${this.hashbangOperatorLine ?? ''}${code}`;
+    }
+}

src/container/InversifyContainerFacade.ts

@@ -2,6 +2,7 @@ import { Container, interfaces } from 'inversify';
 import { ServiceIdentifiers } from './ServiceIdentifiers';
 
 import { analyzersModule } from './modules/analyzers/AnalyzersModule';
+import { codeTransformersModule } from './modules/code-transformers/CodeTransformersModule';
 import { controlFlowTransformersModule } from './modules/node-transformers/ControlFlowTransformersModule';
 import { convertingTransformersModule } from './modules/node-transformers/ConvertingTransformersModule';
 import { customCodeHelpersModule } from './modules/custom-code-helpers/CustomCodeHelpersModule';
@@ -19,6 +20,7 @@ import { utilsModule } from './modules/utils/UtilsModule';
 
 import { TInputOptions } from '../types/options/TInputOptions';
 
+import { ICodeTransformersRunner } from '../interfaces/code-transformers/ICodeTransformersRunner';
 import { IInversifyContainerFacade } from '../interfaces/container/IInversifyContainerFacade';
 import { IJavaScriptObfuscator } from '../interfaces/IJavaScriptObfsucator';
 import { ILogger } from '../interfaces/logger/ILogger';
@@ -27,12 +29,13 @@ import { IObfuscatedCode } from '../interfaces/source-code/IObfuscatedCode';
 import { ISourceCode } from '../interfaces/source-code/ISourceCode';
 import { INodeTransformersRunner } from '../interfaces/node-transformers/INodeTransformersRunner';
 
+import { CodeTransformersRunner } from '../code-transformers/CodeTransformersRunner';
 import { JavaScriptObfuscator } from '../JavaScriptObfuscator';
 import { Logger } from '../logger/Logger';
+import { NodeTransformersRunner } from '../node-transformers/NodeTransformersRunner';
 import { ObfuscationEventEmitter } from '../event-emitters/ObfuscationEventEmitter';
 import { ObfuscatedCode } from '../source-code/ObfuscatedCode';
 import { SourceCode } from '../source-code/SourceCode';
-import { NodeTransformersRunner } from '../node-transformers/NodeTransformersRunner';
 
 export class InversifyContainerFacade implements IInversifyContainerFacade {
     /**
@@ -166,7 +169,12 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
             .inSingletonScope();
 
         this.container
-            .bind<INodeTransformersRunner>(ServiceIdentifiers.ITransformersRunner)
+            .bind<ICodeTransformersRunner>(ServiceIdentifiers.ICodeTransformersRunner)
+            .to(CodeTransformersRunner)
+            .inSingletonScope();
+
+        this.container
+            .bind<INodeTransformersRunner>(ServiceIdentifiers.INodeTransformersRunner)
             .to(NodeTransformersRunner)
             .inSingletonScope();
 
@@ -194,6 +202,7 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
 
         // modules
         this.container.load(analyzersModule);
+        this.container.load(codeTransformersModule);
         this.container.load(controlFlowTransformersModule);
         this.container.load(convertingTransformersModule);
         this.container.load(customCodeHelpersModule);

src/container/ServiceIdentifiers.ts

@@ -1,5 +1,6 @@
 export enum ServiceIdentifiers {
     Factory__ICalleeDataExtractor = 'Factory<ICalleeDataExtractor>',
+    Factory__ICodeTransformer = 'Factory<ICodeTransformer[]>',
     Factory__IControlFlowCustomNode = 'Factory<IControlFlowCustomNode>',
     Factory__IControlFlowReplacer = 'Factory<IControlFlowReplacer>',
     Factory__ICustomCodeHelper = 'Factory<ICustomCodeHelper>',
@@ -17,6 +18,9 @@ export enum ServiceIdentifiers {
     IArrayUtils = 'IArrayUtils',
     ICalleeDataExtractor = 'ICalleeDataExtractor',
     ICallsGraphAnalyzer = 'ICallsGraphAnalyzer',
+    ICodeTransformer = 'ICodeTransformer',
+    ICodeTransformerNamesGroupsBuilder = 'ICodeTransformerNamesGroupsBuilder',
+    ICodeTransformersRunner = 'ICodeTransformersRunner',
     ICryptUtils = 'ICryptUtils',
     ICustomCodeHelper = 'ICustomCodeHelper',
     ICustomCodeHelperGroup = 'ICustomCodeHelperGroup',
@@ -45,7 +49,7 @@ export enum ServiceIdentifiers {
     IScopeAnalyzer = 'IScopeAnalyzer',
     IStringArrayStorage = 'IStringArrayStorage',
     IStringArrayStorageAnalyzer = 'IStringArrayStorageAnalyzer',
-    ITransformersRunner = 'ITransformersRunner',
+    INodeTransformersRunner = 'INodeTransformersRunner',
     Newable__ICustomNode = 'Newable<ICustomNode>',
     Newable__TControlFlowStorage = 'Newable<TControlFlowStorage>',
     TCustomNodeGroupStorage = 'TCustomNodeGroupStorage',

src/container/modules/code-transformers/CodeTransformersModule.ts

@@ -0,0 +1,28 @@
+import { InversifyContainerFacade } from '../../InversifyContainerFacade';
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { ICodeTransformer } from '../../../interfaces/code-transformers/ICodeTransformer';
+import { ITransformerNamesGroupsBuilder } from '../../../interfaces/utils/ITransformerNamesGroupsBuilder';
+
+import { CodeTransformer } from '../../../enums/code-transformers/CodeTransformer';
+
+import { CodeTransformerNamesGroupsBuilder } from '../../../code-transformers/CodeTransformerNamesGroupsBuilder';
+import { HashbangOperatorTransformer } from '../../../code-transformers/preparing-transformers/HashbangOperatorTransformer';
+
+export const codeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // code transformers factory
+    bind<ICodeTransformer>(ServiceIdentifiers.Factory__ICodeTransformer)
+        .toFactory<ICodeTransformer>(InversifyContainerFacade
+            .getCacheFactory<CodeTransformer, ICodeTransformer>(ServiceIdentifiers.ICodeTransformer));
+
+    // code transformer names groups builder
+    bind<ITransformerNamesGroupsBuilder<CodeTransformer, ICodeTransformer>>(ServiceIdentifiers.ICodeTransformerNamesGroupsBuilder)
+        .to(CodeTransformerNamesGroupsBuilder)
+        .inSingletonScope();
+
+    // preparing code transformers
+    bind<ICodeTransformer>(ServiceIdentifiers.ICodeTransformer)
+        .to(HashbangOperatorTransformer)
+        .whenTargetNamed(CodeTransformer.HashbangOperatorTransformer);
+});

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

@@ -3,12 +3,20 @@ import { ContainerModule, interfaces } from 'inversify';
 import { ServiceIdentifiers } from '../../ServiceIdentifiers';
 
 import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+import { ITransformerNamesGroupsBuilder } from '../../../interfaces/utils/ITransformerNamesGroupsBuilder';
 
 import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
+import { NodeTransformerNamesGroupsBuilder } from '../../../node-transformers/NodeTransformerNamesGroupsBuilder';
+
 export const nodeTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // node transformers factory
     bind<INodeTransformer>(ServiceIdentifiers.Factory__INodeTransformer)
         .toFactory<INodeTransformer>(InversifyContainerFacade
             .getCacheFactory<NodeTransformer, INodeTransformer>(ServiceIdentifiers.INodeTransformer));
+
+    // node transformer names groups builder
+    bind<ITransformerNamesGroupsBuilder<NodeTransformer, INodeTransformer>>(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
+        .to(NodeTransformerNamesGroupsBuilder)
+        .inSingletonScope();
 });

src/container/modules/utils/UtilsModule.ts

@@ -5,14 +5,12 @@ import { IArrayUtils } from '../../../interfaces/utils/IArrayUtils';
 import { ICryptUtils } from '../../../interfaces/utils/ICryptUtils';
 import { IEscapeSequenceEncoder } from '../../../interfaces/utils/IEscapeSequenceEncoder';
 import { ILevelledTopologicalSorter } from '../../../interfaces/utils/ILevelledTopologicalSorter';
-import { INodeTransformerNamesGroupsBuilder } from '../../../interfaces/utils/INodeTransformerNamesGroupsBuilder';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 
 import { ArrayUtils } from '../../../utils/ArrayUtils';
 import { CryptUtils } from '../../../utils/CryptUtils';
 import { EscapeSequenceEncoder } from '../../../utils/EscapeSequenceEncoder';
 import { LevelledTopologicalSorter } from '../../../utils/LevelledTopologicalSorter';
-import { NodeTransformerNamesGroupsBuilder } from '../../../utils/NodeTransformerNamesGroupsBuilder';
 import { RandomGenerator } from '../../../utils/RandomGenerator';
 
 export const utilsModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
@@ -39,9 +37,4 @@ export const utilsModule: interfaces.ContainerModule = new ContainerModule((bind
     // levelled topological sorter
     bind<ILevelledTopologicalSorter>(ServiceIdentifiers.ILevelledTopologicalSorter)
         .to(LevelledTopologicalSorter);
-
-    // node transformer names groups builder
-    bind<INodeTransformerNamesGroupsBuilder>(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
-        .to(NodeTransformerNamesGroupsBuilder)
-        .inSingletonScope();
 });

src/enums/code-transformers/CodeTransformationStage.ts

@@ -0,0 +1,4 @@
+export enum CodeTransformationStage {
+    PreparingTransformers = 'PreparingTransformers',
+    FinalizingTransformers = 'FinalizingTransformers',
+}

src/enums/code-transformers/CodeTransformer.ts

@@ -0,0 +1,3 @@
+export enum CodeTransformer {
+    HashbangOperatorTransformer = 'HashbangOperatorTransformer'
+}

src/enums/logger/LoggingMessage.ts

@@ -3,6 +3,7 @@ export enum LoggingMessage {
     ObfuscationCompleted = 'Obfuscation completed. Total time: %s sec.',
     ObfuscationStarted = 'Obfuscation started...',
     RandomGeneratorSeed = 'Random generator seed: %s...',
-    TransformationStage = 'Transformation stage: %s...',
+    CodeTransformationStage = 'Code transformation stage: %s...',
+    NodeTransformationStage = 'AST transformation stage: %s...',
     Version = 'Version: %s'
 }

src/interfaces/ITransformer.ts

@@ -0,0 +1,6 @@
+export interface ITransformer <TTransformerName extends string> {
+    /**
+     * @type {TTransformerName[] | undefined}
+     */
+    runAfter?: TTransformerName[];
+}

src/interfaces/code-transformers/ICodeTransformer.ts

@@ -0,0 +1,13 @@
+import { ITransformer } from '../ITransformer';
+
+import { CodeTransformer } from '../../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
+
+export interface ICodeTransformer extends ITransformer <CodeTransformer> {
+    /**
+     * @param {string} code
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    transformCode (code: string, codeTransformationStage: CodeTransformationStage): string;
+}

src/interfaces/code-transformers/ICodeTransformersRunner.ts

@@ -0,0 +1,16 @@
+import { CodeTransformer } from '../../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
+
+export interface ICodeTransformersRunner {
+    /**
+     * @param {string} code
+     * @param {CodeTransformer[]} codeTransformers
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    transform (
+        code: string,
+        codeTransformers: CodeTransformer[],
+        codeTransformationStage: CodeTransformationStage
+    ): string;
+}

src/interfaces/node-transformers/INodeTransformer.ts

@@ -1,17 +1,13 @@
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
+import { ITransformer } from '../ITransformer';
 import { IVisitor } from './IVisitor';
 
 import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 
-export interface INodeTransformer {
-    /**
-     * @type {NodeTransformer[] | undefined}
-     */
-    runAfter?: NodeTransformer[];
-
+export interface INodeTransformer extends ITransformer <NodeTransformer> {
     /**
      * @param {NodeTransformationStage} nodeTransformationStage
      * @returns {IVisitor | null}

src/interfaces/utils/INodeTransformerNamesGroupsBuilder.ts

@@ -1,11 +0,0 @@
-import { TNormalizedNodeTransformers } from '../../types/node-transformers/TNormalizedNodeTransformers';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-
-export interface INodeTransformerNamesGroupsBuilder {
-    /**
-     * @param {TNormalizedNodeTransformers} normalizedNodeTransformers
-     * @returns {NodeTransformer[][]}
-     */
-    build (normalizedNodeTransformers: TNormalizedNodeTransformers): NodeTransformer[][];
-}

src/interfaces/utils/ITransformerNamesGroupsBuilder.ts

@@ -0,0 +1,12 @@
+import { TObject } from '../../types/TObject';
+
+export interface ITransformerNamesGroupsBuilder <
+    TTransformerName extends string,
+    TTransformer
+> {
+    /**
+     * @param {TObject<TTransformer>} normalizedTransformers
+     * @returns {TTransformerName[][]}
+     */
+    build (normalizedTransformers: TObject<TTransformer>): TTransformerName[][];
+}

src/node-transformers/NodeTransformerNamesGroupsBuilder.ts

@@ -0,0 +1,13 @@
+import { injectable } from 'inversify';
+
+import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
+
+import { AbstractTransformerNamesGroupsBuilder } from '../utils/AbstractTransformerNamesGroupsBuilder';
+
+@injectable()
+export class NodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<
+    NodeTransformer,
+    INodeTransformer
+> {}

src/node-transformers/NodeTransformersRunner.ts

@@ -6,14 +6,14 @@ import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
 import { TNodeTransformerFactory } from '../types/container/node-transformers/TNodeTransformerFactory';
-import { TNormalizedNodeTransformers } from '../types/node-transformers/TNormalizedNodeTransformers';
+import { TObject } from '../types/TObject';
 import { TVisitorDirection } from '../types/node-transformers/TVisitorDirection';
 import { TVisitorFunction } from '../types/node-transformers/TVisitorFunction';
 import { TVisitorResult } from '../types/node-transformers/TVisitorResult';
 
 import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
-import { INodeTransformerNamesGroupsBuilder } from '../interfaces/utils/INodeTransformerNamesGroupsBuilder';
 import { INodeTransformersRunner } from '../interfaces/node-transformers/INodeTransformersRunner';
+import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
 import { IVisitor } from '../interfaces/node-transformers/IVisitor';
 
 import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
@@ -31,19 +31,25 @@ export class NodeTransformersRunner implements INodeTransformersRunner {
     private readonly nodeTransformerFactory: TNodeTransformerFactory;
 
     /**
-     * @type {INodeTransformerNamesGroupsBuilder}
+     * @type {ITransformerNamesGroupsBuilder}
      */
-    private readonly nodeTransformerNamesGroupsBuilder: INodeTransformerNamesGroupsBuilder;
+    private readonly nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
+        NodeTransformer,
+        INodeTransformer
+    >;
 
     /**
      * @param {TNodeTransformerFactory} nodeTransformerFactory
-     * @param {INodeTransformerNamesGroupsBuilder} nodeTransformerNamesGroupsBuilder
+     * @param {ITransformerNamesGroupsBuilder} nodeTransformerNamesGroupsBuilder
      */
     public constructor (
         @inject(ServiceIdentifiers.Factory__INodeTransformer)
             nodeTransformerFactory: TNodeTransformerFactory,
         @inject(ServiceIdentifiers.INodeTransformerNamesGroupsBuilder)
-            nodeTransformerNamesGroupsBuilder: INodeTransformerNamesGroupsBuilder,
+            nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
+                NodeTransformer,
+                INodeTransformer
+            >,
     ) {
         this.nodeTransformerFactory = nodeTransformerFactory;
         this.nodeTransformerNamesGroupsBuilder = nodeTransformerNamesGroupsBuilder;
@@ -64,7 +70,7 @@ export class NodeTransformersRunner implements INodeTransformersRunner {
             return astTree;
         }
 
-        const normalizedNodeTransformers: TNormalizedNodeTransformers =
+        const normalizedNodeTransformers: TObject<INodeTransformer> =
             this.buildNormalizedNodeTransformers(nodeTransformerNames, nodeTransformationStage);
         const nodeTransformerNamesGroups: NodeTransformer[][] =
             this.nodeTransformerNamesGroupsBuilder.build(normalizedNodeTransformers);
@@ -106,15 +112,15 @@ export class NodeTransformersRunner implements INodeTransformersRunner {
     /**
      * @param {NodeTransformer[]} nodeTransformerNames
      * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {TNormalizedNodeTransformers}
+     * @returns {TObject<INodeTransformer>}
      */
     private buildNormalizedNodeTransformers (
         nodeTransformerNames: NodeTransformer[],
         nodeTransformationStage: NodeTransformationStage
-    ): TNormalizedNodeTransformers {
+    ): TObject<INodeTransformer> {
         return nodeTransformerNames
-            .reduce<TNormalizedNodeTransformers>(
-                (acc: TNormalizedNodeTransformers, nodeTransformerName: NodeTransformer) => {
+            .reduce<TObject<INodeTransformer>>(
+                (acc: TObject<INodeTransformer>, nodeTransformerName: NodeTransformer) => {
                     const nodeTransformer: INodeTransformer = this.nodeTransformerFactory(nodeTransformerName);
 
                     if (!nodeTransformer.getVisitor(nodeTransformationStage)) {

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

@@ -85,7 +85,7 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
     public constructor (
         @inject(ServiceIdentifiers.Factory__IDeadCodeInjectionCustomNode)
             deadCodeInjectionCustomNodeFactory: TDeadNodeInjectionCustomNodeFactory,
-        @inject(ServiceIdentifiers.ITransformersRunner) transformersRunner: INodeTransformersRunner,
+        @inject(ServiceIdentifiers.INodeTransformersRunner) transformersRunner: INodeTransformersRunner,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {

src/types/container/code-transformers/TCodeTransformerFactory.ts

@@ -0,0 +1,5 @@
+import { ICodeTransformer } from '../../../interfaces/code-transformers/ICodeTransformer';
+
+import { CodeTransformer } from '../../../enums/code-transformers/CodeTransformer';
+
+export type TCodeTransformerFactory = (codeTransformerName: CodeTransformer) => ICodeTransformer;

src/types/node-transformers/TNodeTransformersRelationEdge.ts

@@ -1,3 +0,0 @@
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-
-export type TNodeTransformersRelationEdge = [NodeTransformer, NodeTransformer | null];

src/types/node-transformers/TNormalizedNodeTransformers.ts

@@ -1,5 +0,0 @@
-import { TObject } from '../TObject';
-
-import { INodeTransformer } from '../../interfaces/node-transformers/INodeTransformer';
-
-export type TNormalizedNodeTransformers = TObject<INodeTransformer>;

src/types/utils/TTransformersRelationEdge.ts

@@ -0,0 +1 @@
+export type TTransformersRelationEdge <TTransformerName extends string> = [TTransformerName, TTransformerName | null];

src/utils/AbstractTransformerNamesGroupsBuilder.ts

@@ -0,0 +1,102 @@
+import { inject, injectable } from 'inversify';
+import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
+
+import { TObject } from '../types/TObject';
+import { TTransformersRelationEdge } from '../types/utils/TTransformersRelationEdge';
+
+import { ILevelledTopologicalSorter } from '../interfaces/utils/ILevelledTopologicalSorter';
+import { ITransformer } from '../interfaces/ITransformer';
+import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
+
+@injectable()
+export abstract class AbstractTransformerNamesGroupsBuilder <
+    TTransformerName extends string,
+    TTransformer extends ITransformer<TTransformerName>
+> implements ITransformerNamesGroupsBuilder <
+    TTransformerName,
+    TTransformer
+> {
+    /**
+     * @type {ILevelledTopologicalSorter<TTransformerName>}
+     */
+    private readonly levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>;
+
+    public constructor (
+        @inject(ServiceIdentifiers.ILevelledTopologicalSorter)
+            levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>
+    ) {
+        this.levelledTopologicalSorter = levelledTopologicalSorter;
+    }
+
+    /**
+     * Builds sorted transformer names by topological sort with levels
+     *
+     * For example, if SplitString transformer has following dependencies inside `runAfter` property:
+     *  - NodeTransformer.ObjectExpressionKeysTransformer,
+     *  - NodeTransformer.TemplateLiteralTransformer
+     *
+     *  Than result node transformer names groups will be like:
+     *  [
+     *      [
+     *          SomeTransformerA,
+     *          ObjectExpressionKeysTransformer,
+     *          TemplateLiteralTransformer,
+     *          SomeTransformerB
+     *      ],
+     *      [
+     *          SplitStringTransformer
+     *      ]
+     *  ]
+     *
+     * @param {TObject<TTransformer>} normalizedTransformers
+     * @returns {TTransformerName[][]}
+     */
+    public build (normalizedTransformers: TObject<TTransformer>): TTransformerName[][] {
+        const transformerNames: TTransformerName[] = <TTransformerName[]>Object.keys(normalizedTransformers);
+        const relationEdges: TTransformersRelationEdge<TTransformerName>[] = this.buildTransformersRelationEdges(
+            transformerNames,
+            normalizedTransformers
+        );
+
+        for (const [precedent, consequent] of relationEdges) {
+            this.levelledTopologicalSorter.add(precedent, consequent);
+        }
+
+        return this.levelledTopologicalSorter.sortByGroups();
+    }
+
+    /**
+     * @param {TTransformerName[]} transformerNames
+     * @param {TObject<TTransformer>} normalizedTransformers
+     * @returns {TTransformersRelationEdge<TTransformerName>[]}
+     */
+    private buildTransformersRelationEdges (
+        transformerNames: TTransformerName[],
+        normalizedTransformers: TObject<TTransformer>
+    ): TTransformersRelationEdge<TTransformerName>[] {
+        const relationEdges: TTransformersRelationEdge<TTransformerName>[] = [];
+
+        for (const transformerName of transformerNames) {
+            const transformer: TTransformer = normalizedTransformers[transformerName];
+            const runAfterRelations: TTransformerName[] | undefined = transformer.runAfter;
+
+            if (!runAfterRelations || !runAfterRelations.length) {
+                relationEdges.push([transformerName, null]);
+                continue;
+            }
+
+            for (const runAfterRelation of runAfterRelations) {
+                const isUnknownRelation: boolean = normalizedTransformers[runAfterRelation] === undefined;
+
+                if (isUnknownRelation) {
+                    relationEdges.push([transformerName, null]);
+                    continue;
+                }
+
+                relationEdges.push([runAfterRelation, transformerName]);
+            }
+        }
+
+        return relationEdges;
+    }
+}

src/utils/NodeTransformerNamesGroupsBuilder.ts

@@ -1,98 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { TNodeTransformersRelationEdge } from '../types/node-transformers/TNodeTransformersRelationEdge';
-import { TNormalizedNodeTransformers } from '../types/node-transformers/TNormalizedNodeTransformers';
-
-import { ILevelledTopologicalSorter } from '../interfaces/utils/ILevelledTopologicalSorter';
-import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
-import { INodeTransformerNamesGroupsBuilder } from '../interfaces/utils/INodeTransformerNamesGroupsBuilder';
-
-import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
-
-@injectable()
-export class NodeTransformerNamesGroupsBuilder implements INodeTransformerNamesGroupsBuilder {
-    /**
-     * @type {ILevelledTopologicalSorter<NodeTransformer>}
-     */
-    private readonly levelledTopologicalSorter: ILevelledTopologicalSorter<NodeTransformer>;
-
-    public constructor (
-        @inject(ServiceIdentifiers.ILevelledTopologicalSorter)
-            levelledTopologicalSorter: ILevelledTopologicalSorter<NodeTransformer>
-    ) {
-        this.levelledTopologicalSorter = levelledTopologicalSorter;
-    }
-
-    /**
-     * Builds sorted NodeTransformer names by topological sort with levels
-     *
-     * For example, if SplitString transformer has following dependencies inside `runAfter` property:
-     *  - NodeTransformer.ObjectExpressionKeysTransformer,
-     *  - NodeTransformer.TemplateLiteralTransformer
-     *
-     *  Than result node transformer names groups will be like:
-     *  [
-     *      [
-     *          SomeTransformerA,
-     *          ObjectExpressionKeysTransformer,
-     *          TemplateLiteralTransformer,
-     *          SomeTransformerB
-     *      ],
-     *      [
-     *          SplitStringTransformer
-     *      ]
-     *  ]
-     *
-     * @param {TNormalizedNodeTransformers} normalizedNodeTransformers
-     * @returns {NodeTransformer[][]}
-     */
-    public build (normalizedNodeTransformers: TNormalizedNodeTransformers): NodeTransformer[][] {
-        const nodeTransformerNames: NodeTransformer[] = <NodeTransformer[]>Object.keys(normalizedNodeTransformers);
-        const relationEdges: TNodeTransformersRelationEdge[] = this.buildNodeTransformersRelationEdges(
-            nodeTransformerNames,
-            normalizedNodeTransformers
-        );
-
-        for (const [precedent, consequent] of relationEdges) {
-            this.levelledTopologicalSorter.add(precedent, consequent);
-        }
-
-        return this.levelledTopologicalSorter.sortByGroups();
-    }
-
-    /**
-     * @param {NodeTransformer[]} nodeTransformerNames
-     * @param {TNormalizedNodeTransformers} normalizedNodeTransformers
-     * @returns {[NodeTransformer, NodeTransformer][]}
-     */
-    private buildNodeTransformersRelationEdges (
-        nodeTransformerNames: NodeTransformer[],
-        normalizedNodeTransformers: TNormalizedNodeTransformers
-    ): TNodeTransformersRelationEdge[] {
-        const relationEdges: TNodeTransformersRelationEdge[] = [];
-
-        for (const nodeTransformerName of nodeTransformerNames) {
-            const nodeTransformer: INodeTransformer = normalizedNodeTransformers[nodeTransformerName];
-            const runAfterRelations: NodeTransformer[] | undefined = nodeTransformer.runAfter;
-
-            if (!runAfterRelations || !runAfterRelations.length) {
-                relationEdges.push([nodeTransformerName, null]);
-                continue;
-            }
-
-            for (const runAfterRelation of runAfterRelations) {
-                const isUnknownRelation: boolean = normalizedNodeTransformers[runAfterRelation] === undefined;
-
-                if (isUnknownRelation) {
-                    relationEdges.push([nodeTransformerName, null]);
-                    continue;
-                }
-
-                relationEdges.push([runAfterRelation, nodeTransformerName]);
-            }
-        }
-
-        return relationEdges;
-    }
-}

test/dev/dev.ts

@@ -7,7 +7,9 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-             /**
+            #!/usr/bin/env node
+        
+            /**
              * @license
              */
             var foo = 'abc';

test/functional-tests/code-transformers/preparing-transformers/hashbang-operator-transformer/HashbangOperatorTransformer.spec.ts

@@ -0,0 +1,83 @@
+import { assert } from 'chai';
+
+import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
+
+import { readFileAsString } from '../../../../helpers/readFileAsString';
+
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
+
+describe('HashbangOperatorTransformer', () => {
+    describe('Variant #1: simple', () => {
+        const regExp: RegExp = new RegExp(
+            `#!\/usr\/bin\/env node\n` +
+            `var foo *= *'abc';`
+        );
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/simple.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET
+                }
+            ).getObfuscatedCode();
+        });
+
+        it('should remove hashbang operator before ast transformation and append it after', () => {
+            assert.match(obfuscatedCode, regExp);
+        });
+    });
+
+    describe('Variant #2: multiple new lines', () => {
+        const regExp: RegExp = new RegExp(
+            `#!\/usr\/bin\/env node\n\n\n\n` +
+            `var foo *= *'abc';`
+        );
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/multiple-new-lines.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET
+                }
+            ).getObfuscatedCode();
+        });
+
+        it('should remove hashbang operator before ast transformation and append it after', () => {
+            assert.match(obfuscatedCode, regExp);
+        });
+    });
+
+    describe('Variant #3: `stringArray` option enabled', () => {
+        const regExp: RegExp = new RegExp(
+            `#!\/usr\/bin\/env node\n` +
+            `var _0x(\\w){4} *= *\\['abc'];`
+        );
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/simple.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    stringArray: true,
+                    stringArrayThreshold: 1
+                }
+            ).getObfuscatedCode();
+        });
+
+        it('should remove hashbang operator before ast transformation and append it after', () => {
+            assert.match(obfuscatedCode, regExp);
+        });
+    });
+});

test/functional-tests/code-transformers/preparing-transformers/hashbang-operator-transformer/fixtures/multiple-new-lines.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+
+
+var foo = 'abc';

test/functional-tests/code-transformers/preparing-transformers/hashbang-operator-transformer/fixtures/simple.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+var foo = 'abc';

test/index.spec.ts

@@ -53,6 +53,7 @@ import './unit-tests/utils/Utils.spec';
  */
 import './functional-tests/analyzers/calls-graph-analyzer/CallsGraphAnalyzer.spec';
 import './functional-tests/cli/JavaScriptObfuscatorCLI.spec';
+import './functional-tests/code-transformers/preparing-transformers/hashbang-operator-transformer/HashbangOperatorTransformer.spec';
 import './functional-tests/custom-code-helpers/console-output/ConsoleOutputDisableExpressionCodeHelper.spec';
 import './functional-tests/custom-code-helpers/common/templates/GlobalVariableNoEvalTemplate.spec';
 import './functional-tests/custom-code-helpers/debug-protection/templates/DebugProtectionFunctionCallTemplate.spec';