Grammalecte  Check-in [091890c8f5]

def makeDictionaries (sp, sVersion):
    with cd(sp+"/dictionnaire"):
        if platform.system() == "Windows":
            os.system("python genfrdic.py -s -gl -v "+sVersion)
        else:
            os.system("python3 ./genfrdic.py -s -gl -v "+sVersion)


def makeThesaurusFiles (sp):
    dThesaurus = {}
    sContent = open(sp+'/data/thes_fr.json', "r", encoding="utf-8").read()
    dThesaurus = json.loads(sContent)
    ## write file for Python
    sCode = "# generated data (do not edit)\n\n" + \
            "dThesaurus = " + str(dThesaurus) + "\n"
    open(sp+"/modules/thesaurus_data.py", "w", encoding="utf-8", newline="\n").write(sCode)
    if bJS:
        ## write file for JavaScript
        file_util.copy_file(sp+'/data/thes_fr.json', sp+"/modules-js/thesaurus_data.json")


def makeConj (sp, bJS=False):
    print("> Conjugaisons ", end="")
    print("(Python et JavaScript)"  if bJS  else "(Python seulement)")
    dVerb = {}
    lVinfo = []; dVinfo = {}; nVinfo = 0
    lTags = []; dTags = {}; nTags = 0

        file_util.copy_file('césures/hyph_fr.dic', spExt+'/dictionaries')
        file_util.copy_file('césures/hyph_fr.iso8859-1.dic', spExt+'/dictionaries')
        file_util.copy_file('césures/frhyph.tex', spExt+'/dictionaries')
        file_util.copy_file('césures/hyph-fr.tex', spExt+'/dictionaries')
        file_util.copy_file('césures/README_hyph_fr-3.0.txt', spExt+'/dictionaries')
        file_util.copy_file('césures/README_hyph_fr-2.9.txt', spExt+'/dictionaries')
        # thesaurus
        file_util.copy_file(spBuild+"/thesaurus-v"+sThesVer+'/thes_fr.dat', spExt+"/dictionaries")
        file_util.copy_file(spBuild+"/thesaurus-v"+sThesVer+'/thes_fr.idx', spExt+"/dictionaries")
        file_util.copy_file(spBuild+"/thesaurus-v"+sThesVer+'/README_thes_fr.txt', spExt+"/dictionaries")
        # zip
        createZipFiles(spExt, spBuild, sExtensionName + '.oxt')
        # copy to Grammalecte Project
        if spDestGL:
            echo("   Dictionnaires Hunspell copiés dans Grammalecte pour LibreOffice...")
            dir_util.copy_tree(spExt+'/dictionaries', spDestGL)

        with open(sPathFile, 'w', encoding='utf-8', newline="\n") as hDst:
            for t in self.lLex:
                hDst.write(str(t)+"\n")
            for e in self.dFlexions.items():
                hDst.write("{} - {}\n".format(e[0], e[1]))


def createThesaurusPackage (spBuild, sVersion, spCopy="", spDataDestGL=""):
    print(" * Création du thésaurus")
    spThesaurus = spBuild+"/thesaurus-v"+sVersion
    dir_util.mkpath(spThesaurus)
    thes_build.build("thesaurus/thes_fr.dat", "thesaurus/synsets_fr.dat", spThesaurus)
    file_util.copy_file('thesaurus/README_thes_fr.txt', spThesaurus)
    if spCopy:
        # copy in libreoffice extension package
        print("   Copie du thésaurus dans:", spCopy)
        file_util.copy_file(spThesaurus+'/thes_fr.dat', spCopy)
        file_util.copy_file(spThesaurus+'/thes_fr.idx', spCopy)
        file_util.copy_file(spThesaurus+'/README_thes_fr.txt', spCopy)
    if spModulesDestGL:
        # copy in data source folder of Grammalecte
        file_util.copy_file(spThesaurus+'/thes_fr.json', spDataDestGL)


def main ():
    xParser = argparse.ArgumentParser()
    xParser.add_argument("-v", "--verdic", help="set dictionary version, i.e. 5.4", type=str, default="X.Y.z")
    xParser.add_argument("-m", "--mode", help="0: no tags,  1: Hunspell tags (default),  2: All tags", type=int, choices=[0, 1, 2], default=1)
    xParser.add_argument("-u", "--uncompress", help="do not use Hunspell compression", action="store_true")

    oStatsLex.addLexFromFile('lexique/corpus_data/stats_litterature.txt', 'L', 'Littérature')
    oStatsLex.write(spBuild+'/test_lex.txt')
    oFrenchDict.calculateStats(oStatsLex, spfStats)

    ### Écriture des paquets
    echo("Création des paquets...")

    nThesaurusVersion = 2.4
    spLexiconDestGL = "../../../lexicons"  if xArgs.grammalecte  else ""
    spLibreOfficeExtDestGL = "../oxt/Dictionnaires/dictionaries"  if xArgs.grammalecte  else ""
    spMozillaExtDestGL = ""  if xArgs.grammalecte  else "" # no more Hunspell dictionaries in Mozilla extensions for now
    spDataDestGL = "../data"  if xArgs.grammalecte  else ""

    ### dictionnaires
    if not xArgs.uncompress:
        oFrenchDict.defineAbreviatedTags(xArgs.mode, spfStats)
    oFrenchDict.createFiles(spBuild, [dTOUTESVAR, dCLASSIQUE, dREFORME1990], xArgs.mode, xArgs.simplify)
    oFrenchDict.createLexiconPackages(spBuild, xArgs.verdic, oStatsLex, spLexiconDestGL)
    oFrenchDict.createFileIfqForDB(spBuild)
    createThesaurusPackage(spBuild, nThesaurusVersion, spLibreOfficeExtDestGL, spDataDestGL)
    oFrenchDict.createLibreOfficeExtension(spBuild, dMOZEXT, [dTOUTESVAR, dCLASSIQUE, dREFORME1990], nThesaurusVersion, spLibreOfficeExtDestGL)
    oFrenchDict.createMozillaExtensions(spBuild, dMOZEXT, [dTOUTESVAR, dCLASSIQUE, dREFORME1990], spMozillaExtDestGL)
    oFrenchDict.createDictConj(spBuild, spDataDestGL)
    oFrenchDict.createDictDecl(spBuild, spDataDestGL)


if __name__ == '__main__':
    main()

# Thesaurus builder

import os
import re
import json


def readFile (spf):
    if os.path.isfile(spf):
        with open(spf, "r", encoding="utf-8") as hSrc:
            for sLine in hSrc:
                yield sLine.strip()
    else:
        print("# Error. File not found or not loadable: " + spf)



