custom node templates update

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

@@ -42,6 +42,7 @@ export class DomainLockNode extends AbstractCustomNode {
 
         return NodeUtils.convertCodeToStructure(
             DomainLockNodeTemplate().formatUnicorn({
+                domainLockFunctionName: Utils.getRandomVariableName(),
                 diff: diff,
                 domains: hiddenDomainsString
             })

src/templates/custom-nodes/console-output-nodes/console-output-disable-expression-node/ConsoleOutputDisableExpressionTemplate.ts

@@ -4,6 +4,18 @@
 export function ConsoleOutputDisableExpressionTemplate (): string {
     return `
         (function () {
+            var getGlobal = function () {
+                if (typeof self !== 'undefined') { return self; }
+                if (typeof window !== 'undefined') { return window; }
+                if (typeof global !== 'undefined') { return global; }
+            };
+        
+            if (getGlobal().firstRun) {
+                return false;
+            }
+                                                    
+            getGlobal().firstRun = true;
+            
             var _ = '(\u0004\u0006\u0003\u0005[]' + '["filter"]["\u0007tructor"]' + '("return this")()' + '.' + '\u0003;\u0006\u0002\u0005\u0004};' + '_\u0003.log\u0001.in' + 'fo\u0001.' + 'war' + 'n\u0001.er' + 'r' + 'or\u0001})();' + '\u0001\u0005_\u0002;' + '_\u0003\u0002function' + '\u0003\u0007ole\u0004\u0002 ()' + '{\u0005 = \u0006var ' + '_\u0007cons', 
                 Y, 
                 $;

src/templates/custom-nodes/domain-lock-nodes/domain-lock-node/DomainLockNodeTemplate.ts

@@ -1,54 +1,75 @@
-import { Utils } from '../../../../Utils';
-
 /**
  * @returns {string}
  */
 export function DomainLockNodeTemplate (): string {
     return `
-        (function () {
-            var regExp = new RegExp("[{diff}]", "g");
-            var domains = "{domains}".replace(regExp, "").split(";");
-            var eval = []["forEach"]["constructor"];
-            var window = eval("return this")();
+        var {domainLockFunctionName} = function () {
+            var getGlobal = function () {
+                if (typeof self !== 'undefined') { return self; }
+                if (typeof window !== 'undefined') { return window; }
+                if (typeof global !== 'undefined') { return global; }
+            };
             
-            for (var d in window) {
-                if (d.length == 8 && d.charCodeAt(7) == 116 && d.charCodeAt(5) == 101 && d.charCodeAt(3) == 117 && d.charCodeAt(0) == 100) {
-                    break;
+            var func = function () {
+                eval('while(true){}')();
+            };
+        
+            if (
+                !getGlobal().argv ||
+                !getGlobal().argv.appParams
+            ) {
+                console.log(2222);
+            
+                getGlobal().argv = {
+                    appParams: -1
+                };
+                
+                var regExp = new RegExp("[{diff}]", "g");
+                var domains = "{domains}".replace(regExp, "").split(";");
+                var eval = []["forEach"]["constructor"];
+                var window = eval("return this")();
+                
+                for (var d in window) {
+                    if (d.length == 8 && d.charCodeAt(7) == 116 && d.charCodeAt(5) == 101 && d.charCodeAt(3) == 117 && d.charCodeAt(0) == 100) {
+                        break;
+                    }
                 }
-            }
-
-            for (var d1 in window[d]) {
-                if (d1.length == 6 && d1.charCodeAt(5) == 110 && d1.charCodeAt(0) == 100) {
-                    break;
+    
+                for (var d1 in window[d]) {
+                    if (d1.length == 6 && d1.charCodeAt(5) == 110 && d1.charCodeAt(0) == 100) {
+                        break;
+                    }
                 }
-            }
-
-            var currentDomain = window[d][d1];
-            
-            if (!currentDomain) {
-                return;
-            }
-            
-            var ok = false;
-                        
-            for (var i = 0; i < domains.length; i++) {
-                var domain = domains[i];
-                var position = currentDomain.length - domain.length;
-                var lastIndex = currentDomain.indexOf(domain, position);
-                var endsWith = lastIndex !== -1 && lastIndex === position;
+    
+                var currentDomain = window[d][d1];
                 
-                if (endsWith) {
-                    if (currentDomain.length == domain.length || domain.indexOf(".") === 0) {
-                        ok = true;
+                if (!currentDomain) {
+                    return;
+                }
+                
+                var ok = false;
+                            
+                for (var i = 0; i < domains.length; i++) {
+                    var domain = domains[i];
+                    var position = currentDomain.length - domain.length;
+                    var lastIndex = currentDomain.indexOf(domain, position);
+                    var endsWith = lastIndex !== -1 && lastIndex === position;
+                    
+                    if (endsWith) {
+                        if (currentDomain.length == domain.length || domain.indexOf(".") === 0) {
+                            ok = true;
+                        }
+                        
+                        break;
                     }
+                }
                     
-                    break;
+                if (!ok) {
+                    func();
                 }
             }
-                
-            if (!ok) {
-                eval('${Utils.stringToJSFuck('while')}(true){}')();
-            }
-        })();
+        };
+        
+        {domainLockFunctionName}();
     `;
 }

src/templates/custom-nodes/self-defending-nodes/self-defending-unicode-node/SelfDefendingTemplate.ts

@@ -9,12 +9,24 @@ import { Utils } from '../../../../Utils';
 export function SelfDefendingTemplate (): string {
     return `
         function {selfDefendingFunctionName} () {
-            if ({selfDefendingFunctionName}.firstRun) {
+            var getGlobal = function () {
+                if (typeof self !== 'undefined') { return self; }
+                if (typeof window !== 'undefined') { return window; }
+                if (typeof global !== 'undefined') { return global; }
+            };
+        
+            if (
+                getGlobal().process && 
+                getGlobal().process.appTimeoutStateCounter++ && 
+                getGlobal().process.appTimeoutStateCounter !== 50
+            ) {
                 return false;
             }
-                                        
-            {selfDefendingFunctionName}.firstRun = true;
             
+            getGlobal().process = {
+                appTimeoutStateCounter: 50
+            };
+              
             var func1 = function(){return 'dev';},
                 func2 = function () {
                     return 'window';

test/functional-tests/templates/custom-nodes/domain-lock-nodes/DomainLockNodeTemplate.spec.ts

@@ -16,6 +16,7 @@ function getFunctionFromTemplate (templateData: any, currentDomain: string) {
     let domainLockTemplate: string = DomainLockNodeTemplate().formatUnicorn(templateData);
 
     return Function(`
+        
         document = {
             domain: '${currentDomain}'
         };
@@ -39,6 +40,7 @@ describe('DomainLockNodeTemplate (): string', () => {
         ] = Utils.hideString(domainsString, domainsString.length * 3);
 
         assert.doesNotThrow(() => getFunctionFromTemplate({
+            domainLockFunctionName: 'func',
             diff: diff,
             domains: hiddenDomainsString
         }, currentDomain));
@@ -53,6 +55,7 @@ describe('DomainLockNodeTemplate (): string', () => {
         ] = Utils.hideString(domainsString, domainsString.length * 3);
 
         assert.doesNotThrow(() => getFunctionFromTemplate({
+            domainLockFunctionName: 'func',
             diff: diff,
             domains: hiddenDomainsString
         }, currentDomain));
@@ -67,6 +70,7 @@ describe('DomainLockNodeTemplate (): string', () => {
         ] = Utils.hideString(domainsString, domainsString.length * 3);
 
         assert.throws(() => getFunctionFromTemplate({
+            domainLockFunctionName: 'func',
             diff: diff,
             domains: hiddenDomainsString
         }, currentDomain));