Obfuscating tranformers and identifier replacer refactoring

src/interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer.d.ts

@@ -5,8 +5,13 @@ import { IObfuscatingReplacer } from './IObfuscatingReplacer';
 export interface IIdentifierObfuscatingReplacer extends IObfuscatingReplacer <ESTree.Identifier> {
     /**
      * @param {string} nodeValue
-     * @param isGlobalDeclaration
      * @param {number} nodeIdentifier
      */
-    storeNames (nodeValue: string, isGlobalDeclaration: boolean, nodeIdentifier: number): void;
+    storeGlobalName (nodeValue: string, nodeIdentifier: number): void;
+
+    /**
+     * @param {string} nodeValue
+     * @param {number} nodeIdentifier
+     */
+    storeLocalName (nodeValue: string, nodeIdentifier: number): void;
 }

src/node-transformers/obfuscating-transformers/CatchClauseTransformer.ts

@@ -90,7 +90,7 @@ export class CatchClauseTransformer extends AbstractNodeTransformer {
      */
     private storeCatchClauseParam (catchClauseNode: ESTree.CatchClause, nodeIdentifier: number): void {
         if (NodeGuards.isIdentifierNode(catchClauseNode.param)) {
-            this.identifierObfuscatingReplacer.storeNames(catchClauseNode.param.name, false, nodeIdentifier);
+            this.identifierObfuscatingReplacer.storeLocalName(catchClauseNode.param.name, nodeIdentifier);
         }
     }
 

src/node-transformers/obfuscating-transformers/ClassDeclarationTransformer.ts

@@ -115,7 +115,11 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
         isGlobalDeclaration: boolean,
         nodeIdentifier: number
     ): void {
-        this.identifierObfuscatingReplacer.storeNames(classDeclarationNode.id.name, isGlobalDeclaration, nodeIdentifier);
+        if (isGlobalDeclaration) {
+            this.identifierObfuscatingReplacer.storeGlobalName(classDeclarationNode.id.name, nodeIdentifier);
+        } else {
+            this.identifierObfuscatingReplacer.storeLocalName(classDeclarationNode.id.name, nodeIdentifier);
+        }
     }
 
     /**

src/node-transformers/obfuscating-transformers/FunctionDeclarationTransformer.ts

@@ -117,7 +117,11 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
         isGlobalDeclaration: boolean,
         nodeIdentifier: number
     ): void {
-        this.identifierObfuscatingReplacer.storeNames(functionDeclarationNode.id.name, isGlobalDeclaration, nodeIdentifier);
+        if (isGlobalDeclaration) {
+            this.identifierObfuscatingReplacer.storeGlobalName(functionDeclarationNode.id.name, nodeIdentifier);
+        } else {
+            this.identifierObfuscatingReplacer.storeLocalName(functionDeclarationNode.id.name, nodeIdentifier);
+        }
     }
 
     /**

src/node-transformers/obfuscating-transformers/FunctionTransformer.ts

@@ -104,13 +104,13 @@ export class FunctionTransformer extends AbstractNodeTransformer {
                 estraverse.traverse(paramsNode, {
                     enter: (node: ESTree.Node): any => {
                         if (NodeGuards.isAssignmentPatternNode(node) && NodeGuards.isIdentifierNode(node.left)) {
-                            this.identifierObfuscatingReplacer.storeNames(node.left.name, false, nodeIdentifier);
+                            this.identifierObfuscatingReplacer.storeLocalName(node.left.name, nodeIdentifier);
 
                             return estraverse.VisitorOption.Skip;
                         }
 
                         if (NodeGuards.isIdentifierNode(node)) {
-                            this.identifierObfuscatingReplacer.storeNames(node.name, false, nodeIdentifier);
+                            this.identifierObfuscatingReplacer.storeLocalName(node.name, nodeIdentifier);
                         }
                     }
                 });

src/node-transformers/obfuscating-transformers/LabeledStatementTransformer.ts

@@ -97,8 +97,7 @@ export class LabeledStatementTransformer extends AbstractNodeTransformer {
      * @param {number} nodeIdentifier
      */
     private storeLabeledStatementName (labeledStatementNode: ESTree.LabeledStatement, nodeIdentifier: number): void {
-        this.identifierObfuscatingReplacer
-            .storeNames(labeledStatementNode.label.name, false, nodeIdentifier);
+        this.identifierObfuscatingReplacer.storeLocalName(labeledStatementNode.label.name, nodeIdentifier);
     }
 
     /**

src/node-transformers/obfuscating-transformers/VariableDeclarationTransformer.ts

@@ -123,7 +123,11 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
         nodeIdentifier: number
     ): void {
         this.traverseDeclarationIdentifiers(variableDeclarationNode, (identifierNode: ESTree.Identifier) => {
-            this.identifierObfuscatingReplacer.storeNames(identifierNode.name, isGlobalDeclaration, nodeIdentifier);
+            if (isGlobalDeclaration) {
+                this.identifierObfuscatingReplacer.storeGlobalName(identifierNode.name, nodeIdentifier);
+            } else {
+                this.identifierObfuscatingReplacer.storeLocalName(identifierNode.name, nodeIdentifier);
+            }
         });
     }
 

src/node-transformers/obfuscating-transformers/obfuscating-replacers/identifier-obfuscating-replacers/BaseIdentifierObfuscatingReplacer.ts

@@ -54,21 +54,35 @@ export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplac
     }
 
     /**
-     * Store all `nodeIdentifier`'s as keys in given `namesMap` with random names as value.
-     * Reserved names will be ignored.
+     * Store `nodeName` of global identifiers as key in map with random name as value.
+     * Reserved name will be ignored.
      *
      * @param {string} nodeName
-     * @param {boolean} isGlobalDeclaration
      * @param {number} nodeIdentifier
      */
-    public storeNames (nodeName: string, isGlobalDeclaration: boolean, nodeIdentifier: number): void {
+    public storeGlobalName (nodeName: string, nodeIdentifier: number): void {
         if (this.isReservedName(nodeName)) {
             return;
         }
 
-        const identifierName: string = isGlobalDeclaration
-            ? this.identifierNamesGenerator.generateWithPrefix()
-            : this.identifierNamesGenerator.generate();
+        const identifierName: string = this.identifierNamesGenerator.generateWithPrefix();
+
+        this.namesMap.set(`${nodeName}-${String(nodeIdentifier)}`, identifierName);
+    }
+
+    /**
+     * Store `nodeName` of local identifier as key in map with random name as value.
+     * Reserved name will be ignored.
+     *
+     * @param {string} nodeName
+     * @param {number} nodeIdentifier
+     */
+    public storeLocalName (nodeName: string, nodeIdentifier: number): void {
+        if (this.isReservedName(nodeName)) {
+            return;
+        }
+
+        const identifierName: string = this.identifierNamesGenerator.generate();
 
         this.namesMap.set(`${nodeName}-${String(nodeIdentifier)}`, identifierName);
     }