class ThesaurusBuilder ():

    def __init__ (self):
        # synsets
        self.dSynEntry = {}     # {sWord: iSynset}
        self.dSynset = {}       # {iSynset: lSynset}
        # thesaurus
        self.dThesaurus = {}    # {sWord: lWord}

    def readSynsets (self, spf):
        if not spf:
            return
        for i, sLine in enumerate(readFile(spf), 1):
            sPOS, *lSynset = sLine.split("|")
            lSynset = self._removeDuplicatesFrom(lSynset)

            sLine = sLine.strip()
            if re.search(r"^[^|]+\|[1-9][0-9]*$", sLine):
                # new entry
                if nClass != nClassFound:
                    print("Ligne:", iEntryLine, ", nombre de liste incorrect")
                iEntryLine = i
                sEntry, sNum = sLine.split("|")
                self.dThesaurus[sEntry] = []
                nClass = int(sNum)
                nClassFound = 0
            else:
                # new list of synonyms
                nClassFound += 1
                sPOS, *lClass = sLine.split("|")
                lClass = self._removeDuplicatesFrom(lClass)
                self.dThesaurus[sEntry].append( (sPOS, lClass) )

    def showThesaurusEntries (self):
        for sWord, lClass in self.dThesaurus.items():
            for sPOS, lWord in lClass:
                print(sWord, sPOS, "|".join(lWord))

    def _removeDuplicatesFrom (self, lWord):
        return [ sWord.strip()  for sWord  in dict.fromkeys(lWord) ]  # remove duplicates: use <dict.fromkeys()> instead of <set()> to keep order

    def merge (self):
        for sWord, lSynset in self.dSynEntry.items():
            for sPOS, iSynset in lSynset:
                if sWord in self.dThesaurus:
                    self.dThesaurus[sWord].append( (sPOS, self.dSynset[iSynset]) )
                else:
                    self.dThesaurus[sWord] = [ (sPOS, self.dSynset[iSynset]) ]

    def write (self, spDest):
        nOffset = 0     # the offset for finding data is the number of bytes (-> encoding("utf-8"))
        dOffset = {}
        with open(spDest + "/thes_fr.dat", "w", encoding="utf-8", newline="\n") as hThes:
            sHeader = "UTF-8\n"
            hThes.write(sHeader)
            nOffset = len(sHeader.encode("utf-8"))
            for sWord, lClass in self.dThesaurus.items():
                dOffset[sWord] = nOffset
                sWordLine = sWord+"|"+str(len(lClass))+"\n"
                hThes.write(sWordLine)
                nOffset += len(sWordLine.encode("utf-8"))
                for sPOS, lWord in lClass:
                    sClassLine = sPOS+"|"+"|".join(lWord)+"\n"
                    hThes.write(sClassLine)
                    nOffset += len(sClassLine.encode("utf-8"))
        with open(spDest + "/thes_fr.idx", "w", encoding="utf-8", newline="\n") as hIndex:
            hIndex.write("UTF-8\n")
            hIndex.write(str(len(self.dThesaurus))+"\n")
            for sWord, nOffset in sorted(dOffset.items()):
                hIndex.write(sWord+"|"+str(nOffset)+"\n")

    def writeAsJSON (self, spDest):
        with open(spDest + "/thes_fr.json", "w", encoding="utf-8", newline="\n") as hJsonThes:
            sJSON = json.dumps(self.dThesaurus, ensure_ascii=False)
            hJsonThes.write(sJSON)


def build (spfThesaurus="", spfSynsets="", spDest="_build"):
    oThes = ThesaurusBuilder()
    oThes.readSynsets(spfSynsets)
    #oThes.showSynsetEntries()
    oThes.readThesaurus(spfThesaurus)
    #oThes.showThesaurusEntries()
    oThes.merge()
    oThes.write(spDest)
    oThes.writeAsJSON(spDest)


if __name__ == '__main__':
    build("thesaurus/thes_fr.dat", "thesaurus/synsets_fr.dat")

// Grammalecte - Thésaurus

/* jshint esversion:6 */
/* jslint esversion:6 */
/* global __dirname */

"use strict";

${string}


if (typeof(process) !== 'undefined') {
    var helpers = require("../graphspell/helpers.js");
}


var thesaurus = {
    _dWord: new Map(),

    bInit: false,
    init: function (sJSONData) {
        try {
            let _oData = JSON.parse(sJSONData);
            this._dWord = helpers.objectToMap(_oData);
            this.bInit = true;
            //console.log(this._dWord);
        }
        catch (e) {
            console.error(e);
        }
    },

    getSyns: function (sWord) {
        // return list of synonyms of <sWord>
        if (!sWord) {
            return [];
        }
        if (this._dWord.has(sWord)) {
            return this._dWord.get(sWord);
        }
        if (sWord.slice(0,1).gl_isUpperCase()) {
            sWord = sWord.toLowerCase();
            if (this._dWord.has(sWord)) {
                return this._dWord.get(sWord);
            }
        }
        return [];
    }
};



// Initialization
if (!thesaurus.bInit && typeof(process) !== 'undefined') {
    // NodeJS
    thesaurus.init(helpers.loadFile(__dirname+"/thesaurus_data.json"));
} else if (!thesaurus.bInit && typeof(browser) !== 'undefined') {
    // WebExtension Standard (but not in Worker)
    thesaurus.init(helpers.loadFile(browser.runtime.getURL("grammalecte/fr/thesaurus_data.json")));
} else if (!thesaurus.bInit && typeof(chrome) !== 'undefined') {
    // WebExtension Chrome (but not in Worker)
    thesaurus.init(helpers.loadFile(chrome.runtime.getURL("grammalecte/fr/thesaurus_data.json")));
} else if (thesaurus.bInit){
    console.log("Module thesaurus déjà initialisé");
} else {
    //console.log("Module thesaurus non initialisé");
}


if (typeof(exports) !== 'undefined') {
    exports._dWord = thesaurus._dWord;
    exports.init = thesaurus.init;
    exports.getSyns = thesaurus.getSyns;
}

"""
Grammalecte - Thesaurus
"""

# License: GPL 3


from .thesaurus_data import dThesaurus as _dThesaurus


