Grammalecte  Check-in [d804292a86]

        }
    }
};


class Verb {

    constructor (sVerb) {
    constructor (sVerb, sVerbPattern="") {
        // conjugate a unknown verb with rules from sVerbPattern
        if (typeof sVerb !== "string" || sVerb === "") {
            throw new TypeError ("The value should be a non-empty string");
        }
        if (sVerbPattern.length == 0) {
            sVerbPattern = sVerb;
        }
        this.sVerb = sVerb;
        this.sVerbAux = "";
        this._sRawInfo = conj.getVtyp(this.sVerb);
        this._sRawInfo = conj.getVtyp(sVerbPattern);
        this.sInfo = this._readableInfo(this._sRawInfo);
        this._tTags = conj._getTags(sVerb);
        this._tTags = conj._getTags(sVerbPattern);
        this._tTagsAux = conj._getTags(this.sVerbAux);
        this.bProWithEn = (this._sRawInfo[5] === "e");
        this.dConj = new Map ([
            [":Y", new Map ([
                ["label", "Infinitif"],
                [":Y", sVerb]
                [":", sVerb]
            ])],
            [":P", new Map ([
                ["label", "Participe présent"],
                [":", conj._getConjWithTags(sVerb, this._tTags, ":PQ", ":P")]
            ])],
            [":PQ", new Map ([
                ["label", "Participes passés et présent"],
            [":Q", new Map ([
                ["label", "Participes passés"],
                [":Q1", conj._getConjWithTags(sVerb, this._tTags, ":PQ", ":Q1")],
                [":Q2", conj._getConjWithTags(sVerb, this._tTags, ":PQ", ":Q2")],
                [":Q3", conj._getConjWithTags(sVerb, this._tTags, ":PQ", ":Q3")],
                [":Q4", conj._getConjWithTags(sVerb, this._tTags, ":PQ", ":Q4")],
                [":P", conj._getConjWithTags(sVerb, this._tTags, ":PQ", ":P")]
            ])],
            [":Ip", new Map ([
                ["label", "Présent"],
                [":1s", conj._getConjWithTags(sVerb, this._tTags, ":Ip", ":1s")],
                [":1ś", conj._getConjWithTags(sVerb, this._tTags, ":Ip", ":1ś")],
                [":2s", conj._getConjWithTags(sVerb, this._tTags, ":Ip", ":2s")],
                [":3s", conj._getConjWithTags(sVerb, this._tTags, ":Ip", ":3s")],

        if (bInt) {
            sInfi += " … ?";
        }
        return sInfi;
    }

    participePasse (sWho) {
        return this.dConj.get(":PQ").get(sWho);
        return this.dConj.get(":Q").get(sWho);
    }

    participePresent (bPro, bNeg, bTpsCo, bInt, bFem) {
        if (!this.dConj.get(":PQ").get(":P")) {
        if (!this.dConj.get(":P").get(":")) {
            return "";
        }
        let sPartPre;
        if (bTpsCo) {
            sPartPre = (!bPro) ? conj._getConjWithTags(this.sVerbAux, this._tTagsAux, ":PQ", ":P") : conj.getConj("être", ":PQ", ":P");
        } else {
            sPartPre = this.dConj.get(":PQ").get(":P");
            sPartPre = this.dConj.get(":P").get(":");
        }
        if (sPartPre === "") {
            return "";
        }
        let bEli = conj._zStartVoy.test(sPartPre);
        if (bPro) {
            if (this.bProWithEn) {

            return sImpe + " " + this._seekPpas(bPro, bFem, sWho.endsWith("p") || this._sRawInfo[5] == "r");
        }
        return sImpe;
    }

    _seekPpas (bPro, bFem, bPlur) {
        if (!bPro && this.sVerbAux == "avoir") {
            return this.dConj.get(":PQ").get(":Q1");
            return this.dConj.get(":Q").get(":Q1");
        }
        if (!bFem) {
            return (bPlur && this.dConj.get(":PQ").get(":Q2")) ? this.dConj.get(":PQ").get(":Q2") : this.dConj.get(":PQ").get(":Q1");
            return (bPlur && this.dConj.get(":Q").get(":Q2")) ? this.dConj.get(":Q").get(":Q2") : this.dConj.get(":Q").get(":Q1");
        }
        if (!bPlur) {
            return (this.dConj.get(":PQ").get(":Q3")) ? this.dConj.get(":PQ").get(":Q3") : this.dConj.get(":PQ").get(":Q1");
            return (this.dConj.get(":Q").get(":Q3")) ? this.dConj.get(":Q").get(":Q3") : this.dConj.get(":Q").get(":Q1");
        }
        return (this.dConj.get(":PQ").get(":Q4")) ? this.dConj.get(":PQ").get(":Q4") : this.dConj.get(":PQ").get(":Q1");
        return (this.dConj.get(":Q").get(":Q4")) ? this.dConj.get(":Q").get(":Q4") : this.dConj.get(":Q").get(":Q1");
    }
}


// Initialization
if (!conj.bInit && typeof(browser) !== 'undefined') {
    // WebExtension Standard (but not in Worker)

        return sWord[:-(ord(sSfx[0])-48)] + sSfx[1:]  if sSfx[0] != '0'  else  sWord + sSfx[1:]  # 48 is the ASCII code for "0"
    except:
        return "## erreur, code : " + str(sSfx) + " ##"
        


class Verb ():
    def __init__ (self, sVerb):
    def __init__ (self, sVerb, sVerbPattern=""):
        # conjugate a unknown verb with rules from sVerbPattern
        if not isinstance(sVerb, str):
            raise TypeError
        if not sVerb:
            raise ValueError

        if sVerbPattern == "":
            sVerbPattern = sVerb

        self.sVerb = sVerb
        self.sVerbAux = ""
        self._sRawInfo = getVtyp(self.sVerb)
        self._sRawInfo = getVtyp(sVerbPattern)
        self.sInfo = self._readableInfo()
        self.bProWithEn = (self._sRawInfo[5] == "e")
        self._tTags = _getTags(sVerb)
        self._tTags = _getTags(sVerbPattern)
        self._tTagsAux = _getTags(self.sVerbAux)

        self.dConj = {
            ":Y": {
                "label": "Infinitif",
                ":Y": sVerb,
                ":": sVerb,
            },
            ":P": {
                "label": "Participe présent",
                ":": _getConjWithTags(sVerb, self._tTags, ":PQ", ":P"),
            },
            ":PQ": {
                "label": "Participes passés et présent",
            ":Q": {
                "label": "Participes passés",
                ":Q1": _getConjWithTags(sVerb, self._tTags, ":PQ", ":Q1"),
                ":Q2": _getConjWithTags(sVerb, self._tTags, ":PQ", ":Q2"),
                ":Q3": _getConjWithTags(sVerb, self._tTags, ":PQ", ":Q3"),
                ":Q4": _getConjWithTags(sVerb, self._tTags, ":PQ", ":Q4"),
                ":P": _getConjWithTags(sVerb, self._tTags, ":PQ", ":P"),
            },
            ":Ip": {
                "label": "Présent",
                ":1s": _getConjWithTags(sVerb, self._tTags, ":Ip", ":1s"),
                ":1ś": _getConjWithTags(sVerb, self._tTags, ":Ip", ":1ś"),
                ":2s": _getConjWithTags(sVerb, self._tTags, ":Ip", ":2s"),
                ":3s": _getConjWithTags(sVerb, self._tTags, ":Ip", ":3s"),

            return sInfi
        except:
            traceback.print_exc()
            return "# erreur"

    def participePasse (self, sWho):
        try:
            return self.dConj[":PQ"][sWho]
            return self.dConj[":Q"][sWho]
        except:
            traceback.print_exc()
            return "# erreur"

    def participePresent (self, bPro, bNeg, bTpsCo, bInt, bFem):
        try:
            if not self.dConj[":PQ"][":P"]:
            if not self.dConj[":P"][":"]:
                return ""
            if bTpsCo:
                sPartPre = _getConjWithTags(self.sVerbAux, self._tTagsAux, ":PQ", ":P")  if not bPro  else  getConj("être", ":PQ", ":P")
            else:
                sPartPre = self.dConj[":PQ"][":P"]
                sPartPre = self.dConj[":P"][":"]
            if not sPartPre:
                return ""
            bEli = True  if _zStartVoy.search(sPartPre)  else  False
            if bPro:
                if self.bProWithEn:
                    sPartPre = "s’en " + sPartPre
                else:

        except:
            traceback.print_exc()
            return "# erreur"

    def _seekPpas (self, bPro, bFem, bPlur):
        try:
            if not bPro and self.sVerbAux == "avoir":
                return self.dConj[":PQ"][":Q1"]
                return self.dConj[":Q"][":Q1"]
            if not bFem:
                return self.dConj[":PQ"][":Q2"]  if bPlur and self.dConj[":PQ"][":Q2"]  else  self.dConj[":PQ"][":Q1"]
                return self.dConj[":Q"][":Q2"]  if bPlur and self.dConj[":Q"][":Q2"]  else  self.dConj[":Q"][":Q1"]
            if not bPlur:
                return self.dConj[":PQ"][":Q3"]  if self.dConj[":PQ"][":Q3"]  else  self.dConj[":PQ"][":Q1"]
            return self.dConj[":PQ"][":Q4"]  if self.dConj[":PQ"][":Q4"]  else  self.dConj[":PQ"][":Q1"]
                return self.dConj[":Q"][":Q3"]  if self.dConj[":Q"][":Q3"]  else  self.dConj[":Q"][":Q1"]
            return self.dConj[":Q"][":Q4"]  if self.dConj[":Q"][":Q4"]  else  self.dConj[":Q"][":Q1"]
        except:
            traceback.print_exc()
            return "# erreur"

//  JavaScript

"use script";
"use strict";

// beta stage, unfinished, may be useless or the root for a new way to generate flexions…

/*
    Règles de conjugaison
*/

    padding: 10px;
    background-color: hsl(0, 10%, 90%);
    color: hsl(0, 10%, 50%);
    font-size: 14px;
    border-radius: 3px;
}

ul {
    margin-left: 30px;
}

input[type=text] {
    display: inline-block;
    width: 250px;
    margin-left: 5px;
    padding: 5px 10px;
    border: 2px solid hsl(0, 0%, 80%);

            <div id="buttons" class="container">
                <div id="lexicon_button" class="main_button">Lexique</div>
                <div id="add_word_button" class="main_button">Ajout</div>
            </div>

            <div id="add_word_page">
                <h2>Nouveau mot</h2>
                <input type="text" id="word" name="word" maxlength="60" value="" placeholder="votre mot" pattern="^[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ._-]+$" autofocus />
                <h2>Nouveau mot (lemme)</h2>
                <input type="text" id="lemma" name="lemma" maxlength="60" value="" placeholder="votre mot" pattern="^[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ._-]+$" autofocus />

                <div id="editor">

                    <div id="categories">
                        <div class="category" id="select_nom" data-tag="N">Nom, adjectif</div>
                        <div class="category" id="select_verbe" data-tag="V">Verbe</div>
                        <div class="category" id="select_adverbe" data-tag="W">Adverbe</div>

                                    <p><input type="radio" id="up_nom_pluriel_s" name="pluriel" value="s" /><label for="up_nom_pluriel_s"> pluriel en ·s</label></p>
                                    <p><input type="radio" id="up_nom_pluriel_x" name="pluriel" value="x" /><label for="up_nom_pluriel_x"> pluriel en ·x</label></p>
                                    <p><input type="radio" id="up_nom_pluriel_i" name="pluriel" value="i" /><label for="up_nom_pluriel_i"> invariable</label></p>
                                </div>
                            </div>

                            <h2>[optionnel] Autre forme (masculine, féminine, variante, etc.)</h2>
                            <input type="text" id="word2" name="word2" maxlength="60" value="" pattern="^[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ._-]+$" placeholder="votre mot" />
                            <input type="text" id="lemma2" name="lemma2" maxlength="60" value="" pattern="^[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ._-]+$" placeholder="votre mot" />
                            <div id="word_section2">
                                <p class="typeline">
                                    <input type="radio" id="up_type_nom2" name="POS2" value=":N" /> <label class="widelabel" for="up_type_nom2">Nom</label>
                                    <input type="radio" id="up_type_adj2" name="POS2" value=":A" /> <label class="widelabel" for="up_type_adj2">Adjectif</label>
                                    <input type="radio" id="up_type_nomadj2" name="POS2" value=":N:A" /> <label class="widelabel" for="up_type_nomadj2">Nom &amp; adjectif</label>
                                </p>
                                <div class="container">

                                        <div class="examples_true">J’ai mangé.<br/>J’ai prié.</div>
                                        <div class="examples_false">Je suis mangé.<br/>Je suis prié.</div>
                                    </div>
                                </details>
                            </div>

                            <div class="block">
                                <h3>Verbe modèle</h3>
                                <p>Indiquez ici le verbe qui doit servir de modèle pour la conjugaison.</p>
                                <h3>Verbe modèle [optionnel]</h3>
                                <p>Ce n’est pas nécessaire pour la très grande majorité des verbes du 1ᵉʳ groupe et du 2ᵉ groupe. Si les formes fléchies engendrées automatiquement ne vous satisfont pas, vous pouvez indiquer le verbe qui doit servir de modèle pour la conjugaison.</p>
                                <input type="text" id="conj_rules_like" name="conj_rules_like" maxlength="60" value="" placeholder="verbe modèle" pattern="^[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ-]+$" />
                                <details>
                                    Il est fortement recommandé d’appliquer les règles d’un verbe du même groupe que celui que vous créez. Mais aucune restriction n’est imposée.<br/>
                                    Classification des groupes :
                                    <p>Il est fortement recommandé d’appliquer les règles d’un verbe du même groupe que celui que vous créez. Mais aucune restriction n’est imposée.</p>
                                    <p>Classification des groupes :</p>
                                    <ul>
                                        <li>1ᵉʳ groupe : verbes finissant par -<i>er</i>. Attention : contrairement au préjugé commun, ce groupe est irrégulier. Beaucoup de verbes voient leur racine modifiée dans certaines formes conjuguées :
                                        <ul>
                                            <li>ajout ou modification de diacritiques (verbes finissant par -<i>ecer</i>, -<i>emer</i>, -<i>ener</i>, -<i>eper</i>, -<i>erer</i>, -<i>eser</i>, -<i>ever</i>, -<i>evrer</i>, -<i>eler</i>, -<i>eter</i>, -<i>ébrer</i>, -<i>écer</i>, -<i>écher</i>, -<i>écrer</i>, -<i>éder</i>, -<i>éger</i>, -<i>égler</i>, -<i>égner</i>, -<i>égrer</i>, -<i>éguer</i>, -<i>éler</i>, -<i>émer</i>, -<i>éner</i>, -<i>éper</i>, -<i>équer</i>, -<i>érer</i>, -<i>éser</i>, -<i>éter</i>, -<i>étrer</i>, -<i>évrer</i>, -<i>éyer</i>),</li>
                                            <li>ajout ou modification de diacritiques (verbes finissant par -<i>cer</i>, -<i>ecer</i>, -<i>emer</i>, -<i>ener</i>, -<i>eper</i>, -<i>erer</i>, -<i>eser</i>, -<i>ever</i>, -<i>evrer</i>, -<i>eler</i>, -<i>eter</i>, -<i>ébrer</i>, -<i>écer</i>, -<i>écher</i>, -<i>écrer</i>, -<i>éder</i>, -<i>éger</i>, -<i>égler</i>, -<i>égner</i>, -<i>égrer</i>, -<i>éguer</i>, -<i>éler</i>, -<i>émer</i>, -<i>éner</i>, -<i>éper</i>, -<i>équer</i>, -<i>érer</i>, -<i>éser</i>, -<i>éter</i>, -<i>étrer</i>, -<i>évrer</i>, -<i>éyer</i>),</li>
                                            <li>un ‹e› euphonique est ajouté sur la plupart des verbes finissant par -<i>ger</i>,</li>
                                            <li>certains verbes finissant par -<i>yer</i> remplacent éventuellement le ‹y› par un ‹i›,</li>
                                            <li>doublement irrégulier de certaines consonnes (<i>geler</i> ne se conjugue pas comme <i>appeler</i>, <i>acheter</i> ne se conjugue pas comme <i>jeter</i>)</li>
                                            <li>irrégularités diverses (<i>aller</i>, <i>envoyer</i>, <i>renvoyer</i>)…
                                        </ul></li>
                                        <li>2ᵉ groupe : verbes finissant par -<i>ir</i>. Ce groupe est de loin le plus régulier. Mais de nombreux verbes finissant par -<i>ir</i> appartiennent au 3ᵉ groupe.</li>
                                        <li>2ᵉ groupe : verbes finissant par -<i>ir</i>. Ce groupe est de loin le plus régulier. Mais de nombreux verbes finissant par -<i>ir</i> appartiennent au 3ᵉ groupe.</li>
                                        <li>3ᵉ groupe. Autres verbes irréguliers.</li>
                                        <li>Les verbes <i>être</i> et <i>avoir</i> n’appartiennent à aucun groupe. Il est recommandé de ne pas s’en servir comme modèle.</li>
                                    </ul>
                                </details>
                            </div>
                        </div>

                                    <p>Les noms propres sont invariables en nombre.</p>
                                </div>
                            </div>
                        </div>

                        <div id="section_autre" class="section">
                            <h2>Autre</h2>
                            <p>Indiquez les étiquettes grammaticales que vous voulez appliquer au mot. À utiliser seulement si vous savez ce que vous faites. Dans le cas contraire, tant pis pour vous.</p>
                            <h3>Lemme</h3>
                            <p><input type="text" id="lemma" name="lemma" maxlength="20" value="" pattern="^[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ._-]+$" placeholder="lemme" /></p>
                            <p>Indiquez les étiquettes grammaticales que vous voulez appliquer au mot. À utiliser seulement si vous savez ce que vous faites.</p>
                            <h3>Flexion</h3>
                            <p><input type="text" id="flexion" name="flexion" maxlength="20" value="" pattern="^[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ._-]+$" placeholder="flexion" /></p>
                            <h3>Étiquettes</h3>
                            <p><input type="text" id="tags" name="tags" maxlength="20" value="" pattern="^:[a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ:._-]+$" placeholder="étiquettes" /></p>
                        </div>
                    </div>
                </div>
                
                <div id="actions">

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


        <script src="../grammalecte/graphspell/helpers.js"></script>
        <script src="../grammalecte/fr/conj.js"></script>
        <script src="lex_conj_data.js"></script>
        <script src="lex_editor.js"></script>
    </body>
    
</html>

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


document.getElementById("lexicon_button").addEventListener("click", () => { oPage.showPage("lexicon"); }, false);
document.getElementById("add_word_button").addEventListener("click", () => { oPage.showPage("word"); }, false);
document.getElementById("add_word_button").addEventListener("click", () => { oPage.showPage("lemma"); }, false);
document.getElementById("editor").addEventListener("click", (xEvent) => { oPage.onSelectionClick(xEvent); }, false);
document.getElementById("word").addEventListener("keyup", () => { oPage.onWrite(); }, false);
document.getElementById("word2").addEventListener("keyup", () => { oPage.onWrite2(); }, false);
document.getElementById("lemma").addEventListener("keyup", () => { oFlex.update(); }, false);
document.getElementById("lemma").addEventListener("keyup", () => { oPage.onWrite(); }, false);
document.getElementById("lemma2").addEventListener("keyup", () => { oPage.onWrite2(); }, false);
document.getElementById("flexion").addEventListener("keyup", () => { oFlex.update(); }, false);
document.getElementById("tags").addEventListener("keyup", () => { oFlex.update(); }, false);
document.getElementById("add_to_lexicon").addEventListener("click", () => { oFlex.addToLexicon(); }, false);



/*
    ACTIONS

        if (document.getElementById(sName)) {
            document.getElementById(sName).style.display = "block";
        }
    },

    clear: function () {
        try {
            document.getElementById("word2").value = "";
            document.getElementById("lemma2").value = "";
            this.hideWord2();
            // nom, adjectif, noms propres
            for (let xElem of document.getElementsByName("POS")) {
                xElem.checked = false;
            }
            for (let xElem of document.getElementsByName("POS2")) {
                xElem.checked = false;

            document.getElementById("up_v_t").checked = false;
            document.getElementById("up_v_n").checked = false;
            document.getElementById("up_v_p").checked = false;
            document.getElementById("up_v_m").checked = false;
            document.getElementById("up_v_ae").checked = false;
            document.getElementById("up_v_aa").checked = false;
            // autre
            document.getElementById("lemma").value = "";
            document.getElementById("flexion").value = "";
            document.getElementById("tags").value = "";
        }
        catch (e) {
            showError(e);
        }
    },

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

    onWrite: function () {
        if (document.getElementById("word").value.trim() !== "") {
        if (document.getElementById("lemma").value.trim() !== "") {
            this.showEditor();
        } else {
            this.showSection("section_vide");
            this.hideEditor();
            this.hideActions();
        }
    },

    onWrite2: function () {
        if (document.getElementById("word2").value.trim() !== "") {
        if (document.getElementById("lemma2").value.trim() !== "") {
            this.showWord2();
        } else {
            this.hideWord2();
        }
    },

    showWord2: function () {

        this.lFlexion.push( [sFlexion, sLemma, sTag] );
    },

    update: function () {
        try {
            this.clear();
            let sGenderTag = "";
            let sWord = document.getElementById("word").value.trim();
            if (sWord.length > 0) {
            let sLemma = document.getElementById("lemma").value.trim();
            if (sLemma.length > 0) {
                switch (this.cMainTag) {
                    case "N":
                        if (!this.getRadioValue("POS") || !this.getRadioValue("genre")) {
                            break;
                        }
                        let sTag = this.getRadioValue("POS") + this.getRadioValue("genre");
                        switch (this.getRadioValue("pluriel")) {
                            case "s":
                                this.addFlexion(sWord, sWord, sTag+":s");
                                this.addFlexion(sWord+"s", sWord, sTag+":p");
                                this.addFlexion(sLemma, sLemma, sTag+":s");
                                this.addFlexion(sLemma+"s", sLemma, sTag+":p");
                                break;
                            case "x":
                                this.addFlexion(sWord, sWord, sTag+":s");
                                this.addFlexion(sWord+"x", sWord, sTag+":p");
                                this.addFlexion(sLemma, sLemma, sTag+":s");
                                this.addFlexion(sLemma+"x", sLemma, sTag+":p");
                                break;
                            case "i":
                                this.addFlexion(sWord, sWord, sTag+":i");
                                this.addFlexion(sLemma, sLemma, sTag+":i");
                                break;
                        }
                        let sWord2 = document.getElementById("word2").value.trim();
                        if (sWord2.length > 0  &&  this.getRadioValue("POS2")  &&  this.getRadioValue("genre2")) {
                        let sLemma2 = document.getElementById("lemma2").value.trim();
                        if (sLemma2.length > 0  &&  this.getRadioValue("POS2")  &&  this.getRadioValue("genre2")) {
                            let sTag2 = this.getRadioValue("POS2") + this.getRadioValue("genre2");
                            switch (this.getRadioValue("pluriel2")) {
                                case "s":
                                    this.addFlexion(sWord2, sWord, sTag2+":s");
                                    this.addFlexion(sWord2+"s", sWord, sTag2+":p");
                                    this.addFlexion(sLemma2, sLemma, sTag2+":s");
                                    this.addFlexion(sLemma2+"s", sLemma, sTag2+":p");
                                    break;
                                case "x":
                                    this.addFlexion(sWord2, sWord, sTag2+":s");
                                    this.addFlexion(sWord2+"x", sWord, sTag2+":p");
                                    this.addFlexion(sLemma2, sLemma, sTag2+":s");
                                    this.addFlexion(sLemma2+"x", sLemma, sTag2+":p");
                                    break;
                                case "i":
                                    this.addFlexion(sWord2, sWord, sTag2+":i");
                                    this.addFlexion(sLemma2, sLemma, sTag2+":i");
                                    break;
                            }
                        }
                        break;
                    case "V": {
                        if (!sWord.endsWith("er") && !sWord.endsWith("ir")) {
                        if (!sLemma.endsWith("er") && !sLemma.endsWith("ir")) {
                            break;
                        }
                        sWord = sWord.toLowerCase();
                        let c_g = (sWord.endsWith("er")) ? "1" : "2";
                        sLemma = sLemma.toLowerCase();
                        let c_g = (sLemma.endsWith("er")) ? "1" : "2";
                        let c_i = (document.getElementById("up_v_i").checked) ? "i" : "_";
                        let c_t = (document.getElementById("up_v_t").checked) ? "t" : "_";
                        let c_n = (document.getElementById("up_v_n").checked) ? "n" : "_";
                        let c_p = (document.getElementById("up_v_p").checked) ? "p" : "_";
                        let c_m = (document.getElementById("up_v_m").checked) ? "m" : "_";
                        let c_ae = (document.getElementById("up_v_ae").checked) ? "e" : "_";
                        let c_aa = (document.getElementById("up_v_aa").checked) ? "a" : "_";
                        let sVerbTag = c_i + c_t + c_n + c_p + c_m + c_ae + c_aa;
                        if (!sVerbTag.endsWith("__") && !sVerbTag.startsWith("____")) {
                            let sVerbPattern = document.getElementById("conj_rules_like").value.trim();
                            if (sVerbPattern.length == 0) {
                                // tables de conjugaison du 1er et du 2e groupe
                            for (let [nCut, sAdd, sFlexTags] of this._getConjRule(sWord)) {
                                this.addFlexion(sWord.slice(0,-nCut)+sAdd, sWord, ":V" + c_g + "_" + sVerbTag+sFlexTags);
                                for (let [nCut, sAdd, sFlexTags, sPattern] of this._getConjRule(sLemma)) {
                                    if (!sPattern || RegExp(sPattern).test(sLemma)) {
                                        this.addFlexion(sLemma.slice(0,-nCut)+sAdd, sLemma, ":V" + c_g + "_" + sVerbTag + sFlexTags);
                                    }
                                }
                            } else {
                                // utilisation du conjugueur
                                let oVerb = new Verb(sLemma, sVerbPattern);
                                for (let [sTag1, dFlex] of oVerb.dConj.entries()) {
                                    if (sTag1 !== ":Q") {
                                        for (let [sTag2, sConj] of dFlex.entries()) {
                                            if (sTag2.startsWith(":") && sConj !== "") {
                                                this.addFlexion(sConj, sLemma, ":V" + c_g + "_" + sVerbTag + sTag1 + sTag2);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    }
                    case "W":
                        sWord = sWord.toLowerCase();
                        this.addFlexion(sWord, sWord, ":W");
                        sLemma = sLemma.toLowerCase();
                        this.addFlexion(sLemma, sLemma, ":W");
                        break;
                    case "M1":
                        sWord = sWord.slice(0,1).toUpperCase() + sWord.slice(1);
                        sLemma = sLemma.slice(0,1).toUpperCase() + sLemma.slice(1);
                        sGenderTag = this.getRadioValue("genre_m1");
                        if (sGenderTag) {
                            this.addFlexion(sWord, sWord, ":M1"+sGenderTag+":i");
                            this.addFlexion(sLemma, sLemma, ":M1"+sGenderTag+":i");
                        }
                        break;
                    case "M2":
                        sWord = sWord.slice(0,1).toUpperCase() + sWord.slice(1);
                        sLemma = sLemma.slice(0,1).toUpperCase() + sLemma.slice(1);
                        sGenderTag = this.getRadioValue("genre_m2");
                        if (sGenderTag) {
                            this.addFlexion(sWord, sWord, ":M2"+sGenderTag+":i");
                            this.addFlexion(sLemma, sLemma, ":M2"+sGenderTag+":i");
                        }
                        break;
                    case "MP":
                        sGenderTag = this.getRadioValue("genre_mp");
                        if (sGenderTag) {
                            this.addFlexion(sWord, sWord, ":MP"+sGenderTag+":i");
                            this.addFlexion(sLemma, sLemma, ":MP"+sGenderTag+":i");
                        }
                        break;
                    case "X":
                        let sLemma = document.getElementById("lemma").value.trim();
                        let sFlexion = document.getElementById("flexion").value.trim();
                        let sTags = document.getElementById("tags").value.trim();
                        if (sLemma.length > 0 && sTags.startsWith(":")) {
                            this.addFlexion(sWord, sLemma, sTags);
                        if (sFlexion.length > 0 && sTags.startsWith(":")) {
                            this.addFlexion(sFlexion, sLemma, sTags);
                        }
                        break;
                }
            }
            this.show();
        }
        catch (e) {
            showError(e);
        }
    },

    _getConjRule: function (sVerb) {
        if (sVerb.endsWith("ir")) {
            // deuxième groupe
            return oConj["V2"];
        } else {
        } else if (sVerb.endsWith("er")) {
            // premier groupe
            if (sVerb.slice(-5) in oConj["V1"]) {
                return oConj["V1"][sVerb.slice(-5)];
            }
            if (sVerb.slice(-4) in oConj["V1"]) {
                if (sVerb.endsWith("eler") || sVerb.endsWith("eter")) {
                    return oConj["V1"][sVerb.slice(-4)]["1"];
                }
                return oConj["V1"][sVerb.slice(-4)];
            }
            if (sVerb.slice(-3) in oConj["V1"]) {
                return oConj["V1"][sVerb.slice(-3)];
            }
            return oConj["V1"]["er"];
        } else {
            // troisième groupe
            return [ [0, "", ":Y/*", false] ];
        }
    },

    getRadioValue: function (sName) {
        if (document.querySelector('input[name="' + sName + '"]:checked')) {
            return document.querySelector('input[name="' + sName + '"]:checked').value;
        }

        }
    },

    addToLexicon: function () {
        try {
            oLexicon.addFlexions(this.lFlexion);
            oLexicon.save();
            document.getElementById("word").value = "";
            document.getElementById("lemma").value = "";
            oPage.showSection("section_vide");
            oPage.hideEditor();
            oPage.hideActions();
            oPage.clear();
            this.clear();
        }
        catch (e) {