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
@@ -195,10 +195,12 @@
             this.parseText(this.sText, this.sText0, true, 0, sCountry, dOpt, bShowRuleId, bDebug, bContext);
         }
         catch (e) {
             console.error(e);
         }
+        this.lTokens = null;
+        this.lTokens0 = null;
         let lParagraphErrors = null;
         if (bFullInfo) {
             lParagraphErrors = Array.from(this.dError.values());
             this.dSentenceError.clear();
         }
@@ -209,30 +211,39 @@
         for (let [iStart, iEnd] of text.getSentenceBoundaries(sText)) {
             try {
                 this.sSentence = sText.slice(iStart, iEnd);
                 this.sSentence0 = this.sText0.slice(iStart, iEnd);
                 this.nOffsetWithinParagraph = iStart;
-                this.lToken = Array.from(gc_engine.oTokenizer.genTokens(this.sSentence, true));
+                this.lTokens = Array.from(gc_engine.oTokenizer.genTokens(this.sSentence, true));
                 this.dTokenPos.clear();
-                for (let dToken of this.lToken) {
+                for (let dToken of this.lTokens) {
                     if (dToken["sType"] != "INFO") {
                         this.dTokenPos.set(dToken["nStart"], dToken);
                     }
                 }
                 if (bFullInfo) {
-                    oSentence = { "nStart": iStart, "nEnd": iEnd, "sSentence": this.sSentence, "lToken": Array.from(this.lToken) };
-                    for (let oToken of oSentence["lToken"]) {
-                        if (oToken["sType"] == "WORD") {
-                            oToken["bValidToken"] = gc_engine.oSpellChecker.isValidToken(oToken["sValue"]);
-                        }
-                    }
+                    this.lTokens0 = Array.from(this.lTokens);
                     // the list of tokens is duplicated, to keep all tokens from being deleted when analysis
                 }
                 this.parseText(this.sSentence, this.sSentence0, false, iStart, sCountry, dOpt, bShowRuleId, bDebug, bContext);
                 if (bFullInfo) {
-                    oSentence["lGrammarErrors"] = Array.from(this.dSentenceError.values());
-                    lSentences.push(oSentence);
+                    for (let oToken of this.lTokens0) {
+                        if (oToken["sType"] == "WORD") {
+                            oToken["bValidToken"] = gc_engine.oSpellChecker.isValidToken(oToken["sValue"]);
+                        }
+                        if (!oToken.hasOwnProperty("lMorph")) {
+                            oToken["lMorph"] = gc_engine.oSpellChecker.getMorph(oToken["sValue"]);
+                        }
+                        gc_engine.oSpellChecker.setLabelsOnToken(oToken);
+                    }
+                    lSentences.push({
+                        "nStart": iStart,
+                        "nEnd": iEnd,
+                        "sSentence": this.sSentence0,
+                        "lTokens": this.lTokens0,
+                        "lGrammarErrors": Array.from(this.dSentenceError.values())
+                    });
                     this.dSentenceError.clear();
                 }
             }
             catch (e) {
                 console.error(e);
@@ -372,13 +383,13 @@
             }
             if (this.dTokenPos.gl_get(oToken["nStart"], {}).hasOwnProperty("aTags")) {
                 oToken["aTags"] = this.dTokenPos.get(oToken["nStart"])["aTags"];
             }
         }
-        this.lToken = lNewToken;
+        this.lTokens = lNewToken;
         this.dTokenPos.clear();
-        for (let oToken of this.lToken) {
+        for (let oToken of this.lTokens) {
             if (oToken["sType"] != "INFO") {
                 this.dTokenPos.set(oToken["nStart"], oToken);
             }
         }
         if (bDebug) {
@@ -614,11 +625,11 @@
     parseGraph (oGraph, 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;
         try {
-            for (let [iToken, oToken] of this.lToken.entries()) {
+            for (let [iToken, oToken] of this.lTokens.entries()) {
                 if (bDebug) {
                     console.log("TOKEN: " + oToken["sValue"]);
                 }
                 // check arcs for each existing pointer
                 let lNextPointer = [];
@@ -666,21 +677,21 @@
                     // Disambiguator [ option, condition, "=", replacement/suggestion/action ]
                     // Tag           [ option, condition, "/", replacement/suggestion/action, iTokenStart, iTokenEnd ]
                     // Immunity      [ option, condition, "!", "",                            iTokenStart, iTokenEnd ]
                     // Test          [ option, condition, ">", "" ]
                     if (!sOption || dOptions.gl_get(sOption, false)) {
-                        bCondMemo = !sFuncCond || gc_functions[sFuncCond](this.lToken, nTokenOffset, nLastToken, sCountry, bCondMemo, this.dTags, this.sSentence, this.sSentence0);
-                        //bCondMemo = !sFuncCond || oEvalFunc[sFuncCond](this.lToken, nTokenOffset, nLastToken, sCountry, bCondMemo, this.dTags, this.sSentence, this.sSentence0);
+                        bCondMemo = !sFuncCond || gc_functions[sFuncCond](this.lTokens, nTokenOffset, nLastToken, sCountry, bCondMemo, this.dTags, this.sSentence, this.sSentence0);
+                        //bCondMemo = !sFuncCond || oEvalFunc[sFuncCond](this.lTokens, nTokenOffset, nLastToken, sCountry, bCondMemo, this.dTags, this.sSentence, this.sSentence0);
                         if (bCondMemo) {
                             if (cActionType == "-") {
                                 // grammar error
                                 let [iTokenStart, iTokenEnd, cStartLimit, cEndLimit, bCaseSvty, nPriority, sMessage, iURL] = eAct;
                                 let nTokenErrorStart = (iTokenStart > 0) ? nTokenOffset + iTokenStart : nLastToken + iTokenStart;
-                                if (!this.lToken[nTokenErrorStart].hasOwnProperty("bImmune")) {
+                                if (!this.lTokens[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"]);
+                                    let nErrorStart = this.nOffsetWithinParagraph + ((cStartLimit == "<") ? this.lTokens[nTokenErrorStart]["nStart"] : this.lTokens[nTokenErrorStart]["nEnd"]);
+                                    let nErrorEnd = this.nOffsetWithinParagraph + ((cEndLimit == ">") ? this.lTokens[nTokenErrorEnd]["nEnd"] : this.lTokens[nTokenErrorEnd]["nStart"]);
                                     if (!this.dError.has(nErrorStart) || nPriority > this.dErrorPriority.gl_get(nErrorStart, -1)) {
                                         this.dError.set(nErrorStart, this._createErrorFromTokens(sWhat, nTokenOffset, nLastToken, nTokenErrorStart, nErrorStart, nErrorEnd, sLineId, sRuleId, bCaseSvty,
                                                                                                  sMessage, gc_rules_graph.dURL[iURL], bShowRuleId, sOption, bContext));
                                         this.dErrorPriority.set(nErrorStart, nPriority);
                                         this.dSentenceError.set(nErrorStart, this.dError.get(nErrorStart));
@@ -695,19 +706,19 @@
                                 let nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
                                 let nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : nLastToken + eAct[1];
                                 this._tagAndPrepareTokenForRewriting(sWhat, nTokenStart, nTokenEnd, nTokenOffset, nLastToken, eAct[2], bDebug);
                                 bChange = true;
                                 if (bDebug) {
-                                    console.log(`    TEXT_PROCESSOR: [${this.lToken[nTokenStart]["sValue"]}:${this.lToken[nTokenEnd]["sValue"]}]  > ${sWhat}`);
+                                    console.log(`    TEXT_PROCESSOR: [${this.lTokens[nTokenStart]["sValue"]}:${this.lTokens[nTokenEnd]["sValue"]}]  > ${sWhat}`);
                                 }
                             }
                             else if (cActionType == "=") {
                                 // disambiguation
-                                gc_functions[sWhat](this.lToken, nTokenOffset, nLastToken);
-                                //oEvalFunc[sWhat](this.lToken, nTokenOffset, nLastToken);
+                                gc_functions[sWhat](this.lTokens, nTokenOffset, nLastToken);
+                                //oEvalFunc[sWhat](this.lTokens, nTokenOffset, nLastToken);
                                 if (bDebug) {
-                                    console.log(`    DISAMBIGUATOR: (${sWhat})  [${this.lToken[nTokenOffset+1]["sValue"]}:${this.lToken[nLastToken]["sValue"]}]`);
+                                    console.log(`    DISAMBIGUATOR: (${sWhat})  [${this.lTokens[nTokenOffset+1]["sValue"]}:${this.lTokens[nLastToken]["sValue"]}]`);
                                 }
                             }
                             else if (cActionType == ">") {
                                 // we do nothing, this test is just a condition to apply all following actions
                                 if (bDebug) {
@@ -717,18 +728,18 @@
                             else if (cActionType == "/") {
                                 // Tag
                                 let nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
                                 let nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : nLastToken + eAct[1];
                                 for (let i = nTokenStart; i <= nTokenEnd; i++) {
-                                    if (this.lToken[i].hasOwnProperty("aTags")) {
-                                        this.lToken[i]["aTags"].add(...sWhat.split("|"))
+                                    if (this.lTokens[i].hasOwnProperty("aTags")) {
+                                        this.lTokens[i]["aTags"].add(...sWhat.split("|"))
                                     } else {
-                                        this.lToken[i]["aTags"] = new Set(sWhat.split("|"));
+                                        this.lTokens[i]["aTags"] = new Set(sWhat.split("|"));
                                     }
                                 }
                                 if (bDebug) {
-                                    console.log(`    TAG:  ${sWhat} > [${this.lToken[nTokenStart]["sValue"]}:${this.lToken[nTokenEnd]["sValue"]}]`);
+                                    console.log(`    TAG:  ${sWhat} > [${this.lTokens[nTokenStart]["sValue"]}:${this.lTokens[nTokenEnd]["sValue"]}]`);
                                 }
                                 for (let sTag of sWhat.split("|")) {
                                     if (!this.dTags.has(sTag)) {
                                         this.dTags.set(sTag, [nTokenStart, nTokenEnd]);
                                     } else {
@@ -742,19 +753,19 @@
                                     console.log("    IMMUNITY: " + sLineId + " / " + sRuleId);
                                 }
                                 let nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
                                 let 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"];
+                                    this.lTokens[nTokenStart]["bImmune"] = true;
+                                    let nErrorStart = this.nOffsetWithinParagraph + this.lTokens[nTokenStart]["nStart"];
                                     if (this.dError.has(nErrorStart)) {
                                         this.dError.delete(nErrorStart);
                                     }
                                 } else {
                                     for (let i = nTokenStart;  i <= nTokenEnd;  i++) {
-                                        this.lToken[i]["bImmune"] = true;
-                                        let nErrorStart = this.nOffsetWithinParagraph + this.lToken[i]["nStart"];
+                                        this.lTokens[i]["bImmune"] = true;
+                                        let nErrorStart = this.nOffsetWithinParagraph + this.lTokens[i]["nStart"];
                                         if (this.dError.has(nErrorStart)) {
                                             this.dError.delete(nErrorStart);
                                         }
                                     }
                                 }
@@ -808,24 +819,24 @@
 
     _createErrorFromTokens (sSugg, nTokenOffset, nLastToken, iFirstToken, nStart, nEnd, sLineId, sRuleId, bCaseSvty, sMsg, sURL, bShowRuleId, sOption, bContext) {
         // suggestions
         let lSugg = [];
         if (sSugg.startsWith("=")) {
-            sSugg = gc_functions[sSugg.slice(1)](this.lToken, nTokenOffset, nLastToken);
-            //sSugg = oEvalFunc[sSugg.slice(1)](this.lToken, nTokenOffset, nLastToken);
+            sSugg = gc_functions[sSugg.slice(1)](this.lTokens, nTokenOffset, nLastToken);
+            //sSugg = oEvalFunc[sSugg.slice(1)](this.lTokens, nTokenOffset, nLastToken);
             lSugg = (sSugg) ? sSugg.split("|") : [];
         } else if (sSugg == "_") {
             lSugg = [];
         } else {
             lSugg = this._expand(sSugg, nTokenOffset, nLastToken).split("|");
         }
-        if (bCaseSvty && lSugg.length > 0 && this.lToken[iFirstToken]["sValue"].slice(0,1).gl_isUpperCase()) {
+        if (bCaseSvty && lSugg.length > 0 && this.lTokens[iFirstToken]["sValue"].slice(0,1).gl_isUpperCase()) {
             lSugg = (this.sSentence.slice(nStart, nEnd).gl_isUpperCase()) ? lSugg.map((s) => s.toUpperCase()) : capitalizeArray(lSugg);
         }
         // Message
-        let sMessage = (sMsg.startsWith("=")) ? gc_functions[sMsg.slice(1)](this.lToken, nTokenOffset, nLastToken) : this._expand(sMsg, nTokenOffset, nLastToken);
-        //let sMessage = (sMsg.startsWith("=")) ? oEvalFunc[sMsg.slice(1)](this.lToken, nTokenOffset, nLastToken) : this._expand(sMsg, nTokenOffset, nLastToken);
+        let sMessage = (sMsg.startsWith("=")) ? gc_functions[sMsg.slice(1)](this.lTokens, nTokenOffset, nLastToken) : this._expand(sMsg, nTokenOffset, nLastToken);
+        //let sMessage = (sMsg.startsWith("=")) ? oEvalFunc[sMsg.slice(1)](this.lTokens, nTokenOffset, nLastToken) : this._expand(sMsg, nTokenOffset, nLastToken);
         if (bShowRuleId) {
             sMessage += "  #" + sLineId + " / " + sRuleId;
         }
         //
         return this._createError(nStart, nEnd, sLineId, sRuleId, sOption, sMessage, lSugg, sURL, bContext);
@@ -853,13 +864,13 @@
 
     _expand (sText, nTokenOffset, nLastToken) {
         let m;
         while ((m = /\\(-?[0-9]+)/.exec(sText)) !== null) {
             if (m[1].slice(0,1) == "-") {
-                sText = sText.replace(m[0], this.lToken[nLastToken+parseInt(m[1],10)+1]["sValue"]);
+                sText = sText.replace(m[0], this.lTokens[nLastToken+parseInt(m[1],10)+1]["sValue"]);
             } else {
-                sText = sText.replace(m[0], this.lToken[nTokenOffset+parseInt(m[1],10)]["sValue"]);
+                sText = sText.replace(m[0], this.lTokens[nTokenOffset+parseInt(m[1],10)]["sValue"]);
             }
         }
         return sText;
     }
 
@@ -894,45 +905,45 @@
     _tagAndPrepareTokenForRewriting (sWhat, nTokenRewriteStart, nTokenRewriteEnd, nTokenOffset, nLastToken, bCaseSvty, bDebug) {
         // text processor: rewrite tokens between <nTokenRewriteStart> and <nTokenRewriteEnd> position
         if (sWhat === "*") {
             // purge text
             if (nTokenRewriteEnd - nTokenRewriteStart == 0) {
-                this.lToken[nTokenRewriteStart]["bToRemove"] = true;
+                this.lTokens[nTokenRewriteStart]["bToRemove"] = true;
             } else {
                 for (let i = nTokenRewriteStart;  i <= nTokenRewriteEnd;  i++) {
-                    this.lToken[i]["bToRemove"] = true;
+                    this.lTokens[i]["bToRemove"] = true;
                 }
             }
         }
         else if (sWhat === "␣") {
             // merge tokens
-            this.lToken[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd;
+            this.lTokens[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd;
         }
         else if (sWhat === "_") {
             // neutralized token
             if (nTokenRewriteEnd - nTokenRewriteStart == 0) {
-                this.lToken[nTokenRewriteStart]["sNewValue"] = "_";
+                this.lTokens[nTokenRewriteStart]["sNewValue"] = "_";
             } else {
                 for (let i = nTokenRewriteStart;  i <= nTokenRewriteEnd;  i++) {
-                    this.lToken[i]["sNewValue"] = "_";
+                    this.lTokens[i]["sNewValue"] = "_";
                 }
             }
         }
         else {
             if (sWhat.startsWith("=")) {
-                sWhat = gc_functions[sWhat.slice(1)](this.lToken, nTokenOffset, nLastToken);
-                //sWhat = oEvalFunc[sWhat.slice(1)](this.lToken, nTokenOffset, nLastToken);
+                sWhat = gc_functions[sWhat.slice(1)](this.lTokens, nTokenOffset, nLastToken);
+                //sWhat = oEvalFunc[sWhat.slice(1)](this.lTokens, nTokenOffset, nLastToken);
             } else {
                 sWhat = this._expand(sWhat, nTokenOffset, nLastToken);
             }
-            let bUppercase = bCaseSvty && this.lToken[nTokenRewriteStart]["sValue"].slice(0,1).gl_isUpperCase();
+            let bUppercase = bCaseSvty && this.lTokens[nTokenRewriteStart]["sValue"].slice(0,1).gl_isUpperCase();
             if (nTokenRewriteEnd - nTokenRewriteStart == 0) {
                 // one token
                 if (bUppercase) {
                     sWhat = sWhat.gl_toCapitalize();
                 }
-                this.lToken[nTokenRewriteStart]["sNewValue"] = sWhat;
+                this.lTokens[nTokenRewriteStart]["sNewValue"] = sWhat;
             }
             else {
                 // several tokens
                 let lTokenValue = sWhat.split("|");
                 if (lTokenValue.length != (nTokenRewriteEnd - nTokenRewriteStart + 1)) {
@@ -943,16 +954,16 @@
                 }
                 let j = 0;
                 for (let i = nTokenRewriteStart;  i <= nTokenRewriteEnd;  i++) {
                     let sValue = lTokenValue[j];
                     if (!sValue || sValue === "*") {
-                        this.lToken[i]["bToRemove"] = true;
+                        this.lTokens[i]["bToRemove"] = true;
                     } else {
                         if (bUppercase) {
                             sValue = sValue.gl_toCapitalize();
                         }
-                        this.lToken[i]["sNewValue"] = sValue;
+                        this.lTokens[i]["sNewValue"] = sValue;
                     }
                     j++;
                 }
             }
         }
@@ -962,22 +973,25 @@
         // rewrite the sentence, modify tokens, purge the token list
         if (bDebug) {
             console.log("REWRITE");
         }
         let lNewToken = [];
+        let lNewTokens0 = [];
         let nMergeUntil = 0;
         let oMergingToken = null;
-        for (let [iToken, oToken] of this.lToken.entries()) {
+        for (let [iToken, oToken] of this.lTokens.entries()) {
             let bKeepToken = true;
+            let bKeepToken0 = true;
             if (oToken["sType"] != "INFO") {
                 if (nMergeUntil && iToken <= nMergeUntil) {
                     oMergingToken["sValue"] += " ".repeat(oToken["nStart"] - oMergingToken["nEnd"]) + oToken["sValue"];
                     oMergingToken["nEnd"] = oToken["nEnd"];
                     if (bDebug) {
                         console.log("  MERGED TOKEN: " + oMergingToken["sValue"]);
                     }
                     bKeepToken = false;
+                    bKeepToken0 = false;
                 }
                 if (oToken.hasOwnProperty("nMergeUntil")) {
                     if (iToken > nMergeUntil) { // this token is not already merged with a previous token
                         oMergingToken = oToken;
                     }
@@ -1017,16 +1031,23 @@
                 catch (e) {
                     console.log(this.asString());
                     console.log(oToken);
                 }
             }
+            if (this.lTokens0 !== null && bKeepToken0) {
+                lNewTokens0.push(oToken);
+            }
         }
         if (bDebug) {
             console.log("  TEXT REWRITED: " + this.sSentence);
         }
-        this.lToken.length = 0;
-        this.lToken = lNewToken;
+        this.lTokens.length = 0;
+        this.lTokens = lNewToken;
+        if (this.lTokens0 !== null) {
+            this.lTokens0.length = 0;
+            this.lTokens0 = lNewTokens0;
+        }
     }
 };
 
 
 if (typeof(exports) !== 'undefined') {

Index: gc_core/py/lang_core/gc_engine.py
==================================================================
--- gc_core/py/lang_core/gc_engine.py
+++ gc_core/py/lang_core/gc_engine.py
@@ -233,11 +233,11 @@
         self.sText = sText
         self.sText0 = sText
         self.sSentence = ""
         self.sSentence0 = ""
         self.nOffsetWithinParagraph = 0
-        self.lToken = []
+        self.lTokens = []
         self.dTokenPos = {}         # {position: token}
         self.dTags = {}             # {position: tags}
         self.dError = {}            # {position: error}
         self.dSentenceError = {}    # {position: error} (for the current sentence only)
         self.dErrorPriority = {}    # {position: priority of the current error}
@@ -244,11 +244,11 @@
 
     def __str__ (self):
         s = "===== TEXT =====\n"
         s += "sentence: " + self.sSentence0 + "\n"
         s += "now:      " + self.sSentence  + "\n"
-        for dToken in self.lToken:
+        for dToken in self.lTokens:
             s += '#{i}\t{nStart}:{nEnd}\t{sValue}\t{sType}'.format(**dToken)
             if "lMorph" in dToken:
                 s += "\t" + str(dToken["lMorph"])
             if "aTags" in dToken:
                 s += "\t" + str(dToken["aTags"])
@@ -265,10 +265,12 @@
         # parse paragraph
         try:
             self.parseText(self.sText, self.sText0, True, 0, sCountry, dOpt, bShowRuleId, bDebug, bContext)
         except:
             raise
+        self.lTokens = None
+        self.lTokens0 = None
         if bFullInfo:
             lParagraphErrors = list(self.dError.values())
             lSentences = []
             self.dSentenceError.clear()
         # parse sentences
@@ -277,22 +279,29 @@
             if 4 < (iEnd - iStart) < 2000:
                 try:
                     self.sSentence = sText[iStart:iEnd]
                     self.sSentence0 = self.sText0[iStart:iEnd]
                     self.nOffsetWithinParagraph = iStart
-                    self.lToken = list(_oTokenizer.genTokens(self.sSentence, True))
-                    self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lToken  if dToken["sType"] != "INFO" }
+                    self.lTokens = list(_oTokenizer.genTokens(self.sSentence, True))
+                    self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lTokens  if dToken["sType"] != "INFO" }
+                    if bFullInfo:
+                        self.lTokens0 = list(self.lTokens)  # the list of tokens is duplicated, to keep all tokens from being deleted when analysis
+                    self.parseText(self.sSentence, self.sSentence0, False, iStart, sCountry, dOpt, bShowRuleId, bDebug, bContext)
                     if bFullInfo:
-                        dSentence = { "nStart": iStart, "nEnd": iEnd, "sSentence": self.sSentence, "lToken": list(self.lToken) }
-                        for dToken in dSentence["lToken"]:
+                        for dToken in self.lTokens0:
                             if dToken["sType"] == "WORD":
                                 dToken["bValidToken"] = _oSpellChecker.isValidToken(dToken["sValue"])
-                        # the list of tokens is duplicated, to keep all tokens from being deleted when analysis
-                    self.parseText(self.sSentence, self.sSentence0, False, iStart, sCountry, dOpt, bShowRuleId, bDebug, bContext)
-                    if bFullInfo:
-                        dSentence["lGrammarErrors"] = list(self.dSentenceError.values())
-                        lSentences.append(dSentence)
+                            if "lMorph" not in dToken:
+                                dToken["lMorph"] = _oSpellChecker.getMorph(dToken["sValue"])
+                            _oSpellChecker.setLabelsOnToken(dToken)
+                        lSentences.append({
+                            "nStart": iStart,
+                            "nEnd": iEnd,
+                            "sSentence": self.sSentence0,
+                            "lTokens": self.lTokens0,
+                            "lGrammarErrors": list(self.dSentenceError.values())
+                        })
                         self.dSentenceError.clear()
                 except:
                     raise
         if bFullInfo:
             # Grammar checking and sentence analysis
@@ -379,18 +388,18 @@
                 self.sSentence = sText
 
     def update (self, sSentence, bDebug=False):
         "update <sSentence> and retokenize"
         self.sSentence = sSentence
-        lNewToken = list(_oTokenizer.genTokens(sSentence, True))
-        for dToken in lNewToken:
+        lNewTokens = list(_oTokenizer.genTokens(sSentence, True))
+        for dToken in lNewTokens:
             if "lMorph" in self.dTokenPos.get(dToken["nStart"], {}):
                 dToken["lMorph"] = self.dTokenPos[dToken["nStart"]]["lMorph"]
             if "aTags" in self.dTokenPos.get(dToken["nStart"], {}):
                 dToken["aTags"] = self.dTokenPos[dToken["nStart"]]["aTags"]
-        self.lToken = lNewToken
-        self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lToken  if dToken["sType"] != "INFO" }
+        self.lTokens = lNewTokens
+        self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lTokens  if dToken["sType"] != "INFO" }
         if bDebug:
             echo("UPDATE:")
             echo(self)
 
     def _getNextPointers (self, dToken, dGraph, dPointer, bDebug=False):
@@ -550,11 +559,11 @@
 
     def parseGraph (self, dGraph, sCountry="${country_default}", dOptions=None, bShowRuleId=False, bDebug=False, bContext=False):
         "parse graph with tokens from the text and execute actions encountered"
         lPointer = []
         bTagAndRewrite = False
-        for iToken, dToken in enumerate(self.lToken):
+        for iToken, dToken in enumerate(self.lTokens):
             if bDebug:
                 echo("TOKEN: " + dToken["sValue"])
             # check arcs for each existing pointer
             lNextPointer = []
             for dPointer in lPointer:
@@ -591,20 +600,20 @@
                     # Disambiguator [ option, condition, "=", replacement/suggestion/action ]
                     # Tag           [ option, condition, "/", replacement/suggestion/action, iTokenStart, iTokenEnd ]
                     # Immunity      [ option, condition, "!", "",                            iTokenStart, iTokenEnd ]
                     # Test          [ option, condition, ">", "" ]
                     if not sOption or dOptions.get(sOption, False):
-                        bCondMemo = not sFuncCond or getattr(gc_functions, sFuncCond)(self.lToken, nTokenOffset, nLastToken, sCountry, bCondMemo, self.dTags, self.sSentence, self.sSentence0)
+                        bCondMemo = not sFuncCond or getattr(gc_functions, sFuncCond)(self.lTokens, nTokenOffset, nLastToken, sCountry, bCondMemo, self.dTags, self.sSentence, self.sSentence0)
                         if bCondMemo:
                             if cActionType == "-":
                                 # grammar error
                                 iTokenStart, iTokenEnd, cStartLimit, cEndLimit, bCaseSvty, nPriority, sMessage, iURL = eAct
                                 nTokenErrorStart = nTokenOffset + iTokenStart  if iTokenStart > 0  else nLastToken + iTokenStart
-                                if "bImmune" not in self.lToken[nTokenErrorStart]:
+                                if "bImmune" not in self.lTokens[nTokenErrorStart]:
                                     nTokenErrorEnd = nTokenOffset + iTokenEnd  if iTokenEnd > 0  else nLastToken + iTokenEnd
-                                    nErrorStart = self.nOffsetWithinParagraph + (self.lToken[nTokenErrorStart]["nStart"] if cStartLimit == "<"  else self.lToken[nTokenErrorStart]["nEnd"])
-                                    nErrorEnd = self.nOffsetWithinParagraph + (self.lToken[nTokenErrorEnd]["nEnd"] if cEndLimit == ">"  else self.lToken[nTokenErrorEnd]["nStart"])
+                                    nErrorStart = self.nOffsetWithinParagraph + (self.lTokens[nTokenErrorStart]["nStart"] if cStartLimit == "<"  else self.lTokens[nTokenErrorStart]["nEnd"])
+                                    nErrorEnd = self.nOffsetWithinParagraph + (self.lTokens[nTokenErrorEnd]["nEnd"] if cEndLimit == ">"  else self.lTokens[nTokenErrorEnd]["nStart"])
                                     if nErrorStart not in self.dError or nPriority > self.dErrorPriority.get(nErrorStart, -1):
                                         self.dError[nErrorStart] = self._createErrorFromTokens(sWhat, nTokenOffset, nLastToken, nTokenErrorStart, nErrorStart, nErrorEnd, sLineId, sRuleId, bCaseSvty, \
                                                                                                sMessage, _rules_graph.dURL.get(iURL, ""), bShowRuleId, sOption, bContext)
                                         self.dErrorPriority[nErrorStart] = nPriority
                                         self.dSentenceError[nErrorStart] = self.dError[nErrorStart]
@@ -615,31 +624,31 @@
                                 nTokenStart = nTokenOffset + eAct[0]  if eAct[0] > 0  else nLastToken + eAct[0]
                                 nTokenEnd = nTokenOffset + eAct[1]  if eAct[1] > 0  else nLastToken + eAct[1]
                                 self._tagAndPrepareTokenForRewriting(sWhat, nTokenStart, nTokenEnd, nTokenOffset, nLastToken, eAct[2], bDebug)
                                 bChange = True
                                 if bDebug:
-                                    echo("    TEXT_PROCESSOR: [{}:{}]  > {}".format(self.lToken[nTokenStart]["sValue"], self.lToken[nTokenEnd]["sValue"], sWhat))
+                                    echo("    TEXT_PROCESSOR: [{}:{}]  > {}".format(self.lTokens[nTokenStart]["sValue"], self.lTokens[nTokenEnd]["sValue"], sWhat))
                             elif cActionType == "=":
                                 # disambiguation
-                                getattr(gc_functions, sWhat)(self.lToken, nTokenOffset, nLastToken)
+                                getattr(gc_functions, sWhat)(self.lTokens, nTokenOffset, nLastToken)
                                 if bDebug:
-                                    echo("    DISAMBIGUATOR: ({})  [{}:{}]".format(sWhat, self.lToken[nTokenOffset+1]["sValue"], self.lToken[nLastToken]["sValue"]))
+                                    echo("    DISAMBIGUATOR: ({})  [{}:{}]".format(sWhat, self.lTokens[nTokenOffset+1]["sValue"], self.lTokens[nLastToken]["sValue"]))
                             elif cActionType == ">":
                                 # we do nothing, this test is just a condition to apply all following actions
                                 if bDebug:
                                     echo("    COND_OK")
                             elif cActionType == "/":
                                 # Tag
                                 nTokenStart = nTokenOffset + eAct[0]  if eAct[0] > 0  else nLastToken + eAct[0]
                                 nTokenEnd = nTokenOffset + eAct[1]  if eAct[1] > 0  else nLastToken + eAct[1]
                                 for i in range(nTokenStart, nTokenEnd+1):
-                                    if "aTags" in self.lToken[i]:
-                                        self.lToken[i]["aTags"].update(sWhat.split("|"))
+                                    if "aTags" in self.lTokens[i]:
+                                        self.lTokens[i]["aTags"].update(sWhat.split("|"))
                                     else:
-                                        self.lToken[i]["aTags"] = set(sWhat.split("|"))
+                                        self.lTokens[i]["aTags"] = set(sWhat.split("|"))
                                 if bDebug:
-                                    echo("    TAG: {} >  [{}:{}]".format(sWhat, self.lToken[nTokenStart]["sValue"], self.lToken[nTokenEnd]["sValue"]))
+                                    echo("    TAG: {} >  [{}:{}]".format(sWhat, self.lTokens[nTokenStart]["sValue"], self.lTokens[nTokenEnd]["sValue"]))
                                 for sTag in sWhat.split("|"):
                                     if sTag not in self.dTags:
                                         self.dTags[sTag] = [nTokenStart, nTokenEnd]
                                     else:
                                         self.dTags[sTag][0] = min(nTokenStart, self.dTags[sTag][0])
@@ -649,18 +658,18 @@
                                 if bDebug:
                                     echo("    IMMUNITY: " + sLineId + " / " + sRuleId)
                                 nTokenStart = nTokenOffset + eAct[0]  if eAct[0] > 0  else nLastToken + eAct[0]
                                 nTokenEnd = nTokenOffset + eAct[1]  if eAct[1] > 0  else nLastToken + eAct[1]
                                 if nTokenEnd - nTokenStart == 0:
-                                    self.lToken[nTokenStart]["bImmune"] = True
-                                    nErrorStart = self.nOffsetWithinParagraph + self.lToken[nTokenStart]["nStart"]
+                                    self.lTokens[nTokenStart]["bImmune"] = True
+                                    nErrorStart = self.nOffsetWithinParagraph + self.lTokens[nTokenStart]["nStart"]
                                     if nErrorStart in self.dError:
                                         del self.dError[nErrorStart]
                                 else:
                                     for i in range(nTokenStart, nTokenEnd+1):
-                                        self.lToken[i]["bImmune"] = True
-                                        nErrorStart = self.nOffsetWithinParagraph + self.lToken[i]["nStart"]
+                                        self.lTokens[i]["bImmune"] = True
+                                        nErrorStart = self.nOffsetWithinParagraph + self.lTokens[i]["nStart"]
                                         if nErrorStart in self.dError:
                                             del self.dError[nErrorStart]
                             else:
                                 echo("# error: unknown action at " + sLineId)
                         elif cActionType == ">":
@@ -694,20 +703,20 @@
         return self._createErrorAsDict(nStart, nEnd, sLineId, sRuleId, sOption, sMessage, lSugg, sURL, bContext)
 
     def _createErrorFromTokens (self, sSugg, nTokenOffset, nLastToken, iFirstToken, nStart, nEnd, sLineId, sRuleId, bCaseSvty, sMsg, sURL, bShowRuleId, sOption, bContext):
         # suggestions
         if sSugg[0:1] == "=":
-            sSugg = getattr(gc_functions, sSugg[1:])(self.lToken, nTokenOffset, nLastToken)
+            sSugg = getattr(gc_functions, sSugg[1:])(self.lTokens, nTokenOffset, nLastToken)
             lSugg = sSugg.split("|")  if sSugg  else []
         elif sSugg == "_":
             lSugg = []
         else:
             lSugg = self._expand(sSugg, nTokenOffset, nLastToken).split("|")
-        if bCaseSvty and lSugg and self.lToken[iFirstToken]["sValue"][0:1].isupper():
+        if bCaseSvty and lSugg and self.lTokens[iFirstToken]["sValue"][0:1].isupper():
             lSugg = list(map(lambda s: s.upper(), lSugg))  if self.sSentence[nStart:nEnd].isupper()  else list(map(lambda s: s[0:1].upper()+s[1:], lSugg))
         # Message
-        sMessage = getattr(gc_functions, sMsg[1:])(self.lToken, nTokenOffset, nLastToken)  if sMsg[0:1] == "="  else self._expand(sMsg, nTokenOffset, nLastToken)
+        sMessage = getattr(gc_functions, sMsg[1:])(self.lTokens, nTokenOffset, nLastToken)  if sMsg[0:1] == "="  else self._expand(sMsg, nTokenOffset, nLastToken)
         if bShowRuleId:
             sMessage += "  #" + sLineId + " / " + sRuleId
         #
         if _bWriterError:
             return self._createErrorForWriter(nStart, nEnd - nStart, sRuleId, sOption, sMessage, lSugg, sURL)
@@ -752,13 +761,13 @@
         return dErr
 
     def _expand (self, sText, nTokenOffset, nLastToken):
         for m in re.finditer(r"\\(-?[0-9]+)", sText):
             if m.group(1)[0:1] == "-":
-                sText = sText.replace(m.group(0), self.lToken[nLastToken+int(m.group(1))+1]["sValue"])
+                sText = sText.replace(m.group(0), self.lTokens[nLastToken+int(m.group(1))+1]["sValue"])
             else:
-                sText = sText.replace(m.group(0), self.lToken[nTokenOffset+int(m.group(1))]["sValue"])
+                sText = sText.replace(m.group(0), self.lTokens[nTokenOffset+int(m.group(1))]["sValue"])
         return sText
 
     def rewriteText (self, sText, sRepl, iGroup, m, bUppercase):
         "text processor: write <sRepl> in <sText> at <iGroup> position"
         nLen = m.end(iGroup) - m.start(iGroup)
@@ -781,80 +790,86 @@
     def _tagAndPrepareTokenForRewriting (self, sWhat, nTokenRewriteStart, nTokenRewriteEnd, nTokenOffset, nLastToken, bCaseSvty, bDebug):
         "text processor: rewrite tokens between <nTokenRewriteStart> and <nTokenRewriteEnd> position"
         if sWhat == "*":
             # purge text
             if nTokenRewriteEnd - nTokenRewriteStart == 0:
-                self.lToken[nTokenRewriteStart]["bToRemove"] = True
+                self.lTokens[nTokenRewriteStart]["bToRemove"] = True
             else:
                 for i in range(nTokenRewriteStart, nTokenRewriteEnd+1):
-                    self.lToken[i]["bToRemove"] = True
+                    self.lTokens[i]["bToRemove"] = True
         elif sWhat == "␣":
             # merge tokens
-            self.lToken[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd
+            self.lTokens[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd
         elif sWhat == "_":
             # neutralized token
             if nTokenRewriteEnd - nTokenRewriteStart == 0:
-                self.lToken[nTokenRewriteStart]["sNewValue"] = "_"
+                self.lTokens[nTokenRewriteStart]["sNewValue"] = "_"
             else:
                 for i in range(nTokenRewriteStart, nTokenRewriteEnd+1):
-                    self.lToken[i]["sNewValue"] = "_"
+                    self.lTokens[i]["sNewValue"] = "_"
         else:
             if sWhat.startswith("="):
-                sWhat = getattr(gc_functions, sWhat[1:])(self.lToken, nTokenOffset, nLastToken)
+                sWhat = getattr(gc_functions, sWhat[1:])(self.lTokens, nTokenOffset, nLastToken)
             else:
                 sWhat = self._expand(sWhat, nTokenOffset, nLastToken)
-            bUppercase = bCaseSvty and self.lToken[nTokenRewriteStart]["sValue"][0:1].isupper()
+            bUppercase = bCaseSvty and self.lTokens[nTokenRewriteStart]["sValue"][0:1].isupper()
             if nTokenRewriteEnd - nTokenRewriteStart == 0:
                 # one token
                 if bUppercase:
                     sWhat = sWhat[0:1].upper() + sWhat[1:]
-                self.lToken[nTokenRewriteStart]["sNewValue"] = sWhat
+                self.lTokens[nTokenRewriteStart]["sNewValue"] = sWhat
             else:
                 # several tokens
                 lTokenValue = sWhat.split("|")
                 if len(lTokenValue) != (nTokenRewriteEnd - nTokenRewriteStart + 1):
                     if (bDebug):
                         echo("Error. Text processor: number of replacements != number of tokens.")
                     return
                 for i, sValue in zip(range(nTokenRewriteStart, nTokenRewriteEnd+1), lTokenValue):
                     if not sValue or sValue == "*":
-                        self.lToken[i]["bToRemove"] = True
+                        self.lTokens[i]["bToRemove"] = True
                     else:
                         if bUppercase:
                             sValue = sValue[0:1].upper() + sValue[1:]
-                        self.lToken[i]["sNewValue"] = sValue
+                        self.lTokens[i]["sNewValue"] = sValue
 
     def rewriteFromTags (self, bDebug=False):
         "rewrite the sentence, modify tokens, purge the token list"
         if bDebug:
             echo("REWRITE")
-        lNewToken = []
+        lNewTokens = []
+        lNewTokens0 = []
         nMergeUntil = 0
         dTokenMerger = {}
-        for iToken, dToken in enumerate(self.lToken):
+        for iToken, dToken in enumerate(self.lTokens):
             bKeepToken = True
+            bKeepToken0 = True
             if dToken["sType"] != "INFO":
                 if nMergeUntil and iToken <= nMergeUntil:
+                    # token to merge
                     dTokenMerger["sValue"] += " " * (dToken["nStart"] - dTokenMerger["nEnd"]) + dToken["sValue"]
                     dTokenMerger["nEnd"] = dToken["nEnd"]
                     if bDebug:
                         echo("  MERGED TOKEN: " + dTokenMerger["sValue"])
                     bKeepToken = False
+                    bKeepToken0 = False
                 if "nMergeUntil" in dToken:
-                    if iToken > nMergeUntil: # this token is not already merged with a previous token
+                    # first token to be merge with
+                    if iToken > nMergeUntil: # this token is not to be merged with a previous token
                         dTokenMerger = dToken
                     if dToken["nMergeUntil"] > nMergeUntil:
                         nMergeUntil = dToken["nMergeUntil"]
                     del dToken["nMergeUntil"]
                 elif "bToRemove" in dToken:
+                    # deletion required
                     if bDebug:
                         echo("  REMOVED: " + dToken["sValue"])
                     self.sSentence = self.sSentence[:dToken["nStart"]] + " " * (dToken["nEnd"] - dToken["nStart"]) + self.sSentence[dToken["nEnd"]:]
                     bKeepToken = False
             #
             if bKeepToken:
-                lNewToken.append(dToken)
+                lNewTokens.append(dToken)
                 if "sNewValue" in dToken:
                     # rewrite token and sentence
                     if bDebug:
                         echo(dToken["sValue"] + " -> " + dToken["sNewValue"])
                     dToken["sRealValue"] = dToken["sValue"]
@@ -867,9 +882,14 @@
                 try:
                     del self.dTokenPos[dToken["nStart"]]
                 except KeyError:
                     echo(self)
                     echo(dToken)
+            if self.lTokens0 is not None and bKeepToken0:
+                lNewTokens0.append(dToken)
         if bDebug:
             echo("  TEXT REWRITED: " + self.sSentence)
-        self.lToken.clear()
-        self.lToken = lNewToken
+        self.lTokens.clear()
+        self.lTokens = lNewTokens
+        if self.lTokens0 is not None:
+            self.lTokens0.clear()
+            self.lTokens0 = lNewTokens0

Index: gc_lang/fr/webext/content_scripts/init.js
==================================================================
--- gc_lang/fr/webext/content_scripts/init.js
+++ gc_lang/fr/webext/content_scripts/init.js
@@ -342,16 +342,16 @@
 
     parseAndSpellcheck1: function (sText, sDestination, sParagraphId) {
         this.send("parseAndSpellcheck1", { sText: sText, sCountry: "FR", bDebug: false, bContext: false }, { sDestination: sDestination, sParagraphId: sParagraphId });
     },
 
-    getListOfTokens: function (sText) {
-        this.send("getListOfTokens", { sText: sText }, {});
+    parseFull: function (sText, sDestination, sParagraphId) {
+        this.send("parseFull", { sText: sText, sCountry: "FR", bDebug: false, bContext: false }, { sDestination: sDestination });
     },
 
-    parseFull: function (sText) {
-        this.send("parseFull", { sText: sText, sCountry: "FR", bDebug: false, bContext: false }, {});
+    getListOfTokens: function (sText, sDestination) {
+        this.send("getListOfTokens", { sText: sText }, { sDestination: sDestination });
     },
 
     getVerb: function (sVerb, bStart=true, bPro=false, bNeg=false, bTpsCo=false, bInt=false, bFem=false) {
         this.send("getVerb", { sVerb: sVerb, bPro: bPro, bNeg: bNeg, bTpsCo: bTpsCo, bInt: bInt, bFem: bFem }, { bStart: bStart });
     },
@@ -420,18 +420,22 @@
                     if (oInfo.sDestination == "__GrammalectePanel__") {
                         oGrammalecte.oGCPanel.refreshParagraph(oInfo.sParagraphId, result);
                     }
                     break;
                 case "parseFull":
-                    // TODO
+                    if (oInfo.sDestination == "__GrammalectePanel__") {
+                        oGrammalecte.oGCPanel.showParagraphAnalysis(result);
+                    }
                     break;
                 case "getListOfTokens":
-                    if (!bEnd) {
-                        oGrammalecte.oGCPanel.addListOfTokens(result);
-                    } else {
-                        oGrammalecte.oGCPanel.stopWaitIcon();
-                        oGrammalecte.oGCPanel.endTimer();
+                    if (oInfo.sDestination == "__GrammalectePanel__") {
+                        if (!bEnd) {
+                            oGrammalecte.oGCPanel.addListOfTokens(result);
+                        } else {
+                            oGrammalecte.oGCPanel.stopWaitIcon();
+                            oGrammalecte.oGCPanel.endTimer();
+                        }
                     }
                     break;
                 case "getSpellSuggestions":
                     if (oInfo.sDestination == "__GrammalectePanel__") {
                         oGrammalecte.oGCPanel.oTooltip.setSpellSuggestionsFor(result.sWord, result.aSugg, result.iSuggBlock, oInfo.sErrorId);

Index: gc_lang/fr/webext/content_scripts/panel_gc.css
==================================================================
--- gc_lang/fr/webext/content_scripts/panel_gc.css
+++ gc_lang/fr/webext/content_scripts/panel_gc.css
@@ -9,25 +9,23 @@
     overflow: auto;
 }
 
 div.grammalecte_paragraph_block {
     margin: 5px 5px 0 5px;
+    background-color: hsl(0, 0%, 96%);
+    border-radius: 2px;
 }
-
 p.grammalecte_paragraph {
     margin: 0;
     padding: 12px;
-    background-color: hsl(0, 0%, 96%);
-    border-radius: 2px;
     line-height: 1.3;
     text-align: left;
     font-size: 14px;
     font-family: "Courier New", Courier, "Lucida Sans Typewriter", "Lucida Typewriter", monospace;
     color: hsl(0, 0%, 0%);
     hyphens: none;
 }
-
 
 /*
     Action buttons
 */
 div.grammalecte_paragraph_actions {
@@ -45,10 +43,17 @@
     font-size: 14px;
     color: hsl(0, 0%, 96%);
     border-radius: 2px;
 }
 
+div.grammalecte_paragraph_actions .grammalecte_blue {
+    color: hsl(0, 0%, 80%);
+}
+div.grammalecte_paragraph_actions .grammalecte_blue:hover {
+    background-color: hsl(210, 50%, 40%);
+    color: hsl(0, 0%, 100%);
+}
 div.grammalecte_paragraph_actions .grammalecte_green {
     color: hsl(0, 0%, 80%);
 }
 div.grammalecte_paragraph_actions .grammalecte_green:hover {
     background-color: hsl(120, 50%, 40%);

Index: gc_lang/fr/webext/content_scripts/panel_gc.js
==================================================================
--- gc_lang/fr/webext/content_scripts/panel_gc.js
+++ gc_lang/fr/webext/content_scripts/panel_gc.js
@@ -3,19 +3,22 @@
 /* jshint esversion:6, -W097 */
 /* jslint esversion:6 */
 /* global GrammalectePanel, oGrammalecte, oGrammalecteBackgroundPort, showError, window, document, console */
 
 "use strict";
+
 
 function onGrammalecteGCPanelClick (xEvent) {
     try {
         let xElem = xEvent.target;
         if (xElem.id) {
             if (xElem.id.startsWith("grammalecte_sugg")) {
                 oGrammalecte.oGCPanel.applySuggestion(xElem.id);
             } else if (xElem.id === "grammalecte_tooltip_ignore") {
                 oGrammalecte.oGCPanel.ignoreError(xElem.id);
+            } else if (xElem.id.startsWith("grammalecte_analysis")) {
+                oGrammalecte.oGCPanel.sendParagraphToGrammaticalAnalysis(parseInt(xElem.dataset.para_num, 10));
             } else if (xElem.id.startsWith("grammalecte_check")) {
                 oGrammalecte.oGCPanel.recheckParagraph(parseInt(xElem.dataset.para_num, 10));
             } else if (xElem.id.startsWith("grammalecte_hide")) {
                 xElem.parentNode.parentNode.style.display = "none";
             } else if (xElem.id.startsWith("grammalecte_err")
@@ -64,10 +67,22 @@
         this.iLastEditedParagraph = -1;
         this.nParagraph = 0;
         // Lexicographer
         this.nLxgCount = 0;
         this.xLxgPanelContent = oGrammalecte.createNode("div", {id: "grammalecte_lxg_panel_content"});
+        this.xLxgInputBlock = oGrammalecte.createNode("div", {id: "grammalecte_lxg_input_block"});
+        this.xLxgInput = oGrammalecte.createNode("div", {id: "grammalecte_lxg_input", lang: "fr", contentEditable: "true"});
+        this.xLxgInputButton = oGrammalecte.createNode("div", {id: "grammalecte_lxg_input_button", textContent: "Analyse grammaticale"});
+        this.xLxgInputButton.addEventListener("click", () => { this.grammaticalAnalysis(); }, false);
+        this.xLxgInputButton2 = oGrammalecte.createNode("div", {id: "grammalecte_lxg_input_button", textContent: "Analyse lexicale"});
+        this.xLxgInputButton2.addEventListener("click", () => { this.getListOfTokens(); }, false);
+        this.xLxgInputBlock.appendChild(this.xLxgInput);
+        this.xLxgInputBlock.appendChild(this.xLxgInputButton);
+        this.xLxgInputBlock.appendChild(this.xLxgInputButton2);
+        this.xLxgPanelContent.appendChild(this.xLxgInputBlock);
+        this.xLxgResultZone = oGrammalecte.createNode("div", {id: "grammalecte_lxg_result_zone"});
+        this.xLxgPanelContent.appendChild(this.xLxgResultZone);
         this.xPanelContent.appendChild(this.xLxgPanelContent);
         // Conjugueur
         this.xConjPanelContent = oGrammalecte.createNode("div", {id: "grammalecte_conj_panel_content"});
         this.xConjPanelContent.innerHTML = sGrammalecteConjugueurHTML;  // @Reviewers: sGrammalecteConjugueurHTML is a const value defined in <content_scripts/html_src.js>
         this.xPanelContent.appendChild(this.xConjPanelContent);
@@ -112,14 +127,10 @@
             this.setAutoRefreshButton();
         }
         this.xLxgButton.onclick = () => {
             if (!this.bWorking) {
                 this.showLexicographer();
-                this.clearLexicographer();
-                this.startWaitIcon();
-                oGrammalecteBackgroundPort.getListOfTokens(this.oTextControl.getText());
-                //oGrammalecteBackgroundPort.parseFull(this.oTextControl.getText())
             }
         };
         this.xConjButton.onclick = () => {
             if (!this.bWorking) {
                 this.showConjugueur();
@@ -238,14 +249,14 @@
 
     addParagraphResult (oResult) {
         try {
             this.resetTimer();
             if (oResult && (oResult.sParagraph.trim() !== "" || oResult.aGrammErr.length > 0 || oResult.aSpellErr.length > 0)) {
-                let xNodeDiv = oGrammalecte.createNode("div", {className: "grammalecte_paragraph_block"});
                 // actions
                 let xActionsBar = oGrammalecte.createNode("div", {className: "grammalecte_paragraph_actions"});
                 xActionsBar.appendChild(oGrammalecte.createNode("div", {id: "grammalecte_check" + oResult.iParaNum, className: "grammalecte_paragraph_button grammalecte_green", textContent: "↻", title: "Réanalyser…"}, {para_num: oResult.iParaNum}));
+                xActionsBar.appendChild(oGrammalecte.createNode("div", {id: "grammalecte_analysis" + oResult.iParaNum, className: "grammalecte_paragraph_button grammalecte_blue", textContent: "»", title: "Analyse grammaticale…"}, {para_num: oResult.iParaNum}));
                 xActionsBar.appendChild(oGrammalecte.createNode("div", {id: "grammalecte_hide" + oResult.iParaNum, className: "grammalecte_paragraph_button grammalecte_red", textContent: "×", title: "Cacher", style: "font-weight: bold;"}));
                 // paragraph
                 let xParagraph = oGrammalecte.createNode("p", {id: "grammalecte_paragraph"+oResult.iParaNum, className: "grammalecte_paragraph", lang: "fr", contentEditable: "true"}, {para_num: oResult.iParaNum});
                 xParagraph.setAttribute("spellcheck", "false"); // doesn’t seem possible to use “spellcheck” as a common attribute.
                 xParagraph.dataset.timer_id = "0";
@@ -260,13 +271,14 @@
                     this.oTextControl.setParagraph(parseInt(xEvent.target.dataset.para_num, 10), xEvent.target.textContent);
                 }.bind(this)
                 , true);
                 this._tagParagraph(xParagraph, oResult.sParagraph, oResult.iParaNum, oResult.aGrammErr, oResult.aSpellErr);
                 // creation
-                xNodeDiv.appendChild(xActionsBar);
-                xNodeDiv.appendChild(xParagraph);
-                this.xParagraphList.appendChild(xNodeDiv);
+                let xParagraphBlock = oGrammalecte.createNode("div", {className: "grammalecte_paragraph_block"});
+                xParagraphBlock.appendChild(xActionsBar);
+                xParagraphBlock.appendChild(xParagraph);
+                this.xParagraphList.appendChild(xParagraphBlock);
                 this.nParagraph += 1;
             }
         }
         catch (e) {
             showError(e);
@@ -530,36 +542,131 @@
 
     // Lexicographer
 
     clearLexicographer () {
         this.nLxgCount = 0;
-        while (this.xLxgPanelContent.firstChild) {
-            this.xLxgPanelContent.removeChild(this.xLxgPanelContent.firstChild);
-        }
-    }
-
-    addLxgSeparator (sText) {
-        if (this.xLxgPanelContent.textContent !== "") {
-            this.xLxgPanelContent.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_separator", textContent: sText}));
-        }
-    }
-
-    addMessageToLxgPanel (sMessage) {
-        let xNode = oGrammalecte.createNode("div", {className: "grammalecte_panel_flow_message", textContent: sMessage});
-        this.xLxgPanelContent.appendChild(xNode);
-    }
-
-    addListOfTokens (lToken) {
+        while (this.xLxgResultZone.firstChild) {
+            this.xLxgResultZone.removeChild(this.xLxgResultZone.firstChild);
+        }
+    }
+
+    //  Grammatical analysis
+
+    sendParagraphToGrammaticalAnalysis (iParaNum) {
+        let xParagraph = this.xParent.getElementById("grammalecte_paragraph" + iParaNum);
+        this.xLxgInput.textContent = xParagraph.textContent;
+        this.grammaticalAnalysis();
+        this.showLexicographer();
+    }
+
+    grammaticalAnalysis (iParaNum) {
+        if (!this.bOpened || this.bWorking) {
+            return;
+        }
+        this.startWaitIcon();
+        this.clearLexicographer();
+        let sText = this.xLxgInput.innerText.replace(/\n/g, " ");
+        console.log(sText);
+        oGrammalecteBackgroundPort.parseFull(sText, "__GrammalectePanel__");
+    }
+
+    showParagraphAnalysis (oResult) {
+        if (!this.bOpened || oResult === null) {
+            return;
+        }
+        try {
+            for (let oSentence of oResult.lSentences) {
+                this.nLxgCount += 1;
+                if (oSentence.sSentence.trim() !== "") {
+                    let xSentenceBlock = oGrammalecte.createNode("div", {className: "grammalecte_lxg_paragraph_sentence_block"});
+                    xSentenceBlock.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_list_num", textContent: this.nLxgCount}));
+                    xSentenceBlock.appendChild(oGrammalecte.createNode("p", {className: "grammalecte_lxg_paragraph_sentence", textContent: oSentence.sSentence}));
+                    let xTokenList = oGrammalecte.createNode("div", {className: "grammalecte_lxg_list_of_tokens"});
+                    for (let oToken of oSentence.lTokens) {
+                        if (oToken["sType"] != "INFO") {
+                            xTokenList.appendChild(this._createTokenBlock2(oToken));
+                        }
+                    }
+                    xSentenceBlock.appendChild(xTokenList);
+                    this.xLxgResultZone.appendChild(xSentenceBlock);
+                }
+            }
+        }
+        catch (e) {
+            showError(e);
+        }
+        this.stopWaitIcon();
+    }
+
+    _createTokenBlock2 (oToken) {
+        let xTokenBlock = oGrammalecte.createNode("div", {className: "grammalecte_lxg_token_block"});
+        // token description
+        xTokenBlock.appendChild(this._createTokenDescr2(oToken));
+        return xTokenBlock;
+    }
+
+    _createTokenDescr2 (oToken) {
+        try {
+            let xTokenDescr = oGrammalecte.createNode("div", {className: "grammalecte_lxg_token_descr"});
+            xTokenDescr.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_token grammalecte_lxg_token_" + oToken.sType, textContent: oToken.sValue}));
+            xTokenDescr.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_token_colon", textContent: ":"}));
+            if (oToken.aLabels) {
+                if (oToken.aLabels.length < 2) {
+                    // one morphology only
+                    xTokenDescr.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_morph_elem_inline", textContent: oToken.aLabels[0]}));
+                } else {
+                    // several morphology
+                    let xMorphList = oGrammalecte.createNode("div", {className: "grammalecte_lxg_morph_list"});
+                    for (let sLabel of oToken.aLabels) {
+                        xMorphList.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_morph_elem", textContent: "• " + sLabel}));
+                    }
+                    xTokenDescr.appendChild(xMorphList);
+                }
+            } else {
+                xTokenDescr.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_morph_elem_inline", textContent: "étiquettes non décrites : [" + oToken.lMorph + "]" }));
+            }
+            // other labels description
+            if (oToken.aOtherLabels) {
+                let xSubBlock = oGrammalecte.createNode("div", {className: "grammalecte_lxg_token_subblock"});
+                for (let sLabel of oToken.aOtherLabels) {
+                    xSubBlock.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_other_tags", textContent: "• " + sLabel}));
+                }
+                xTokenDescr.appendChild(xSubBlock);
+            }
+            return xTokenDescr;
+        }
+        catch (e) {
+            showError(e);
+        }
+    }
+
+    //  Lexical analysis
+
+    getListOfTokens () {
+        if (!this.bOpened || this.bWorking) {
+            return;
+        }
+        this.startWaitIcon();
+        this.clearLexicographer();
+        let sText = this.xLxgInput.innerText; // to get carriage return (\n)
+        console.log(sText);
+        oGrammalecteBackgroundPort.getListOfTokens(sText, "__GrammalectePanel__");
+    }
+
+    addListOfTokens (oResult) {
         try {
-            if (lToken) {
+            if (oResult && oResult.sParagraph != "") {
                 this.nLxgCount += 1;
+                let xSentenceBlock = oGrammalecte.createNode("div", {className: "grammalecte_lxg_paragraph_sentence_block"});
+                xSentenceBlock.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_list_num", textContent: this.nLxgCount}));
+                xSentenceBlock.appendChild(oGrammalecte.createNode("p", {className: "grammalecte_lxg_paragraph_sentence", textContent: oResult.sParagraph}));
                 let xTokenList = oGrammalecte.createNode("div", {className: "grammalecte_lxg_list_of_tokens"});
-                xTokenList.appendChild(oGrammalecte.createNode("div", {className: "grammalecte_lxg_list_num", textContent: this.nLxgCount}));
-                for (let oToken of lToken) {
+                for (let oToken of oResult.lTokens) {
                     xTokenList.appendChild(this._createTokenBlock(oToken));
                 }
-                this.xLxgPanelContent.appendChild(xTokenList);
+                xSentenceBlock.appendChild(xTokenList);
+                this.xLxgResultZone.appendChild(xSentenceBlock);
             }
         }
         catch (e) {
             showError(e);
         }
@@ -600,16 +707,10 @@
         catch (e) {
             showError(e);
         }
     }
 
-    setHidden (sClass, bHidden) {
-        let xPanelContent = this.xParent.getElementById('grammalecte_panel_content');
-        for (let xNode of xPanelContent.getElementsByClassName(sClass)) {
-            xNode.hidden = bHidden;
-        }
-    }
 
     // Conjugueur
 
     listenConj () {
         if (!this.bListenConj) {

Index: gc_lang/fr/webext/content_scripts/panel_lxg.css
==================================================================
--- gc_lang/fr/webext/content_scripts/panel_lxg.css
+++ gc_lang/fr/webext/content_scripts/panel_lxg.css
@@ -6,21 +6,66 @@
     position: absolute;
     height: 100%;
     width: 100%;
     font-size: 13px;
 }
+
+div#grammalecte_lxg_input_block {
+    padding: 10px;
+    /*background-color: hsl(210, 50%, 95%);*/
+    /*border-bottom: solid 1px hsl(210, 0%, 90%);*/
+    text-align: right;
+}
+
+div#grammalecte_lxg_result_zone {
+
+}
+
+div#grammalecte_lxg_input {
+    min-height: 100px;
+    padding: 10px;
+    background-color: hsl(210, 0%, 100%);
+    border: solid 1px hsl(210, 20%, 80%);
+    border-radius: 3px;
+    font-family: "Courier New", Courier, "Lucida Sans Typewriter", "Lucida Typewriter", monospace;
+    text-align: left;
+}
+
+div#grammalecte_lxg_input_button {
+    display: inline-block;
+    margin: 0 10px 0 0;
+    padding: 3px 10px;
+    background-color: hsl(210, 50%, 50%);
+    color: hsl(210, 50%, 98%);
+    text-align: center;
+    cursor: pointer;
+    border-radius: 0 0 3px 3px;
+}
+
+div.grammalecte_lxg_paragraph_sentence_block {
+    margin: 5px 0px 20px 0px;
+    background-color: hsl(210, 50%, 95%);
+    border-radius: 3px;
+    border-top: solid 1px hsl(210, 50%, 90%);
+    border-bottom: solid 1px hsl(210, 50%, 90%);
+    hyphens: none;
+}
+p.grammalecte_lxg_paragraph_sentence {
+    padding: 3px 10px;
+    font-weight: bold;
+    color: hsl(210, 50%, 40%);
+}
 
 div.grammalecte_lxg_list_of_tokens {
-    margin: 10px 5px 0 5px;
     padding: 10px;
-    background-color: hsla(0, 0%, 95%, 1);
+    background-color: hsl(210, 50%, 99%);
     border-radius: 5px;
 }
 
 div.grammalecte_lxg_list_num {
     float: right;
-    margin: -12px 0 5px 10px;
+    margin: -2px 5px 5px 10px;
     padding: 5px 10px;
     font-family: "Trebuchet MS", "Fira Sans", "Ubuntu Condensed", "Liberation Sans", sans-serif;
     font-size: 14px;
     font-weight: bold;
     border-radius: 0 0 4px 4px;
@@ -85,10 +130,16 @@
 }
 div.grammalecte_lxg_morph_elem {
     font-family: "Trebuchet MS", "Fira Sans", "Ubuntu Condensed", "Liberation Sans", sans-serif;
     color: hsl(0, 0%, 0%);
 }
+div.grammalecte_lxg_other_tags {
+    padding-left: 20px;
+    font-family: "Trebuchet MS", "Fira Sans", "Ubuntu Condensed", "Liberation Sans", sans-serif;
+    color: hsl(0, 0%, 50%);
+}
+
 div.grammalecte_lxg_token_LOC {
     background-color: hsla(150, 50%, 30%, 1);
 }
 div.grammalecte_lxg_token_WORD {
     background-color: hsla(150, 50%, 50%, 1);

Index: gc_lang/fr/webext/gce_worker.js
==================================================================
--- gc_lang/fr/webext/gce_worker.js
+++ gc_lang/fr/webext/gce_worker.js
@@ -229,29 +229,24 @@
     let aGrammErr = gc_engine.parse(sParagraph, sCountry, bDebug, null, bContext);
     let aSpellErr = oSpellChecker.parseParagraph(sParagraph);
     postMessage(createResponse("parseAndSpellcheck1", {sParagraph: sParagraph, aGrammErr: aGrammErr, aSpellErr: aSpellErr}, oInfo, true));
 }
 
-function parseFull (sText, sCountry, bDebug, bContext, oInfo={}) {
-    let i = 0;
-    sText = sText.replace(/­/g, "").normalize("NFC");
-    for (let sParagraph of text.getParagraph(sText)) {
-        let lSentence = gc_engine.parse(sParagraph, sCountry, bDebug, null, bContext, true);
-        console.log("*", lSentence);
-        postMessage(createResponse("parseFull", {sParagraph: sParagraph, iParaNum: i, lSentence: lSentence}, oInfo, false));
-        i += 1;
-    }
-    postMessage(createResponse("parseFull", null, oInfo, true));
+function parseFull (sParagraph, sCountry, bDebug, bContext, oInfo={}) {
+    sParagraph = sParagraph.replace(/­/g, "").normalize("NFC");
+    let [lParagraphErrors, lSentences] = gc_engine.parse(sParagraph, sCountry, bDebug, null, bContext, true);
+    //console.log(lSentences);
+    postMessage(createResponse("parseFull", { lParagraphErrors: lParagraphErrors, lSentences: lSentences }, oInfo, true));
 }
 
 function getListOfTokens (sText, oInfo={}) {
     // lexicographer
     try {
         sText = sText.replace(/­/g, "").normalize("NFC");
         for (let sParagraph of text.getParagraph(sText)) {
             if (sParagraph.trim() !== "") {
-                postMessage(createResponse("getListOfTokens", lexgraph_fr.getListOfTokensReduc(sParagraph, true), oInfo, false));
+                postMessage(createResponse("getListOfTokens", { sParagraph: sParagraph, lTokens: lexgraph_fr.getListOfTokens(sParagraph, true) }, oInfo, false));
             }
         }
         postMessage(createResponse("getListOfTokens", null, oInfo, true));
     }
     catch (e) {

Index: grammalecte-cli.py
==================================================================
--- grammalecte-cli.py
+++ grammalecte-cli.py
@@ -340,11 +340,11 @@
                     lParagraphErrors, lSentences = oGrammarChecker.gce.parse(sParagraph, bDebug=xArgs.debug, bFullInfo=True)
                     echo(txt.getReadableErrors(lParagraphErrors, xArgs.width))
                     for dSentence in lSentences:
                         echo("{nStart}:{nEnd}".format(**dSentence))
                         echo("   <" + dSentence["sSentence"]+">")
-                        for dToken in dSentence["lToken"]:
+                        for dToken in dSentence["lTokens"]:
                             echo("    {0[nStart]:>3}:{0[nEnd]:<3} {1} {0[sType]:<14} {2} {0[sValue]:<16} {3:<10}   {4}".format(dToken, \
                                                                                                             "×" if dToken.get("bToRemove", False) else " ",
                                                                                                             "!" if dToken["sType"] == "WORD" and not dToken.get("bValidToken", False) else " ",
                                                                                                             " ".join(dToken.get("lMorph", "")), \
                                                                                                             "·".join(dToken.get("aTags", "")) ) )

Index: graphspell-js/lexgraph_fr.js
==================================================================
--- graphspell-js/lexgraph_fr.js
+++ graphspell-js/lexgraph_fr.js
@@ -164,13 +164,16 @@
             [':f', [" féminin", "féminin"]],
             [':s', [" singulier", "singulier"]],
             [':p', [" pluriel", "pluriel"]],
             [':i', [" invariable", "invariable"]],
 
-            [':V1', [" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"]],
-            [':V2', [" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"]],
-            [':V3', [" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"]],
+            [':V1_', [" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"]],
+            [':V2_', [" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"]],
+            [':V3_', [" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"]],
+            [':V1e', [" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"]],
+            [':V2e', [" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"]],
+            [':V3e', [" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"]],
             [':V0e', [" verbe,", "Verbe auxiliaire être"]],
             [':V0a', [" verbe,", "Verbe auxiliaire avoir"]],
 
             [':Y', [" infinitif,", "infinitif"]],
             [':P', [" participe présent,", "participe présent"]],
@@ -221,16 +224,16 @@
             [':Ĉ', [" conjonction (él.),", "Conjonction (élément)"]],
             [':Cc', [" conjonction de coordination,", "Conjonction de coordination"]],
             [':Cs', [" conjonction de subordination,", "Conjonction de subordination"]],
             [':Ĉs', [" conjonction de subordination (él.),", "Conjonction de subordination (élément)"]],
 
-            [':Ñ', [" locution nominale (él.),", "Locution nominale (élément)"]],
-            [':Â', [" locution adjectivale (él.),", "Locution adjectivale (élément)"]],
-            [':Ṽ', [" locution verbale (él.),", "Locution verbale (élément)"]],
-            [':Ŵ', [" locution adverbiale (él.),", "Locution adverbiale (élément)"]],
-            [':Ŕ', [" locution prépositive (él.),", "Locution prépositive (élément)"]],
-            [':Ĵ', [" locution interjective (él.),", "Locution interjective (élément)"]],
+            [':ÉN', [" locution nominale (él.),", "Locution nominale (élément)"]],
+            [':ÉA', [" locution adjectivale (él.),", "Locution adjectivale (élément)"]],
+            [':ÉV', [" locution verbale (él.),", "Locution verbale (élément)"]],
+            [':ÉW', [" locution adverbiale (él.),", "Locution adverbiale (élément)"]],
+            [':ÉR', [" locution prépositive (él.),", "Locution prépositive (élément)"]],
+            [':ÉJ', [" locution interjective (él.),", "Locution interjective (élément)"]],
 
             [':Zp', [" préfixe,", "Préfixe"]],
             [':Zs', [" suffixe,", "Suffixe"]],
 
             [':H', ["", "<Hors-norme, inclassable>"]],
@@ -277,64 +280,87 @@
             ['t', " transitive directe"],
             ['p', " pronominale"],
             ['m', " impersonnelle"],
         ]),
 
-    dElidedPrefix: new Map([
-            ['d', "(de), déterminant épicène invariable"],
-            ['l', "(le/la), déterminant masculin/féminin singulier"],
-            ['j', "(je), pronom personnel sujet, 1ʳᵉ pers., épicène singulier"],
-            ['m', "(me), pronom personnel objet, 1ʳᵉ pers., épicène singulier"],
-            ['t', "(te), pronom personnel objet, 2ᵉ pers., épicène singulier"],
-            ['s', "(se), pronom personnel objet, 3ᵉ pers., épicène singulier/pluriel"],
-            ['n', "(ne), adverbe de négation"],
-            ['c', "(ce), pronom démonstratif, masculin singulier/pluriel"],
-            ['ç', "(ça), pronom démonstratif, masculin singulier"],
+    dValues: new Map([
+            ['d’', "(de), préposition ou déterminant épicène invariable"],
+            ['l’', "(le/la), déterminant ou pronom personnel objet, masculin/féminin singulier"],
+            ['j’', "(je), pronom personnel sujet, 1ʳᵉ pers., épicène singulier"],
+            ['m’', "(me), pronom personnel objet, 1ʳᵉ pers., épicène singulier"],
+            ['t’', "(te), pronom personnel objet, 2ᵉ pers., épicène singulier"],
+            ['s’', "(se), pronom personnel objet, 3ᵉ pers., épicène singulier/pluriel"],
+            ['n’', "(ne), adverbe de négation"],
+            ['c’', "(ce), pronom démonstratif, masculin singulier/pluriel"],
+            ['ç’', "(ça), pronom démonstratif, masculin singulier"],
             ['qu', "(que), conjonction de subordination"],
-            ['lorsqu', "(lorsque), conjonction de subordination"],
-            ['puisqu', "(lorsque), conjonction de subordination"],
-            ['quoiqu', "(quoique), conjonction de subordination"],
-            ['jusqu', "(jusque), préposition"]
-        ]),
-
-    dPronoms: new Map([
-            ['je', " pronom personnel sujet, 1ʳᵉ pers. sing."],
-            ['tu', " pronom personnel sujet, 2ᵉ pers. sing."],
-            ['il', " pronom personnel sujet, 3ᵉ pers. masc. sing."],
-            ['on', " pronom personnel sujet, 3ᵉ pers. sing. ou plur."],
-            ['elle', " pronom personnel sujet, 3ᵉ pers. fém. sing."],
-            ['nous', " pronom personnel sujet/objet, 1ʳᵉ pers. plur."],
-            ['vous', " pronom personnel sujet/objet, 2ᵉ pers. plur."],
-            ['ils', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
-            ['elles', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
-
-            ["là", " particule démonstrative"],
-            ["ci", " particule démonstrative"],
-
-            ['le', " COD, masc. sing."],
-            ['la', " COD, fém. sing."],
-            ['les', " COD, plur."],
-
-            ['moi', " COI (à moi), sing."],
-            ['toi', " COI (à toi), sing."],
-            ['lui', " COI (à lui ou à elle), sing."],
-            ['nous2', " COI (à nous), plur."],
-            ['vous2', " COI (à vous), plur."],
-            ['leur', " COI (à eux ou à elles), plur."],
-
-            ['y', " pronom adverbial"],
-            ["m'y", " (me) pronom personnel objet + (y) pronom adverbial"],
-            ["t'y", " (te) pronom personnel objet + (y) pronom adverbial"],
-            ["s'y", " (se) pronom personnel objet + (y) pronom adverbial"],
-
-            ['en', " pronom adverbial"],
-            ["m'en", " (me) pronom personnel objet + (en) pronom adverbial"],
-            ["t'en", " (te) pronom personnel objet + (en) pronom adverbial"],
-            ["s'en", " (se) pronom personnel objet + (en) pronom adverbial"]
-        ]),
-
-    dChar: new Map([
+            ['lorsqu’', "(lorsque), conjonction de subordination"],
+            ['puisqu’', "(lorsque), conjonction de subordination"],
+            ['quoiqu’', "(quoique), conjonction de subordination"],
+            ['jusqu’', "(jusque), préposition"],
+
+            ['-je', " pronom personnel sujet, 1ʳᵉ pers. sing."],
+            ['-tu', " pronom personnel sujet, 2ᵉ pers. sing."],
+            ['-il', " pronom personnel sujet, 3ᵉ pers. masc. sing."],
+            ['-iel', " pronom personnel sujet, 3ᵉ pers. sing."],
+            ['-on', " pronom personnel sujet, 3ᵉ pers. sing. ou plur."],
+            ['-elle', " pronom personnel sujet, 3ᵉ pers. fém. sing."],
+            ['-t-il', " “t” euphonique + pronom personnel sujet, 3ᵉ pers. masc. sing."],
+            ['-t-on', " “t” euphonique + pronom personnel sujet, 3ᵉ pers. sing. ou plur."],
+            ['-t-elle', " “t” euphonique + pronom personnel sujet, 3ᵉ pers. fém. sing."],
+            ['-t-iel', " “t” euphonique + pronom personnel sujet, 3ᵉ pers. sing."],
+            ['-nous', " pronom personnel sujet/objet, 1ʳᵉ pers. plur.  ou  COI (à nous), plur."],
+            ['-vous', " pronom personnel sujet/objet, 2ᵉ pers. plur.  ou  COI (à vous), plur."],
+            ['-ils', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
+            ['-elles', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
+            ['-iels', " pronom personnel sujet, 3ᵉ pers. plur."],
+
+            ["-là", " particule démonstrative (là)"],
+            ["-ci", " particule démonstrative (ci)"],
+
+            ['-le', " COD, masc. sing."],
+            ['-la', " COD, fém. sing."],
+            ['-les', " COD, plur."],
+
+            ['-moi', " COI (à moi), sing."],
+            ['-toi', " COI (à toi), sing."],
+            ['-lui', " COI (à lui ou à elle), sing."],
+            ['-nous2', " COI (à nous), plur."],
+            ['-vous2', " COI (à vous), plur."],
+            ['-leur', " COI (à eux ou à elles), plur."],
+
+            ['-le-moi', " COD, masc. sing. + COI (à moi), sing."],
+            ['-le-toi', " COD, masc. sing. + COI (à toi), sing."],
+            ['-le-lui', " COD, masc. sing. + COI (à lui ou à elle), sing."],
+            ['-le-nous', " COD, masc. sing. + COI (à nous), plur."],
+            ['-le-vous', " COD, masc. sing. + COI (à vous), plur."],
+            ['-le-leur', " COD, masc. sing. + COI (à eux ou à elles), plur."],
+
+            ['-la-moi', " COD, fém. sing. + COI (à moi), sing."],
+            ['-la-toi', " COD, fém. sing. + COI (à toi), sing."],
+            ['-la-lui', " COD, fém. sing. + COI (à lui ou à elle), sing."],
+            ['-la-nous', " COD, fém. sing. + COI (à nous), plur."],
+            ['-la-vous', " COD, fém. sing. + COI (à vous), plur."],
+            ['-la-leur', " COD, fém. sing. + COI (à eux ou à elles), plur."],
+
+            ['-les-moi', " COD, plur. + COI (à moi), sing."],
+            ['-les-toi', " COD, plur. + COI (à toi), sing."],
+            ['-les-lui', " COD, plur. + COI (à lui ou à elle), sing."],
+            ['-les-nous', " COD, plur. + COI (à nous), plur."],
+            ['-les-vous', " COD, plur. + COI (à vous), plur."],
+            ['-les-leur', " COD, plur. + COI (à eux ou à elles), plur."],
+
+            ['-y', " pronom adverbial"],
+            ["-m’y", " (me) pronom personnel objet + (y) pronom adverbial"],
+            ["-t’y", " (te) pronom personnel objet + (y) pronom adverbial"],
+            ["-s’y", " (se) pronom personnel objet + (y) pronom adverbial"],
+
+            ['-en', " pronom adverbial"],
+            ["-m’en", " (me) pronom personnel objet + (en) pronom adverbial"],
+            ["-t’en", " (te) pronom personnel objet + (en) pronom adverbial"],
+            ["-s’en", " (se) pronom personnel objet + (en) pronom adverbial"],
+
             ['.', "point"],
             ['·', "point médian"],
             ['…', "points de suspension"],
             [':', "deux-points"],
             [';', "point-virgule"],
@@ -373,12 +399,12 @@
     oTokenizer: null,
     oLocGraph: null,
 
     _zPartDemForm: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-(là|ci)$", "i"),
     _aPartDemExceptList: new Set(["celui", "celle", "ceux", "celles", "de", "jusque", "par", "marie-couche-toi"]),
-    _zInterroVerb: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-(t-(?:il|elle|on)|je|tu|ils?|elles?|on|[nv]ous)$", "i"),
-    _zImperatifVerb: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-((?:les?|la)-(?:moi|toi|lui|[nv]ous|leur)|y|en|[mts][’'](?:y|en)|les?|la|[mt]oi|leur|lui)$", "i"),
+    _zInterroVerb: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)(-(?:t-(?:ie?l|elle|on)|je|tu|ie?ls?|elles?|on|[nv]ous))$", "i"),
+    _zImperatifVerb: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)(-(?:l(?:es?|a)-(?:moi|toi|lui|[nv]ous|leur)|y|en|[mts][’'](?:y|en)|les?|la|[mt]oi|leur|lui))$", "i"),
     _zTag: new RegExp("[:;/][a-zA-Z0-9ÑÂĴĈŔÔṼŴ!][^:;/]*", "g"),
 
 
     load: function (oSpellChecker, oTokenizer, oLocGraph) {
         this.oSpellChecker = oSpellChecker;
@@ -403,10 +429,130 @@
             sSuffix = m[2];
         }
         // split word in 3 parts: prefix, root, suffix
         return [sPrefix, sWord, sSuffix];
     },
+
+    analyze: function (sWord) {
+        // return meaning of <sWord> if found else an empty string
+        sWord = sWord.toLowerCase();
+        if (this.dValues.has(sWord)) {
+            return this.dValues.get(sWord);
+        }
+        return "";
+    },
+
+    readableMorph: function (sMorph) {
+        let sRes = "";
+        sMorph = sMorph.replace(/:V([0-3][ea_])[itpqnmr_eaxz]+/, ":V$1");
+        let m;
+        while ((m = this._zTag.exec(sMorph)) !== null) {
+            if (this.dTag.has(m[0])) {
+                sRes += this.dTag.get(m[0])[0];
+            } else {
+                sRes += " [" + m[0] + "]?";
+            }
+        }
+        if (sRes.startsWith(" verbe") && !sRes.includes("infinitif")) {
+            sRes += " [" + sMorph.slice(1, sMorph.indexOf("/")) + "]";
+        }
+        if (!sRes) {
+            return " [" + sMorph + "]: étiquettes inconnues";
+        }
+        return sRes.gl_trimRight(",");
+    },
+
+    setLabelsOnToken (oToken) {
+        // Token: .sType, .sValue, .nStart, .nEnd, .lMorph
+        let m = null;
+        try {
+            switch (oToken.sType) {
+                case 'PUNC':
+                case 'SIGN':
+                    oToken["aLabels"] = [this.dValues.gl_get(oToken.sValue, "signe de ponctuation divers")];
+                    break;
+                case 'NUM':
+                    oToken["aLabels"] = ["nombre"];
+                    break;
+                case 'LINK':
+                    oToken["aLabels"] = ["hyperlien"];
+                    break;
+                case 'TAG':
+                    oToken["aLabels"] = ["étiquette (hashtag)"];
+                    break;
+                case 'HTML':
+                    oToken["aLabels"] = ["balise HTML"];
+                    break;
+                case 'PSEUDOHTML':
+                    oToken["aLabels"] = ["balise pseudo-HTML"];
+                    break;
+                case 'HTMLENTITY':
+                    oToken["aLabels"] = ["entité caractère XML/HTML"];
+                    break;
+                case 'HOUR':
+                    oToken["aLabels"] = ["heure"];
+                    break;
+                case 'WORD_ELIDED':
+                    oToken["aLabels"] = [this.dValues.gl_get(oToken.sValue, "préfixe élidé inconnu")];
+                    break;
+                case 'WORD_ORDINAL':
+                    oToken["aLabels"] = ["nombre ordinal"];
+                    break;
+                case 'FOLDERUNIX':
+                    oToken["aLabels"] = ["dossier UNIX (et dérivés)"];
+                    break;
+                case 'FOLDERWIN':
+                    oToken["aLabels"] = ["dossier Windows"];
+                    break;
+                case 'WORD_ACRONYM':
+                    oToken["aLabels"] = ["sigle ou acronyme"];
+                    break;
+                case 'WORD':
+                    if (oToken.hasOwnProperty("lMorph")  &&  oToken["lMorph"].length > 0) {
+                        // with morphology
+                        oToken["aLabels"] = [];
+                        for (let sMorph of oToken["lMorph"]) {
+                            oToken["aLabels"].push(this.readableMorph(sMorph));
+                        }
+                        if (oToken.hasOwnProperty("sTags")) {
+                            let aTags = [];
+                            for (let sTag of oToken["sTags"]) {
+                                if (this.dValues.has(sTag)) {
+                                    aTags.push(this.dValues.get(sTag))
+                                }
+                            }
+                            if (aTags.length > 0) {
+                                oToken["aOtherLabels"] = aTags;
+                            }
+                        }
+                    } else {
+                        // no morphology, guessing
+                        if (oToken.sValue.gl_count("-") > 4) {
+                            oToken["aLabels"] = ["élément complexe indéterminé"];
+                        }
+                        else if (m = this._zPartDemForm.exec(oToken.sValue)) {
+                            // mots avec particules démonstratives
+                            oToken["aLabels"] = ["mot avec particule démonstrative"];
+                        }
+                        else if (m = this._zImperatifVerb.exec(oToken.sValue)) {
+                            // formes interrogatives
+                            oToken["aLabels"] = ["forme verbale impérative"];
+                        }
+                        else if (m = this._zInterroVerb.exec(oToken.sValue)) {
+                            // formes interrogatives
+                            oToken["aLabels"] = ["forme verbale interrogative"];
+                        }
+                    }
+                    break;
+                default:
+                    oToken["aLabels"] = ["token de nature inconnue"];
+            }
+        } catch (e) {
+            console.error(e);
+        }
+        return null;
+    },
 
     getInfoForToken: function (oToken) {
         // Token: .sType, .sValue, .nStart, .nEnd
         // return a object {sType, sValue, aLabel}
         let m = null;
@@ -415,11 +561,11 @@
                 case 'PUNC':
                 case 'SIGN':
                     return {
                         sType: oToken.sType,
                         sValue: oToken.sValue,
-                        aLabel: [this.dChar.gl_get(oToken.sValue, "caractère indéterminé")]
+                        aLabel: [this.dValues.gl_get(oToken.sValue, "caractère indéterminé")]
                     };
                     break;
                 case 'NUM':
                     return {
                         sType: oToken.sType,
@@ -468,15 +614,14 @@
                         sValue: oToken.sValue,
                         aLabel: ["heure"]
                     };
                     break;
                 case 'WORD_ELIDED':
-                    let sTemp = oToken.sValue.replace("’", "").replace("'", "").replace("`", "").toLowerCase();
                     return {
                         sType: oToken.sType,
                         sValue: oToken.sValue,
-                        aLabel: [this.dElidedPrefix.gl_get(sTemp, "préfixe élidé inconnu")]
+                        aLabel: [this.dValues.gl_get(oToken.sValue.toLowerCase(), "préfixe élidé inconnu")]
                     };
                     break;
                 case 'WORD_ORDINAL':
                     return {
                         sType: oToken.sType,
@@ -524,34 +669,34 @@
                         return {
                             sType: oToken.sType,
                             sValue: oToken.sValue,
                             aLabel: ["mot avec particule démonstrative"],
                             aSubElem: [
-                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
-                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
+                                { sType: oToken.sType, sValue: m[1], aLabel: this._getMorph(m[1]) },
+                                { sType: oToken.sType, sValue: m[2], aLabel: [ this._formatSuffix(m[2]) ] }
                             ]
                         };
                     } else if (m = this._zImperatifVerb.exec(oToken.sValue)) {
                         // formes interrogatives
                         return {
                             sType: oToken.sType,
                             sValue: oToken.sValue,
                             aLabel: ["forme verbale impérative"],
                             aSubElem: [
-                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
-                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
+                                { sType: oToken.sType, sValue: m[1], aLabel: this._getMorph(m[1]) },
+                                { sType: oToken.sType, sValue: m[2], aLabel: [ this._formatSuffix(m[2]) ] }
                             ]
                         };
                     } else if (m = this._zInterroVerb.exec(oToken.sValue)) {
                         // formes interrogatives
                         return {
                             sType: oToken.sType,
                             sValue: oToken.sValue,
                             aLabel: ["forme verbale interrogative"],
                             aSubElem: [
-                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
-                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
+                                { sType: oToken.sType, sValue: m[1], aLabel: this._getMorph(m[1]) },
+                                { sType: oToken.sType, sValue: m[2], aLabel: [ this._formatSuffix(m[2]) ] }
                             ]
                         };
                     } else if (this.oSpellChecker.isValidToken(oToken.sValue)) {
                         return {
                             sType: oToken.sType,
@@ -580,65 +725,24 @@
     },
 
     _getMorph (sWord) {
         let aElem = [];
         for (let s of this.oSpellChecker.getMorph(sWord)) {
-            if (s.includes(":")) aElem.push(this._formatTags(s));
+            if (s.includes(":")) aElem.push(this.readableMorph(s));
         }
         if (aElem.length == 0) {
             aElem.push("mot inconnu du dictionnaire");
         }
         return aElem;
     },
 
-    _formatTags (sTags) {
-        let sRes = "";
-        sTags = sTags.replace(/V([0-3][ea]?)[itpqnmr_eaxz]+/, "V$1");
-        let m;
-        while ((m = this._zTag.exec(sTags)) !== null) {
-            sRes += this.dTag.get(m[0])[0];
-        }
-        if (sRes.startsWith(" verbe") && !sRes.includes("infinitif")) {
-            sRes += " [" + sTags.slice(1, sTags.indexOf("/")) + "]";
-        }
-        if (!sRes) {
-            return "#Erreur. Étiquette inconnue : [" + sTags + "]";
-        }
-        return sRes.gl_trimRight(",");
-    },
-
-    _formatTagsLoc (sTags) {
-        let sRes = "";
-        let m;
-        while ((m = this._zTag.exec(sTags)) !== null) {
-            if (m[0].startsWith(":LV")) {
-                sRes += this.dLocTag.get(":LV");
-                for (let c of m[0].slice(3)) {
-                    sRes += this.dLocVerb.get(c);
-                }
-            } else {
-                sRes += this.dLocTag.get(m[0]);
-            }
-        }
-        if (!sRes) {
-            return "#Erreur. Étiquette inconnue : [" + sTags + "]";
-        }
-        return sRes.gl_trimRight(",");
-    },
-
-    _formatSuffix (s) {
-        if (s.startsWith("t-")) {
-            return "“t” euphonique +" + this.dPronoms.get(s.slice(2));
-        }
-        if (!s.includes("-")) {
-            return this.dPronoms.get(s.replace("’", "'"));
-        }
-        if (s.endsWith("ous")) {
-            s += '2';
-        }
-        let nPos = s.indexOf("-");
-        return this.dPronoms.get(s.slice(0, nPos)) + " +" + this.dPronoms.get(s.slice(nPos + 1));
+    _formatSuffix (sSuffix) {
+        sSuffix = sSuffix.replace(/['’ʼ‘‛´`′‵՚ꞌꞋ]/g, "’").toLowerCase();
+        if (this.dValues.has(sSuffix)) {
+            return this.dValues.get(sSuffix);
+        }
+        return " suffixe inconnu";
     },
 
     getListOfTokens (sText, bInfo=true) {
         let aElem = [];
         if (sText !== "") {
@@ -654,106 +758,13 @@
             }
         }
         return aElem;
     },
 
-    * generateInfoForTokenList (lToken) {
-        for (let oToken of lToken) {
-            let aRes = this.getInfoForToken(oToken);
-            if (aRes) {
-                yield aRes;
-            }
-        }
-    },
-
-    getListOfTokensReduc (sText, bInfo=true) {
-        let lToken = this.getListOfTokens(sText.replace("'", "’").trim(), false);
-        let iToken = 0;
-        let aElem = [];
-        if (lToken.length == 0) {
-            return aElem;
-        }
-        do {
-            let oToken = lToken[iToken];
-            let sMorphLoc = '';
-            let aTokenTempList = [oToken];
-            if (oToken.sType == "WORD" || oToken.sType == "WORD_ELIDED"){
-                let iLocEnd = iToken + 1;
-                let oLocNode = this.oLocGraph[oToken.sValue.toLowerCase()];
-                while (oLocNode) {
-                    let oTokenNext = lToken[iLocEnd];
-                    iLocEnd++;
-                    if (oTokenNext) {
-                        oLocNode = oLocNode[oTokenNext.sValue.toLowerCase()];
-                    }
-                    if (oLocNode && iLocEnd <= lToken.length) {
-                        sMorphLoc = oLocNode["_:_"];
-                        aTokenTempList.push(oTokenNext);
-                    } else {
-                        break;
-                    }
-                }
-            }
-
-            if (sMorphLoc) {
-                // we have a locution
-                let sValue = '';
-                for (let oTokenWord of aTokenTempList) {
-                    sValue += oTokenWord.sValue+' ';
-                }
-                let oTokenLocution = {
-                    'nStart': aTokenTempList[0].nStart,
-                    'nEnd': aTokenTempList[aTokenTempList.length-1].nEnd,
-                    'sType': "LOC",
-                    'sValue': sValue.replace('’ ','’').trim(),
-                    'aSubToken': aTokenTempList
-                };
-                if (bInfo) {
-                    let aSubElem = null;
-                    if (sMorphLoc.startsWith("*|")) {
-                        // cette suite de tokens n’est une locution que dans certains cas minoritaires
-                        oTokenLocution.sType = "LOCP";
-                        for (let oElem of this.generateInfoForTokenList(aTokenTempList)) {
-                            aElem.push(oElem);
-                        }
-                        sMorphLoc = sMorphLoc.slice(2);
-                    } else {
-                        aSubElem = [...this.generateInfoForTokenList(aTokenTempList)];
-                    }
-                    // cette suite de tokens est la plupart du temps une locution
-                    let aFormatedTag = [];
-                    for (let sTagLoc of sMorphLoc.split('|') ){
-                        aFormatedTag.push(this._formatTagsLoc(sTagLoc));
-                    }
-                    aElem.push({
-                        sType: oTokenLocution.sType,
-                        sValue: oTokenLocution.sValue,
-                        aLabel: aFormatedTag,
-                        aSubElem: aSubElem
-                    });
-                } else {
-                    aElem.push(oTokenLocution);
-                }
-                iToken = iToken + aTokenTempList.length;
-            }
-            else {
-                // No locution, we just add information
-                if (bInfo) {
-                    let aRes = this.getInfoForToken(oToken);
-                    if (aRes) {
-                        aElem.push(aRes);
-                    }
-                } else {
-                    aElem.push(oToken);
-                }
-                iToken++;
-            }
-        } while (iToken < lToken.length);
-        return aElem;
-    },
 
     // Other functions
+
     filterSugg: function (aSugg) {
         return aSugg.filter((sSugg) => { return !sSugg.endsWith("è") && !sSugg.endsWith("È"); });
     }
 }
 

Index: graphspell-js/spellchecker.js
==================================================================
--- graphspell-js/spellchecker.js
+++ graphspell-js/spellchecker.js
@@ -132,13 +132,53 @@
     loadLexicographer (sLangCode) {
         // load default suggestion module for <sLangCode>
         if (typeof(process) !== 'undefined') {
             this.lexicographer = require(`./lexgraph_${sLangCode}.js`);
         }
-        else if (typeof(require) !== 'undefined') {
-            this.lexicographer = require(`resource://grammalecte/graphspell/lexgraph_${sLangCode}.js`);
+        else if (self && self.hasOwnProperty("lexgraph_"+sLangCode)) { // self is the Worker
+            this.lexicographer = self["lexgraph_"+sLangCode];
+        }
+    }
+
+    analyze (sWord) {
+        // returns a list of words and their morphologies
+        if (!this.lexicographer) {
+            return [];
+        }
+        let lWordAndMorph = [];
+        for (let sElem of this.lexicographer.split(sWord)) {
+            if (sElem) {
+                let lMorph = this.getMorph(sElem);
+                let sLex = this.lexicographer.analyze(sElem)
+                let aRes = [];
+                if (sLex) {
+                    aRes = [ [lMorph.join(" | "), sLex] ];
+                } else {
+                    for (let sMorph of lMorph) {
+                        aRes.push([sMorph, this.lexicographer.formatTags(sMorph)]);
+                    }
+                }
+                if (aRes.length > 0) {
+                    lWordAndMorph.push([sElem, aRes]);
+                }
+            }
+        }
+        return lWordAndMorph;
+    }
+
+    readableMorph (sMorph) {
+        if (!this.lexicographer) {
+            return [];
+        }
+        return this.lexicographer.formatTags(sMorph);
+    }
+
+    setLabelsOnToken (oToken) {
+        if (!this.lexicographer) {
+            return;
         }
+        this.lexicographer.setLabelsOnToken(oToken);
     }
 
 
     // Storage
 

Index: graphspell/lexgraph_fr.py
==================================================================
--- graphspell/lexgraph_fr.py
+++ graphspell/lexgraph_fr.py
@@ -7,11 +7,11 @@
 #     <dSugg> : a dictionary for default suggestions.
 #     <bLexicographer> : a boolean False
 #       if the boolean is True, 4 functions are required:
 #           split(sWord) -> returns a list of string (that will be analyzed)
 #           analyze(sWord) -> returns a string with the meaning of word
-#           formatTags(sTags) -> returns a string with the meaning of tags
+#           readableMorph(sMorph) -> returns a string with the meaning of tags
 #           filterSugg(aWord) -> returns a filtered list of suggestions
 
 
 import re
 
@@ -170,13 +170,16 @@
     ':f': (" féminin", "féminin"),
     ':s': (" singulier", "singulier"),
     ':p': (" pluriel", "pluriel"),
     ':i': (" invariable", "invariable"),
 
-    ':V1': (" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"),
-    ':V2': (" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"),
-    ':V3': (" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"),
+    ':V1_': (" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"),
+    ':V2_': (" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"),
+    ':V3_': (" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"),
+    ':V1e': (" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"),
+    ':V2e': (" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"),
+    ':V3e': (" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"),
     ':V0e': (" verbe,", "Verbe auxiliaire être"),
     ':V0a': (" verbe,", "Verbe auxiliaire avoir"),
 
     ':Y': (" infinitif,", "infinitif"),
     ':P': (" participe présent,", "participe présent"),
@@ -272,22 +275,25 @@
     'jusqu’': "(jusque), préposition",
 
     '-je': " pronom personnel sujet, 1ʳᵉ pers. sing.",
     '-tu': " pronom personnel sujet, 2ᵉ pers. sing.",
     '-il': " pronom personnel sujet, 3ᵉ pers. masc. sing.",
+    '-iel': " pronom personnel sujet, 3ᵉ pers. sing.",
     '-on': " pronom personnel sujet, 3ᵉ pers. sing. ou plur.",
     '-elle': " pronom personnel sujet, 3ᵉ pers. fém. sing.",
     '-t-il': " “t” euphonique + pronom personnel sujet, 3ᵉ pers. masc. sing.",
     '-t-on': " “t” euphonique + pronom personnel sujet, 3ᵉ pers. sing. ou plur.",
     '-t-elle': " “t” euphonique + pronom personnel sujet, 3ᵉ pers. fém. sing.",
+    '-t-iel': " “t” euphonique + pronom personnel sujet, 3ᵉ pers. sing.",
     '-nous': " pronom personnel sujet/objet, 1ʳᵉ pers. plur.  ou  COI (à nous), plur.",
     '-vous': " pronom personnel sujet/objet, 2ᵉ pers. plur.  ou  COI (à vous), plur.",
     '-ils': " pronom personnel sujet, 3ᵉ pers. masc. plur.",
     '-elles': " pronom personnel sujet, 3ᵉ pers. masc. plur.",
+    '-iels': " pronom personnel sujet, 3ᵉ pers. plur.",
 
-    "-là": " particule démonstrative",
-    "-ci": " particule démonstrative",
+    "-là": " particule démonstrative (là)",
+    "-ci": " particule démonstrative (ci)",
 
     '-le': " COD, masc. sing.",
     '-la': " COD, fém. sing.",
     '-les': " COD, plur.",
 
@@ -324,10 +330,45 @@
 
     '-en': " pronom adverbial",
     "-m’en": " (me) pronom personnel objet + (en) pronom adverbial",
     "-t’en": " (te) pronom personnel objet + (en) pronom adverbial",
     "-s’en": " (se) pronom personnel objet + (en) pronom adverbial",
+
+    '.': "point",
+    '·': "point médian",
+    '…': "points de suspension",
+    ':': "deux-points",
+    ';': "point-virgule",
+    ',': "virgule",
+    '?': "point d’interrogation",
+    '!': "point d’exclamation",
+    '(': "parenthèse ouvrante",
+    ')': "parenthèse fermante",
+    '[': "crochet ouvrant",
+    ']': "crochet fermant",
+    '{': "accolade ouvrante",
+    '}': "accolade fermante",
+    '-': "tiret",
+    '—': "tiret cadratin",
+    '–': "tiret demi-cadratin",
+    '«': "guillemet ouvrant (chevrons)",
+    '»': "guillemet fermant (chevrons)",
+    '“': "guillemet ouvrant double",
+    '”': "guillemet fermant double",
+    '‘': "guillemet ouvrant",
+    '’': "guillemet fermant",
+    '"': "guillemets droits (déconseillé en typographie)",
+    '/': "signe de la division",
+    '+': "signe de l’addition",
+    '*': "signe de la multiplication",
+    '=': "signe de l’égalité",
+    '<': "inférieur à",
+    '>': "supérieur à",
+    '⩽': "inférieur ou égal à",
+    '⩾': "supérieur ou égal à",
+    '%': "signe de pourcentage",
+    '‰': "signe pour mille"
 }
 
 
 _zElidedPrefix = re.compile("(?i)^([ldmtsnjcç]|lorsqu|presqu|jusqu|puisqu|quoiqu|quelqu|qu)[’'‘`ʼ]([\\w-]+)")
 _zCompoundWord = re.compile("(?i)(\\w+)(-(?:(?:les?|la)-(?:moi|toi|lui|[nv]ous|leur)|t-(?:il|elle|on)|y|en|[mts]’(?:y|en)|les?|l[aà]|[mt]oi|leur|lui|je|tu|ils?|elles?|on|[nv]ous|ce))$")
@@ -356,22 +397,91 @@
     if sWord in _dValues:
         return _dValues[sWord]
     return ""
 
 
-def formatTags (sTags):
+def readableMorph (sMorph):
     "returns string: readable tags"
     sRes = ""
-    sTags = re.sub("(?<=V[1-3])[itpqnmr_eaxz]+", "", sTags)
-    sTags = re.sub("(?<=V0[ea])[itpqnmr_eaxz]+", "", sTags)
-    for m in _zTag.finditer(sTags):
-        sRes += _dTAGS.get(m.group(0), " [{}]".format(m.group(0)))[0]
+    sMorph = re.sub("(?<=V[0123][ea_])[itpqnmr_eaxz]+", "", sMorph)
+    for m in _zTag.finditer(sMorph):
+        if m.group(0) in _dTAGS:
+            sRes += _dTAGS[m.group(0)][0]
+        else:
+            sRes += " [" + m.group(0) + "]?"
     if sRes.startswith(" verbe") and not sRes.endswith("infinitif"):
-        sRes += " [{}]".format(sTags[1:sTags.find("/")])
+        sRes += " [" + sMorph[1:sMorph.find("/")] +"]"
+    if not sRes:
+        return " [" + sMorph + "]: étiquettes inconnues"
     return sRes.rstrip(",")
 
+
+_zPartDemForm = re.compile("([\\w]+)-(là|ci)$")
+_zInterroVerb = re.compile("([\\w]+)(-(?:t-(?:ie?l|elle|on)|je|tu|ie?ls?|elles?|on|[nv]ous))$")
+_zImperatifVerb = re.compile("([\\w]+)(-(?:l(?:es?|a)-(?:moi|toi|lui|[nv]ous|leur)|y|en|[mts][’'](?:y|en)|les?|la|[mt]oi|leur|lui))$")
+
+def setLabelsOnToken (dToken):
+    # Token: .sType, .sValue, .nStart, .nEnd, .lMorph
+    try:
+        if dToken["sType"] == "PUNC" or dToken["sType"] == "SIGN":
+            dToken["aLabels"] = [_dValues.get(dToken["sValue"], "signe de ponctuation divers")]
+        elif dToken["sType"] == 'NUM':
+            dToken["aLabels"] = ["nombre"]
+        elif dToken["sType"] == 'LINK':
+            dToken["aLabels"] = ["hyperlien"]
+        elif dToken["sType"] == 'TAG':
+            dToken["aLabels"] = ["étiquette (hashtag)"]
+        elif dToken["sType"] == 'HTML':
+            dToken["aLabels"] = ["balise HTML"]
+        elif dToken["sType"] == 'PSEUDOHTML':
+            dToken["aLabels"] = ["balise pseudo-HTML"]
+        elif dToken["sType"] == 'HTMLENTITY':
+            dToken["aLabels"] = ["entité caractère XML/HTML"]
+        elif dToken["sType"] == 'HOUR':
+            dToken["aLabels"] = ["heure"]
+        elif dToken["sType"] == 'WORD_ELIDED':
+            dToken["aLabels"] = [_dValues.get(dToken["sValue"], "préfixe élidé inconnu")]
+        elif dToken["sType"] == 'WORD_ORDINAL':
+            dToken["aLabels"] = ["nombre ordinal"]
+        elif dToken["sType"] == 'FOLDERUNIX':
+            dToken["aLabels"] = ["dossier UNIX (et dérivés)"]
+        elif dToken["sType"] == 'FOLDERWIN':
+            dToken["aLabels"] = ["dossier Windows"]
+        elif dToken["sType"] == 'WORD_ACRONYM':
+            dToken["aLabels"] = ["sigle ou acronyme"]
+        elif dToken["sType"] == 'WORD':
+            if "lMorph" in dToken and dToken["lMorph"]:
+                # with morphology
+                dToken["aLabels"] = []
+                for sMorph in dToken["lMorph"]:
+                    dToken["aLabels"].append(readableMorph(sMorph))
+                if "sTags" in dToken:
+                    aTags = []
+                    for sTag in dToken["sTags"]:
+                        if sTag in _dValues:
+                            aTags.append(_dValues[sTag])
+                    if aTags:
+                        dToken["aOtherLabels"] = aTags
+            else:
+                # no morphology, guessing
+                if dToken["sValue"].count("-") > 4:
+                    dToken["aLabels"] = ["élément complexe indéterminé"]
+                elif _zPartDemForm.search(dToken["sValue"]):
+                    # mots avec particules démonstratives
+                    dToken["aLabels"] = ["mot avec particule démonstrative"]
+                elif _zImperatifVerb.search(dToken["sValue"]):
+                    # formes interrogatives
+                    dToken["aLabels"] = ["forme verbale impérative"]
+                elif _zInterroVerb.search(dToken["sValue"]):
+                    # formes interrogatives
+                    dToken["aLabels"] = ["forme verbale interrogative"]
+        else:
+            dToken["aLabels"] = ["token de nature inconnue"]
+    except:
+        return
+
 
 # Other functions
 
 def filterSugg (aSugg):
     "exclude suggestions"
     return filter(lambda sSugg: not sSugg.endswith(("è", "È")), aSugg)

Index: graphspell/spellchecker.py
==================================================================
--- graphspell/spellchecker.py
+++ graphspell/spellchecker.py
@@ -98,11 +98,11 @@
     def deactivatePersonalDictionary (self):
         "deactivate personal dictionary"
         self.bPersonalDic = False
 
 
-    # Default suggestions
+    # Lexicographer
 
     def loadLexicographer (self, sLangCode):
         "load default suggestion module for <sLangCode>"
         try:
             self.lexicographer = importlib.import_module(".lexgraph_"+sLangCode, "grammalecte.graphspell")
@@ -120,15 +120,25 @@
                 lMorph = self.getMorph(sElem)
                 sLex = self.lexicographer.analyze(sElem)
                 if sLex:
                     aRes = [ (" | ".join(lMorph), sLex) ]
                 else:
-                    aRes = [ (sMorph, self.lexicographer.formatTags(sMorph)) for sMorph in lMorph ]
+                    aRes = [ (sMorph, self.lexicographer.readableMorph(sMorph)) for sMorph in lMorph ]
                 if aRes:
                     lWordAndMorph.append((sElem, aRes))
         return lWordAndMorph
 
+    def readableMorph (self, sMorph):
+        if not self.lexicographer:
+            return ""
+        return self.lexicographer.readableMorph(sMorph)
+
+    def setLabelsOnToken (dToken):
+        if not self.lexicographer:
+            return
+        self.lexicographer.setLabelsOnToken(dToken)
+
 
     # Storage
 
     def activateStorage (self):
         "store all lemmas and morphologies retrieved from the word graph"
@@ -233,11 +243,11 @@
             return self._dLemmas[sWord]
         return { s[1:s.find("/")]  for s in self.getMorph(sWord) }
 
     def suggest (self, sWord, nSuggLimit=10):
         "generator: returns 1, 2 or 3 lists of suggestions"
-        if self.lexicographer.dSugg:
+        if self.lexicographer:
             if sWord in self.lexicographer.dSugg:
                 yield self.lexicographer.dSugg[sWord].split("|")
             elif sWord.istitle() and sWord.lower() in self.lexicographer.dSugg:
                 lRes = self.lexicographer.dSugg[sWord.lower()].split("|")
                 yield list(map(lambda sSugg: sSugg[0:1].upper()+sSugg[1:], lRes))