def getSyns (sWord):
    "return list of synonyms of <sWord>"
    if not sWord:
        return []
    if sWord in _dThesaurus:
        return _dThesaurus[sWord]
    if sWord[0:1].isupper():
        sWord = sWord.lower()
        if sWord in _dThesaurus:
            return _dThesaurus[sWord]
    return []

                    case "parse":
                    case "parseAndSpellcheck":
                    case "parseAndSpellcheck1":
                    case "parseFull":
                    case "getListOfTokens":
                    case "getSpellSuggestions":
                    case "getVerb":
                    case "getSyns":
                        // send result to content script
                        if (typeof(oInfo.iReturnPort) === "number") {
                            let xPort = dConnx.get(oInfo.iReturnPort);
                            xPort.postMessage(e.data);
                        } else {
                            console.log("[background] don’t know where to send results");
                            console.log(e.data);

            oWorkerHandler.restart(oParam["nDelayLimit"]);
            break;
        case "openURL":
            browser.tabs.create({url: oParam.sURL});
            break;
        case "openConjugueurTab":
            openConjugueurTab();
            break;
        case "openThesaurusTab":
            openThesaurusTab();
            break;
        case "openLexiconEditor":
            openLexiconEditor(oParam["dictionary"]);
            break;
        case "openDictionaries":
            openDictionaries();
            break;

            case "parse":
            case "parseAndSpellcheck":
            case "parseAndSpellcheck1":
            case "parseFull":
            case "getListOfTokens":
            case "getSpellSuggestions":
            case "getVerb":
            case "getSyns":
                oRequest.oInfo.iReturnPort = iPortId; // we pass the id of the return port to receive answer
                oWorkerHandler.xGCEWorker.postMessage(oRequest);
                break;
            case "restartWorker":
                oWorkerHandler.restart(oParam["nDelayLimit"]);
                break;
            case "openURL":
                browser.tabs.create({url: oParam.sURL});
                break;
            case "openConjugueurTab":
                openConjugueurTab();
                break;
            case "openConjugueurWindow":
                openConjugueurWindow();
                break;
            case "openThesaurusTab":
                openThesaurusTab();
                break;
            case "openThesaurusWindow":
                openThesaurusWindow();
                break;
            case "openLexiconEditor":
                openLexiconEditor("__personal__", oParam["sWord"]);
                break;
            default:
                console.log("[background] Unknown command: " + sCommand);
                console.log(oRequest);
        }

    browser.contextMenus.create({ id: "grammar_checker_page",       title: "Analyser la page",                          contexts: ["all"] });
    browser.contextMenus.create({ id: "separator_tools",            type: "separator",                                  contexts: ["all"] });
    // Tools
    browser.contextMenus.create({ id: "conjugueur_tab",             title: "Conjugueur [onglet]",                       contexts: ["all"] });
    browser.contextMenus.create({ id: "conjugueur_window",          title: "Conjugueur [fenêtre]",                      contexts: ["all"] });
    //browser.contextMenus.create({ id: "dictionaries",               title: "Dictionnaires",                             contexts: ["all"] });
    browser.contextMenus.create({ id: "lexicon_editor",             title: "Éditeur lexical",                           contexts: ["all"] });
    browser.contextMenus.create({ id: "thesaurus_tab",              title: "Thésaurus [onglet]",                        contexts: ["all"] });
    browser.contextMenus.create({ id: "thesaurus_window",           title: "Thésaurus [fenêtre]",                       contexts: ["all"] });

    browser.contextMenus.onClicked.addListener(function (xInfo, xTab) {
        // xInfo = https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/contextMenus/OnClickData
        // xTab = https://developer.mozilla.org/en-US/Add-ons/WebExtensions/API/tabs/Tab
        // confusing: no way to get the node where we click?!
        switch (xInfo.menuItemId) {
            // analyze

                break;
            // tools
            case "conjugueur_window":
                openConjugueurWindow();
                break;
            case "conjugueur_tab":
                openConjugueurTab();
                break;
            case "thesaurus_window":
                openConjugueurWindow();
                break;
            case "thesaurus_tab":
                openConjugueurTab();
                break;
            case "lexicon_editor":
                openLexiconEditor();
                break;
            case "dictionaries":
                openDictionaries();
                break;

    switch (sCommand) {
        case "grammar_checker":
            sendCommandToCurrentTab("shortcutGrammarChecker");
            break;
        case "conjugueur_tab":
            openConjugueurTab();
            break;
        case "thesaurus_tab":
            openThesaurusTab();
            break;
        case "lexicon_editor":
            openLexiconEditor();
            break;
        case "dictionaries":
            openDictionaries();
            break;
    }
});


/*
    Tabs
*/
let nTabLexiconEditor = null;
let nTabDictionaries = null;
let nTabConjugueur = null;
let nTabThesaurus = null;

browser.tabs.onRemoved.addListener(function (nTabId, xRemoveInfo) {
    switch (nTabId) {
        case nTabLexiconEditor: nTabLexiconEditor = null; break;
        case nTabDictionaries:  nTabDictionaries = null; break;
        case nTabConjugueur:    nTabConjugueur = null; break;
        case nTabThesaurus:     nTabThesaurus = null; break;
    }
});


/*
    Actions
*/

        url: browser.runtime.getURL("panel/conjugueur.html"),
        type: "popup",
        width: 710,
        height: 980
    });
}


function openThesaurusTab () {
    if (nTabThesaurus === null) {
        if (bChrome) {
            browser.tabs.create({
                url: browser.runtime.getURL("panel/thesaurus.html")
            }, onThesaurusOpened);
            return;
        }
        let xThesTab = browser.tabs.create({
            url: browser.runtime.getURL("panel/thesaurus.html")
        });
        xThesTab.then(onThesaurusOpened, showError);
    }
    else {
        browser.tabs.update(nTabThesaurus, {active: true});
    }
}

function onThesaurusOpened (xTab) {
    nTabThesaurus = xTab.id;
}

function openThesaurusWindow () {
    if (bChrome) {
        browser.windows.create({
            url: browser.runtime.getURL("panel/thesaurus.html"),
            type: "popup",
            width: 710,
            height: 980
        });
        return;
    }
    let xConjWindow = browser.windows.create({
        url: browser.runtime.getURL("panel/thesaurus.html"),
        type: "popup",
        width: 710,
        height: 980
    });
}

function showError (e) {
    console.error(e);
    //console.error(e.fileName + "\n" + e.name + "\nline: " + e.lineNumber + "\n" + e.message);
}

    @Reviewers:
    This file only defines HTML nodes in const values
*/


const sGrammalecteConjugueurHTML = `
    <div class="grammalecte_centered_bar">
        <div contenteditable="true" id="grammalecte_conj_verb" autofocus >entrez un verbe</div>
        <div id="grammalecte_conj_erase_button">×</div>
    </div>

    <div class="grammalecte_clearer"></div>

    <h1 class="grammalecte_conj_title" id="grammalecte_conj_verb_title" class="center">&nbsp;</h1>
    <div id="grammalecte_conj_verb_info" class="center">&nbsp;</div>

            </div>
        </div>
    </div>

    <div class="grammalecte_clearer"></div>
`;

