diff --git a/dist/index.js b/dist/index.js
index 44c99405..722ef773 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -201,6 +201,7 @@ var esprima = __webpack_require__(49);
 var estraverse = __webpack_require__(18);
 var NodeType_1 = __webpack_require__(15);
 var Node_1 = __webpack_require__(12);
+var Nodes_1 = __webpack_require__(22);
 
 var NodeUtils = function () {
     function NodeUtils() {
@@ -333,7 +334,7 @@ var NodeUtils = function () {
                         if (node.type === NodeType_1.NodeType.Program) {
                             value = node;
                         } else {
-                            value = Node_1.Node.getProgramNode([node]);
+                            value = Nodes_1.Nodes.getProgramNode([node]);
                             value.parentNode = value;
                         }
                         isRootNode = false;
@@ -562,16 +563,6 @@ var Node = function () {
     }
 
     (0, _createClass3.default)(Node, null, [{
-        key: "getProgramNode",
-        value: function getProgramNode(bodyNode) {
-            return {
-                'type': NodeType_1.NodeType.Program,
-                'body': bodyNode,
-                'sourceType': 'script',
-                'obfuscated': false
-            };
-        }
-    }, {
         key: "isArrowFunctionExpressionNode",
         value: function isArrowFunctionExpressionNode(node) {
             return node.type === NodeType_1.NodeType.ArrowFunctionExpression;
@@ -5117,14 +5108,14 @@ var BlockStatementControlFlowTransformer = BlockStatementControlFlowTransformer_
                 return blockStatementNode;
             }
             var blockStatementBody = blockStatementNode.body;
+            if (blockStatementBody.length <= 4) {
+                return blockStatementNode;
+            }
             var originalKeys = [].concat((0, _toConsumableArray3.default)(Array(blockStatementBody.length).keys()));
             var shuffledKeys = Utils_1.Utils.arrayShuffle(originalKeys);
             var originalKeysIndexesInShuffledArray = originalKeys.map(function (key) {
                 return shuffledKeys.indexOf(key);
             });
-            if (blockStatementBody.length <= 4) {
-                return blockStatementNode;
-            }
             var blockStatementControlFlowFlatteningCustomNode = this.customNodeFactory(CustomNodes_1.CustomNodes.BlockStatementControlFlowFlatteningNode);
             blockStatementControlFlowFlatteningCustomNode.initialize(blockStatementBody, shuffledKeys, originalKeysIndexesInShuffledArray);
             return blockStatementControlFlowFlatteningCustomNode.getNode()[0];
diff --git a/src/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.ts b/src/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.ts
index 8c150041..df9c6fe8 100644
--- a/src/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.ts
+++ b/src/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.ts
@@ -62,14 +62,14 @@ export class BlockStatementControlFlowTransformer extends AbstractNodeTransforme
         }
 
         const blockStatementBody: ESTree.Statement[] = blockStatementNode.body;
-        const originalKeys: number[] = [...Array(blockStatementBody.length).keys()];
-        const shuffledKeys: number[] = Utils.arrayShuffle(originalKeys);
-        const originalKeysIndexesInShuffledArray: number[] = originalKeys.map((key: number) => shuffledKeys.indexOf(key));
 
         if (blockStatementBody.length <= 4) {
             return blockStatementNode;
         }
 
+        const originalKeys: number[] = [...Array(blockStatementBody.length).keys()];
+        const shuffledKeys: number[] = Utils.arrayShuffle(originalKeys);
+        const originalKeysIndexesInShuffledArray: number[] = originalKeys.map((key: number) => shuffledKeys.indexOf(key));
         const blockStatementControlFlowFlatteningCustomNode: ICustomNode = this.customNodeFactory(
             CustomNodes.BlockStatementControlFlowFlatteningNode
         );
diff --git a/src/node/Node.ts b/src/node/Node.ts
index 89f16bf7..046f092d 100644
--- a/src/node/Node.ts
+++ b/src/node/Node.ts
@@ -1,24 +1,10 @@
 import * as ESTree from 'estree';
 
 import { TNodeWithBlockStatement } from '../types/node/TNodeWithBlockStatement';
-import { TStatement } from '../types/node/TStatement';
 
 import { NodeType } from '../enums/NodeType';
 
 export class Node {
-    /**
-     * @param bodyNode
-     * @returns ESTree.Program
-     */
-    public static getProgramNode (bodyNode: TStatement[]): ESTree.Program {
-        return {
-            'type': NodeType.Program,
-            'body': bodyNode,
-            'sourceType': 'script',
-            'obfuscated': false
-        };
-    }
-
     /**
      * @param node
      * @returns {boolean}
@@ -109,9 +95,7 @@ export class Node {
         const parentNodeIsContinueStatementNode: boolean = Node.isContinueStatementNode(parentNode) && parentNode.label === node;
         const parentNodeIsBreakStatementNode: boolean = Node.isBreakStatementNode(parentNode) && parentNode.label === node;
 
-        return parentNodeIsLabeledStatementNode ||
-            parentNodeIsContinueStatementNode ||
-            parentNodeIsBreakStatementNode;
+        return parentNodeIsLabeledStatementNode || parentNodeIsContinueStatementNode || parentNodeIsBreakStatementNode;
     }
 
     /**
@@ -181,9 +165,7 @@ export class Node {
             parentNode.property === node
         );
 
-        return !parentNodeIsPropertyNode &&
-            !parentNodeIsMemberExpressionNode &&
-            !Node.isLabelIdentifierNode(node, parentNode);
+        return !parentNodeIsPropertyNode && !parentNodeIsMemberExpressionNode && !Node.isLabelIdentifierNode(node, parentNode);
     }
 
     /**
diff --git a/src/node/NodeUtils.ts b/src/node/NodeUtils.ts
index 14e95125..fb4edfaa 100644
--- a/src/node/NodeUtils.ts
+++ b/src/node/NodeUtils.ts
@@ -9,6 +9,7 @@ import { TStatement } from '../types/node/TStatement';
 import { NodeType } from '../enums/NodeType';
 
 import { Node } from './Node';
+import { Nodes } from './Nodes';
 
 export class NodeUtils {
     /**
@@ -166,7 +167,7 @@ export class NodeUtils {
                     if (node.type === NodeType.Program) {
                         value = node;
                     } else {
-                        value = Node.getProgramNode(<TStatement[]>[node]);
+                        value = Nodes.getProgramNode(<TStatement[]>[node]);
                         value.parentNode = value;
                     }