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
@@ -181,11 +181,11 @@
     asString () {
         let s = "===== TEXT =====\n"
         s += "sentence: " + this.sSentence0 + "\n";
         s += "now:      " + this.sSentence  + "\n";
         for (let dToken of this.lToken) {
-            s += '#${dToken["i"]}\t${dToken["nStart"]}:{$dToken["nEnd"]}\t${dToken["sValue"]}\t${dToken["sType"]}';
+            s += `#${dToken["i"]}\t${dToken["nStart"]}:${dToken["nEnd"]}\t${dToken["sValue"]}\t${dToken["sType"]}`;
             if (dToken.hasOwnProperty("lMorph")) {
                 s += "\t" + dToken["lMorph"].toString();
             }
             if (dToken.hasOwnProperty("tags")) {
                 s += "\t" + dToken["tags"].toString();
@@ -193,16 +193,17 @@
             s += "\n";
         }
         return s;
     }
 
-    parse (sText, sCountry="${country_default}", bDebug=false, dOptions=null, bContext=false) {
+    parse (sCountry="${country_default}", bDebug=false, dOptions=null, bContext=false) {
         // analyses the paragraph sText and returns list of errors
         let dOpt = dOptions || _dOptions;
+        let bShowRuleId = option('idrule');
         // parse paragraph
         try {
-            this.parseText(this.sText, this.sText0, true, 0, sCountry, dOpt, bDebug, bContext);
+            this.parseText(this.sText, this.sText0, true, 0, sCountry, dOpt, bShowRuleId, bDebug, bContext);
         }
         catch (e) {
             console.error(e);
         }
 
@@ -231,22 +232,21 @@
                 for (let dToken of this.lToken) {
                     if (dToken["sType"] != "INFO") {
                         this.dTokenPos.set(dToken["nStart"], dToken);
                     }
                 }
-                this.parseText(this.sSentence, this.sSentence0, false, iStart, sCountry, dOpt, bDebug, bContext);
+                this.parseText(this.sSentence, this.sSentence0, false, iStart, sCountry, dOpt, bShowRuleId, bDebug, bContext);
             }
             catch (e) {
                 console.error(e);
             }
         }
         return Array.from(this.dError.values());
     }
 
-    parseText (sText, sText0, bParagraph, nOffset, sCountry, dOptions, bDebug, bContext) {
+    parseText (sText, sText0, bParagraph, nOffset, sCountry, dOptions, bShowRuleId, bDebug, bContext) {
         let bChange = false;
-        let bIdRule = option('idrule');
         let m;
 
         for (let [sOption, lRuleGroup] of gc_engine.getRules(bParagraph)) {
             if (sOption == "@@@@") {
                 // graph rules
@@ -255,13 +255,13 @@
                     bChange = false;
                 }
                 for (let [sGraphName, sLineId] of lRuleGroup) {
                     if (!dOptions.has(sGraphName) || dOptions.get(sGraphName)) {
                         if (bDebug) {
-                            console.log("\n>>>> GRAPH: " + sGraphName + " " + sLineId);
+                            console.log(">>>> GRAPH: " + sGraphName + " " + sLineId);
                         }
-                        sText = this.parseGraph(gc_rules_graph.dAllGraph[sGraphName] , sCountry, dOptions, bDebug, bContext);
+                        sText = this.parseGraph(gc_rules_graph.dAllGraph[sGraphName], sCountry, dOptions, bShowRuleId, bDebug, bContext);
                     }
                 }
             }
             else if (!sOption || option(sOption)) {
                 for (let [zRegex, bUppercase, sLineId, sRuleId, nPriority, lActions, lGroups, lNegLookBefore] of lRuleGroup) {
@@ -277,11 +277,11 @@
                                             case "-":
                                                 // grammar error
                                                 //console.log("-> error detected in " + sLineId + "\nzRegex: " + zRegex.source);
                                                 let nErrorStart = nOffset + m.start[eAct[0]];
                                                 if (!this.dError.has(nErrorStart) || nPriority > this.dErrorPriority.get(nErrorStart)) {
-                                                    this.dError.set(nErrorStart, this._createErrorFromRegex(sText, sText0, sWhat, nOffset, m, eAct[0], sLineId, sRuleId, bUppercase, eAct[1], eAct[2], bIdRule, sOption, bContext));
+                                                    this.dError.set(nErrorStart, this._createErrorFromRegex(sText, sText0, sWhat, nOffset, m, eAct[0], sLineId, sRuleId, bUppercase, eAct[1], eAct[2], bShowRuleId, sOption, bContext));
                                                     this.dErrorPriority.set(nErrorStart, nPriority);
                                                 }
                                                 break;
                                             case "~":
                                                 // text processor
@@ -325,11 +325,11 @@
         }
         if (bChange) {
             if (bParagraph) {
                 this.sText = sText;
             } else {
-                this.sSentence = sText
+                this.sSentence = sText;
             }
         }
     }
 
     update (sSentence, bDebug=false) {
@@ -591,11 +591,11 @@
                         if (bCondMemo) {
                             if (cActionType == "-") {
                                 // grammar error
                                 let [iTokenStart, iTokenEnd, cStartLimit, cEndLimit, bCaseSvty, nPriority, sMessage, sURL] = eAct;
                                 let nTokenErrorStart = (iTokenStart > 0) ? nTokenOffset + iTokenStart : nLastToken + iTokenStart;
-                                if (this.lToken[nTokenErrorStart].hasOwnProperty("bImmune")) {
+                                if (!this.lToken[nTokenErrorStart].hasOwnProperty("bImmune")) {
                                     let nTokenErrorEnd = (iTokenEnd > 0) ? nTokenOffset + iTokenEnd : nLastToken + iTokenEnd;
                                     let nErrorStart = this.nOffsetWithinParagraph + ((cStartLimit == "<") ? this.lToken[nTokenErrorStart]["nStart"] : this.lToken[nTokenErrorStart]["nEnd"]);
                                     let nErrorEnd = this.nOffsetWithinParagraph + ((cEndLimit == ">") ? this.lToken[nTokenErrorEnd]["nEnd"] : this.lToken[nTokenErrorEnd]["nStart"]);
                                     if (!this.dError.has(nErrorStart) || nPriority > this.dErrorPriority.get(nErrorStart, -1)) {
                                         this.dError[nErrorStart] = this._createErrorFromTokens(sWhat, nTokenOffset, nLastToken, nTokenErrorStart, nErrorStart, nErrorEnd, sLineId, sRuleId, bCaseSvty, sMessage, sURL, bShowRuleId, sOption, bContext);
@@ -794,11 +794,11 @@
             }
         } else {
             sNew = sRepl.gl_expand(m);
             sNew = sNew + " ".repeat(ln-sNew.length);
         }
-        //console.log("\n"+sText+"\nstart: "+m.start[iGroup]+" end:"+m.end[iGroup])
+        //console.log(sText+"\nstart: "+m.start[iGroup]+" end:"+m.end[iGroup]);
         return sText.slice(0, m.start[iGroup]) + sNew + sText.slice(m.end[iGroup]);
     }
 
     _tagAndPrepareTokenForRewriting (sWhat, nTokenRewriteStart, nTokenRewriteEnd, nTokenOffset, nLastToken, bCaseSvty, bDebug) {
         // text processor: rewrite tokens between <nTokenRewriteStart> and <nTokenRewriteEnd> position