const sGrammalecteThesaurusHTML = `
    <div class="grammalecte_centered_bar">
        <div contenteditable="true" id="grammalecte_thes_word" autofocus ></div>
        <div id="grammalecte_thes_erase_button">×</div>
    </div>

    <div class="grammalecte_clearer"></div>

    <h1 class="grammalecte_thes_title" id="grammalecte_thes_title" class="center">&nbsp;</h1>

    <div id="grammalecte_separator">❦</div>
    <div id="grammalecte_thes_word_info" class="center" style="display: none;">Aucun synonyme trouvé</div>

    <div id="grammalecte_synonyms_list">

    </div>

    <div class="grammalecte_clearer"></div>
`;

    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 });
    },

    getSyns: function (sWord) {
        this.send("getSyns", { sWord: sWord });
    },

    getSpellSuggestions: function (sWord, sDestination, sErrorId) {
        this.send("getSpellSuggestions", { sWord: sWord }, { sDestination: sDestination, sErrorId: sErrorId });
    },

    openURL: function (sURL) {
        this.send("openURL", { "sURL": sURL });

                case "getVerb":
                    if (oInfo.bStart) {
                        oGrammalecte.oGCPanel.conjugateWith(result.oVerb, result.oConjTable);
                    } else {
                        oGrammalecte.oGCPanel.displayConj(result.oConjTable);
                    }
                    break;
                case "getSyns":
                    oGrammalecte.oGCPanel.displaySyns(result.sWord, result.lSyns);
                    break;
                case "workerRestarted":
                    oGrammalecte.oGCPanel.stopWaitIcon();
                    oGrammalecte.oGCPanel.showMessage("Le serveur grammatical a été arrêté et relancé.");
                    oGrammalecte.oGCPanel.endTimer();
                    break;
                /*
                    Commands received from the context menu

    color: hsla(210, 0%, 100%, 1);
}

div.grammalecte_panel_menu {
    display: flex;
    flex-direction: row;
    justify-content: space-around;
    flex-wrap: nowrap;
}
div.grammalecte_menu_button {
    color: hsl(210, 50%, 96%);
    padding: 5px 5px;
    font-size: 12px;
    font-variant: small-caps;
    cursor: pointer;
    border-radius: 3px;
}
div.grammalecte_menu_button:hover {
    background-color: hsl(210, 80%, 40%);

    insertIntoPage () {
        if (this.bShadow) {
            oGrammalecte.createStyle("content_scripts/panel.css", null, this.xShadowRoot);
            oGrammalecte.createStyle("content_scripts/panel_gc.css", null, this.xShadowRoot);
            oGrammalecte.createStyle("content_scripts/panel_lxg.css", null, this.xShadowRoot);
            oGrammalecte.createStyle("content_scripts/panel_conj.css", null, this.xShadowRoot);
            oGrammalecte.createStyle("content_scripts/panel_thes.css", null, this.xShadowRoot);
            oGrammalecte.createStyle("content_scripts/panel_tf.css", null, this.xShadowRoot);
            this.xShadowRoot.appendChild(this.xPanel);
            document.body.appendChild(this.xShadowHost);
        } else {
            if (!document.getElementById("grammalecte_csspanel")) {
                oGrammalecte.createStyle("content_scripts/panel.css", "grammalecte_csspanel", document.head);
                oGrammalecte.createStyle("content_scripts/panel_gc.css", null, document.head);
                oGrammalecte.createStyle("content_scripts/panel_lxg.css", null, document.head);
                oGrammalecte.createStyle("content_scripts/panel_conj.css", null, document.head);
                oGrammalecte.createStyle("content_scripts/panel_thes.css", null, document.head);
                oGrammalecte.createStyle("content_scripts/panel_tf.css", null, document.head);
            }
            document.body.appendChild(this.xPanel);
        }
    }

    show () {

/*
   CSS Document
*/

div#grammalecte_conj_panel_content {
    padding: 20px 0;
    width: 100%;
}

div.grammalecte_centered_bar {
    display: flex;
    justify-content: center;
    align-items: stretch;
    width: 500px;
    margin: 0 auto;
}

    font: normal 18px Tahoma, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", sans-serif;
    color: hsl(0, 0%, 30%);
}
div#grammalecte_conj_verb {
    color: hsl(0, 0%, 70%);
}


div#grammalecte_conj_erase_button {
    display: inline-block;
    margin: 3px;
    padding: 5px 10px;
    font-weight: bold;
    color: hsl(0, 0%, 100%);
    background-color: hsl(0, 0%, 80%);

    border-radius: 4px;




}
div#grammalecte_conj_erase_button:hover {
    background-color: hsl(0, 50%, 50%);
    cursor: pointer;

}

