Keep comments with specific keywords

src/JavaScriptObfuscator.ts

@@ -32,6 +32,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @type {GenerateOptions}
      */
     private static readonly escodegenParams: escodegen.GenerateOptions = {
+        comment: true,
         verbatim: 'x-verbatim-property',
         sourceMapWithCode: true
     };
@@ -78,6 +79,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @type {NodeTransformer[]}
      */
     private static readonly preparingTransformersList: NodeTransformer[] = [
+        NodeTransformer.CommentsTransformer,
         NodeTransformer.ObfuscatingGuardsTransformer,
         NodeTransformer.ParentificationTransformer
     ];
@@ -193,7 +195,11 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @returns {Program}
      */
     private transformAstTree (astTree: ESTree.Program): ESTree.Program {
-        if (NodeGuards.isProgramNode(astTree) && !astTree.body.length) {
+        const isEmptyAstTree: boolean = NodeGuards.isProgramNode(astTree)
+            && !astTree.body.length
+            && !astTree.leadingComments;
+
+        if (isEmptyAstTree) {
             this.logger.warn(LoggingMessage.EmptySourceCode);
 
             return astTree;

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

@@ -9,12 +9,17 @@ import { NodeTransformer } from '../../../enums/node-transformers/NodeTransforme
 import { ObfuscatingGuard } from '../../../enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard';
 
 import { BlackListObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/BlackListObfuscatingGuard';
+import { CommentsTransformer } from '../../../node-transformers/preparing-transformers/CommentsTransformer';
 import { ConditionalCommentObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard';
 import { ObfuscatingGuardsTransformer } from '../../../node-transformers/preparing-transformers/ObfuscatingGuardsTransformer';
 import { ParentificationTransformer } from '../../../node-transformers/preparing-transformers/ParentificationTransformer';
 
 export const preparingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // preparing transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(CommentsTransformer)
+        .whenTargetNamed(NodeTransformer.CommentsTransformer);
+
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(ObfuscatingGuardsTransformer)
         .whenTargetNamed(NodeTransformer.ObfuscatingGuardsTransformer);

src/enums/node-transformers/NodeTransformer.ts

@@ -1,6 +1,7 @@
 export enum NodeTransformer {
     BlockStatementControlFlowTransformer,
     ClassDeclarationTransformer,
+    CommentsTransformer,
     DeadCodeInjectionTransformer,
     FunctionControlFlowTransformer,
     CatchClauseTransformer,

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

@@ -0,0 +1,85 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeGuards } from '../../node/NodeGuards';
+
+@injectable()
+export class CommentsTransformer extends AbstractNodeTransformer {
+    /**
+     * @type {string[]}
+     */
+    private static preservedWords: string[] = ['@license', '@preserve', 'javascript-obfuscator'];
+
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(randomGenerator, options);
+    }
+
+    /**
+     * @return {IVisitor}
+     */
+    public getVisitor (): IVisitor {
+        return {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
+                if (parentNode && NodeGuards.isNodeWithComments(node)) {
+                    return this.transformNode(node, parentNode);
+                }
+            }
+        };
+    }
+
+    /**
+     * Removes all comments from node except comments that contain
+     * `@license`, `@preserve` or `javascript-obfuscator` words
+     *
+     * @param {Node} node
+     * @param {Node} parentNode
+     * @returns {NodeGuards}
+     */
+    public transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node {
+        if (node.leadingComments) {
+            node.leadingComments = this.transformComments(node.leadingComments);
+        }
+
+        if (node.trailingComments) {
+            node.trailingComments = this.transformComments(node.trailingComments);
+        }
+
+        return node;
+    }
+
+    /**
+     * @param {Comment[]} comments
+     * @returns {Comment[]}
+     */
+    private transformComments (comments: ESTree.Comment[]): ESTree.Comment[] {
+        let i: number = comments.length;
+
+        while (i--) {
+            const comment: ESTree.Comment = comments[i];
+            const commentHasPreservedWords: boolean = CommentsTransformer.preservedWords
+                .some((availableWord: string) => comment.value.includes(availableWord));
+
+            if (commentHasPreservedWords) {
+                continue;
+            }
+
+            comments.splice(i, 1);
+        }
+
+        return comments;
+    }
+}

src/node/NodeGuards.ts

@@ -178,6 +178,14 @@ export class NodeGuards {
         return Array.isArray((<TNodeWithBlockStatement>node).body);
     }
 
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isNodeWithComments (node: ESTree.Node): node is ESTree.Node {
+        return Boolean(node.leadingComments) || Boolean(node.trailingComments);
+    }
+
     /**
      * @param {Node} node
      * @returns {boolean}