fixed incorrect append of nody By CustomNodeAppender

src/custom-nodes/CustomNodeAppender.ts

@@ -47,17 +47,17 @@ export class CustomNodeAppender {
     }
 
     /**
-     * @param blockStatementBodyLength
+     * @param stackTraceRootLength
      * @param threshold
      */
-    public static getIndexByThreshold (blockStatementBodyLength: number, threshold: number = 0.1): number {
+    public static getStackTraceIndexByThreshold (stackTraceRootLength: number, threshold: number = 0.1): number {
         if (threshold < 0 || threshold > 1) {
             throw new RangeError('`threshold` parameter should has value between 0 and 1');
         }
 
         return Utils.getRandomGenerator().integer({
             min: 0,
-            max: Math.round((blockStatementBodyLength - 1) * threshold)
+            max: Math.round((stackTraceRootLength - 1) * threshold)
         });
     }
 

src/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.ts

@@ -27,7 +27,7 @@ export class ConsoleOutputDisableExpressionNode extends AbstractCustomNode {
             stackTraceData,
             blockScopeNode.body,
             this.getNode(),
-            CustomNodeAppender.getIndexByThreshold(blockScopeNode.body.length)
+            CustomNodeAppender.getStackTraceIndexByThreshold(stackTraceData.length)
         );
     }
 

src/custom-nodes/domain-lock-nodes/DomainLockNode.ts

@@ -30,7 +30,7 @@ export class DomainLockNode extends AbstractCustomNode {
             stackTraceData,
             blockScopeNode.body,
             this.getNode(),
-            CustomNodeAppender.getIndexByThreshold(blockScopeNode.body.length)
+            CustomNodeAppender.getStackTraceIndexByThreshold(stackTraceData.length)
         );
     }
 

src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.ts

@@ -30,7 +30,7 @@ export class SelfDefendingUnicodeNode extends AbstractCustomNode {
             stackTraceData,
             blockScopeNode.body,
             this.getNode(),
-            CustomNodeAppender.getIndexByThreshold(blockScopeNode.body.length)
+            CustomNodeAppender.getStackTraceIndexByThreshold(stackTraceData.length)
         );
     }
 

test/dev/test.ts

@@ -8,6 +8,12 @@ const JavaScriptObfuscator: any = require("../../index");
 
 let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
     `
+    var start = new Date();
+
+    var log = console.log;
+    
+    console.log = function () {};
+    
     (function(){
         var result = 1,
             term1 = 0,
@@ -66,6 +72,10 @@ let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
             console.log(error);
         }
     })();
+    
+    console.log = log;
+
+    console.log(new Date() - start);
     `,
     {
         disableConsoleOutput: false,

test/unit-tests/custom-nodes/CustomNodeAppender.spec.ts

@@ -278,29 +278,108 @@ describe('CustomNodeAppender', () => {
 
                 assert.deepEqual(astTree, expectedAstTree);
             });
+
+            it('should append node into deepest function call by specified index in calls trace - variant #3', () => {
+                astTree = <ESTree.Program>NodeUtils.convertCodeToStructure(`
+                    var start = new Date();
+
+                    var log = console.log;
+                    
+                    console.log = function () {};
+                
+                    (function () {
+                        function bar () {
+                            function inner1 () {
+                            
+                            }
+                        
+                            function inner2 () {
+                                var inner3 = function () {
+                                
+                                }
+                                
+                                inner3();
+                            }
+                            
+                            inner2();
+                            inner1();
+                        }
+                        
+                        bar();
+                    })();
+
+                    console.log = log;
+
+                    console.log(new Date() - start);
+                `, false);
+                expectedAstTree = <ESTree.Program>NodeUtils.convertCodeToStructure(`
+                    var start = new Date();
+
+                    var log = console.log;
+                    
+                    console.log = function () {};
+                
+                    (function () {
+                        function bar () {
+                            function inner1 () {
+                            
+                            }
+                        
+                            function inner2 () {
+                                var inner3 = function () {
+                                    var test = 1;
+                                }
+                                
+                                inner3();
+                            }
+                            
+                            inner2();
+                            inner1();
+                        }
+                        
+                        bar();
+                    })();
+
+                    console.log = log;
+
+                    console.log(new Date() - start);
+                `, false);
+
+                stackTraceData = new StackTraceAnalyzer(astTree.body).analyze();
+                CustomNodeAppender.appendNode(
+                    stackTraceData,
+                    astTree.body,
+                    node,
+                    CustomNodeAppender.getStackTraceIndexByThreshold(stackTraceData.length)
+                );
+
+                NodeUtils.parentize(astTree);
+
+                assert.deepEqual(astTree, expectedAstTree);
+            });
         });
     });
 
-    describe('getIndexByThreshold (blockStatementBodyLength: number, threshold: number = 0.1): number', () => {
+    describe('getIndexByThreshold (stackTraceRootLength: number, threshold: number = 0.1): number', () => {
         it('should returns random index between 0 and index based on threshold value', () => {
             let index: number;
 
             for (let i: number = 0; i < 10; i++) {
-                index = CustomNodeAppender.getIndexByThreshold(100, 0.1);
+                index = CustomNodeAppender.getStackTraceIndexByThreshold(100, 0.1);
 
                 assert.isAtLeast(index, 0);
                 assert.isAtMost(index, 10);
             }
 
             for (let i: number = 0; i < 10; i++) {
-                index = CustomNodeAppender.getIndexByThreshold(10, 0.5);
+                index = CustomNodeAppender.getStackTraceIndexByThreshold(10, 0.5);
 
                 assert.isAtLeast(index, 0);
                 assert.isAtMost(index, 5);
             }
 
             for (let i: number = 0; i < 10; i++) {
-                index = CustomNodeAppender.getIndexByThreshold(1, 1);
+                index = CustomNodeAppender.getStackTraceIndexByThreshold(1, 1);
 
                 assert.equal(index, 0);
             }