div#grammalecte_conj_options {
    margin: 10px 0 0 5px;
    font-size: 16px;
    text-align: center;
}

                oGrammalecteBackgroundPort.openURL(xElem.dataset.url);
            } else {
                oGrammalecte.oGCPanel.oTooltip.hide();
            }
        } else {
            oGrammalecte.oGCPanel.oTooltip.hide();
        }
        if (xElem.className == "grammalecte_synonym") {
            oGrammalecte.oGCPanel.getSyns(xElem.textContent.trim());
        }
    }
    catch (e) {
        showError(e);
    }
}

        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);
        this.sVerb = "";
        this.bListenConj = false;
        // Thésaurus
        this.xThesPanelContent = oGrammalecte.createNode("div", {id: "grammalecte_thes_panel_content"});
        this.xThesPanelContent.innerHTML = sGrammalecteThesaurusHTML;  // @Reviewers: sGrammalecteThesaurusHTML is a const value defined in <content_scripts/html_src.js>
        this.xPanelContent.appendChild(this.xThesPanelContent);
        this.sWord = "";
    }

    createMenu () {
        this.xMenu = oGrammalecte.createNode("div", {className: "grammalecte_panel_menu"});
        // tabs
        this.xTFButton = oGrammalecte.createNode("div", {className: "grammalecte_menu_button", textContent: "Formateur de texte"});
        this.xEditorButton = oGrammalecte.createNode("div", {className: "grammalecte_menu_button", textContent: "Éditeur"});
        this.xLxgButton = oGrammalecte.createNode("div", {className: "grammalecte_menu_button", textContent: "Lexicographe"});
        this.xConjButton = oGrammalecte.createNode("div", {className: "grammalecte_menu_button", textContent: "Conjugueur"});
        this.xThesButton = oGrammalecte.createNode("div", {className: "grammalecte_menu_button", textContent: "Thésaurus"});
        // buttons
        this.xLexEditButton = oGrammalecte.createNode("div", {className: "grammalecte_menu_subbutton", textContent: "Édit.", title: "Ouvrir l’éditeur lexical", style: "background-color: hsl(210, 50%, 40%)"});
        this.xLxgButton.appendChild(this.xLexEditButton);
        this.xAutoRefresh = oGrammalecte.createNode("div", {className: "grammalecte_menu_subbutton", textContent: "AutoRafr", title: "Auto-rafraîchissement de la correction grammaticale (3 s après la dernière frappe)"});
        this.xEditorButton.appendChild(this.xAutoRefresh);
        this.bAutoRefresh = oGrammalecte.bAutoRefresh;
        this.setAutoRefreshButton();
        this.xTFButton.onclick = () => {
            if (!this.bWorking) {

                this.showLexicographer();
            }
        };
        this.xConjButton.onclick = () => {
            if (!this.bWorking) {
                this.showConjugueur();
            }
        };
        this.xThesButton.onclick = () => {
            if (!this.bWorking) {
                this.showThesaurus();
            }
        };
        this.xLexEditButton.onclick = () => {
            oGrammalecteBackgroundPort.openLexiconEditor();
        };
        // Add tabs to menu
        this.xMenu.appendChild(this.xTFButton);
        this.xMenu.appendChild(this.xEditorButton);
        this.xMenu.appendChild(this.xLxgButton);
        this.xMenu.appendChild(this.xConjButton);
        this.xMenu.appendChild(this.xThesButton);
        this.xPanelBar.appendChild(this.xMenu);
    }

    start (what, xResultNode=null) {
        this.oTooltip.hide();
        this.bWorking = false;
        this.clear();

        oGrammalecteBackgroundPort.parseAndSpellcheck(this.oTextControl.getText(), "__GrammalectePanel__");
    }

    showEditor () {
        this.switchContentOn(this.xGCPanelContent, this.xEditorButton);
        this.switchContentOff(this.xLxgPanelContent, this.xLxgButton);
        this.switchContentOff(this.xConjPanelContent, this.xConjButton);
        this.switchContentOff(this.xThesPanelContent, this.xThesButton);
        this.xPanel.style.background = "";
    }

    showLexicographer () {
        this.switchContentOff(this.xGCPanelContent, this.xEditorButton);
        this.switchContentOn(this.xLxgPanelContent, this.xLxgButton);
        this.switchContentOff(this.xConjPanelContent, this.xConjButton);
        this.switchContentOff(this.xThesPanelContent, this.xThesButton);
        this.xPanel.style.background = "";
    }

    showConjugueur () {
        this.switchContentOff(this.xGCPanelContent, this.xEditorButton);
        this.switchContentOff(this.xLxgPanelContent, this.xLxgButton);
        this.switchContentOn(this.xConjPanelContent, this.xConjButton);
        this.switchContentOff(this.xThesPanelContent, this.xThesButton);
        this.xPanel.style.background = "linear-gradient(to bottom, hsla(0,0%,100%,1) 0%, hsla(0,0%,95%,1) 55%, hsla(0,0%,90%,1) 100%)";
        this.listenConj();
        if (!this.sVerb) {
            this.conjugateVerb("être");
        }
    }

    showThesaurus () {
        this.switchContentOff(this.xGCPanelContent, this.xEditorButton);
        this.switchContentOff(this.xLxgPanelContent, this.xLxgButton);
        this.switchContentOff(this.xConjPanelContent, this.xConjButton);
        this.switchContentOn(this.xThesPanelContent, this.xThesButton);
        this.xPanel.style.background = "";
        this.listenThes();
    }

    switchContentOn (xContent, xNodeButton) {
        xContent.style.display = "block";
        xNodeButton.style.backgroundColor = "hsl(210, 60%, 40%)";
        xNodeButton.style.textShadow = "2px 0 0 hsla(210, 40%, 35%, .5), -2px 0 0 hsla(210, 40%, 35%, .5), 0 2px 0 hsla(210, 40%, 35%, .5), 0 -2px 0 hsla(210, 40%, 35%, .5), 1px 1px hsla(210, 40%, 35%, .5), -1px -1px 0 hsla(210, 40%, 35%, .5), 1px -1px 0 hsla(210, 40%, 35%, .5), -1px 1px 0 hsla(210, 30%, 35%, .5)";
    }

    }


    // Conjugueur

    listenConj () {
        if (!this.bListenConj) {


            // text field
            this.xParent.getElementById('grammalecte_conj_verb').addEventListener("input", (e) => { this.conjugateVerb(); });
            // erase button
            this.xParent.getElementById('grammalecte_conj_erase_button').addEventListener("click", (e) => { this.clearConjInput(); });
            // options
            this.xParent.getElementById('grammalecte_conj_oneg').addEventListener("click", (e) => { this.switchOption('grammalecte_conj_oneg'); this.updateConj(); });
            this.xParent.getElementById('grammalecte_conj_opro').addEventListener("click", (e) => { this.switchOption('grammalecte_conj_opro'); this.updateConj(); });
            this.xParent.getElementById('grammalecte_conj_oint').addEventListener("click", (e) => { this.switchOption('grammalecte_conj_oint'); this.updateConj(); });
            this.xParent.getElementById('grammalecte_conj_ofem').addEventListener("click", (e) => { this.switchOption('grammalecte_conj_ofem'); this.updateConj(); });
            this.xParent.getElementById('grammalecte_conj_otco').addEventListener("click", (e) => { this.switchOption('grammalecte_conj_otco'); this.updateConj(); });
            this.bListenConj = true;
        }
    }

    clearConjInput () {


        this.xParent.getElementById('grammalecte_conj_verb').innerText = "";




        this.xParent.getElementById('grammalecte_conj_verb').style = "";
    }

    switchOption (sOption) {
        if (this.xParent.getElementById(sOption).dataset.disabled == "off") {
            this.xParent.getElementById(sOption).dataset.selected = (this.xParent.getElementById(sOption).dataset.selected == "off") ? "on" : "off";
            this.xParent.getElementById(sOption).className = (this.xParent.getElementById(sOption).dataset.selected == "on") ? "grammalecte_conj_option_on" : "grammalecte_conj_option_off";
        }

    disableOption (sOption) {
        this.xParent.getElementById(sOption).dataset.disabled = "on";
        this.xParent.getElementById(sOption).style.color = "#CCC";
    }

    conjugateVerb (sVerb="") {
        try {




            this.resetOption('grammalecte_conj_oneg');
            this.resetOption('grammalecte_conj_opro');
            this.resetOption('grammalecte_conj_oint');
            this.resetOption('grammalecte_conj_otco');
            this.resetOption('grammalecte_conj_ofem');
            // request analyzing
            if (!sVerb) {
                sVerb = this.xParent.getElementById('grammalecte_conj_verb').innerText;
                if (sVerb.indexOf("\n") != -1) {
                    sVerb = this.purgeInputText(sVerb);
                    this.xParent.getElementById('grammalecte_conj_verb').textContent = sVerb;
                } else {
                    sVerb = this.purgeInputText(sVerb);
                }
            }
            sVerb = sVerb.trim().toLowerCase().replace(/’/g, "'").replace(/  +/g, " ");
            if (sVerb) {
                if (sVerb.startsWith("ne pas ")) {
                    this.selectOption('grammalecte_conj_oneg');
                    sVerb = sVerb.slice(7).trim();
                }
                if (sVerb.startsWith("se ")) {
                    this.selectOption('grammalecte_conj_opro');
                    sVerb = sVerb.slice(3).trim();
                }
                else if (sVerb.startsWith("s'")) {
                    this.selectOption('grammalecte_conj_opro');
                    sVerb = sVerb.slice(2).trim();
                }
                if (sVerb.endsWith("?")) {
                    this.selectOption('grammalecte_conj_oint');
                    sVerb = sVerb.slice(0,-1).trim();
                }
                if (sVerb) {
                    if (sVerb.search("(?:[ei]r|re)$")) {
                        this.sVerb = sVerb;
                        this.updateConj(true);


                    }
                }
            }
        }
        catch (e) {
            showError(e);
        }
    }

            this.xParent.getElementById('grammalecte_conj_simp5').textContent = oConjTable["simp5"] || " ";
            this.xParent.getElementById('grammalecte_conj_simp6').textContent = oConjTable["simp6"] || " ";
        }
        catch (e) {
            showError(e);
        }
    }


    // Thesaurus

    listenThes () {
        if (!this.bListenThes) {
            // text field
            this.xParent.getElementById('grammalecte_thes_word').addEventListener("input", (e) => {
                let sWord = this.xParent.getElementById('grammalecte_thes_word').innerText;
                this.getSyns(sWord);
            });
            // erase button
            this.xParent.getElementById('grammalecte_thes_erase_button').addEventListener("click", (e) => {
                this.clearWordInput();
            });
            this.bListenThes = true;
        }
    }

    clearWordInput () {
        this.xParent.getElementById('grammalecte_thes_word').innerText = "";
        this.xParent.getElementById('grammalecte_thes_word').style = "";
    }

    getSyns (sWord) {
        sWord = sWord.trim();
        oGrammalecteBackgroundPort.getSyns(sWord);
    }

    displaySyns (sWord, lSyns) {
        try {
            if (sWord) {
                this.xParent.getElementById('grammalecte_thes_title').textContent = sWord;
                this.emptySynList();
                if (lSyns.length == 0) {
                    this.xParent.getElementById('grammalecte_thes_word').style = "color: #BB4411;";
                    this.xParent.getElementById('grammalecte_thes_word_info').style = "display: block";
                } else {
                    this.xParent.getElementById('grammalecte_thes_word').style = "";
                    this.xParent.getElementById('grammalecte_thes_word_info').style = "display: none";
                    this.populateSynList(lSyns);
                }
            }
        }
        catch (e) {
            console.error(e);
        }
    }

    emptySynList () {
        let xSynonymsList = this.xParent.getElementById('grammalecte_synonyms_list');
        while (xSynonymsList.firstChild) {
            xSynonymsList.removeChild(xSynonymsList.firstChild);
        }
    }

    populateSynList (lSyns) {
        let xSynonymsList = this.xParent.getElementById('grammalecte_synonyms_list');
        for (let [sCat, lSyn] of lSyns) {
            let xSynBlok = oGrammalecte.createNode("div", { className: "grammalecte_syn_block" });
            xSynonymsList.appendChild(xSynBlok);
            xSynBlok.appendChild(oGrammalecte.createNode("div", { className: "grammalecte_cat_name", textContent: sCat }));
            let xSynonyms = oGrammalecte.createNode("div", { className: "grammalecte_synonyms" });
            xSynBlok.appendChild(xSynonyms);
            for (let sSyn of lSyn) {
                xSynonyms.appendChild(oGrammalecte.createNode("div", { className: "grammalecte_synonym", textContent: sSyn }));
            }
        }
    }

    purgeInputText (sText) {
        // Thunderbird doesn’t accept input fields
        // So we use editable node and we purge it
        let nIndexCut = sText.indexOf("\n");
        if (nIndexCut != -1) {
            sText = sText.slice(0, nIndexCut);
        };
        return sText.trim();
    }
}


