repalced `forEach` loops on `for` loops in places where performance is very important

CHANGELOG.md

@@ -1,5 +1,9 @@
 Change Log
 ===
+v0.9.0-beta.5
+---
+* Increased performance
+
 v0.9.0-beta.4
 ---
 * Increased performance

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.9.0-beta.4",
+  "version": "0.9.0-beta.5",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",

src/Obfuscator.ts

@@ -159,20 +159,27 @@ export class Obfuscator implements IObfuscator {
         astTree: ESTree.Program,
         nodeTransformers: NodeTransformers[]
     ): ESTree.Program {
-        const visitors: IVisitor[] = nodeTransformers
-            .map((nodeTransformer: NodeTransformers): IVisitor => {
-                return this.nodeTransformersFactory(nodeTransformer).getVisitor();
-            });
+        const enterVisitors: IVisitor[] = [];
+        const leaveVisitors: IVisitor[] = [];
+        const nodeTransformersLength: number = nodeTransformers.length;
+
+        let visitor: IVisitor;
+
+        for (let i: number = 0; i < nodeTransformersLength; i++) {
+            visitor = this.nodeTransformersFactory(nodeTransformers[i]).getVisitor();
+
+            if (visitor.enter) {
+                enterVisitors.push(visitor);
+            }
+
+            if (visitor.leave) {
+                leaveVisitors.push(visitor);
+            }
+        }
 
         estraverse.replace(astTree, {
-            enter: this.mergeVisitorsForDirection(
-                visitors.filter((visitor: IVisitor) => visitor.enter !== undefined),
-                VisitorDirection.enter
-            ),
-            leave: this.mergeVisitorsForDirection(
-                visitors.filter((visitor: IVisitor) => visitor.leave !== undefined),
-                VisitorDirection.leave
-            )
+            enter: this.mergeVisitorsForDirection(enterVisitors, VisitorDirection.enter),
+            leave: this.mergeVisitorsForDirection(leaveVisitors, VisitorDirection.leave)
         });
 
         return astTree;
@@ -188,22 +195,28 @@ export class Obfuscator implements IObfuscator {
             return (node: ESTree.Node, parentNode: ESTree.Node) => node;
         }
 
+        const visitorsLength: number = visitors.length;
+
+        let visitor: IVisitor;
+
         return (node: ESTree.Node, parentNode: ESTree.Node) => {
-            visitors.forEach((visitor: IVisitor) => {
+            for (let i: number = 0; i < visitorsLength; i++) {
+                visitor = visitors[i];
+
                 const visitorFunction: TVisitorFunction | undefined = visitor[direction];
 
                 if (!visitorFunction) {
-                    return;
+                    continue;
                 }
 
                 const visitorResult: ESTree.Node | void = visitorFunction(node, parentNode);
 
                 if (!visitorResult) {
-                    return;
+                    continue;
                 }
 
-                node = <ESTree.Node>visitorResult;
-            });
+                node = visitorResult;
+            }
 
             return node;
         };

src/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.ts

@@ -56,9 +56,9 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
     private readonly visitedFunctionNodes: Set<ESTree.Function> = new Set();
 
     /**
-     * @type {TNodeWithBlockStatement[]}
+     * @type {Set<TNodeWithBlockStatement>}
      */
-    private readonly hostNodesWithControlFlowNode: TNodeWithBlockStatement[] = [];
+    private readonly hostNodesWithControlFlowNode: Set<TNodeWithBlockStatement> = new Set();
 
     /**
      * @type {TControlFlowReplacerFactory}
@@ -161,7 +161,7 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
 
         controlFlowStorageCustomNode.initialize(controlFlowStorage);
         NodeAppender.prependNode(hostNode, controlFlowStorageCustomNode.getNode());
-        this.hostNodesWithControlFlowNode.push(hostNode);
+        this.hostNodesWithControlFlowNode.add(hostNode);
 
         return functionNode;
     }
@@ -174,7 +174,7 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
         const controlFlowStorage: IStorage <ICustomNode> = this.controlFlowStorageFactory();
 
         if (this.controlFlowData.has(hostNode)) {
-            if (this.hostNodesWithControlFlowNode.indexOf(hostNode) !== -1) {
+            if (this.hostNodesWithControlFlowNode.has(hostNode)) {
                 hostNode.body.shift();
             }