Index: gc_core/js/lang_core/gc_engine.js
==================================================================
--- gc_core/js/lang_core/gc_engine.js
+++ gc_core/js/lang_core/gc_engine.js
@@ -353,11 +353,11 @@
             console.log("UPDATE:");
             console.log(this.asString());
         }
     }
 
-    _getNextPointers (self, dToken, dGraph, dPointer, bDebug=false) {
+    * _getNextPointers (self, dToken, dGraph, dPointer, bDebug=false) {
         // generator: return nodes where <dToken> “values” match <dNode> arcs
         let dNode = dPointer["dNode"];
         let iNode1 = dPointer["iNode1"];
         let bTokenFound = false;
         // token value
@@ -400,16 +400,17 @@
         if (dToken["sType"] != "INFO"  &&  dToken["sType"] != "PUNC"  &&  dToken["sType"] != "SIGN") {
             if (dNode.hasOwnProperty("<re_value>")) {
                 for (let sRegex in dNode["<re_value>"]) {
                     if (!sRegex.includes("¬")) {
                         // no anti-pattern
-                        if (dToken["sValue"].search(sRegex) !== -1):
+                        if (dToken["sValue"].search(sRegex) !== -1) {
                             if (bDebug) {
                                 console.log("  MATCH: ~" + sRegex);
                             }
                             yield { "iNode1": iNode1, "dNode": dGraph[dNode["<re_value>"][sRegex]] };
                             bTokenFound = true;
+                        }
                     } else {
                         // there is an anti-pattern
                         let [sPattern, sNegPattern] = sRegex.split("¬", 1);
                         if (sNegPattern && dToken["sValue"].search(sNegPattern) !== -1) {
                             continue;
@@ -484,11 +485,11 @@
                 }
             }
         }
         // token tags
         if (dToken.hasOwnProperty("tags") && dNode.hasOwnProperty("<tags>")) {
-            for (dToken["tags"].has(sTag)) {
+            for (let sTag in dToken["tags"]) {
                 if (dNode["<tags>"].hasOwnProperty(sTag)) {
                     if (bDebug) {
                         console.log("  MATCH: /" + sTag);
                     }
                     yield { "iNode1": iNode1, "dNode": dGraph[dNode["<tags>"][sTag]] };
@@ -498,11 +499,11 @@
         }
         // meta arc (for token type)
         if (dNode.hasOwnProperty("<meta>")) {
             for (let sMeta in dNode["<meta>"]) {
                 // no regex here, we just search if <dNode["sType"]> exists within <sMeta>
-                if (sMeta == "*" or dToken["sType"] == sMeta) {
+                if (sMeta == "*" || dToken["sType"] == sMeta) {
                     if (bDebug) {
                         console.log("  MATCH: *" + sMeta);
                     }
                     yield { "iNode1": iNode1, "dNode": dGraph[dNode["<meta>"][sMeta]] };
                     bTokenFound = true;
@@ -521,21 +522,21 @@
         if (!bTokenFound  &&  dPointer.hasOwnProperty("bKeep")) {
             yield dPointer;
         }
         // JUMP
         // Warning! Recurssion!
-        if (dNode.has("<>")) {
+        if (dNode.hasOwnPropertys("<>")) {
             let dPointer2 = { "iNode1": iNode1, "dNode": dGraph[dNode["<>"]], "bKeep": True };
             yield* this._getNextPointers(dToken, dGraph, dPointer2, bDebug);
         }
     }
 
     parseGraph (dGraph, sCountry="${country_default}", dOptions=null, bShowRuleId=false, bDebug=false, bContext=false) {
         // parse graph with tokens from the text and execute actions encountered
         let lPointer = [];
         let bTagAndRewrite = false;
-        for let [iToken, dToken] in this.lToken.entries():
+        for (let [iToken, dToken] in this.lToken.entries()) {
             if (bDebug) {
                 console.log("TOKEN: " + dToken["sValue"]);
             }
             // check arcs for each existing pointer
             let lNextPointer = [];
@@ -547,17 +548,18 @@
             lPointer.push(...this._getNextPointers(dToken, dGraph, { "iNode1": iToken, "dNode": dGraph[0] }, bDebug));
             // check if there is rules to check for each pointer
             for (let dPointer of lPointer) {
                 //if bDebug:
                 //    console.log("+", dPointer);
-                if ("<rules>" in dPointer["dNode"]) {
+                if (dPointer["dNode"].hasOwnProperty("<rules>")) {
                     let bChange = this._executeActions(dGraph, dPointer["dNode"]["<rules>"], dPointer["iNode1"]-1, iToken, dOpt, sCountry, bShowRuleId, bDebug, bContext);
                     if (bChange) {
                         bTagAndRewrite = true;
                     }
                 }
             }
+        }
         if (bTagAndRewrite) {
             this.rewriteFromTags(bDebug);
         }
         if (bDebug) {
             console.log(this);
@@ -568,11 +570,11 @@
     _executeActions (dGraph, dNode, nTokenOffset, nLastToken, dOptions, sCountry, bShowRuleId, bDebug, bContext) {
         // execute actions found in the DARG
         let bChange = false;
         for (let [sLineId, nextNodeKey] of Object.entries(dNode)) {
             let bCondMemo = null;
-            for sRuleId in dGraph[nextNodeKey]:
+            for (let sRuleId in dGraph[nextNodeKey]) {
                 try {
                     if (bDebug) {
                         console.log("   >TRY: " + sRuleId);
                     }
                     let [sOption, sFuncCond, cActionType, sWhat, ...eAct] = gc_rules_graph.dRule[sRuleId];
@@ -642,20 +644,20 @@
                                     console.log("       " + sWhat + " > " + this.lToken[nTokenStart]["sValue"] + " : " + this.lToken[nTokenEnd]["sValue"]);
                                 }
                                 if (!this.dTags.has(sWhat)) {
                                     this.dTags.set(sWhat, [nTokenStart, nTokenStart]);
                                 } else {
-                                    this.dTags.set(sWhat, [min(nTokenStart, this.dTags.get(sWhat)[0], max(nTokenEnd, this.dTags.get(sWhat)[1]]);
+                                    this.dTags.set(sWhat, [Math.min(nTokenStart, this.dTags.get(sWhat)[0]), Math.max(nTokenEnd, this.dTags.get(sWhat)[1])]);
                                 }
                             }
                             else if (cActionType == "%") {
                                 // immunity
                                 if (bDebug) {
                                     console.log("    IMMUNITY:\n      " + _rules_graph.dRule[sRuleId]);;
                                 }
-                                nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : else nLastToken + eAct[0];
-                                nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : else nLastToken + eAct[1];
+                                nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
+                                nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : nLastToken + eAct[1];
                                 if (nTokenEnd - nTokenStart == 0) {
                                     this.lToken[nTokenStart]["bImmune"] = True
                                     let nErrorStart = this.nOffsetWithinParagraph + this.lToken[nTokenStart]["nStart"];
                                     if (nErrorStart in this.dError) {
                                         this.dError.delete(nErrorStart);
@@ -662,11 +664,11 @@
                                     }
                                 } else {
                                     for (let i = nTokenStart;  i <= nTokenEnd;  i++) {
                                         this.lToken[i]["bImmune"] = true;
                                         let nErrorStart = this.nOffsetWithinParagraph + this.lToken[i]["nStart"];
-                                        if (nErrorStart in this.dError) {
+                                        if (this.dError.has(nErrorStart)) {
                                             this.dError.delete(nErrorStart);
                                         }
                                     }
                                 }
                             } else {
@@ -683,10 +685,11 @@
                 }
                 catch (e) {
                     console.log("Error: ", sLineId, sRuleId, this.sSentence);
                     console.error(e);
                 }
+            }
         }
         return bChange;
     }
 
     _createErrorFromRegex (sText, sText0, sSugg, nOffset, m, iGroup, sLineId, sRuleId, bUppercase, sMsg, sURL, bShowRuleId, sOption, bContext) {
@@ -741,11 +744,11 @@
         oErr = {
             "nStart": nStart,
             "nEnd": nEnd,
             "sLineId": sLineId,
             "sRuleId": sRuleId,
-            "sType": sOption  if sOption  else "notype",
+            "sType": sOption || "notype",
             "sMessage": sMessage,
             "aSuggestions": lSugg,
             "URL": sURL
         }
         if (bContext) {
@@ -757,11 +760,11 @@
     }
 
     _expand (sText, nTokenOffset, nLastToken) {
         let m;
         while ((m = /\\(-?[0-9]+)/.exec(sText)) !== null) {
-            if (m[1][0:1] == "-") {
+            if (m[1].slice(0,1) == "-") {
                 sText = sText.replace(m[0], self.lToken[nLastToken+parseInt(m[1],10)+1]["sValue"]);
             } else {
                 sText = sText.replace(m[0], self.lToken[nTokenOffset+parseInt(m[1],10)]["sValue"]);
             }
         }
@@ -772,15 +775,18 @@
         // text processor: write sRepl in sText at iGroup position"
         let ln = m.end[iGroup] - m.start[iGroup];
         let sNew = "";
         if (sRepl === "*") {
             sNew = " ".repeat(ln);
-        } else if (sRepl === ">" || sRepl === "_" || sRepl === "~") {
+        }
+        else if (sRepl === ">" || sRepl === "_" || sRepl === "~") {
             sNew = sRepl + " ".repeat(ln-1);
-        } else if (sRepl === "@") {
+        }
+        else if (sRepl === "@") {
             sNew = "@".repeat(ln);
-        } else if (sRepl.slice(0,1) === "=") {
+        }
+        else if (sRepl.slice(0,1) === "=") {
             sNew = oEvalFunc[sRepl.slice(1)](sText, m);
             sNew = sNew + " ".repeat(ln-sNew.length);
             if (bUppercase && m[iGroup].slice(0,1).gl_isUpperCase()) {
                 sNew = sNew.gl_toCapitalize();
             }
@@ -903,13 +909,13 @@
                     if (bDebug) {
                         console.log(dToken["sValue"] + " -> " + dToken["sNewValue"]);
                     }
                     dToken["sRealValue"] = dToken["sValue"];
                     dToken["sValue"] = dToken["sNewValue"];
-                    nDiffLen = len(dToken["sRealValue"]) - len(dToken["sNewValue"]);
-                    sNewRepl = (nDiffLen >= 0) ? (dToken["sNewValue"] + " ".repeat(nDiffLen) : dToken["sNewValue"].slice(0, len(dToken["sRealValue"]));
-                    this.sSentence = this.sSentence[:dToken["nStart"]] + sNewRepl + this.sSentence[dToken["nEnd"]:];
+                    nDiffLen = dToken["sRealValue"].length - dToken["sNewValue"].length;
+                    sNewRepl = (nDiffLen >= 0) ? dToken["sNewValue"] + " ".repeat(nDiffLen) : dToken["sNewValue"].slice(0, dToken["sRealValue"].length);
+                    this.sSentence = this.sSentence.slice(0,dToken["nStart"]) + sNewRepl + this.sSentence.slice(dToken["nEnd"]);
                     delete dToken["sNewValue"];
                 }
             }
             else {
                 try {
@@ -1051,10 +1057,11 @@
     if (sNegPattern) {
         // check negative condition
         if (sNegPattern === "*") {
             // all morph must match sPattern
             return lMorph.every(sMorph  =>  (sMorph.search(sPattern) !== -1));
+        }
         else {
             if (lMorph.some(sMorph  =>  (sMorph.search(sNegPattern) !== -1))) {
                 return false;
         }
     }
@@ -1071,10 +1078,11 @@
     if (sNegPattern) {
         // check negative condition
         if (sNegPattern === "*") {
             // all morph must match sPattern
             return lMorph.every(sMorph  =>  (sMorph.search(sPattern) !== -1));
+        }
         else {
             if (lMorph.some(sMorph  =>  (sMorph.search(sNegPattern) !== -1))) {
                 return false;
         }
     }
@@ -1097,11 +1105,11 @@
         }
     }
     else if (dToken["sValue"].gl_isUpperCase()) {
         //if sValue.lower() in sValues:
         //    return true;
-        sValue = "|"+sValue[1:].gl_toCapitalize();
+        sValue = "|"+sValue.slice(1).gl_toCapitalize();
         if (sValues.includes(sValue)) {
             return true;
         }
     }
     return false;