class GrammalecteTooltip {

    constructor (xParent, xGCPanelContent) {
        this.xParent = xParent;

/*
   CSS Document
*/

div#grammalecte_thes_panel_content {
    padding: 20px 0;
    width: 100%;
}

h1.grammalecte_thes_title {
    margin: 5px 0 2px 0;
    color: hsl(210, 50%, 50%);
    font: bold 30px Tahoma, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", sans-serif;
    text-align: center;
}

div#grammalecte_thes_word_info {
    text-align: center;
    color: hsl(210, 00%, 40%);
}

div#grammalecte_thes_word {
    display: inline-block;
    width: 230px;
    margin-left: 5px;
    padding: 5px 10px;
    border: 2px solid hsl(0, 0%, 80%);
    border-radius: 3px;
    height: 20px;
    background: transparent;
    font: normal 18px Tahoma, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", sans-serif;
    color: hsl(0, 0%, 50%);
}
div#grammalecte_thes_erase_button {
    display: inline-block;
    margin: 3px;
    padding: 5px 10px;
    font-weight: bold;
    color: hsl(0, 0%, 100%);
    background-color: hsl(0, 0%, 80%);
    border-radius: 4px;
}
div#grammalecte_thes_erase_button:hover {
    background-color: hsl(0, 50%, 50%);
    cursor: pointer;
}

div#grammalecte_separator {
    margin: 10px 20px;
    font-size: 11px;
    color: hsl(0, 0%, 60%);
    text-align: center;
}

div.grammalecte_syn_block {
    display: flex;
    flex-direction: row;
    flex-wrap: nowrap;
    justify-content: flex-start;
    align-items: flex-start;
}

div.grammalecte_cat_name {
    flex: 0 0 15%;
    padding: 9px;
}

div.grammalecte_synonyms {
    padding: 5px;
}

div.grammalecte_synonym {
    display: inline-block;
    padding: 2px 5px;
    background: hsl(210, 100%, 95%);
    border-radius: 3px;
    margin: 2px 3px;
    cursor: pointer;
}

div.grammalecte_synonym:hover {
    background: hsl(0, 100%, 95%);
}

importScripts("grammalecte/graphspell/ibdawg.js");
importScripts("grammalecte/graphspell/spellchecker.js");
importScripts("grammalecte/text.js");
importScripts("grammalecte/graphspell/tokenizer.js");
importScripts("grammalecte/fr/conj.js");
importScripts("grammalecte/fr/mfsp.js");
importScripts("grammalecte/fr/phonet.js");
importScripts("grammalecte/fr/thesaurus.js");
importScripts("grammalecte/fr/cregex.js");
importScripts("grammalecte/fr/gc_options.js");
importScripts("grammalecte/fr/gc_functions.js");
importScripts("grammalecte/fr/gc_rules.js");
importScripts("grammalecte/fr/gc_rules_graph.js");
importScripts("grammalecte/fr/gc_engine.js");
importScripts("grammalecte/tests.js");

            break;
        case "getSpellSuggestions":
            getSpellSuggestions(oParam.sWord, oInfo);
            break;
        case "getVerb":
            getVerb(oParam.sVerb, oParam.bPro, oParam.bNeg, oParam.bTpsCo, oParam.bInt, oParam.bFem, oInfo);
            break;
        case "getSyns":
            getSyns(oParam.sWord, oInfo);
            break;
        default:
            console.log("[Worker] Unknown command: " + sCommand);
            showData(e.data);
    }
}



let bInitDone = false;

let oSpellChecker = null;
let oTokenizer = null;
let oTest = null;
let oLocution = null;


/*
    Technical note:
    This worker doesn’t work as a PromiseWorker (which returns a promise),  so when we send request
    to this worker, we can’t wait the return of the answer just after the request made.
    The answer is received by the background in another function (onmessage).
    That’s why the full text to analyze is send in one block, but analyse is returned paragraph
    by paragraph.
*/

function init (sExtensionPath, dOptions=null, sContext="JavaScript", oInfo={}) {
    try {
        if (!bInitDone) {
            //console.log("[Worker] Loading… Extension path: " + sExtensionPath);
            conj.init(helpers.loadFile(sExtensionPath + "/grammalecte/fr/conj_data.json"));
            phonet.init(helpers.loadFile(sExtensionPath + "/grammalecte/fr/phonet_data.json"));
            mfsp.init(helpers.loadFile(sExtensionPath + "/grammalecte/fr/mfsp_data.json"));
            thesaurus.init(helpers.loadFile(sExtensionPath + "/grammalecte/fr/thesaurus_data.json"));
            //console.log("[Worker] Modules have been initialized…");
            gc_engine.load(sContext, "aHSL", sExtensionPath+"grammalecte/graphspell/_dictionaries");
            oSpellChecker = gc_engine.getSpellChecker();
            oTest = new TestGrammarChecking(gc_engine, sExtensionPath+"/grammalecte/fr/tests_data.json");
            oTokenizer = new Tokenizer("fr");
            if (dOptions !== null) {
                if (!(dOptions instanceof Map)) {

        postMessage(createResponse("getVerb", { oVerb: oVerb, oConjTable: oConjTable }, oInfo, true));
    }
    catch (e) {
        console.error(e);
        postMessage(createResponse("getVerb", createErrorResult(e, "no verb"), oInfo, true, true));
    }
}


// Thesaurus

function getSyns (sWord, oInfo) {
    try {
        let lSyns = thesaurus.getSyns(sWord)
        postMessage(createResponse("getSyns", { sWord: sWord, lSyns: lSyns }, oInfo, true));
    }
    catch (e) {
        console.error(e);
        postMessage(createResponse("getSyns", createErrorResult(e, "no synonyms"), oInfo, true, true));
    }
}

      "suggested_key": { "default": "Ctrl+Shift+F" },
      "description": "Ouvre le correcteur grammatical"
    },
    "conjugueur_tab": {
      "suggested_key": { "default": "Ctrl+Shift+6" },
      "description": "Ouvre le conjugueur"
    },
    "thesaurus_tab": {
      "suggested_key": { "default": "Ctrl+Shift+7" },
      "description": "Ouvre le thésaurus"
    },
    "lexicon_editor": {
      "suggested_key": { "default": "Ctrl+Shift+8" },
      "description": "Ouvre l’éditeur lexical"
    }
  },

  "web_accessible_resources": [
    "content_scripts/api.js",
    "content_scripts/panel.css",
    "content_scripts/panel_tf.css",
    "content_scripts/panel_gc.css",
    "content_scripts/panel_lxg.css",
    "content_scripts/panel_conj.css",
    "content_scripts/message_box.css",
    "content_scripts/menu.css",
    "grammalecte/graphspell/_dictionaries/fr-allvars.json",
    "grammalecte/graphspell/_dictionaries/fr-classic.json",
    "grammalecte/graphspell/_dictionaries/fr-reform.json",
    "grammalecte/fr/conj_data.json",
    "grammalecte/fr/mfsp_data.json",
    "grammalecte/fr/phonet_data.json",
    "grammalecte/fr/thesaurus_data.json",
    "grammalecte/fr/tests_data.json",
    "img/logo-16.png"
  ],

  "permissions": [
    "*://localhost/*",
    "*://dic.grammalecte.net/*",

          </div>
          <h2>Raccourcis clavier</h2>
          <p class="shortcut">CTRL+MAJ+F</p>
          <p class="shortcut_label">Correcteur grammatical</p>
          <p class="shortcut">CTRL+MAJ+6</p>
          <p class="shortcut_label">Conjugueur</p>
          <p class="shortcut">CTRL+MAJ+7</p>
          <p class="shortcut_label">Dictionnaire des synonymes</p>
          <p class="shortcut">CTRL+MAJ+8</p>
          <p class="shortcut_label">Éditeur lexical</p>
          <!--<p class="shortcut">CTRL+MAJ+8</p>
          <p class="shortcut_label">Dictionnaires communautaires</p>-->
        </section> <!-- #ui_options_page -->

        <section id="gc_options_page" class="page">
          <h1>OPTIONS GRAMMATICALES</h1>

/*
   CSS Document
   White
   Design par Olivier R.
*/

* { margin: 0; padding: 0; }
img { border: none; }


/* Generic classes */

.fleft {
    float: left;
}
.fright {
    float: right;
}
.center {
    text-align: center;
}
.right {
    text-align: right;
}
.left {
    text-align: left;
}
.justify {
    text-align: justify;
}
.hidden {
    display: none;
}

.clearer {
    clear: both;
    font-size: 0;
    height: 0;
}

body {
    background: #FFFFFF url(../img/lines.png);
    font: normal 16px Tahoma, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", sans-serif;
    color: #505050;
}

.mainflow {
    width: 800px;
    margin: 0 auto 0 auto;
}

.logo {
    position: absolute;
    background-color: #FFFFFF;
    border: 3px solid #F0F0F0;
    border-radius: 96px;
    padding: 4px 4px 0 4px;
}


/* MAIN ====================================================================== */

#main .inbox {
    width: 800px;
    margin: 20px auto 10px auto;
    padding: 10px 30px 30px 30px;
    background: #FFFFFF;
    border: 2px solid #F0F0F0;
    border-radius: 20px;
}

#main h1 {
    margin: 5px 0 2px 0;
    color: hsl(210, 50%, 50%);
    font: bold 30px Tahoma, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", sans-serif;
}

#main .syn_block {
    display: flex;
    flex-direction: row;
    flex-wrap: nowrap;
    justify-content: flex-start;
    align-items: flex-start;
}

.cat_name {
    flex: 0 0 15%;
    padding: 9px;
}

.synonyms {
    padding: 5px;
}

.synonym {
    display: inline-block;
    padding: 2px 5px;
    background: hsl(210, 100%, 95%);
    border-radius: 3px;
    margin: 2px 3px;
    cursor: pointer;
}

.synonym:hover {
    background: hsl(0, 100%, 95%);
}

/*.box {
    border-left: 2px solid #8BC5EF;
    border-bottom: 2px solid #8BC5EF;
    border-radius: 5px;
    padding: 0 0 2px 10px;
}*/

input#word {
    display: inline-block;
    width: 230px;
    margin-left: 5px;
    padding: 5px 10px;
    border: 2px solid hsl(0, 0%, 80%);
    border-radius: 3px;
    height: 24px;
    background: transparent;
    font: normal 20px Tahoma, "Ubuntu Condensed";
    color: hsl(0, 0%, 30%);
}
input[placeholder]#word {
    color: hsl(0, 0%, 70%);
}

#fetch {
    display: inline-block;
    padding: 7px 10px;
    font-size: 18px;
    background-color: hsl(210, 30%, 50%);
    color: hsl(210, 30%, 80%);
    border-radius: 3px;
    text-transform: uppercase;
    text-align: center;
    text-decoration: none;
    cursor: pointer;
}
#fetch:hover {
    background-color: hsl(210, 60%, 40%);
    color: hsl(210, 60%, 90%);
    box-shadow: 0 0 2px hsl(210, 60%, 50%);
}

#separator {
    margin: 10px 0 10px 0;
    font-size: 11px;
    color: hsl(0, 0%, 60%);
    text-align: center;
}

<!DOCTYPE HTML>
<html>
    <head>
        <link rel="stylesheet" type="text/css" href="thesaurus.css" />
        <title>Grammalecte · Thesaurus</title>
        <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    </head>

    <body>
        <header>
            <div class="mainflow">
                <div class="logo" style="margin: -10px 0 0 0;">
                    <img src="../img/logo-96.png" alt="" />
                </div>
            </div>
        </header>

        <div id="main">
            <div class="inbox">

                <div class="right" style="margin: 10px 180px 0 0">
                    <input type="text" id="word" name="word" maxlength="40" value="" placeholder="entrez un mot" autofocus />
                    <div id="fetch">Synonymes</div>
                </div>

                <h1 id="word_title" class="center">&nbsp;</h1>
                <p id="info" class="center">&nbsp;</p>

                <p id="separator">❦</p>

                <div id="synonyms_list">

                </div>
            </div>
        </div>

        <script src="../grammalecte/graphspell/helpers.js"></script>
        <script src="../grammalecte/fr/thesaurus.js"></script>
        <script src="thesaurus.js"></script>
    </body>

</html>

// JavaScript

"use strict";


// button
document.getElementById('fetch').addEventListener("click", function (event) {
    showSynonymsOf(document.getElementById('word').value);
});

// text field
document.getElementById('word').addEventListener("change", function (event) {
    showSynonymsOf(document.getElementById('word').value);
});

// click on synonyms
document.getElementById('synonyms_list').addEventListener("click", function (xEvent) {
    let xElem = xEvent.target;
    if (xElem.className == "synonym") {
        showSynonymsOf(xElem.textContent);
    }
});


function createNode (sType, oAttr, oDataset=null) {
    try {
        let xNode = document.createElement(sType);
        Object.assign(xNode, oAttr);
        if (oDataset) {
            Object.assign(xNode.dataset, oDataset);
        }
        return xNode;
    }
    catch (e) {
        showError(e);
    }
}


function showSynonymsOf (sWord) {
    try {
        sWord = sWord.trim().toLowerCase().replace(/’/g, "'").replace(/  +/g, " ");
        if (sWord) {
        	document.getElementById('word_title').textContent = sWord;
        	let lSyns = thesaurus.getSyns(sWord);
            if (lSyns.length == 0) {
                document.getElementById('word').style = "color: #BB4411;";
                emptyList();
                document.getElementById('synonyms_list').textContent = "Aucun synonyme trouvé.";
            } else {
                document.getElementById('word').style = "";
                document.getElementById('word').value = "";
                emptyList();
                populateList(lSyns);
            }
        }
    }
    catch (e) {
        console.error(e.fileName + "\n" + e.name + "\nline: " + e.lineNumber + "\n" + e.message);
    }
}


function populateList (lSyns) {
    let xSynonymsList = document.getElementById('synonyms_list');
    for (let [sCat, lSyn] of lSyns) {
        let xSynBlok = createNode("div", {className: "syn_block"});
        xSynonymsList.appendChild(xSynBlok);
        xSynBlok.appendChild(createNode("div", { className: "cat_name", textContent: sCat}));
        let xSynonyms = createNode("div", { className: "synonyms" });
        xSynBlok.appendChild(xSynonyms);
        for (let sSyn of lSyn) {
            xSynonyms.appendChild(createNode("div", { className: "synonym", textContent: sSyn }));
        }
    }
}


function emptyList () {
    let xSynonymsList = document.getElementById('synonyms_list');
    while (xSynonymsList.firstChild) {
        xSynonymsList.removeChild(xSynonymsList.firstChild);
    }
}


showSynonymsOf("être");

document.getElementById("word").focus();

import re
import traceback

import grammalecte
import grammalecte.text as txt
import grammalecte.graphspell.str_transform as strt
from grammalecte.graphspell.echo import echo
import grammalecte.fr.thesaurus as thes


_EXAMPLE = "Quoi ? Racontes ! Racontes-moi ! Bon sangg, parles ! Oui. Il y a des menteur partout. " \
           "Je suit sidéré par la brutales arrogance de cette homme-là. Quelle salopard ! Un escrocs de la pire espece. " \
           "Quant sera t’il châtiés pour ses mensonge ?             Merde ! J’en aie marre."

_HELP = """
Analysis commands:
    any_text                            grammar checking
    ?word1 [word2] ...                  words analysis
    !word                               spelling suggestion
    >word                               draw path of word in the word graph
    =[filter1][=[filter2]]              show entries which fit to filters (filter1 for word, filter2 for morphology)
    ≠word1 word2 [word3] ...            show distance between words
    $some_text                          show sentences and tokens of text
    #word1 [word2] ...                  get synonyms of words

Other commands:
    /help                       /h      show this text
    /lopt                       /lo     list options
    /lrules [pattern]           /lr     list rules
    /o+ option1 [option2] ...           activate grammar checking options
    /o- option1 [option2] ...           deactivate grammar checking options

                # distances calculation
                lWords = sText[1:].split()
                for s1, s2 in itertools.combinations(lWords, 2):
                    strt.showDistance(s1, s2)
                    if xArgs.debug:
                        strt.showDistance(strt.simplifyWord(s1), strt.simplifyWord(s2))
                        echo("")
            elif sText.startswith("#"):
                # synonyms
                lWords = sText[1:].split()
                for sWord in lWords:
                    lSyns = thes.getSyns(sWord)
                    if lSyns:
                        echo(f"\n{sWord}")
                        for sCat, lSyn in lSyns:
                            echo(f"> {sCat} : " + " | ".join(lSyn))
                    else:
                        echo(f"\n{sWord}: pas de synonymes trouvés")
            elif sText.startswith("/o+ "):
                oGrammarChecker.gce.setOptions({ opt:True  for opt in sText[3:].strip().split()  if opt in oGrammarChecker.gce.getOptions() })
                echo("done")
            elif sText.startswith("/o- "):
                oGrammarChecker.gce.setOptions({ opt:False  for opt in sText[3:].strip().split()  if opt in oGrammarChecker.gce.getOptions() })
                echo("done")
            elif sText.startswith("/r- "):

    },

    loadFile: function (spf) {
        // load ressources in workers (suggested by Mozilla extensions reviewers)
        // for more options have a look here: https://gist.github.com/Noitidart/ec1e6b9a593ec7e3efed
        // if not in workers, use sdk/data.load() instead
        try {
            if (typeof(process) !== 'undefined') {
                //console.log('loadFile(disque): ' + spf);
                let fs = require("fs");
                return fs.readFileSync(spf, "utf8");
            } else {
                console.log("loadFile: " + spf);
                let xRequest;
                xRequest = new XMLHttpRequest();