Grammalecte  Check-in [f7f4aac204]

def rewriteCode (sCode):
    "convert simple code syntax to a string of Python code"
    if sCode[0:1] == "=":
        sCode = sCode[1:]
    sCode = sCode.replace("__also__", "bCondMemo")
    sCode = sCode.replace("__else__", "not bCondMemo")
    sCode = sCode.replace("sContext", "_sAppContext")
    sCode = re.sub(r"\b(morph[0x]?|morphVC|value|tag|meta|info)[(]\\(\d+)", 'g_\\1(lToken[nTokenOffset+\\2]', sCode)
    sCode = re.sub(r"\b(morph[0x]?|morphVC|value|tag|meta|info)[(]\\-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1]', sCode)
    sCode = re.sub(r"\b(select|define|definefrom|rewrite|addmorph|setmeta)[(][\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2]', sCode)
    sCode = re.sub(r"\b(select|define|definefrom|rewrite|addmorph|setmeta)[(][\\]-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\](\d+), *[\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2], lToken[nTokenOffset+\\3]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\](\d+), *[\\]-(\d+)", 'g_\\1(lToken[nTokenOffset+\\2], lToken[nLastToken-\\3+1]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\]-(\d+), *[\\](\d+)", 'g_\\1(lToken[nLastToken-\\2+1], lToken[nTokenOffset+\\3]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\]-(\d+), *[\\]-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1], lToken[nLastToken-\\3+1]', sCode)
    sCode = re.sub(r"\b(tagbefore|tagafter)[(][\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2], dTags', sCode)

        if m:
            sOption = m.group(1)
            sAction = sAction[m.end():].strip()
        if nPriority == -1:
            nPriority = self.dOptPriority.get(sOption, 4)

        # valid action?
        m = re.search(r"(?P<action>[-=~/!>&])(?P<start>-?\d+\.?|)(?P<end>:\.?-?\d+|)(?P<casing>:|)>>", sAction)
        if not m:
            print("\n# Error. No action found at: ", sLineId, sActionId)
            exit()

        # Condition
        sCondition = sAction[:m.start()].strip()
        if sCondition:

        checkTokenNumbers(sCondition, sActionId, nToken)    # check tokens in condition
        checkTokenNumbers(sAction, sActionId, nToken)       # check tokens in action

        if cAction == ">":
            ## no action, break loop if condition is False
            return [sLineId, sOption, sCondition, cAction, ""]

        if not sAction and cAction not in "!#":
            print(f"\n# Error in action at line <{sLineId}/{sActionId}>:  This action is empty.")
            exit()

        if sAction[0:1] != "=" and cAction != "=":
            checkIfThereIsCode(sAction, sActionId)

        if cAction == "-":

                nToken = sAction.count("|") + 1
                if iStartAction > 0 and iEndAction > 0:
                    if (iEndAction - iStartAction + 1) != nToken:
                        print(f"\n# Error in action at line <{sLineId}/{sActionId}>: numbers of modified tokens modified.")
                elif iStartAction < 0 or iEndAction < 0 and iStartAction != iEndAction:
                    print(f"\n# Warning in action at line <{sLineId}/{sActionId}>: rewriting with possible token position modified.")
            return [sLineId, sOption, sCondition, cAction, sAction, iStartAction, iEndAction, bCaseSensitivity]
        if cAction in "!/&":
            ## tags
            return [sLineId, sOption, sCondition, cAction, sAction, iStartAction, iEndAction]
        if cAction == "=":
            ## disambiguator
            sAction = self.createFunction("da", sAction)
            return [sLineId, sOption, sCondition, cAction, sAction]
        print("\n# Unknown action at ", sLineId, sActionId)

        elif sLine.startswith("        ||"):
            # tokens line continuation
            iPrevLine, sPrevLine = lTokenLine[-1]
            lTokenLine[-1] = [iPrevLine, sPrevLine + " " + sLine.strip()[2:]]
        elif sLine.startswith("        <<- "):
            # actions
            lActions.append([iLine, sLine[12:].strip()])
            if not re.search(r"[-=~/!>&](?:-?\d\.?(?::\.?-?\d+|)|):?>>", sLine):
                bActionBlock = True
        elif sLine.startswith("        && "):
            # action message
            iPrevLine, sPrevLine = lActions[-1]
            lActions[-1] = [iPrevLine, sPrevLine + sLine]
        elif sLine.startswith("        ") and bActionBlock:
            # action line continuation
            iPrevLine, sPrevLine = lActions[-1]
            lActions[-1] = [iPrevLine, sPrevLine + " " + sLine.strip()]
            if re.search(r"[-=~/!>&](?:-?\d\.?(?::\.?-?\d+|)|):?>>", sLine):
                bActionBlock = False
        elif re.match("[  ]*$", sLine):
            # empty line to end merging
            if not lTokenLine:
                continue
            if bActionBlock or not lActions:
                print("# Error. No action found at line:", iLine)

        # Used as a key in a python dictionary.
        # Nodes are equivalent if they have identical arcs, and each identical arc leads to identical states.
        return self.__str__() == other.__str__()

    def getNodeAsDict (self):
        "returns the node as a dictionary structure"
        dNode = {}
        dReValue = {}       # regex for token values
        dReMorph = {}       # regex for morph
        dMorph = {}         # simple search in morph
        dReMultiMorph = {}  # regex for morph in multi-tokens
        dLemma = {}
        dPhonet = {}
        dMeta = {}
        dTag = {}
        dRule = {}
        for sArc, oNode in self.dArcs.items():
            if sArc.startswith("@") and len(sArc) > 1:
                dReMorph[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("$") and len(sArc) > 1:
                dMorph[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("&") and len(sArc) > 1:
                dReMultiMorph[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("~") and len(sArc) > 1:
                dReValue[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith(">") and len(sArc) > 1:
                dLemma[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("%") and len(sArc) > 1:
                dPhonet[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("*") and len(sArc) > 1:
                dMeta[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("/") and len(sArc) > 1:
                dTag[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("##"):
                dRule[sArc[1:]] = oNode.__hash__()
            else:
                dNode[sArc] = oNode.__hash__()
        if dReValue:
            dNode["<re_value>"] = dReValue
        if dReMorph:
            dNode["<re_morph>"] = dReMorph
        if dReMultiMorph:
            dNode["<re_mmorph>"] = dReMultiMorph
        if dMorph:
            dNode["<morph>"] = dMorph
        if dLemma:
            dNode["<lemmas>"] = dLemma
        if dPhonet:
            dNode["<phonet>"] = dPhonet
        if dTag:

            s += `#${dToken["i"]}\t${dToken["nStart"]}:${dToken["nEnd"]}\t${dToken["sValue"]}\t${dToken["sType"]}`;
            if (dToken.hasOwnProperty("lMorph")) {
                s += "\t" + dToken["lMorph"].toString();
            }
            if (dToken.hasOwnProperty("aTags")) {
                s += "\t" + dToken["aTags"].toString();
            }
            if (dToken.hasOwnProperty("nMultiStartTo")) {
                s += "\t>>" + dToken["nMultiStartTo"].toString();
            }
            s += "\n";
        }
        return s;
    }

    parse (sCountry="${country_default}", bDebug=false, dOptions=null, bContext=false, bFullInfo=false) {
        // analyses <sText> and returns an iterable of errors or (with option <bFullInfo>) a list of sentences with tokens and errors

                }
            }
            else if (!sOption || option(sOption)) {
                for (let [zRegex, bUppercase, sLineId, sRuleId, nPriority, lActions, lGroups, lNegLookBefore] of lRuleGroup) {
                    if (!gc_engine.aIgnoredRules.has(sRuleId)) {
                        while ((m = zRegex.gl_exec2(sText, lGroups, lNegLookBefore)) !== null) {
                            let bCondMemo = null;
                            for (let [sFuncCond, cActionType, sAction, ...eAct] of lActions) {
                                // action in lActions: [ condition, action type, replacement/suggestion/action[, iGroup[, message, URL]] ]
                                try {
                                    bCondMemo = (!sFuncCond || gc_functions[sFuncCond](sText, sText0, m, this.dTokenPos, sCountry, bCondMemo));
                                    if (bCondMemo) {
                                        switch (cActionType) {
                                            case "-":
                                                // grammar error
                                                //console.log("-> error detected in " + sLineId + "\nzRegex: " + zRegex.source);
                                                let nErrorStart = nOffset + m.start[eAct[0]];
                                                if (!this.dError.has(nErrorStart) || nPriority > this.dErrorPriority.get(nErrorStart)) {
                                                    this.dError.set(nErrorStart, this._createErrorFromRegex(sText, sText0, sAction, nOffset, m, eAct[0], sLineId, sRuleId, bUppercase, eAct[1], eAct[2], bShowRuleId, sOption, bContext));
                                                    this.dErrorPriority.set(nErrorStart, nPriority);
                                                    this.dSentenceError.set(nErrorStart, this.dError.get(nErrorStart));
                                                }
                                                break;
                                            case "~":
                                                // text processor
                                                //console.log("-> text processor by " + sLineId + "\nzRegex: " + zRegex.source);
                                                sText = this.rewriteText(sText, sAction, eAct[0], m, bUppercase);
                                                bChange = true;
                                                if (bDebug) {
                                                    console.log("~ " + sText + "  -- " + m[eAct[0]] + "  # " + sLineId);
                                                }
                                                break;
                                            case "=":
                                                // disambiguation
                                                //console.log("-> disambiguation by " + sLineId + "\nzRegex: " + zRegex.source);
                                                gc_functions[sAction](sText, m, this.dTokenPos);
                                                if (bDebug) {
                                                    console.log("= " + m[0] + "  # " + sLineId, "\nDA:", this.dTokenPos);
                                                }
                                                break;
                                            case ">":
                                                // we do nothing, this test is just a condition to apply all following actions
                                                break;

        }
        if (bDebug) {
            console.log("UPDATE:");
            console.log(this.asString());
        }
    }

    * _getNextNodes (oGraph, oToken, oNode, bKeep=false) {
        // generator: return matches where <oToken> “values” match <oNode> arcs
        try {
            let bTokenFound = false;
            // token value
            if (oNode.hasOwnProperty(oToken["sValue"])) {
                yield [" ", oToken["sValue"], oNode[oToken["sValue"]]];
                bTokenFound = true;

                                        bTokenFound = true;
                                    }
                                }
                            }
                        }
                    }
                }
                // regex multi morph arcs
                if (oNode.hasOwnProperty("<re_mmorph>")) {
                    if (oToken.hasOwnProperty("nMultiStartTo")) {
                        let lMorph = oToken["oMultiToken"]["lMorph"];
                        for (let sRegex in oNode["<re_mmorph>"]) {
                            if (!sRegex.includes("¬")) {
                                // no anti-pattern
                                if (lMorph.some(sMorph  =>  (sMorph.search(sRegex) !== -1))) {
                                    yield ["&", sRegex, oNode["<re_mmorph>"][sRegex]];
                                    bTokenFound = true;
                                }
                            } else {
                                // there is an anti-pattern
                                let [sPattern, sNegPattern] = sRegex.split("¬", 2);
                                if (sNegPattern == "*") {
                                    // all morphologies must match with <sPattern>
                                    if (sPattern) {
                                        if (lMorph.every(sMorph  =>  (sMorph.search(sPattern) !== -1))) {
                                            yield ["&", sRegex, oNode["<re_mmorph>"][sRegex]];
                                            bTokenFound = true;
                                        }
                                    }
                                } else {
                                    if (sNegPattern  &&  lMorph.some(sMorph  =>  (sMorph.search(sNegPattern) !== -1))) {
                                        continue;
                                    }
                                    if (!sPattern  ||  lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1))) {
                                        yield ["&", sRegex, oNode["<re_mmorph>"][sRegex]];
                                        bTokenFound = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            // token tags
            if (oToken.hasOwnProperty("aTags") && oNode.hasOwnProperty("<tags>")) {
                for (let sTag of oToken["aTags"]) {
                    if (oNode["<tags>"].hasOwnProperty(sTag)) {
                        yield ["/", sTag, oNode["<tags>"][sTag]];
                        bTokenFound = true;

            }
            if (!bTokenFound && bKeep) {
                yield [null, "", -1];
            }
            // JUMP
            // Warning! Recurssion!
            if (oNode.hasOwnProperty("<>")) {
                yield* this._getNextNodes(oGraph, oToken, oGraph[oNode["<>"]], bKeep=true);
            }
        }
        catch (e) {
            console.error(e);
        }
    }

    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 lPointers = [];
        let bTagAndRewrite = false;
        try {
            for (let [iToken, oToken] of this.lTokens.entries()) {
                if (bDebug) {
                    console.log("TOKEN: " + oToken["sValue"]);
                }
                // check arcs for each existing pointer
                let lNextPointers = [];
                for (let oPointer of lPointers) {
                    if (oPointer["nMultiEnd"] != -1) {
                        if (oToken["i"] <= oPointer["nMultiEnd"]) {
                            lNextPointers.push(oPointer);
                        }
                        if (oToken["i"] != oPointer["nMultiEnd"]) {
                            continue;
                        }
                    }
                    for (let [cNodeType, sMatch, iNode] of this._getNextNodes(oGraph, oToken, oGraph[oPointer["iNode"]])) {
                        if (cNodeType === null) {
                            lNextPointers.push(oPointer);
                            continue;
                        }
                        if (bDebug) {
                            console.log("  MATCH: " + cNodeType + sMatch);
                        }
                        let nMultiEnd = (cNodeType != "&") ? -1 : oToken["nMultiStartTo"];
                        lNextPointers.push({ "iToken1": oPointer["iToken1"], "iNode": iNode, "nMultiEnd": nMultiEnd });
                    }
                }
                lPointers = lNextPointers;
                // check arcs of first nodes
                for (let [cNodeType, sMatch, iNode] of this._getNextNodes(oGraph, oToken, oGraph[0])) {
                    if (cNodeType === null) {
                        continue;
                    }
                    if (bDebug) {
                        console.log("  MATCH: " + cNodeType + sMatch);
                    }
                    let nMultiEnd = (cNodeType != "&") ? -1 : oToken["nMultiStartTo"];
                    lPointers.push({ "iToken1": iToken, "iNode": iNode, "nMultiEnd": nMultiEnd });
                }
                // check if there is rules to check for each pointer
                for (let oPointer of lPointers) {
                    if (oPointer["nMultiEnd"] != -1) {
                        if (oToken["i"] < oPointer["nMultiEnd"]) {
                            continue;
                        }
                        if (oToken["i"] >= oPointer["nMultiEnd"]) {
                            oPointer["nMultiEnd"] = -1;
                        }
                    }
                    if (oGraph[oPointer["iNode"]].hasOwnProperty("<rules>")) {
                        let bChange = this._executeActions(oGraph, oGraph[oPointer["iNode"]]["<rules>"], oPointer["iToken1"]-1, iToken, dOptions, sCountry, bShowRuleId, bDebug, bContext);
                        if (bChange) {
                            bTagAndRewrite = true;
                        }
                    }
                }

        for (let [sLineId, nextNodeKey] of Object.entries(oNode)) {
            let bCondMemo = null;
            for (let sRuleId of oGraph[nextNodeKey]) {
                try {
                    if (bDebug) {
                        console.log("   >TRY: " + sRuleId + " " + sLineId);
                    }
                    let [_, sOption, sFuncCond, cActionType, sAction, ...eAct] = gc_rules_graph.dRule[sRuleId];
                    // Suggestion    [ option, condition, "-", replacement/suggestion/action, iTokenStart, iTokenEnd, cStartLimit, cEndLimit, bCaseSvty, nPriority, sMessage, iURL ]
                    // TextProcessor [ option, condition, "~", replacement/suggestion/action, iTokenStart, iTokenEnd, bCaseSvty ]
                    // Disambiguator [ option, condition, "=", replacement/suggestion/action ]
                    // Tag           [ option, condition, "/", replacement/suggestion/action, iTokenStart, iTokenEnd ]
                    // Immunity      [ option, condition, "!", "",                            iTokenStart, iTokenEnd ]
                    // Immunity      [ option, condition, "&", "",                            iTokenStart, iTokenEnd ]
                    // Test          [ option, condition, ">", "" ]
                    if (!sOption || dOptions.gl_get(sOption, false)) {
                        bCondMemo = !sFuncCond || gc_functions[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.lTokens[nTokenErrorStart].hasOwnProperty("sImmunity") || (this.lTokens[nTokenErrorStart]["sImmunity"] != "*" && !this.lTokens[nTokenErrorStart]["sImmunity"].includes(sOption))) {
                                    let nTokenErrorEnd = (iTokenEnd > 0) ? nTokenOffset + iTokenEnd : nLastToken + iTokenEnd;
                                    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(sAction, 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));
                                        if (bDebug) {
                                            console.log("    NEW_ERROR: ",  this.dError.get(nErrorStart));
                                        }
                                    }
                                }
                            }
                            else if (cActionType == "~") {
                                // text processor
                                let nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
                                let nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : nLastToken + eAct[1];
                                this._tagAndPrepareTokenForRewriting(sAction, nTokenStart, nTokenEnd, nTokenOffset, nLastToken, eAct[2], bDebug);
                                bChange = true;
                                if (bDebug) {
                                    console.log(`    TEXT_PROCESSOR: [${this.lTokens[nTokenStart]["sValue"]}:${this.lTokens[nTokenEnd]["sValue"]}]  > ${sAction}`);
                                }
                            }
                            else if (cActionType == "=") {
                                // disambiguation
                                gc_functions[sAction](this.lTokens, nTokenOffset, nLastToken);
                                if (bDebug) {
                                    console.log(`    DISAMBIGUATOR: (${sAction})  [${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) {
                                    console.log("    COND_OK");
                                }
                            }
                            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.lTokens[i].hasOwnProperty("aTags")) {
                                        this.lTokens[i]["aTags"].add(...sAction.split("|"))
                                    } else {
                                        this.lTokens[i]["aTags"] = new Set(sAction.split("|"));
                                    }
                                }
                                if (bDebug) {
                                    console.log(`    TAG:  ${sAction} > [${this.lTokens[nTokenStart]["sValue"]}:${this.lTokens[nTokenEnd]["sValue"]}]`);
                                }
                                for (let sTag of sAction.split("|")) {
                                    if (!this.dTags.has(sTag)) {
                                        this.dTags.set(sTag, [nTokenStart, nTokenEnd]);
                                    } else {
                                        this.dTags.set(sTag, [Math.min(nTokenStart, this.dTags.get(sTag)[0]), Math.max(nTokenEnd, this.dTags.get(sTag)[1])]);
                                    }
                                }
                            }
                            else if (cActionType == "!") {
                                // immunity
                                if (bDebug) {
                                    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];
                                let sImmunity = sAction || "*";
                                if (nTokenEnd - nTokenStart == 0) {
                                    this.lTokens[nTokenStart]["sImmunity"] = sImmunity;
                                    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.lTokens[i]["sImmunity"] = sImmunity;
                                        let nErrorStart = this.nOffsetWithinParagraph + this.lTokens[i]["nStart"];
                                        if (this.dError.has(nErrorStart)) {
                                            this.dError.delete(nErrorStart);
                                        }
                                    }
                                }
                            }
                            else if (cActionType == "&") {
                                // multi-tokens
                                let nTokenStart = (eAct[0] > 0) ? nTokenOffset + eAct[0] : nLastToken + eAct[0];
                                let nTokenEnd = (eAct[1] > 0) ? nTokenOffset + eAct[1] : nLastToken + eAct[1];
                                let oMultiToken = {
                                    "nTokenStart": nTokenStart,
                                    "nTokenEnd": nTokenEnd,
                                    "lTokens": this.lTokens.slice(nTokenStart, nTokenEnd+1),
                                    "lMorph": (sAction) ? sAction.split("|") : [":HM"]
                                }
                                this.lTokens[nTokenStart]["nMultiStartTo"] = this.lTokens[nTokenEnd]["i"];
                                this.lTokens[nTokenEnd]["nMultiEndFrom"] = this.lTokens[nTokenStart]["i"];
                                this.lTokens[nTokenStart]["oMultiToken"] = oMultiToken;
                                this.lTokens[nTokenEnd]["oMultiToken"] = oMultiToken;
                                if (bDebug) {
                                    console.log(`"    MULTI-TOKEN: ${sAction}  [${this.lTokens[nTokenStart]["sValue"]}:${this.lTokens[nTokenEnd]["sValue"]}]`);
                                }
                            }
                            else {
                                console.log("# error: unknown action at " + sLineId);
                            }
                        }
                        else if (cActionType == ">") {
                            if (bDebug) {
                                console.log("    COND_BREAK");
                            }

            sNew = sRepl.gl_expand(m);
            sNew = sNew + " ".repeat(ln-sNew.length);
        }
        //console.log(sText+"\nstart: "+m.start[iGroup]+" end:"+m.end[iGroup]);
        return sText.slice(0, m.start[iGroup]) + sNew + sText.slice(m.end[iGroup]);
    }

    _tagAndPrepareTokenForRewriting (sAction, nTokenRewriteStart, nTokenRewriteEnd, nTokenOffset, nLastToken, bCaseSvty, bDebug) {
        // text processor: rewrite tokens between <nTokenRewriteStart> and <nTokenRewriteEnd> position
        if (sAction === "*") {
            // purge text
            if (nTokenRewriteEnd - nTokenRewriteStart == 0) {
                this.lTokens[nTokenRewriteStart]["bToRemove"] = true;
            } else {
                for (let i = nTokenRewriteStart;  i <= nTokenRewriteEnd;  i++) {
                    this.lTokens[i]["bToRemove"] = true;
                }
            }
        }
        else if (sAction === "␣") {
            // merge tokens
            this.lTokens[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd;
        }
        else if (sAction.startsWith("␣")) {
            sAction = this._expand(sAction, nTokenOffset, nLastToken);
            this.lTokens[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd;
            this.lTokens[nTokenRewriteStart]["sMergedValue"] = sAction.slice(1);
        }
        else if (sAction === "_") {
            // neutralized token
            if (nTokenRewriteEnd - nTokenRewriteStart == 0) {
                this.lTokens[nTokenRewriteStart]["sNewValue"] = "_";
            } else {
                for (let i = nTokenRewriteStart;  i <= nTokenRewriteEnd;  i++) {
                    this.lTokens[i]["sNewValue"] = "_";
                }
            }
        }
        else {
            if (sAction.startsWith("=")) {
                sAction = gc_functions[sAction.slice(1)](this.lTokens, nTokenOffset, nLastToken);
            } else {
                sAction = this._expand(sAction, nTokenOffset, nLastToken);
            }
            let bUppercase = bCaseSvty && this.lTokens[nTokenRewriteStart]["sValue"].slice(0,1).gl_isUpperCase();
            if (nTokenRewriteEnd - nTokenRewriteStart == 0) {
                // one token
                if (bUppercase) {
                    sAction = sAction.gl_toCapitalize();
                }
                this.lTokens[nTokenRewriteStart]["sNewValue"] = sAction;
            }
            else {
                // several tokens
                let lTokenValue = sAction.split("|");
                if (lTokenValue.length != (nTokenRewriteEnd - nTokenRewriteStart + 1)) {
                    if (bDebug) {
                        console.log("Error. Text processor: number of replacements != number of tokens.");
                    }
                    return;
                }
                let j = 0;

        if (sValues.includes(sValue)) {
            return true;
        }
    }
    return false;
}

function g_morph (oToken, sPattern, sNegPattern="", nLeft=null, nRight=null) {
    // analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies
    let lMorph;
    if (oToken.hasOwnProperty("lMorph")) {
        lMorph = oToken["lMorph"];
    }
    else {
        if (nLeft !== null) {
            let sValue = (nRight !== null) ? oToken["sValue"].slice(nLeft, nRight) : oToken["sValue"].slice(nLeft);
            lMorph = gc_engine.oSpellChecker.getMorph(sValue);



        } else {
            lMorph = gc_engine.oSpellChecker.getMorph(oToken["sValue"]);
        }
    }
    if (lMorph.length == 0) {
        return false;
    }

            }
        }
    }
    // search sPattern
    return lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1));
}

function g_morphx (oToken, sPattern, sNegPattern="") {
    // analyse a multi-token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies
    if (!oToken.hasOwnProperty("oMultiToken")) {
        return false;
    }
    let lMorph = oToken["oMultiToken"]["lMorph"];
    if (lMorph.length == 0) {
        return false;
    }
    // check negative condition
    if (sNegPattern) {
        if (sNegPattern == "*") {
            // all morph must match sPattern
            return lMorph.every(sMorph  =>  (sMorph.search(sPattern) !== -1));
        }
        else {
            if (lMorph.some(sMorph  =>  (sMorph.search(sNegPattern) !== -1))) {
                return false;
            }
        }
    }
    // search sPattern
    return lMorph.some(sMorph  =>  (sMorph.search(sPattern) !== -1));
}

function g_morph0 (oToken, sPattern, sNegPattern="", nLeft=null, nRight=null) {
    // analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies
    let lMorph;
    if (nLeft !== null) {
        let sValue = (nRight !== null) ? oToken["sValue"].slice(nLeft, nRight) : oToken["sValue"].slice(nLeft);
        lMorph = gc_engine.oSpellChecker.getMorph(sValue);



    } else {
        lMorph = gc_engine.oSpellChecker.getMorph(oToken["sValue"]);
    }
    if (lMorph.length == 0) {
        return false;
    }
    // check negative condition

        s += "now:      " + self.sSentence  + "\n"
        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"])
            if "nMultiStartTo" in dToken:
                s += "\t>>" + str(dToken["nMultiStartTo"])
            s += "\n"
        #for nPos, dToken in self.dTokenPos.items():
        #    s += "{}\t{}\n".format(nPos, dToken)
        return s

    def parse (self, sCountry="${country_default}", bDebug=False, dOptions=None, bContext=False, bFullInfo=False):
        "analyses <sText> and returns an iterable of errors or (with option <bFullInfo>) paragraphs errors and sentences with tokens and errors"

                        sText = self.parseGraph(_rules_graph.dAllGraph[sGraphName], sCountry, dOptions, bShowRuleId, bDebug, bContext)
            elif not sOption or dOptions.get(sOption, False):
                # regex rules
                for zRegex, bUppercase, sLineId, sRuleId, nPriority, lActions in lRuleGroup:
                    if sRuleId not in _aIgnoredRules:
                        for m in zRegex.finditer(sText):
                            bCondMemo = None
                            for sFuncCond, cActionType, sAction, *eAct in lActions:
                                # action in lActions: [ condition, action type, replacement/suggestion/action[, iGroup[, message, URL]] ]
                                try:
                                    bCondMemo = not sFuncCond or getattr(gc_functions, sFuncCond)(sText, sText0, m, self.dTokenPos, sCountry, bCondMemo)
                                    if bCondMemo:
                                        if bDebug:
                                            echo("RULE: " + sLineId)
                                        if cActionType == "-":
                                            # grammar error
                                            nErrorStart = nOffset + m.start(eAct[0])
                                            if nErrorStart not in self.dError or nPriority > self.dErrorPriority.get(nErrorStart, -1):
                                                self.dError[nErrorStart] = self._createErrorFromRegex(sText, sText0, sAction, nOffset, m, eAct[0], sLineId, sRuleId, bUppercase, eAct[1], eAct[2], bShowRuleId, sOption, bContext)
                                                self.dErrorPriority[nErrorStart] = nPriority
                                                self.dSentenceError[nErrorStart] = self.dError[nErrorStart]
                                        elif cActionType == "~":
                                            # text processor
                                            sText = self.rewriteText(sText, sAction, eAct[0], m, bUppercase)
                                            bChange = True
                                            if bDebug:
                                                echo("~ " + sText + "  -- " + m.group(eAct[0]) + "  # " + sLineId)
                                        elif cActionType == "=":
                                            # disambiguation
                                            if not bParagraph:
                                                getattr(gc_functions, sAction)(sText, m, self.dTokenPos)
                                                if bDebug:
                                                    echo("= " + m.group(0) + "  # " + sLineId)
                                        elif cActionType == ">":
                                            # we do nothing, this test is just a condition to apply all following actions
                                            pass
                                        else:
                                            echo("# error: unknown action at " + sLineId)

                dToken["aTags"] = self.dTokenPos[dToken["nStart"]]["aTags"]
        self.lTokens = lNewTokens
        self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lTokens  if dToken["sType"] != "INFO" }
        if bDebug:
            echo("UPDATE:")
            echo(self)

    def _getNextNodes (self, dGraph, dToken, dNode, bKeep=False):
        "generator: return matches where <dToken> “values” match <dNode> arcs"
        bTokenFound = False
        # token value
        if dToken["sValue"] in dNode:
            yield (" ", dToken["sValue"], dNode[dToken["sValue"]])
            bTokenFound = True
        if dToken["sValue"][0:2].istitle(): # we test only 2 first chars, to match words such as "Laissez-les", "Crève-cœur".

                                        bTokenFound = True
                            else:
                                if sNegPattern and any(re.search(sNegPattern, sMorph)  for sMorph in lMorph):
                                    continue
                                if not sPattern or any(re.search(sPattern, sMorph)  for sMorph in lMorph):
                                    yield ("@", sRegex, dNode["<re_morph>"][sRegex])
                                    bTokenFound = True
            # regex multi morph arcs
            if "<re_mmorph>" in dNode:
                if "nMultiStartTo" in dToken:
                    lMorph = dToken["dMultiToken"]["lMorph"]
                    for sRegex in dNode["<re_mmorph>"]:
                        if "¬" not in sRegex:
                            # no anti-pattern
                            if any(re.search(sRegex, sMorph)  for sMorph in lMorph):
                                yield ("&", sRegex, dNode["<re_mmorph>"][sRegex])
                                bTokenFound = True
                        else:
                            # there is an anti-pattern
                            sPattern, sNegPattern = sRegex.split("¬", 1)
                            if sNegPattern == "*":
                                # all morphologies must match with <sPattern>
                                if sPattern:
                                    if all(re.search(sPattern, sMorph)  for sMorph in lMorph):
                                        yield ("&", sRegex, dNode["<re_mmorph>"][sRegex])
                                        bTokenFound = True
                            else:
                                if sNegPattern and any(re.search(sNegPattern, sMorph)  for sMorph in lMorph):
                                    continue
                                if not sPattern or any(re.search(sPattern, sMorph)  for sMorph in lMorph):
                                    yield ("&", sRegex, dNode["<re_mmorph>"][sRegex])
                                    bTokenFound = True
        # token tags
        if "aTags" in dToken and "<tags>" in dNode:
            for sTag in dToken["aTags"]:
                if sTag in dNode["<tags>"]:
                    yield ("/", sTag, dNode["<tags>"][sTag])
                    bTokenFound = True
        # meta arc (for token type)

                        yield ("*", sMeta, dNode["<meta>"][sMeta])
                        bTokenFound = True
        if not bTokenFound and bKeep:
            yield (None, "", -1)
        # JUMP
        # Warning! Recursion!
        if "<>" in dNode:
            yield from self._getNextNodes(dGraph, dToken, dGraph[dNode["<>"]], bKeep=True)

    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"
        lPointers = []
        bTagAndRewrite = False
        for iToken, dToken in enumerate(self.lTokens):
            if bDebug:
                echo("TOKEN: " + dToken["sValue"])
            # check arcs for each existing pointer
            lNextPointers = []
            for dPointer in lPointers:
                if dPointer["nMultiEnd"] != -1:
                    if dToken["i"] <= dPointer["nMultiEnd"]:
                        lNextPointers.append(dPointer)
                    if dToken["i"] != dPointer["nMultiEnd"]:
                        continue
                for cNodeType, sMatch, iNode in self._getNextNodes(dGraph, dToken, dGraph[dPointer["iNode"]]):
                    if cNodeType is None:
                        lNextPointers.append(dPointer)
                        continue
                    if bDebug:
                        echo("  MATCH: " + cNodeType + sMatch)
                    nMultiEnd = -1  if cNodeType != "&"  else dToken["nMultiStartTo"]
                    lNextPointers.append({ "iToken1": dPointer["iToken1"], "iNode": iNode, "nMultiEnd": nMultiEnd })
            lPointers = lNextPointers
            # check arcs of first nodes
            for cNodeType, sMatch, iNode in self._getNextNodes(dGraph, dToken, dGraph[0]):
                if cNodeType is None:
                    continue
                if bDebug:
                    echo("  MATCH: " + cNodeType + sMatch)
                nMultiEnd = -1  if cNodeType != "&"  else dToken["nMultiStartTo"]
                lPointers.append({ "iToken1": iToken, "iNode": iNode, "nMultiEnd": nMultiEnd })
            # check if there is rules to check for each pointer
            for dPointer in lPointers:
                if dPointer["nMultiEnd"] != -1:
                    if dToken["i"] < dPointer["nMultiEnd"]:
                        continue
                    if dToken["i"] >= dPointer["nMultiEnd"]:
                        dPointer["nMultiEnd"] = -1
                if "<rules>" in dGraph[dPointer["iNode"]]:
                    bChange = self._executeActions(dGraph, dGraph[dPointer["iNode"]]["<rules>"], dPointer["iToken1"]-1, iToken, dOptions, sCountry, bShowRuleId, bDebug, bContext)
                    if bChange:
                        bTagAndRewrite = True
        if bTagAndRewrite:
            self.rewriteFromTags(bDebug)
        if bDebug:
            echo(self)
        return self.sSentence

    def _executeActions (self, dGraph, dNode, nTokenOffset, nLastToken, dOptions, sCountry, bShowRuleId, bDebug, bContext):
        "execute actions found in the DARG"
        bChange = False
        for sLineId, nextNodeKey in dNode.items():
            bCondMemo = None
            for sRuleId in dGraph[nextNodeKey]:
                try:
                    if bDebug:
                        echo("   >TRY: " + sRuleId + " " + sLineId)
                    _, sOption, sFuncCond, cActionType, sAction, *eAct = _rules_graph.dRule[sRuleId]
                    # Suggestion    [ option, condition, "-", replacement/suggestion/action, iTokenStart, iTokenEnd, cStartLimit, cEndLimit, bCaseSvty, nPriority, sMessage, iURL ]
                    # TextProcessor [ option, condition, "~", replacement/suggestion/action, iTokenStart, iTokenEnd, bCaseSvty ]
                    # Disambiguator [ option, condition, "=", replacement/suggestion/action ]
                    # Tag           [ option, condition, "/", replacement/suggestion/action, iTokenStart, iTokenEnd ]
                    # Immunity      [ option, condition, "!", option,                        iTokenStart, iTokenEnd ]
                    # Multi-token   [ option, condition, "&", morphologies,                  iTokenStart, iTokenEnd ]
                    # Test          [ option, condition, ">", "" ]
                    if not sOption or dOptions.get(sOption, False):
                        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 "sImmunity" not in self.lTokens[nTokenErrorStart] or (self.lTokens[nTokenErrorStart]["sImmunity"] != "*" and sOption not in self.lTokens[nTokenErrorStart]["sImmunity"]):
                                    nTokenErrorEnd = nTokenOffset + iTokenEnd  if iTokenEnd > 0  else nLastToken + iTokenEnd
                                    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(sAction, 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]
                                        if bDebug:
                                            echo("    NEW_ERROR: {}".format(self.dError[nErrorStart]))
                            elif cActionType == "~":
                                # text processor
                                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(sAction, nTokenStart, nTokenEnd, nTokenOffset, nLastToken, eAct[2], bDebug)
                                bChange = True
                                if bDebug:
                                    echo("    TEXT_PROCESSOR: [{}:{}]  > {}".format(self.lTokens[nTokenStart]["sValue"], self.lTokens[nTokenEnd]["sValue"], sAction))
                            elif cActionType == "=":
                                # disambiguation
                                getattr(gc_functions, sAction)(self.lTokens, nTokenOffset, nLastToken)
                                if bDebug:
                                    echo("    DISAMBIGUATOR: ({})  [{}:{}]".format(sAction, 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.lTokens[i]:
                                        self.lTokens[i]["aTags"].update(sAction.split("|"))
                                    else:
                                        self.lTokens[i]["aTags"] = set(sAction.split("|"))
                                if bDebug:
                                    echo("    TAG: {} >  [{}:{}]".format(sAction, self.lTokens[nTokenStart]["sValue"], self.lTokens[nTokenEnd]["sValue"]))
                                for sTag in sAction.split("|"):
                                    if sTag not in self.dTags:
                                        self.dTags[sTag] = [nTokenStart, nTokenEnd]
                                    else:
                                        self.dTags[sTag][0] = min(nTokenStart, self.dTags[sTag][0])
                                        self.dTags[sTag][1] = max(nTokenEnd, self.dTags[sTag][1])
                            elif cActionType == "!":
                                # immunity
                                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]
                                sImmunity = sAction or "*"
                                if nTokenEnd - nTokenStart == 0:
                                    self.lTokens[nTokenStart]["sImmunity"] = sImmunity
                                    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.lTokens[i]["sImmunity"] = sImmunity
                                        nErrorStart = self.nOffsetWithinParagraph + self.lTokens[i]["nStart"]
                                        if nErrorStart in self.dError:
                                            del self.dError[nErrorStart]
                            elif cActionType == "&":
                                # multi-tokens
                                nTokenStart = nTokenOffset + eAct[0]  if eAct[0] > 0  else nLastToken + eAct[0]
                                nTokenEnd = nTokenOffset + eAct[1]  if eAct[1] > 0  else nLastToken + eAct[1]
                                dMultiToken = {
                                    "nTokenStart": nTokenStart,
                                    "nTokenEnd": nTokenEnd,
                                    "lTokens": self.lTokens[nTokenStart:nTokenEnd+1],
                                    "lMorph": sAction.split("|")  if sAction else  [":HM"]
                                }
                                self.lTokens[nTokenStart]["nMultiStartTo"] = self.lTokens[nTokenEnd]["i"]
                                self.lTokens[nTokenEnd]["nMultiEndFrom"] = self.lTokens[nTokenStart]["i"]
                                self.lTokens[nTokenStart]["dMultiToken"] = dMultiToken
                                self.lTokens[nTokenEnd]["dMultiToken"] = dMultiToken
                                if bDebug:
                                    echo("    MULTI-TOKEN: ({})  [{}:{}]".format(sAction, self.lTokens[nTokenStart]["sValue"], self.lTokens[nTokenEnd]["sValue"]))
                                #print(dMultiToken)
                            else:
                                echo("# error: unknown action at " + sLineId)
                        elif cActionType == ">":
                            if bDebug:
                                echo("    COND_BREAK")
                            break
                except Exception as e:

            if bUppercase and m.group(iGroup)[0:1].isupper():
                sNew = sNew.capitalize()
        else:
            sNew = m.expand(sRepl)
            sNew = sNew + " " * (nLen-len(sNew))
        return sText[0:m.start(iGroup)] + sNew + sText[m.end(iGroup):]

    def _tagAndPrepareTokenForRewriting (self, sAction, nTokenRewriteStart, nTokenRewriteEnd, nTokenOffset, nLastToken, bCaseSvty, bDebug):
        "text processor: rewrite tokens between <nTokenRewriteStart> and <nTokenRewriteEnd> position"
        if sAction == "*":
            # purge text
            if nTokenRewriteEnd - nTokenRewriteStart == 0:
                self.lTokens[nTokenRewriteStart]["bToRemove"] = True
            else:
                for i in range(nTokenRewriteStart, nTokenRewriteEnd+1):
                    self.lTokens[i]["bToRemove"] = True
        elif sAction == "␣":
            # merge tokens
            self.lTokens[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd
        elif sAction.startswith("␣"):
            sAction = self._expand(sAction, nTokenOffset, nLastToken)
            self.lTokens[nTokenRewriteStart]["nMergeUntil"] = nTokenRewriteEnd
            self.lTokens[nTokenRewriteStart]["sMergedValue"] = sAction[1:]
        elif sAction == "_":
            # neutralized token
            if nTokenRewriteEnd - nTokenRewriteStart == 0:
                self.lTokens[nTokenRewriteStart]["sNewValue"] = "_"
            else:
                for i in range(nTokenRewriteStart, nTokenRewriteEnd+1):
                    self.lTokens[i]["sNewValue"] = "_"
        else:
            if sAction.startswith("="):
                sAction = getattr(gc_functions, sAction[1:])(self.lTokens, nTokenOffset, nLastToken)
            else:
                sAction = self._expand(sAction, nTokenOffset, nLastToken)
            bUppercase = bCaseSvty and self.lTokens[nTokenRewriteStart]["sValue"][0:1].isupper()
            if nTokenRewriteEnd - nTokenRewriteStart == 0:
                # one token
                if bUppercase:
                    sAction = sAction[0:1].upper() + sAction[1:]
                self.lTokens[nTokenRewriteStart]["sNewValue"] = sAction
            else:
                # several tokens
                lTokenValue = sAction.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.lTokens[i]["bToRemove"] = True

            return True
        sValue = sValue.lower()
        if sValue in sValues:
            return True
    return False


def g_morph (dToken, sPattern, sNegPattern="", nLeft=None, nRight=None):
    "analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies"
    if "lMorph" in dToken:
        lMorph = dToken["lMorph"]
    else:
        if nLeft is not None:
            lMorph = _oSpellChecker.getMorph(dToken["sValue"][slice(nLeft, nRight)])


        else:
            lMorph = _oSpellChecker.getMorph(dToken["sValue"])
    if not lMorph:
        return False
    # check negative condition
    if sNegPattern:
        if sNegPattern == "*":
            # all morph must match sPattern
            zPattern = re.compile(sPattern)
            return all(zPattern.search(sMorph)  for sMorph in lMorph)
        zNegPattern = re.compile(sNegPattern)
        if any(zNegPattern.search(sMorph)  for sMorph in lMorph):
            return False
    # search sPattern
    zPattern = re.compile(sPattern)
    return any(zPattern.search(sMorph)  for sMorph in lMorph)


def g_morphx (dToken, sPattern, sNegPattern=""):
    "analyse a multi-token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies"
    if not "dMultiToken" in dToken:
        return False
    lMorph = dToken["dMultiToken"]["lMorph"]
    if not lMorph:
        return False
    # check negative condition
    if sNegPattern:
        if sNegPattern == "*":
            # all morph must match sPattern
            zPattern = re.compile(sPattern)
            return all(zPattern.search(sMorph)  for sMorph in lMorph)
        zNegPattern = re.compile(sNegPattern)
        if any(zNegPattern.search(sMorph)  for sMorph in lMorph):
            return False
    # search sPattern
    zPattern = re.compile(sPattern)
    return any(zPattern.search(sMorph)  for sMorph in lMorph)


def g_morph0 (dToken, sPattern, sNegPattern="", nLeft=None, nRight=None):
    "analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies (disambiguation off)"
    if nLeft is not None:
        lMorph = _oSpellChecker.getMorph(dToken["sValue"][slice(nLeft, nRight)])


    else:
        lMorph = _oSpellChecker.getMorph(dToken["sValue"])
    if not lMorph:
        return False
    # check negative condition
    if sNegPattern:
        if sNegPattern == "*":

    _zNPf: new RegExp(":(?:M[12P]|T):f"),
    _zNPe: new RegExp(":(?:M[12P]|T):e"),


    ///// FONCTIONS

    getLemmaOfMorph: function (sMorph) {
        let m = this._zLemma.exec(sMorph);
        if (m) {
            return m[1];
        }
        return "";
    },

    agreement: function (l1, l2) {
        // returns True if agreement in gender and number is possible between morphologies <l1> and <l2>
        let [sGender1, sNumber1] = this.getGenderNumber(l1);
        let [sGender2, sNumber2] = this.getGenderNumber(l2);
        if (sNumber1 !== ":i" && sNumber2 !== ":i" && sNumber1 !== sNumber2) {

        if (oToken["sValue"].includes("-t-")) {
            nEnd = nEnd - 2;
        }
        else if (oToken["sValue"].search(/-l(?:es?|a)-(?:[mt]oi|nous|leur)$|(?:[nv]ous|lui|leur)-en$/) != -1) {
            nEnd = oToken["sValue"].slice(0,nEnd).lastIndexOf("-");
        }
    }
    return g_morph(oToken, sPattern, sNegPattern, 0, nEnd);
}

function apposition (sWord1, sWord2) {
    // returns true if nom + nom (no agreement required)
    return sWord2.length < 2 || (cregex.mbNomNotAdj(gc_engine.oSpellChecker.getMorph(sWord2)) && cregex.mbPpasNomNotAdj(gc_engine.oSpellChecker.getMorph(sWord1)));
}

NPe = re.compile(":(?:M[12P]|T):e")


#### FONCTIONS

def getLemmaOfMorph (s):
    "return lemma in morphology <s>"
    m = Lemma.search(s)
    if m:
        return m.group(1)
    return ""

def agreement (l1, l2):
    "returns True if agreement in gender and number is possible between morphologies <l1> and <l2>"
    sGender1, sNumber1 = getGenderNumber(l1)
    sGender2, sNumber2 = getGenderNumber(l2)
    if sNumber1 != ":i" and sNumber2 != ":i" and sNumber1 != sNumber2:
        return False

#### GRAMMAR CHECKING ENGINE PLUGIN: Parsing functions for French language

from . import cregex as cr


def g_morphVC (dToken, sPattern, sNegPattern=""):
    "lance la fonction g_morph() sur la première partie d’un verbe composé (ex: vient-il)"
    nEnd = dToken["sValue"].rfind("-")
    if dToken["sValue"].count("-") > 1:
        if "-t-" in dToken["sValue"]:
            nEnd = nEnd - 2
        elif re.search("-l(?:es?|a)-(?:[mt]oi|nous|leur)$|(?:[nv]ous|lui|leur)-en$", dToken["sValue"]):
            nEnd = dToken["sValue"][0:nEnd].rfind("-")
    return g_morph(dToken, sPattern, sNegPattern, 0, nEnd)


def apposition (sWord1, sWord2):
    "returns True if nom + nom (no agreement required)"
    return len(sWord2) < 2 or (cr.mbNomNotAdj(_oSpellChecker.getMorph(sWord2)) and cr.mbPpasNomNotAdj(_oSpellChecker.getMorph(sWord1)))

    [)]\b(?![s¹²³⁴⁵⁶⁷⁸⁹⁰]\b)
        <<- not before("\\((?:[rR][eéEÉ]|[qQ][uU]’|[nNmMtTsSdDlL]’)$") ->> ") "                               && Il manque un espace après la parenthèse.
__<s>/typo(typo_parenthèse_ouvrante_collée)__
    \b[(](?=[^)][^)][^)])
        <<- ->> " ("                                                                                && Il manque un espace avant la parenthèse.

TEST: C’est au fond du couloir{{(}}celui du deuxième étage{{)}}qu’il se trouve.     ->> " (|||) "
TEST: de gain différentiel 𝐴 (𝑉ᵣ = 𝐴·𝑣H{{)}}et associé                              ->> ") "
TEST: (a + b)²
TEST: il faut (re)former tout ça.
TEST: il (n’)est (qu’)ingénieur


# Points et espaces
__<s>/typo(typo_point_entre_deux_espaces)__      [  ][.](?=[  ])  <<- ->> .                         && Pas d’espace avant un point.

TEST: « Je suis donc perdu ? », dit Paul.
TEST: “C’est bon !”, croit savoir Marie.
TEST: “Parce que… ?” finit par demander Paul.
TEST: « Dans quel pays sommes-nous ? » demanda un manifestant.


!!!! Purge des références aux notes                                                               !!

# les références aux notes
__<s>(p_exposants)__
    [¹²³⁴⁵⁶⁷⁸⁹⁰]+
        <<- ~>> *

__[i](p_références_aux_notes)__
    ({w_2})(\d+)  @@0,$
        <<- not morph(\0, ":") and morph(\1, ":") ~2>> *

TEST: POLITIQUESOCIÉTÉÉCONOMIEMONDECULTUREART DE VIVREMAGAZINE (qui peut faire boguer JavaScript avec certaines regex)


!!!! Normalisation du “t” euphonique                                                              !!

__<i]/tu(tu_t_euphonique_incorrect)__
    ([-–—− ]t(?:[’' ][-–—−]?|[-–—−][’' ]?))(ie?ls?|elles?|on|tu)  @@0,$
        <<- re.search("(?i)^(?:ie?ls|elles|tu)$", \2) -1>> -    && Le “t” euphonique n’est pas nécessaire avec “\2”.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?T1=t+euphonique&id=2513
        <<- __else__ and \1 != "-t-" and \1 != "-T-" -1>> -t-   && Pour le “t” euphonique, il faut deux traits d’union. Pas d’apostrophe. Pas d’espace.
        <<- \1 != "-t-" ~1>> -t-
__<i]/tu(tu_t_euphonique_superflu)__
    [td]([- ]t[-’' ])(?:ie?l|elle|on)  @@1
        <<- -1>> -                                              && Le “t” euphonique est superflu quand le verbe se termine par “t” ou “d”.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?T1=t+euphonique&id=2513
        <<- \1 != "-t-" ~1>> -t-
__<i]/eleu(eleu_t_euphonique_manquant)__
    [aec](-(ie?l|elle|on))  @@1,2  <<- -1>> -t-\2               && Euphonie. Il faut un “t” euphonique.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?T1=t+euphonique&id=2513

TEST: va{{ t’}}il y parvenir ?                          ->> -t-
TEST: A{{ t’}}elle soif ?                               ->> -t-
TEST: A{{ t-}}elle faim ?                               ->> -t-
TEST: a{{ t'}}elle                                      ->> -t-
TEST: a{{-t'}}il                                        ->> -t-
TEST: a{{-t }}il.                                       ->> -t-
TEST: a{{ t’}}il.                                       ->> -t-
TEST: a{{ t-}}on.                                       ->> -t-
TEST: donne{{ t-}}il                                    ->> -t-
TEST: donne{{-t }}il                                    ->> -t-
TEST: vient{{-t-}}il                                    ->> -
TEST: viendras{{-t-}}tu                                 ->> -
TEST: Viendront{{ t-}}ils                               ->> -
TEST: viennent{{ t-}}ils                                ->> -
TEST: mangent{{-t-}}elles                               ->> -
TEST: Ont{{ t’}}ils                                     ->> -
TEST: Ont{{-t’}}ils                                     ->> -
TEST: l’ont{{ t’}}ils vu ?                              ->> -
TEST: exploite{{−t−}}il les ressources numériques       ->> -t-
TEST: vainc{{-il}} ses ennemis aisément                 ->> -t-il
TEST: Assis, gronde{{-t -}}elle                         ->> -t-
TEST: vient-il demain ?
TEST: prend-elle l’avantage ?
TEST: saura-t-on jamais la vérité ?
TEST: arrive-t-elle ce matin ?
TEST: y aura-t-il du poulet au dîner ?



!!
!!
!!
!!
!!

__[s]/num(num_lettre_O_zéro1)__  [\dO]+[O][\dO]+ <<- not option("ocr") ->> =\0.replace("O", "0")    && S’il s’agit d’un nombre, utilisez le chiffre « 0 » plutôt que la lettre « O ».
__[s]/num(num_lettre_O_zéro2)__  [1-9]O <<- not option("ocr") ->> =\0.replace("O", "0")             && S’il s’agit d’un nombre, utilisez le chiffre « 0 » plutôt que la lettre « O ».

TEST: année {{2O11}}                                                        ->> 2011
TEST: {{3O}} (chiffre avec un O).                                           ->> 30

















!!!! Traits d’union                                                                               !!

__[i]/tu(tu_trait_union_douteux)__
    ({w1})(?:--|—|–|−|⁃)({w1})  @@0,$
    <<- spell(\1+"-"+\2) and analyse(\1+"-"+\2, ":") ->> \1-\2                                      && Trait d’union : un tiret simple suffit.

TEST: Nous préparons une {{contre–attaque}}.                    ->> contre-attaque
TEST: Nous préparons une {{contre−attaque}}.                    ->> contre-attaque











































@@@@
@@@@
@@@@
@@@@
@@@@GRAPH: graphe0|g0                                                                              _

__purge_punc_début_phrase__
    <start>  [?|!|:|;|…|‘|’|'|¿|¡]
        <<- ~2>> *

    <start>  [-|–|—]  ?[-|–|—]¿
        <<- /2>> _tiret1_
        <<- ~2>> *

    <start>  [•|·|.]
        <<- /2>> _puce1_
        <<- ~2>> *


__purge_fin_phrase__
    [.|…|?|!|:|;|–|—|•|·|…|«|»|‘|’|“|”|"|'|¿|¡|-]  ?[.|…|?|!|:|;|–|—|•|·|…|«|»|‘|’|“|”|"|'|¿|¡|-]¿  ?[.|…|?|!|:|;|–|—|•|·|…|«|»|‘|’|“|”|"|'|¿|¡|-]¿  <end>
        <<- ~1:-2>> *


__purge_mot_nombre_parenthèses_crochets_accolades__
    (  [*WORD|*NUM]  )
    {  [*WORD|*NUM]  }
        <<- ~>> *

    ( … )
        <<- ->> […]                 && Pour indiquer une troncature de texte, on utilise usuellement des crochets.
        <<- />> _CUT_
        <<- ~>> *

    (  [re|ré]  )  *WORD
    [  [re|ré]  ]  *WORD
        <<- space(<1, 1) and space(\3, 0, 0) ~1:3>>  *

    [  *NUM  ]
        <<- ~>> *

    [  …  ]
        <<- />> _CUT_
        <<- ~>> *

    [  *WORD  ]
        <<- space(<1, 1, 3) and space(\-1, 1, 3) >>>
        <<- />> _CUT_
        <<- morph(\2, ":G") ~>> |\2|
        <<- __else__ ~>> *

    ## chapitres, références
    (  [*WORD|*NUM]  ,  *NUM  )
    [  [*WORD|*NUM]  ,  *NUM  ]
    {  [*WORD|*NUM]  ,  *NUM  }

    contre la montre
        <<- =>> select(\1, ":R")

    [la|les|des|une|cette|ma|ta|sa|notre|votre|leur+s] >lutte           ?$:A¬:G¿  contre
    [>accusation|>action|>assaut|>attaque|>attentat|>croisade|>guerre]  ?$:A¬:G¿  contre
    [>guerre|>jihad|offensive+s|>ratonnade|>sortilège|>violence]        ?$:A¬:G¿  contre
    [>antidote|>crime|>philtre|>remède|>sérum|>vaccin|>solution]        ?$:A¬:G¿  contre
    >mandat d’ arrêt                                                    ?$:A¬:G¿  contre
        <<- =>> select(\-1, ":R")

    contre
        <<- not morph(<1, ":[DA].*:[me]:[si]") =>> select(\1, "", ":N")

__da_courant__
    courant

__tag_ni__
    ni
        <<- />> _ni_



!!!! Fusions et immunités                                                                         !!


__locutions_prépositives__
    à [bord|bout|charge|cause|contre-courant|côté|défaut|destination|disposition|distance|droite]                       [de|du|d’|des]
    à [flanc|gauche|hauteur|mesure|mi-chemin|portée|proximité|propos|raison|rebours]                                    [de|du|d’|des]
    à [compter|partir]                                                                                                  [de|du|d’|des]
    à [base|concurrence|court|titre]                                                                                    [de|d’]
    à [bonne|faible|grande] distance                                                                                    [de|du|d’|des]
    à peu [de|d’] distance                                                                                              [de|du|d’|des]
    à l’ [abri|adresse|affût|affut|approche|arrière|attention|aune|aulne|avant]                                         [de|du|d’|des]
    à l’ [écart|égal|égard|encontre|endroit|entour|épreuve|est|exception|exclusion|exemple|extérieur]                   [de|du|d’|des]
    à l’ [imitation|insu|instar|instigation|intension|intérieur|inverse|issue|occasion|ombre|opposé|orée|ouest|unisson] [de|du|d’|des]
    à l’ autre bout                                                                                                     [de|du|d’|des]
    à la [barbe|différence|faveur|hauteur|lumière|manière|merci|portée|proximité|recherche|suite|tête|vue]              [de|du|d’|des]
    à la grande surprise                                                                                                [de|du|d’|des]
    à [quelques|plusieurs] [mètres|kilomètres|lieues|pas|minutes|heures]                                                [de|du|d’|des]
    à [quelques|plusieurs] [dizaines|centaines|milliers] [de|d’] [mètres|kilomètres]                                    [de|du|d’|des]
    à [base|force|raison]                                                                                               [de|d’]
    à grand renfort                                                                                                     [de|d’]
    à grands coups                                                                                                      [de|d’]
    au [bénéfice|bord|bout|chevet|contraire|courant|côté|cours|début|détour|détriment|fil|fond|gré|hasard|large|lieu]   [de|du|d’|des]
    au [long|mépris|moyen|nord|préjudice|profit|ras|rebours|regard|sein|secours|sommet|sud|sujet|travers|voisinage|vu]  [de|du|d’|des]
    ?d’¿ au ?beau¿ milieu                                                                                               [de|du|d’|des]
    au fin fond                                                                                                         [de|du|d’|des]
    au grand [dam|désespoir]                                                                                            [de|du|d’|des]
    au plus [près|profond]                                                                                              [de|du|d’|des]
    au fur et à mesure                                                                                                  [de|du|d’|des]
    au lieu et place                                                                                                    [de|du|d’|des]
    au vu et ?au¿ su                                                                                                    [de|du|d’|des]
    au nez et à la barbe                                                                                                [de|du|d’|des]
    au secours                                                                                                          [de|du|d’|des]
    au sortir                                                                                                           [de|du|d’|des]
    aux [abords|côtés|dépens]                                                                                           [de|du|d’|des]
    aux [dizaines|douzaines|vingtaines|centaines|milliers|millions|milliards|trillions|trilliards]                      [de|d’]
    aux [dizaines|douzaines|vingtaines|centaines|milliers|millions|milliards|trillions|trilliards]
        || [de|d’] [milliers|millions|milliards|trillions|trilliards]                                                   [de|d’]
    aux bons soins                                                                                                      [de|du|d’|des]
    aux lieu et place                                                                                                   [de|du|d’|des]
    compte tenu                                                                                                         [de|du|d’|des]
    d’ un bout à l’ autre                                                                                               [de|du|d’|des]
    dans l’ [attente|éventualité]                                                                                       [de|du|d’|des]
    dans la ligne de mire                                                                                               [de|du|d’|des]
    dans le sillage                                                                                                     [de|du|d’|des]
    des [quatre|4] coins                                                                                                [de|du|d’|des]
    en [arrière|attente|amont|arrière|aval|avant|bas|cas|conséquence|considération|cours|deçà|dehors|dépit|direction|face|faveur|fonction|haut|marge]  [de|du|d’|des]
    en [mémoire|possession|présence|pproportion|provenance|quête|raison|surplomb|sus|tête|termes|travers|vertu|vue]     [de|du|d’|des]
    en [ma|ta|sa|notre|votre|leur] qualité                                                                              [de|d’]
    en dépit de la proximité                                                                                            [de|du|d’|des]
    en [comparaison|forme|guise|matière|qualité|signe]                                                                  [de|d’]
    en flagrant délit                                                                                                   [de|d’]
    en [hommage|proie|réaction]                                                                                         [à|au|aux]
    en l’ [absence|attente|honneur]                                                                                     [de|du|d’|des]
    en lieu et place                                                                                                    [de|du|d’|des]
    en plein milieu                                                                                                     [de|du|d’|des]
    le long                                                                                                             [de|du|d’|des]
    jusqu’ à concurrence                                                                                                [de|d’]
    par égard                                                                                                           pour
    par le biais                                                                                                        [de|du|d’|des]
    par l’ [entremise|intermédiaire]                                                                                    [de|du|d’|des]
    par [manière|manque]                                                                                                [de|d’]
    par [crainte|habitude|suite]                                                                                        [de|du|d’|des]
    pour le compte                                                                                                      [de|du|d’|des]
    sans distinction                                                                                                    [de|d’]
    sans parler                                                                                                         [de|du|d’|des]
    sous l’ aile                                                                                                        [de|du|d’|des]
    sous l’ œil attentif                                                                                                [de|du|d’|des]
    sous la [coupe|houlette]                                                                                            [de|du|d’|des]
    sous le [coup|couvert|nez]                                                                                          [de|du|d’|des]
    sous [couleur|couvert|forme]                                                                                        [de|d’]
    sur les talons                                                                                                      [de|du|d’|des]
        <<- &>> :LR

    à travers $:D
    à travers >différent
        <<- =>> define(\2, ">travers/:ÉR")
        <<- &1:2>> :LR


__fusions_mots_grammaticaux__
    c’ est-à-dire
        <<- ~>> ␣
        <<- =>> setmeta(\1, "WORD")

    le ou la  *WORD

        <<- morph(\1, ":V") !-2>>

    soit pour soit contre
        <<- !3>>

    y [a|avait|eut|aura|aurait|eût] ?@:[WX]¿ faute
        <<- !-1>>



!!!
!!!
!!! Locutions                                                                                     !!
!!!
!!!

__locutions_siècles_millénaires__
    à [compter|partir] du       [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    à [compter|partir] du       ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    ?jusqu’¿ à l’ orée du       [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    ?jusqu’¿ à l’ orée du       ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    ?jusqu’¿ au                 [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    ?jusqu’¿ au                 ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    [avant|après] le            [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    [avant|après] le            ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    au cours du                 [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    au cours du                 ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    dans le                     [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    dans le                     ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    dans le courant du          [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    dans le courant du          ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    [dès|depuis] le             [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    [dès|depuis] le             ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    du                          [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    du                          ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
    par rapport à l’            [Ier|Iᵉʳ|IId|Ind|IIᵈ|IIⁿᵈ] [siècle|millénaire]
    par rapport à l’            ~^[xXvViI]+(?:[eᵉ]|i?[èe]me)$ [siècle|millénaire]
        <<- &>> :LW;T

    ?d’¿ av ?.¿ J.-C.
    ?d’¿ avant J.-C.
    ?d’¿ avant Jésus-Christ
    ?d’¿ avant notre ère ?[industrielle|technologique]¿
        <<- &>> :LW;T

    au cours de notre ère ?[industrielle|technologique]¿
        <<- &>> :LW;T

__locutions_années__
    à [compter|partir] [de|d’] l’   an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    à [compter|partir] [de|d’] l’   année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    à [compter|partir] des          années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    ?jusqu’¿ à l’ orée de l’        an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ à l’ orée de l’        année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    ?jusqu’¿ à l’ orée des          années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    ?jusqu’¿ à l’                   an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ à l’                   année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    ?jusqu’¿ aux                    années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    [avant|après] l’                an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] l’                année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    [avant|après] les               années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    au cours [de|d’] l’             an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    au cours [de|d’] l’             année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    au cours des                    années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    dans l’                         an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    dans l’                         année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    dans les                        années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    dans le courant de l’           an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    dans le courant de l’           année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    dans le courant des             années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    [dès|depuis|de|d’] l’           an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dès|depuis|de|d’] l’           année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    [dès|depuis] [les|ces]          années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    par rapport à l’                an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport à l’                année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    par rapport aux                 années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
        <<- &>> :LW;T

    à [compter|partir] du           [début|milieu] de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    à [compter|partir] du           [début|milieu] de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    à [compter|partir] du           [début|milieu] des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    ?jusqu’¿ au                     [début|milieu] de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ au                     [début|milieu] de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    ?jusqu’¿ au                     [début|milieu] des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    [avant|après] le                [début|milieu] de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] le                [début|milieu] de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    [avant|après] le                [début|milieu] des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    [dans|dès|depuis] le            [début|milieu] de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dans|dès|depuis] le            [début|milieu] de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    [dans|dès|depuis] le            [début|milieu] des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    par rapport au                  [début|milieu] de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au                  [début|milieu] de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    par rapport au                  [début|milieu] des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
        <<- &>> :LW;T

    à [compter|partir] [de|d’] la   fin de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    à [compter|partir] [de|d’] la   fin de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    à [compter|partir] [de|d’] la   fin des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    ?jusqu’¿ à la                   fin de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ à la                   fin de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    ?jusqu’¿ à la                   fin des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    [avant|après] la                fin de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] la                fin de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    [avant|après] la                fin des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    [dans|dès|depuis|de|d’] la      fin de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dans|dès|depuis|de|d’] la      fin de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    [dans|dès|depuis|de|d’] la      fin des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
    par rapport à la                fin de l’ an ?[dernier|nouveau|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport à la                fin de l’ année ?[dernière|nouvelle|passée|précédente|prochaine|~^[0-9]{2,5}$]¿
    par rapport à la                fin des années [dernières|passées|précédentes|prochaines|~^[0-9]{2,5}$]
        <<- &>> :LW;T

    à [compter|partir] [de|d’]  ~^[0-9]{2,5}$
    [avant|après]               ~^[0-9]{2,5}$
    [dès|depuis]                ~^[0-9]{2,5}$
    jusqu’ à                    ~^[0-9]{2,5}$
    par rapport à               ~^[0-9]{2,5}$
        <<- not morph(>1, ":N.*:p|;S") &>> :LW;T

    en  ~^[0-9]{2,5}$  [,|<end>|)]
    en  ~^[0-9]{2,5}$  @:¬:[AN].*:[pi]
    de  ~^[0-9]{2,5}$  @:A.*:s
        <<- &1:2>> :LW;T

    en  l’  an  ~^[0-9]{2,5}$
    en  l’  an  de  grâce  ~^[0-9]{2,5}$
        <<- &>> :LW;T

    [de|d’] [plusieurs|quelques|$:B|*NUM] [ans|années|mois] [mon|ton|son|notre|votre|leur] [cadet|aîné+e]
    [de|d’] [plusieurs|quelques|$:B|*NUM] [ans|années|mois] [ma|ta|sa|notre|votre|leur] cadette
        <<- &>> :LW;T


__locutions_saisons__
    à [compter|partir] [de|d’]  l’ [automne|été|hiver]
    [à|dès|depuis|de|d’]        l’ [automne|été|hiver]
    à l’ orée [de|d’]           l’ [automne|été|hiver]
    au cours [de|d’]            l’ [automne|été|hiver]
    [avant|après]               l’ [automne|été|hiver]
    dans le courant [de|d’]     l’ [automne|été|hiver]
    jusqu’ à                    l’ [automne|été|hiver]
    par rapport à               l’ [automne|été|hiver]
    à [compter|partir] du       printemps
    [au|du]                     printemps
    à l’ orée du                printemps
    au cours du                 printemps
    [avant|après] le            printemps
    dans le courant du          printemps
    jusqu’ au                   printemps
    par rapport au              printemps
        <<- not morph(>1, ":A.*:[me]:[si]") &>> :LW;T

    à [compter|partir] [de|d’]  l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [à|dès|depuis|de|d’]        l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à l’ orée [de|d’]           l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    au cours [de|d’]            l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [avant|après]               l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    dans le courant [de|d’]     l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    jusqu’ à                    l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    par rapport à               l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à [compter|partir] du       printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [au|du]                     printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à l’ orée du                printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    au cours du                 printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [avant|après] le            printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    dans le courant du          printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    jusqu’ au                   printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    par rapport au              printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
        <<- &>> :LW;T

    à [compter|partir] du       [début|milieu] [de|d’] l’ [automne|été|hiver]
    [au|du]                     [début|milieu] [de|d’] l’ [automne|été|hiver]
    à l’ orée du                [début|milieu] [de|d’] l’ [automne|été|hiver]
    au cours du                 [début|milieu] [de|d’] l’ [automne|été|hiver]
    [avant|après] le            [début|milieu] [de|d’] l’ [automne|été|hiver]
    jusqu’ au                   [début|milieu] [de|d’] l’ [automne|été|hiver]
    par rapport au              [début|milieu] [de|d’] l’ [automne|été|hiver]
    à [compter|partir] du       [début|milieu] du printemps
    [au|du]                     [début|milieu] du printemps
    à l’ orée du                [début|milieu] du printemps
    au cours du                 [début|milieu] du printemps
    [avant|après] le            [début|milieu] du printemps
    jusqu’ au                   [début|milieu] du printemps
    par rapport au              [début|milieu] du printemps
        <<- not morph(>1, ":A.*:[me]:[si]") &>> :LW;T

    à [compter|partir] du       [début|milieu] [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [au|du]                     [début|milieu] [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à l’ orée du                [début|milieu] [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    au cours du                 [début|milieu] [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [avant|après] le            [début|milieu] [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    jusqu’ au                   [début|milieu] [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    par rapport au              [début|milieu] [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à [compter|partir] du       [début|milieu] du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [au|du]                     [début|milieu] du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à l’ orée du                [début|milieu] du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    au cours du                 [début|milieu] du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [avant|après] le            [début|milieu] du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    jusqu’ au                   [début|milieu] du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    par rapport au              [début|milieu] du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
        <<- &>> :LW;T

    à [compter|partir] [de|d’]  la fin [de|d’] l’ [automne|été|hiver]
    [à|dès|depuis|de|d’]        la fin [de|d’] l’ [automne|été|hiver]
    à l’ orée [de|d’]           la fin [de|d’] l’ [automne|été|hiver]
    au cours [de|d’]            la fin [de|d’] l’ [automne|été|hiver]
    [avant|après]               la fin [de|d’] l’ [automne|été|hiver]
    jusqu’ à                    la fin [de|d’] l’ [automne|été|hiver]
    par rapport à               la fin [de|d’] l’ [automne|été|hiver]
    à [compter|partir] [de|d’]  la fin du printemps
    [à|dès|depuis|de|d’]        la fin du printemps
    à l’ orée [de|d’]           la fin du printemps
    au cours [de|d’]            la fin du printemps
    [avant|après]               la fin du printemps
    jusqu’ à                    la fin du printemps
    par rapport à               la fin du printemps
        <<- not morph(>1, ":A.*:[me]:[si]") &>> :LW;T

    à [compter|partir] [de|d’]  la fin [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [à|dès|depuis|de|d’]        la fin [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à l’ orée [de|d’]           la fin [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    au cours [de|d’]            la fin [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [avant|après]               la fin [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    jusqu’ à                    la fin [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    par rapport à               la fin [de|d’] l’ [automne|été|hiver]  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à [compter|partir] [de|d’]  la fin du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [à|dès|depuis|de|d’]        la fin du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    à l’ orée [de|d’]           la fin du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    au cours [de|d’]            la fin du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    [avant|après]               la fin du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    jusqu’ à                    la fin du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
    par rapport à               la fin du printemps  [dernier|passé|précédent|prochain|~^[0-9]{2,5}$]
        <<- &>> :LW;T

    par un [beau|chaud|frais|froid] [matin|soir|lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche] [de|d’] l’ [été|automne|hiver] ~^[0-9]{2,5}$
    par un [beau|chaud|frais|froid] [matin|soir|lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche] [de|d’] l’ [été|automne|hiver] de l’ [an|année] ~^[0-9]{2,5}$
    par un [beau|chaud|frais|froid] [matin|soir|lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche] du printemps ~^[0-9]{2,5}$
    par un [beau|chaud|frais|froid] [matin|soir|lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche] du printemps de l’ [an|année] ~^[0-9]{2,5}$
    par un [beau|chaud|frais|froid] [matin|soir|lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche] d’ [été|automne|hiver] ?~^[0-9]{2,5}$¿
    par un [beau|chaud|frais|froid] [matin|soir|lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche] [de|d’] printemps ?~^[0-9]{2,5}$¿
    par un [bel|chaud|frais|froid] après-midi [de|d’] l’ [été|automne|hiver] ~^[0-9]{2,5}$
    par un [bel|chaud|frais|froid] après-midi [de|d’] l’ [été|automne|hiver] de l’ [an|année] ~^[0-9]{2,5}$
    par un [bel|chaud|frais|froid] après-midi du printemps ~^[0-9]{2,5}$
    par un [bel|chaud|frais|froid] après-midi du printemps de l’ [an|année] ~^[0-9]{2,5}$
    par un [bel|chaud|frais|froid] après-midi d’ [été|automne|hiver] ?~^[0-9]{2,5}$¿
    par un [bel|chaud|frais|froid] après-midi [de|d’] printemps ?~^[0-9]{2,5}$¿
    par une [belle|chaude|fraîche|froide] [journée|matinée|nuit|soirée] [de|d’] l’ [été|automne|hiver] ~^[0-9]{2,5}$
    par une [belle|chaude|fraîche|froide] [journée|matinée|nuit|soirée] [de|d’] l’ [été|automne|hiver] de l’ [an|année] ~^[0-9]{2,5}$
    par une [belle|chaude|fraîche|froide] [journée|matinée|nuit|soirée] du printemps ~^[0-9]{2,5}$
    par une [belle|chaude|fraîche|froide] [journée|matinée|nuit|soirée] du printemps de l’ [an|année] ~^[0-9]{2,5}$
    par une [belle|chaude|fraîche|froide] [journée|matinée|nuit|soirée] d’ [été|automne|hiver] ?~^[0-9]{2,5}$¿
    par une [belle|chaude|fraîche|froide] [journée|matinée|nuit|soirée] [de|d’] printemps ?~^[0-9]{2,5}$¿
        <<- &>> :LW;T

    au cours [de|d’] l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿ et ?[de|d’]¿ l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿
    au cours [de|d’] l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿ et du printemps ?~^[0-9]{2,5}$¿
    au cours du printemps ?~^[0-9]{2,5}$¿ et ?[de|d’]¿ l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿
    entre ?[le|l’]¿ [printemps|été|automne|hiver] ?~^[0-9]{2,5}$¿ et ?[le|l’]¿ [printemps|été|automne|hiver] ?~^[0-9]{2,5}$¿
    du printemps ?~^[0-9]{2,5}$¿ au printemps ?~^[0-9]{2,5}$¿
    du printemps ?~^[0-9]{2,5}$¿ à l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿
    de l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿ au printemps ?~^[0-9]{2,5}$¿
    de l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿ à l’ [été|automne|hiver] ?~^[0-9]{2,5}$¿
        <<- &>> :LW;T


__locutions_semestre_trimestre__
    à [compter|partir] du   ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [au|du]                 ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    à l’ orée du            ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    au cours du             ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après]           ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    depuis le               ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    jusqu’ au               ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au          ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    à [compter|partir] du   [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [au|du]                 [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    à l’ orée du            [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    au cours du             [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après]           [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    depuis le               [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    jusqu’ au               [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au          [début|milieu] du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    à [compter|partir] de   la fin du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [à|dès|depuis|de|d’]    la fin du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    à l’ orée [de|d’]       la fin du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    au cours [de|d’]        la fin du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après]           la fin du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    jusqu’ à                la fin du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport à           la fin du ?[premier|deuxième|troisième|quatrième]¿ [semestre|trimestre]  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T


__locutions_dates_mois__
    à [compter|partir] du   [1er|1ᵉʳ|~^\d\d?$]  {_mois_}    ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dès|depuis] le         [1er|1ᵉʳ|~^\d\d?$]  {_mois_}    ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [le|du]                 [1er|1ᵉʳ|~^\d\d?$]  {_mois_}    ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] le        [1er|1ᵉʳ|~^\d\d?$]  {_mois_}    ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ au             [1er|1ᵉʳ|~^\d\d?$]  {_mois_}    ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au          [1er|1ᵉʳ|~^\d\d?$]  {_mois_}    ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    [les|des]               [1er|1ᵉʳ|~^\d\d?$] et ~^\d\d?$ {_mois_}    ?[derniers|passés|précédents|prochains|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    dans la nuit du         [1er|1ᵉʳ|~^\d\d?$]  {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    dans la nuit du         [1er|1ᵉʳ|~^\d\d?$]  ?{_mois_}¿ au  [1er|1ᵉʳ|~^\d\d?$]  {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    au cours         [de|d’]    {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    au cours du mois [de|d’]    {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    à l’ orée du mois [de|d’]   {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    à [compter|partir] [de|d’]  {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ [en|à]             {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après]               {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dès|depuis|de|d’]          {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au              {_mois_}  ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    ?[à|avant|après|de|d’|depuis]¿ [début|milieu|fin] {_mois_} ?~^[0-9]{2,5}$¿
        <<- not morph(<1, ":D") &>> :LW;T

    à [compter|partir]          [début|milieu|fin] {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ [en|à]             [début|milieu|fin] {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dès|depuis|de|d’]          [début|milieu|fin] {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport à               [début|milieu|fin] {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    ?jusqu’¿ au         [début|milieu]                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ au         [début|milieu] [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ au         [début|milieu] du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] le    [début|milieu]                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] le    [début|milieu] [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] le    [début|milieu] du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dès|depuis] le     [début|milieu]                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dès|depuis] le     [début|milieu] [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [dès|depuis] le     [début|milieu] du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    du                  [début|milieu]                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    du                  [début|milieu] [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    du                  [début|milieu] du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au      [début|milieu]                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au      [début|milieu] [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport au      [début|milieu] du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    ?jusqu’¿ à la           fin                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ à la           fin [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    ?jusqu’¿ à la           fin du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] la        fin                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] la        fin [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [avant|après] la        fin du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [de|d’|dès|depuis] la   fin                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [de|d’|dès|depuis] la   fin [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    [de|d’|dès|depuis] la   fin du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport à la        fin                   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport à la        fin [de|d’]           {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
    par rapport à la        fin du mois [de|d’]   {_mois_} ?[dernier|passé|précédent|prochain|~^[0-9]{2,5}$]¿
        <<- &>> :LW;T

    en ce début     {_mois_} ?~^[0-9]{2,5}$¿
    [à|en] la fin   {_mois_} ?~^[0-9]{2,5}$¿
        <<- &>> :LW;T

    [début|fin] {_mois_} ~^[0-9]{2,5}$
        <<- not morph(<1, ":D") &>> :LW;T

    entre {_mois_} ?~^[0-9]{2,5}$¿ et {_mois_} ?~^[0-9]{2,5}$¿
        <<- &>> :LW;T

    ?jusqu’¿ à                      la {_mi_mois_} ?~^[0-9]{2,5}$¿
    [après|avant|dès|depuis|de|d’]  la {_mi_mois_} ?~^[0-9]{2,5}$¿
    par rapport à                   la {_mi_mois_} ?~^[0-9]{2,5}$¿
        <<- &>> :LW;T


__locutions_horaires_et_durée__
    24      [heures|h]      [sur|/]  24
    7       [jours|j]       [sur|/]  7
    sept    [jours|j]       [sur|/]  sept
    vingt-quatre  heures    [sur|/]  vingt-quatre
        <<- &>> :LW;T

    ?jusqu’¿ à                   *NUM  h
    à [partir|compter] de        *NUM  h
    [avant|après|de|dès|depuis]  *NUM  h
    ?jusqu’¿ à                   [1|01]  heure
    à [partir|compter] de        [1|01]  heure
    [avant|après|de|dès|depuis]  [1|01]  heure
    ?jusqu’¿ à                   *HOUR
    à [partir|compter] de        *HOUR
    [avant|après|de|dès|depuis]  *HOUR
    ?jusqu’¿ à                   une        heure
    à [partir|compter] de        une        heure
    [avant|après|de|dès|depuis]  une        heure
    ?jusqu’¿ à                   @:B:.:p    heures
    à [partir|compter] de        @:B:.:p    heures
    [avant|après|de|dès|depuis]  @:B:.:p    heures
        <<- &>> :LW;T

    ?jusqu’¿ à                   *NUM  heures
    à [partir|compter] de        *NUM  heures
    [avant|après|de|dès|depuis]  *NUM  heures
        <<- \-2.isdigit() and \-2 != "1" and \-2 != "01" &>> :LW;T

    ?jusqu’¿ à                   [midi|minuit]
    à [partir|compter] de        [midi|minuit]
    [avant|après|de|dès|depuis]  [midi|minuit]
        <<- &>> :LW;T

    [avant|après|dès|depuis] la nuit tombée
    [avant|après|dès|depuis] la tombée de la nuit
    [avant|après|dès|depuis] le jour levé
    [avant|après|dès|depuis] le lever [de|du] soleil
    [avant|après|dès|depuis] le lever du jour
    [avant|après|dès|depuis] l’ aube
    [avant|après|dès|depuis] le crépuscule
        <<- &>> :LW;T

    dans la [matinée|nuit|soirée] de [lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche] à [lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche]
        <<- &>> :LW;T

    dès le premier [jour|soir]
    dès la première [matinée|nuit]
        <<- &>> :LW;T

    à la fin de [la|l’]             [après-midi|matinée|nuit|soirée]
    au [début|milieu] de [la|l’]    [après-midi|matinée|nuit|soirée]
    en [début|milieu|fin] [de|d’]   [après-midi|matinée|soirée]
        <<- &>> :LW;T

    ## purge de queue
    ~^\d\d?$  h  ?~^\d\d?$¿  ?[tapantes|pétantes|pile]¿
    ~^\d\d?$  h  ?~^\d\d?$¿  ?[tapantes|pétantes|pile]¿   [du|ce]  [matin|soir]
    ~^\d\d?$  h  ?~^\d\d?$¿  ?[tapantes|pétantes|pile]¿   de  l’ après-midi
    ~^\d\d?$  h  ?~^\d\d?$¿  ?[tapantes|pétantes|pile]¿   cet  après-midi
    ~^\d\d?$  h  ?~^\d\d?$¿  ?[tapantes|pétantes|pile]¿   [demain|hier|après-demain|avant-hier]  ?[matin|soir|après-midi]¿
        <<- ~3:0>> *

    *HOUR  ?[tapantes|pétantes|pile]¿
    *HOUR  ?[tapantes|pétantes|pile]¿  [du|ce]  [matin|soir]
    *HOUR  ?[tapantes|pétantes|pile]¿  de  l’ après-midi
    *HOUR  ?[tapantes|pétantes|pile]¿  cet  après-midi
    *HOUR  ?[tapantes|pétantes|pile]¿  [demain|hier|après-demain|avant-hier]  ?[matin|soir|après-midi]¿
    >heure moins le quart
    >heure et [demie|quart]
    >heure ?,¿ @:B:.:p minutes
    >heure ?,¿ @:B:.:p minutes ?,¿ @:B:.:p secondes
    [midi|minuit] pile
    [midi|minuit] moins le quart
    [midi|minuit] et [demie|quart]
        <<- ~2:0>> *

    à cette heure ?[tardive|indue|matinale]¿
    à cette heure de la [journée|nuit]
    à cette heure du jour
    à l’ heure actuelle
    à l’ heure qu’ il est
    à la nuit [tombée|tombante]
    à n’importe quelle heure du jour et de la nuit
    à toute heure
    à toute heure de la nuit
    à toute heure de la nuit et du jour
    à toute heure du jour
    à toute heure du jour et de la nuit
    à une heure ?[aussi|très|trop]¿ [décente|indue|tardive]
    au jour et à l’ heure dits
    au cours de la [dernière|précédente|prochaine] [seconde|minute|heure]
    au cours de l’ heure ?[dernière|passée|précédente|prochaine]¿
    au cours de la [seconde|minute] ?[dernière|passée|précédente|prochaine]¿
    au cours [de|d’] la nuit
    [de|d’] ?[assez|si|très|trop]¿ bonne heure
    [de|d’] tout à l’ heure
    dès la première heure
    l’ heure venue
    jusqu’ à pas d’ heure
    sur l’ heure
    tout à l’ heure
    ?[de|d’]¿ trois quarts d’ heure plus [tôt|tard]
    ?[de|d’]¿ trois quarts d’ heure auparavant
    ?d’¿ un quart d’ heure plus [tôt|tard]
    ?d’¿ un quart d’ heure auparavant
    ?d’¿ une fraction [de|d’] seconde auparavant
    ?d’¿ une fraction [de|d’] seconde plus [tard|tôt]
    vers [midi|minuit]
        <<- &>> :LW;T

DEF: unit_mesure_sing_mas   [jour|mois|trimestre|semestre|an|siècle|millénaire]
DEF: unit_mesure_sing_fem   [nanoseconde|milliseconde|seconde|minute|heure|journée|semaine|année|décennie]
DEF: unit_mesure_plur       [nanosecondes|millisecondes|secondes|minutes|heures|jours|journées|semaines|mois|trimestres|semestres|ans|années|décennies|siècles|millénaires]
DEF: unit_mesure_plur_mas   [jours|mois|trimestres|semestres|ans|siècles|millénaires]
DEF: unit_mesure_plur_fem   [nanosecondes|millisecondes|secondes|minutes|heures|journées|semaines|années|décennies]


__locutions_temporelles_communes__
    d’ un [jour|mois|trinestre|semestre|an|siècle|millénaire] à l’ autre
    d’ une [nanoseconde|milliseconde|seconde|minute|seconde|heure|journée|semaine|année|décennie] à l’ autre
    [de|d’] dernière [seconde|minute|heure|année]
        <<- &>> :LW;T

    [*NUM|$:B]  {unit_mesure_plur}      [plus|moins]  [>ancien|>jeune|>récent|>vieux]  <>  [que|qu’]
    un          {unit_mesure_sing_mas}  [plus|moins]  [>ancien|>jeune|>récent|>vieux]  <>  [que|qu’]
    une         {unit_mesure_sing_fem}  [plus|moins]  [>ancien|>jeune|>récent|>vieux]  <>  [que|qu’]
        <<- &1:3>> :LW;T

    ## locutions au singulier
    au bout d’ un                                   {unit_mesure_sing_mas}
    après un                                        {unit_mesure_sing_mas}
    depuis un                                       {unit_mesure_sing_mas}
    en un                                           {unit_mesure_sing_mas}
    pendant un                                      {unit_mesure_sing_mas}
        <<- not morph(>1, ":A.*:[me]:[pi]") &>> :LW;T

    au bout d’ une                                  {unit_mesure_sing_fem}
    après une                                       {unit_mesure_sing_fem}
    depuis une                                      {unit_mesure_sing_fem}
    en une                                          {unit_mesure_sing_fem}
    pendant une                                     {unit_mesure_sing_fem}
        <<- not morph(>1, ":A.*:[fe]:[pi]") and not (value(\-1, "|année|") and re.search("^[0-9]+$", >1)) &>> :LW;T

    à un                                            {unit_mesure_sing_mas} près
    à une                                           {unit_mesure_sing_fem} près
    après un                                        {unit_mesure_sing_mas} de bons et loyaux services
    après une                                       {unit_mesure_sing_fem} de bons et loyaux services
    après près [de|d’] un                           {unit_mesure_sing_mas}
    après près [de|d’] un                           {unit_mesure_sing_mas} de bons et loyaux services
    après près [de|d’] une                          {unit_mesure_sing_fem}
    après près [de|d’] une                          {unit_mesure_sing_fem} de bons et loyaux services
    au fil du                                       {unit_mesure_sing_mas} à venir
    au fil de la                                    {unit_mesure_sing_fem} à venir
    au fil de l’                                    [an|année|heure] à venir
    dans le                                         {unit_mesure_sing_mas} à venir
    dans la                                         {unit_mesure_sing_fem} à venir
    dans l’                                         [an|année|heure] à venir
    depuis près [de|d’] un                          {unit_mesure_sing_mas}
    depuis près [de|d’] une                         {unit_mesure_sing_fem}
    d’ ici un                                       {unit_mesure_sing_mas}
    d’ ici une                                      {unit_mesure_sing_fem}
    ?d’¿ il y a un                                  {unit_mesure_sing_mas}
    ?d’¿ il y a une                                 {unit_mesure_sing_fem}
    ?d’¿ il y a [moins|plus] [de|d’] un             {unit_mesure_sing_mas}
    ?d’¿ il y a [moins|plus] [de|d’] une            {unit_mesure_sing_fem}
    pendant près d’ un                              {unit_mesure_sing_mas}
    pendant près d’ une                             {unit_mesure_sing_fem}
    un                                              {unit_mesure_sing_mas} [après|avant|auparavant]
    une                                             {unit_mesure_sing_fem} [après|avant|auparavant]
    un                                              {unit_mesure_sing_mas} plus [tard|tôt]
    une                                             {unit_mesure_sing_fem} plus [tard|tôt]
    un peu [moins|plus] d’un                        {unit_mesure_sing_mas} auparavant
    un peu [moins|plus] d’une                       {unit_mesure_sing_fem} auparavant
        <<- &>> :LW;T

    au cours de l’          an                        [dernier|passé|précédent|prochain|suivant]
    au cours de l’          [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    au cours du             {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    au cours de la          {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    au fil de l’            an                        [dernier|passé|précédent|prochain|suivant]
    au fil de l’            [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    au fil du               {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    au fil de la            {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    dans l’                 an                        [dernier|passé|précédent|prochain|suivant]
    dans l’                 [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    dans le                 {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    dans la                 {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    dans le courant de l’   an                        [dernier|passé|précédent|prochain|suivant]
    dans le courant de l’   [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    dans le courant du      {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    dans le courant de la   {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    depuis l’               an                        [dernier|passé|précédent|prochain|suivant]
    depuis l’               [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    depuis le               {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    depuis la               {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    de l’                   an                        [dernier|passé|précédent|prochain|suivant]
    de l’                   [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    du                      {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    de la                   {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    par rapport à l’        an                        [dernier|passé|précédent|prochain|suivant]
    par rapport à l’        [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    par rapport au          {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    par rapport à la        {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    pendant l’              an                        [dernier|passé|précédent|prochain|suivant]
    pendant l’              [heure|année]             [dernière|passée|précédente|prochaine|suivante]
    pendant le              {unit_mesure_sing_mas}    [dernier|passé|précédent|prochain|suivant]
    pendant la              {unit_mesure_sing_fem}    [dernière|passée|précédente|prochaine|suivante]
    au cours du             [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    au cours de la          [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    au fil du               [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    au fil de la            [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    dans le                 [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    dans la                 [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    dans le courant du      [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    dans le courant de la   [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    depuis le               [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    depuis la               [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    du                      [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    de la                   [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    par rapport au          [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    par rapport à la        [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    pendant le              [dernier|précédent|prochain]        {unit_mesure_sing_mas}
    pendant la              [dernière|précédente|prochaine]     {unit_mesure_sing_fem}
    depuis un               ?[assez|si|très|trop]¿ long     {unit_mesure_sing_mas}
    depuis une              ?[assez|si|très|trop]¿ longue   {unit_mesure_sing_fem}
    pendant un  ?[long]¿    {unit_mesure_sing_mas}
    pendant une ?[longue]¿  {unit_mesure_sing_fem}
        <<- &>> :LW;T

    ## locutions plurielles
    au bout de [nombreux|plusieurs|quelques]        {unit_mesure_plur_mas}
    après [des|plusieurs|quelques|*NUM|@:B:.:p]     {unit_mesure_plur_mas}
    après près [de|d’] [*NUM|@:B:.:p]               {unit_mesure_plur_mas}
    depuis @:B:.:p                                  {unit_mesure_plur_mas}
    depuis *NUM                                     {unit_mesure_plur_mas}
    depuis près [de|d’] @:B:.:p                     {unit_mesure_plur_mas}
    depuis près [de|d’] *NUM                        {unit_mesure_plur_mas}
    depuis quelques                                 {unit_mesure_plur_mas}
    en *NUM                                         {unit_mesure_plur_mas}
    pendant [des|plusieurs|quelques|*NUM|@:B:.:p]   {unit_mesure_plur_mas}
    pendant près [de|d’] [*NUM|@:B:.:p]             {unit_mesure_plur_mas}
    un ou deux                                      {unit_mesure_plur_mas} plus [tôt|tard]
        <<- not morph(>1, ":A.*:[me]:[pi]") &>> :LW;T

    au bout de [nombreuses|plusieurs|quelques]      {unit_mesure_plur_fem}
    après [des|plusieurs|quelques|*NUM|@:B:.:p]     {unit_mesure_plur_fem}
    après près [de|d’] [*NUM|@:B:.:p]               {unit_mesure_plur_fem}
    depuis @:B:.:p                                  {unit_mesure_plur_fem}
    depuis *NUM                                     {unit_mesure_plur_fem}
    depuis près [de|d’] @:B:.:p                     {unit_mesure_plur_fem}
    depuis près [de|d’] *NUM                        {unit_mesure_plur_fem}
    depuis quelques                                 {unit_mesure_plur_fem}
    en *NUM                                         {unit_mesure_plur_fem}
    pendant [des|plusieurs|quelques|*NUM|@:B:.:p]   {unit_mesure_plur_fem}
    pendant près [de|d’] [*NUM|@:B:.:p]             {unit_mesure_plur_fem}
    une ou deux                                     {unit_mesure_plur_fem} plus [tôt|tard]
        <<- not morph(>1, ":A.*:[fe]:[pi]") &>> :LW;T

    @:B:.:p                                         {unit_mesure_plur} auparavant
    @:B:.:p                                         {unit_mesure_plur} plus [tôt|tard]
    @:B:.:p ou @:B:.:p                              {unit_mesure_plur} plus [tôt|tard]
    à quelques                                      {unit_mesure_plur} près
    après [des|plusieurs|quelques|*NUM|@:B:.:p]     {unit_mesure_plur} de bons et loyaux services
    après près [de|d’] [*NUM|@:B:.:p]               {unit_mesure_plur} de bons et loyaux services
    au fil des                                      {unit_mesure_plur} à venir
    dans les                                        {unit_mesure_plur} à venir
    des                                             {unit_mesure_plur} plus [tôt|tard]
    des                                             {unit_mesure_plur} à venir
    d’ ici quelques                                 {unit_mesure_plur}
    ?d’¿ il y a [*NUM|@:B:.:p]                      {unit_mesure_plur}
    ?d’¿ il y a [moins|plus] [de|d’] [*NUM|@:B:.:p] {unit_mesure_plur}
    ?d’¿ il y a quelques                            {unit_mesure_plur}
    quelques                                        {unit_mesure_plur} [après|avant|auparavant]
    quelques                                        {unit_mesure_plur} plus [tard|tôt]
    un peu [moins|plus] de [@:B:.:p|*NUM]           {unit_mesure_plur} auparavant
        <<- &>> :LW;T

    au cours des            ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    au cours des            ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    au fil des              ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    au fil des              ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    dans les                ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    dans les                ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    dans le courant des     ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    dans le courant des     ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    depuis les              ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    depuis les              ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    des                     ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    des                     ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    par rapport aux         ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    par rapport aux         ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    pendant les             ?@:B:.:p¿ {unit_mesure_plur_mas}    [derniers|passés|précédents|prochains|suivants]
    pendant les             ?@:B:.:p¿ {unit_mesure_plur_fem}    [dernières|passées|précédentes|prochaines|suivantes]
    au cours des            ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    au cours des            ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    au fil des              ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    au fil des              ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    dans les                ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    dans les                ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    dans le courant des     ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    dans le courant des     ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    depuis les              ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    depuis les              ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    des                     ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    des                     ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    par rapport aux         ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    par rapport aux         ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    pendant les             ?@:B:.:p¿ [derniers|précédents|prochains]       {unit_mesure_plur_mas}
    pendant les             ?@:B:.:p¿ [dernières|précédentes|prochaines]    {unit_mesure_plur_fem}
    depuis [de|d’]          ?[assez|si|très|trop]¿ longs {unit_mesure_plur_mas}
    depuis [de|d’]          ?[assez|si|très|trop]¿ longues {unit_mesure_plur_fem}
    pendant de [nombreux|longs]         {unit_mesure_plur_mas}
    pendant de [nombreuses|longues]     {unit_mesure_plur_fem}
        <<- &>> :LW;T


__locutions_temps_après_avant__
    peu de          [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   [après|avant]
    plusieurs       [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   [après|avant]
    quelques        [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   [après|avant]
    de nombreux     [jours|ans|siècles|millénaires]                                                                                     [après|avant]
    de nombreuses   [nanosecondes|millisecondes|secondes|minutes|heures|semaines|années|décennies]                                      [après|avant]
        <<- not value(<1, "|de|d’|")
            and ( morph(>1, ">[,)]|<end>|:(?:Ov|3[sp])", ":D") or ( value(>1, "|le|la|l’|leur|les|") and morph(>2, ":V", ":[NAQ]") ) )
        &>> :LW;T

    peu de          [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   auparavant
    plusieurs       [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   auparavant
    quelques        [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   auparavant
    de nombreux     [jours|ans|siècles|millénaires]                                                                                     auparavant
    de nombreuses   [nanosecondes|millisecondes|secondes|minutes|heures|semaines|années|décennies]                                      auparavant
        <<- &>> :LW;T

    peu de          [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   plus [tôt|tard]
    plusieurs       [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   plus [tôt|tard]
    quelques        [nanosecondes|millisecondes|secondes|minutes|heures|jours|semaines|mois|années|ans|décennies|siècles|millénaires]   plus [tôt|tard]
    de nombreux     [jours|ans|siècles|millénaires]                                                                                     plus [tôt|tard]
    de nombreuses   [nanosecondes|millisecondes|secondes|minutes|heures|semaines|années|décennies]                                      plus [tôt|tard]
        <<- &>> :LW;T


__locutions_énumération_temporelle__
    [de|d’] nanoseconde   en  nanoseconde
    [de|d’] milliseconde  en  milliseconde
    [de|d’] seconde       en  seconde
    [de|d’] minute        en  minute
    [de|d’] heure         en  heure
    [de|d’] matin         en  matin
    [de|d’] matinée       en  matinée
    [de|d’] après         en  après
    [de|d’] soir          en  soir
    [de|d’] soirée        en  soirée
    [de|d’] jour          en  jour
    [de|d’] journée       en  journée
    [de|d’] nuit          en  nuit
    [de|d’] semaine       en  semaine
    [de|d’] mois          en  mois
    [de|d’] trimestre     en  trimestre
    [de|d’] semestre      en  semestre
    [de|d’] mois          en  mois
    [de|d’] année         en  année
    [de|d’] décennie      en  décennie
    [de|d’] génération    en  génération
    [de|d’] siècle        en  siècle
    [de|d’] millénaire    en  millénaire
        <<- &>> :LW;T

    nanoseconde     [après|par]     nanoseconde
    milliseconde    [après|par]     milliseconde
    seconde         [après|par]     seconde
    minute          [après|par]     minute
    heure           [après|par]     heure
    matin           [après|par]     matin
    matinée         [après|par]     matinée
    après-midi      [après|par]     après-midi
    soir            [après|par]     soir
    soirée          [après|par]     soirée
    jour            [après|par]     jour
    journée         [après|par]     journée
    nuit            [après|par]     nuit
    semaine         [après|par]     semaine
    mois            [après|par]     mois
    trimestre       [après|par]     trimestre
    semestre        [après|par]     semestre
    mois            [après|par]     mois
    année           [après|par]     année
    décennie        [après|par]     décennie
    génération      [après|par]     génération
    siècle          [après|par]     siècle
    millénaire      [après|par]     millénaire
        <<- &>> :LW;T


__locutions_locutions_temps__
    à longueur [de|d’] temps
    après un ?bon¿ bout de temps ?passé¿
    après un certain temps ?passé¿
    au bout d’ un certain temps  ?passé¿
    au fil du temps
    avec un ?[léger|petit]¿ temps d’ avance
    avec un temps d’ avance ?$:W¿ [considérable|énorme|gigantesque|important|phénoménal]
    avec un ?[léger|petit]¿ temps [de|d’] retard
    avec un temps [de|d’] retard ?$:W¿ [considérable|énorme|gigantesque|important|phénoménal]
    comme au bon vieux temps
    dans peu de temps
    dans très peu de temps
    dans un [premier|second|troisième|quatrième] temps
    depuis ce temps-là
    depuis peu
    depuis ?[assez|si|très|trop]¿ peu de temps
    depuis la nuit des temps
    depuis quelque temps
    depuis tout ce temps ?passé¿
    d’ ici peu de temps
    ?[de|d’]¿ ces derniers temps
    ?d’¿ il y a ?[assez|si|très|trop]¿ peu [de|d’] temps
    ?d’¿ il y a quelque temps
    [de|d’] tous temps
    [de|d’] tout temps
    [de|d’] temps à autre
    [de|d’] temps en temps
    en ?[assez|si|très|trop]¿ peu [de|d’] temps
    en ce temps-là
    en d’ autres temps
    en d’ autres temps et d’ autres lieux
    en des temps [moins|plus] [anciens|récents]
    en des temps meilleurs
    en même temps
    en moins [de|d’] temps qu’ il ?[ne|n’]¿ [faut|fallut|faudra|faudrait] pour [le|l’] [dire|prononcer|raconter]
    en moins [de|d’] temps qu’ il ?[ne|n’]¿ [faut|fallut|faudra|faudrait] pour [le|l’] faire comprendre
    en moins [de|d’] temps qu’ il ?[ne|n’]¿ [faut|fallut|faudra|faudrait] pour l’ expliquer
    en moins [de|d’] temps qu’ il ?n’¿ [a|eut|aura|aurait] fallu pour [le|l’] [dire|prononcer|raconter]
    en moins [de|d’] temps qu’ il ?n’¿ [a|eut|aura|aurait] fallu pour [le|l’] faire comprendre
    en moins [de|d’] temps qu’ il ?n’¿ [a|eut|aura|aurait] fallu pour l’ expliquer
    en temps [de|d’] [guerre|paix]  ?[économique|religieuse]¿
    en temps [normal|opportun|ordinaire|utile|voulu]
    en temps et en heure
    en un temps record
    en un rien [de|d’] temps
    jusqu’ à la fin des temps
    la plupart du temps
    le [moins|plus] [de|d’] temps possible
    le plus clair de [mon|ton|son|notre|votre|leur] temps ?libre¿
    le plus clair de [mon|ton|son|notre|votre|leur] temps [de|d’] travail
    par les temps qui courent
    par temps [de|d’] pluie
    pendant ce temps-là
    pendant quelque temps
    pendant un [court|certain|petit] laps de temps
    pendant qu’ il ?en¿ est ?encore¿ temps
    peu [de|d’] temps auparavant
    pour quelque temps
    quelque temps
    tout le temps
        <<- &>> :LW;T

    ?[bien|si|assez]¿ longtemps
    avant longtemps
    depuis ?[assez|si|très|trop]¿ longtemps
    depuis bien longtemps
    dès longtemps
    ?d’¿ il n’y a pas ?[assez|si|très|trop]¿ longtemps
    ?d’¿ il y a ?[assez|si|très|trop]¿ longtemps
    pendant ?[bien|si|assez|très]¿ longtemps
    [plus|moins|aussi] longtemps
    [plus|moins|aussi] longtemps que [prévu|nécessaire]
    [plus|moins|aussi] longtemps que d’ habitude
    un peu [plus|moins] longtemps
    un peu [plus|moins] longtemps que [prévu|nécessaire]
    un peu [plus|moins] longtemps que d’ habitude
        <<- &>> :LW;T

__locutions_instant_moment__
    à aucun moment
    à ce [moment|moment-là] ?[exact|particulier|précis]¿
    à cet [instant|instant-là] ?[exact|particulier|précis]¿
    à chaque [instant|moment] ?passé¿
    à un moment donné
    à un moment ou à un autre
    au [dernier|même|bon|mauvais] [moment|instant]
    au bon endroit ?,¿ au bon moment
    au mauvais endroit ?,¿ au mauvais moment
    au bout d’ un [instant|moment]
    dans ces moments-là
    d’ instant en instant
    d’ un [instant|moment] à l’ autre
    durant un ?[si|très|trop]¿ [court|long] [instant|moment]
    en ce [moment|moment-là] ?[particulier]¿
    en ces [temps-là|temps-ci]
    en cet instant ?[particulier|précis]¿
    ?en¿ l’ espace d’ un [instant|moment]
    le moment venu
    par [instants|moments]
    pendant un ?[si|très|trop]¿ [court|long] [instant|moment]
    un court [instant|moment]
    un [instant|moment] plus [tôt|tard]
        <<- &>> :LW;T

__locutions_temporelles_diverses__
    à cette [date|occasion] ?fatidique¿
    à longueur [de|d’] [journée|année]
    à cette époque
    à cette époque de l’ année
    à durée [déterminée|indéterminée|limitée]
    à intervalles [irréguliers|réguliers]
    à partir [de|d’]  [aujourd’hui|ici|là|maintenant|rien]
    à partir [de|d’]  [demain|hier]  ?[matin|midi|soir]¿
    ?[d’|dès|jusqu’|pour|après|avant]¿ après demain
    [d’|dès|jusqu’|pour|après|avant] après-demain
    après cette date ?fatidique¿
    au commencement
    au début
    au fur et à mesure
    au jour j
    au jour le jour
    au milieu de la nuit
    au plus [tard|tôt] ?[lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche]¿
    avant demain ?[matin|soir|après-midi]¿
    comme autrefois
    comme avant
    comme d’ [habitude|hab]
    comme toujours
    dans [ma|ta|sa|notre|votre|leur] prime jeunesse
    dans un lointain passé
    depuis belle lurette
    depuis des lustres
    depuis lors
    depuis toujours
    depuis un bail
    dès à présent
    dès [demain|hier] ?[soir|matin|après-midi]¿
    dès [maintenant|lors|aujourd’hui]
    dès [mon|ton|son|notre|votre|leur] plus jeune âge
    dès [ma|ta|sa|notre|votre|leur] première rencontre
    dès potron-minet
    dès que possible
    du début à la fin
    du jour au lendemain
    du jour j
    d’ antan
    d’ après-guerre
    d’ avant-guerre
    d’ aujourd’hui
    d’ autrefois
    d’ habitude
    d’ ici ?[là|peu|demain|après-demain]¿
    d’ ici une [seconde|minute|journée|semaine|année|décennie]
    d’ ici un [mois|trimestre|semestre|siècle|millénaire]
    d’ [hier|avant-hier] ?[matin|soir|après-midi]¿
    [de|d’] jadis
    [de|d’] maintenant
    ?d’¿ il y a belle lurette
    ?[de|d’]¿ [demain|après-demain] ?[matin|soir|après-midi]¿
    [de|d’] ?[assez|si|très|trop]¿ [courte|longue] durée
    [de|d’] ?[assez|si|très|trop]¿ bon matin
    [de|d’] ?[assez|si|très|trop]¿ longue [date|haleine]
    [de|d’] ?[assez|si|très|trop]¿ nombreuses années plus [tôt|tard]
    [de|d’] courte [durée|vue]
    [de|d’] demain ?[matin|soir|après-midi]¿
    [de|d’] dernière minute
    [de|d’] jour comme [de|d’] nuit
    [de|d’] nos jours
    [de|d’] si bon matin
    [de|d’] toute éternité
    en début [de|d’] [journée|matinée|soirée|après-midi]
    en milieu [de|d’] [journée|matinée|soirée|après-midi]
    en fin [de|d’] [journée|matinée|soirée|après-midi]
    en un claquement de doigts
    en un clin d’ œil
    été comme hiver
    jour pour jour
    jusqu’ [alors|ici|aujourd’hui|Noël|Pâques]
    jusqu’ au nouvel an
    jusqu’ à [demain|hier] ?[matin|soir|après-midi]¿
    jusqu’ à [ma|sa|ta|notre|votre|leur] mort
    jusqu’ à [mon|ton|son|notre|votre|leur] dernier [souffle|soupir]
    jusqu’ à [mon|ton|son|notre|votre|leur] dernier souffle [de|d’] vie
    jusqu’ à aujourd’hui
    jusqu’ à ce que [ils|elles|iels] en sachent plus
    jusqu’ à ce que [j’|il|elle|on] en sache plus
    jusqu’ à ce que mort s’ ensuive
    jusqu’ à ce que nous en sachions plus
    jusqu’ à ce que tu en saches plus
    jusqu’ à ce que vous en sachiez plus
    jusqu’ à la dernière [minute|seconde]
    jusqu’ à la fin
    jusqu’ à la fin [de|d’] [mes|tes|ses|nos|vos|leurs] jours
    jusqu’ à la tombée [de|d’] la nuit
    jusqu’ à maintenant
    jusqu’ à nouvel ordre
    jusqu’ à plus ample informé
    jusqu’ à présent
    jusqu’ à récemment
    le jour venu
    le [moins|plus] [de|d’] [gens|monde] possible
    le [moins|plus] [tôt|tard|souvent] ?possible¿
    moins [près|loin|tôt|tard]
    moins ?[près|loin|tôt|tard]¿ que d’ habitude
    moins ?[près|loin|tôt|tard]¿ que [prévu|nécessaire]
    plus [près|loin|tôt|tard]
    plus ?[près|loin|tôt|tard]¿ que [prévu|nécessaire]
    plus ?[près|loin|tôt|tard]¿ que d’ habitude
    par la suite
    par le passé
    plus jamais
    plus que d’ habitude
    pour lors
    pour le restant [de|d’] [mes|tes|ses|nos|vos|leurs] jours
    quant à présent
    sine die
    sans délai ?supplémentaire¿
    sur ces entrefaites
    séance tenante
    tout [de|d’] [suite|go]
    tout à coup
    toute affaire cessante
    toutes affaires cessantes
    tôt ou tard
    un jour ou l’autre
    un peu [moins|plus] ?[près|loin|tôt|tard]¿ que prévu
    [voici|voilà] belle lurette
        <<- &>> :LW;T

__locutions_échéance__
    à ?[si|très|trop]¿ [brève|courte|longue] échéance
    à moyenne échéance
    à plus ou moins [brève|courte|longue] échéance
        <<- &>> :LW;T

__locutions_terme__
    à ?[si|très|trop]¿ court terme
    à ?[si|très|trop]¿ long terme
    à moyen terme
    à moyen [et|ou] ?à¿ [court|long] terme
    à court [et|ou] ?à¿ [moyen|long] terme
    à long [et|ou] ?à¿ [court|moyen] terme
    à ?[si|très|trop]¿ long [et|ou] ?à¿ ?[si|très|trop]¿ [court|moyen] terme
    à ?[si|très|trop]¿ court [et|ou] ?à¿ ?[si|très|trop]¿ [long|moyen] terme
    avant terme
    sur le ?[très|trop]¿ [long|moyen|court] terme
        <<- &>> :LW;T

__locutions_fois__
    à la fois
    à chaque fois
    bien des fois
    à d’ autres fois
    d’ innombrables fois
    [de|d’] ?[assez|si|très|trop]¿ nombreuses fois
    [de|d’] ?[assez|si|très|trop]¿ nombreuses fois par [seconde|minute|heure|jour|semaine|mois|trimestre|semestre|an|année|décennie|siècle|millénaire]
    depuis la [première|dernière|~ième$] fois
    encore une fois
    par $:B fois
    pas plus [de|d’] [une|$:B] fois
    plein [de|d’] fois
    plus d’ une fois
    plus d’ une fois par [seconde|minute|heure|jour|semaine|mois|trimestre|semestre|an|année|décennie|siècle|millénaire]
    pour la [première|seconde|dernière|~ième$] fois
    pour la [première|seconde|dernière|~ième$] fois [de|d’] [mon|ton|son|ma|ta|sa|notre|votre|leur] ?[misérable|insignifiante|palpitante]¿ [existence|vie] ?[misérable|insignifiante|palpitante]¿
    pour la [première|seconde|~ième$] et dernière fois
    pour la [première|seconde|~ième$] et dernière fois [de|d’] [mon|ton|son|ma|ta|sa|notre|votre|leur] ?[misérable|insignifiante|palpitante]¿ [existence|vie] ?[misérable|insignifiante|palpitante]¿
    pour la [seconde|dernière|~ième$] fois [de|d’] suite
    pour [trois|3] fois rien
    pour [cette|une] fois
    quelques fois
    sans y [réfléchir|songer|penser] à [deux|2] fois
    souventes fois
    tant de fois
        <<- &>> :LW;T

    cette [fois|fois-là|fois-ci]
    chaque fois
    d’ autres fois
    des fois
    des [dizaines|douzaines|vingtaines|trentaines|quarantaines|cinquantaines|soixantaines|centaines|milliers|millions|milliards] de fois
    des [dizaines|douzaines|vingtaines|trentaines|quarantaines|cinquantaines|soixantaines|centaines|milliers|millions|milliards] de fois par [seconde|minute|heure|jour|semaine|mois|trimestre|semestre|an|année|décennie|siècle|millénaire]
    $:B fois
    $:B fois [de|d’] suite
    $:B fois par [seconde|minute|heure|jour|semaine|mois|trimestre|semestre|an|année|décennie|siècle|millénaire]
    la derrière fois
    la prochaine fois
    maintes fois
    plusieurs fois
    plusieurs fois [de|d’] suite
    plusieurs fois par [seconde|minute|heure|jour|semaine|mois|trimestre|semestre|an|année|décennie|siècle|millénaire]
    une autre fois
    un [millier|million|milliard] [de|d’] fois
    une [autre|nouvelle|première|seconde|troisième|quatrième|cinquième|sixième|septième|huitième|neuvième|dixième|onzième|douzième|treizième|quatorzième|quinzième|seizième|dix-septième|dix-huitième|dix-huitième|dix-neuvième|vingtième|centième|millième] fois
    une bonne fois pour toutes
    une dernière fois
    une fois [de|d’] plus
    une fois n’ est pas coutume
    une ?bonne¿ fois pour toutes
    une prochaine fois
    une seule fois
        <<- not morph(<1, ":R") &>> :LW;T

__locutions_circonstances__
    dans d’ autres circonstances
    dans certaines circonstances ?particulières¿
    dans cette circonstance ?particulière¿
    dans cette circonstance-là
    dans ces circonstances ?particulières¿
    dans ces circonstances-là
    en aucune circonstance
    en certaines circonstances ?particulières¿
    en cette circonstance ?particulière¿
    en cette circonstance-là
    en ces circonstances ?particulières¿
    en ces circonstances-là
    en d’ autres circonstances
    en [de|d’] [semblables|telles] circonstances
    en toute circonstance ?semblables¿
    en toutes circonstances ?semblables¿
    en [certaines|quelques|plusieurs] circonstances
        <<- &>> :LW;T

__locutions_occasion__
    à l’ occasion
    à la [dernière|moindre|première|prochaine] occasion
    à la toute première occasion
    à cette occasion ?particulière¿
    à cette occasion-là
    en cette occasion ?particulière¿
    en cette occasion-là
    en ces occasions ?particulières¿
    en ces occasions-là
    en d’ [autres|innombrables] occasions
    en [de|d’] [rares|semblables|telles] occasions
    en [certaines|quelques|toutes|plusieurs] occasions
    en maintes occasions
    en toute occasion
    en toutes occasions
    en une ?tout¿ autre occasion
    par la même occasion
        <<- &>> :LW;T


TEST: Le train de 2 h 47 {{arriveraient}} en retard.                        ->> arriverait
TEST: Le train de 2 h 47 du matin {{arriveraient}} en retard.               ->> arriverait
TEST: Le train de 2h47 du matin {{arriveraient}} en retard.                 ->> arriverait
TEST: ils sont depuis le 2 janvier {{parti}} à l’étranger.                  ->> partis
TEST: ils sont depuis le 2 janvier 2012 {{parti}} à l’étranger.             ->> partis
TEST: Une étude de 2005 publiée dans le Journal
TEST: Les cinq variantes de la couverture du magazine Wired d’avril 2016 consacrée à Silicon Valley.
TEST: c’est donc la cinquième en 50 ans
TEST: profanation de plusieurs églises françaises début février.


__locutions_distance__
    à ?seulement¿ [*NUM|@:B:.:p|quelques|plusieurs] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] [de|d’] [distance|ici]
    à ?seulement¿ [*NUM|@:B:.:p|quelques|plusieurs] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] en [amont|aval]
    à ?seulement¿ [*NUM|@:B:.:p|quelques|plusieurs] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] plus loin
    à ?seulement¿ [*NUM|@:B:.:p|quelques|plusieurs] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] à la ronde
    à ?seulement¿ [*NUM|@:B:.:p|quelques|plusieurs] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] aux alentours
    à [de|d’] nombreux [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|parsecs] [de|d’] [distance|ici]
    à [de|d’] nombreux [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|parsecs] en [amont|aval]
    à [de|d’] nombreux [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|parsecs] plus loin
    à [de|d’] nombreux [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|parsecs] à la ronde
    à [de|d’] nombreux [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|parsecs] aux alentours
    à [de|d’] nombreuses [lieues|verstes|UA|années-lumière] [de|d’] [distance|ici]
    à [de|d’] nombreuses [lieues|verstes|UA|années-lumière] en [amont|aval]
    à [de|d’] nombreuses [lieues|verstes|UA|années-lumière] plus loin
    à [de|d’] nombreuses [lieues|verstes|UA|années-lumière] à la ronde
    à [de|d’] nombreuses [lieues|verstes|UA|années-lumière] aux alentours
    à des [dizaines|douzaines|centaines|milliers|millions|milliards] [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] [de|d’] [distance|ici]
    à des [dizaines|douzaines|centaines|milliers|millions|milliards] [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] en [amont|aval]
    à des [dizaines|douzaines|centaines|milliers|millions|milliards] [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] plus loin
    à des [dizaines|douzaines|centaines|milliers|millions|milliards] [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] à la ronde
    à des [dizaines|douzaines|centaines|milliers|millions|milliards] [de|d’] [nanomètres|millimètres|centimètres|décamètres|pas|mètres|kilomètres|verstes|lieues|UA|parsecs|années-lumière] aux alentours
    à un jet [de|d’] pierre [de|d’] [distance|ici]
    à un jet [de|d’] pierre en [amont|aval]
    à un jet [de|d’] pierre plus loin
    à un jet [de|d’] pierre à la ronde
    à un jet [de|d’] pierre aux alentours
        <<- &>> :LW

    à ?[moins|plus|si|très|trop]¿ haute altitude
    à ?[moins|plus|si|très|trop]¿ grande profondeur
    à ?[si|très|trop]¿ peu [de|d’] distance
        <<- &>> :LW

    au loin
    au plus [près|loin]
    d’ un peu trop [près|loin]
    [de|d’] loin en loin
    [de|d’] près ou [de|d’] loin
    [de|d’] ?[assez|aussi|moins|fort|plus|si|très|trop]¿ [loin|près]
    [assez|aussi|moins|fort|plus|si|très|trop] [loin|près]
    [loin|près] [de|d’] [là|ici]
    [loin|près] [de|d’] tout [ça|cela|ceci]
    ni [de|d’] près ?,¿ ni [de|d’] loin
        <<- &>> :LW


__locutions_latines__
    [a|à] [contrario|cappella|fortiori|giorno|minima|priori|postériori|posteriori]
        <<- &>> :LW
        <<- !1>>

    ab [absurdo|initio|ovo]
    ad [hoc|hominem|infinitum|libitum|limina|nauseam|nutum|valorem|patres]
    ad majorem dei gloriam
    ad vitam æternam
    alea jacta est
    de [facto|jure|plano|profondis]
    et [cætera|cetera]
    ex [abrupto|absurdo|cathedra|nihilo|professo]
    grosso modo
    hic et nunc
    id est
    in [abstracto|extenso|extremis|fine|memoriam|petto|situ|utero|vitro|vivo]
    ipso facto
    mutatis mutandis
    ne varietur
    pro domo
    recto tono
        <<- &>> :LW

    in anima vili
    in cauda venenum
    in vino veritas
    sursum corda
    sic transit gloria mundi
        <<- &>> :LP


__locutions__
    à *NUM  [%|‰]
    à [autrui|bâbord|brûle-pourpoint|califourchon|chacun|cheval|cloche-pied|confesse|contre-courant|contrecœur|contre-cœur|contre-pied|contre-sens|contretemps|contre-temps|>demi-mot|demi-voix|dessein|foison|grand-peine|genoux|gogo|jamais|jeun|loisir|merveille|moitié|nouveau|outrance|peine|perpète|perpette|perpétuité|présent|raison|rallonge|rebrousse-poil|reculons|regret|renverse|revers|risque|sec|tâtons|tire-d’aile|tire-larigot|tort|tribord|tout-va|vif]
    à [mi-chemin|mi-côte|mi-jambe+s|mi-mandat|mi-mot+s|mi-parcours|mi-temps|mi-voix]
    à air comprimé
    à angle droit
    à armes égales
    à aucun prix
    à autre chose
    à ?[si|très|trop]¿ bas [bruit|cout|coût|prix]
    à bâtons rompus
    à beaucoup près
    à belles dents
    à bien des égards
    à bien pire
    à ?[si|très|trop]¿ courte portée
    à ?[si|très|trop]¿ bon [compte|escient|droit]
    à ?[si|très|trop]¿ bonne allure
    à bout [de|d’] [bras|souffle|force|forces|nerf|nerfs]
    à bout [portant|touchant]
    à bras ouverts
    à bras-le-corps
    à bride abattue
    à but ?non¿ lucratif
    à cadence forcée
    à canon [court|long|scié]
    à cause [de|d’]  [ça|cela|ceci|moi|toi|lui|nous|vous|elle|elles|eux|iel|iels]
    à ce [compte-là|moment-là|titre]
    à ce [que|qu’] je [peux|pouvais|pus|pourrai|pourrais] en [apercevoir|comprendre|juger|percevoir|voir]
    à ce [que|qu’] tu [peux|pouvais|pus|pourras|pourrais] en [apercevoir|comprendre|juger|percevoir|voir]
    à ce qu’ [il|elle|on|iel] [peut|pouvait|put|pourra|pourrait] en [apercevoir|comprendre|juger|percevoir|voir]
    à ce [que|qu’] nous [pouvons|pouvions|pûmes|pourrons|pourrions] en [apercevoir|comprendre|juger|percevoir|voir]
    à ce [que|qu’] vous [pouvez|pouviez|pûtes|pourrez|pourriez] en [apercevoir|comprendre|juger|percevoir|voir]
    à ce qu’ [ils|elles|iels] [pouvent|pouvaient|purent|pourront|pourraient] en [apercevoir|comprendre|juger|percevoir|voir]
    à certains égards
    à cet égard
    à ciel ouvert
    à charge [de|d’] revanche
    à ?[si|très|trop]¿ chaudes larmes
    à cœur [joie|ouvert|perdu]
    à compter [de|d’] [demain|aujourd’hui|hier|maintenant]
    à connotation sexuelle
    à contre-jour
    à corps perdu
    à côté  [de|d’]  [ça|moi|toi|lui|nous|vous|elle|elles|eux|iel|iels]
    à couilles rabattues
    à coup sûr
    à couper le souffle
    à >coussin d’ air
    à couteaux tirés
    à défaut d’ autre chose
    à domicile ?fixe¿
    à dormir debout
    à dose homéopathique
    à *NUM reprises
    à @:B:[fe]:p reprises
    à [plusieurs|quelques|maintes] reprises
    à [de|d’]  ?[assez|aussi|si|très|trop]¿  [nombreuses|multiples|innombrables]  reprises
    à double [titre|tranchant]
    à en juger par [mon|ton|son|notre|votre|leur] ?immense¿ expérience
    à en juger par [ma|ta|sa|notre|votre|leur] [grande|petite] expérience
    à en perdre haleine
    à en perdre la tête
    à ?[moins|plus|si|très|trop]¿ faible [allure|revenu]
    à ?[moins|plus|si|très|trop]¿ faible tirant d’ eau
    à feu et à sang
    à flanc [de|d’] [colline|montagne]
    à fleur [de|d’] peau
    à franchement parler
    à fond [de|d’] train
    à fonds perdus
    à géométrie variable
    à glacer le sang
    à glacer les sangs
    à gorge déployée
    à ?[moins|plus|si|très|trop]¿ grand bruit
    à ?[moins|plus|si|très|trop]¿ grande échelle
    à ?[moins|plus|si|très|trop]¿ grands frais
    à ?[moins|plus|si|très|trop]¿ grands traits ?[imprécis|rageurs|précis|vagues]¿
    à ?[moins|plus|si|très|trop]¿ haut risque
    à ?[moins|plus|si|très|trop]¿ haute voix
    à ?[moins|plus|si|très|trop]¿ haute et intelligible voix
    à heure fixe
    à hue et à dia
    à huis clos
    à hurler [de|d’] rire
    à juste [raison|titre]
    à l’ [accoutumée|amiable|arrache|arraché|arrachée|avance|avenant|aveuglette|emporte-pièce|envi|évidence|étouffée|improviste|inverse|unanimité|unisson]
    à l’ air libre
    à l’ autre bout du fil
    à l’ avenir ?[incertain|prometteur]¿
    à l’ échelon [local|cantonal|départemental|régional|national|européen|américain|africaine|asiatique|continental|international|planétaire|galactique|universel]
    à l’ échelle [locale|cantonale|départementale|régionale|nationale|européenne|américaine|africaine|asiatique|continentale|internationale|planétaire|galactique|universelle]
    à l’ en croire
    à l’ environ
    à l’ état pur
    à l’ exclusion [de|d’] toute autre chose
    à l’ extrémité [est|ouest|nord|sud]
    à l’ ordre du jour
    à l’ un d’ entre [nous|vous|eux|iels]
    à l’ une d’ entre [nous|vous|elles|iels]
    à l’ échelle [nationale|mondiale|régionale|départementale|cantonale|locale|galactique|universelle]
    à l’ exclusion [de|d’] toute autre chose
    à l’ œil nu
    à l’ [un|une] des leurs
    à l’ [un|une] comme à l’ autre
    à la [bourre|con|coule|dérobée|diable|leur|manque|mords-moi-le-nœud|papa|ramasse|renverse|redresse|rescousse|sauvette|va-vite|volée]
    à la belle étoile
    à la bonne franquette
    à la limite du supportable
    à la lumière [de|d’] tout [ceci|cela|ça]
    à la mords-moi le nœud
    à la petite semaine
    à la [force|pointe] [de|d’] l’ épée
    à la pointe du progrès ?[algorithmique|biologique|cybernétique|écologique|industriel|informatique|numérique|scientifique|social|spatial|technique|technologique]¿
    à la queue leu leu
    à la surprise générale
    à la virgule près
    à la vitesse [de|d’] l’ éclair
    à [un|cet|l’] instant t
    à ?[moins|plus|si|très|trop]¿ large échelle
    à ?[moins|plus|si|très|trop]¿ large spectre
    à ?[moins|plus|si|très|trop]¿ [court|moyen|long] rayon d’ action
    à ?[moins|plus|si|très|trop]¿ longue [distance|portée]
    à loyer modéré
    à main [armée|droite|gauche|levée|nue]
    à mains nues
    à maints égards
    à marche forcée
    à marée [basse|haute]
    à même le sol
    à merveille
    à [mi-course|mi-distance|mi-temps]
    à moindre [coût|cout]
    à moindres frais
    à mots couverts
    à [mes|tes|ses|nos|vos|leurs] [côtés|dépens|trousses]
    à [mes|tes|ses|nos|vos|leurs] risques et périls
    à [ma|ta|sa|notre|votre|leur] [connaissance|disposition|guise|portée]
    à [ma|ta|sa|notre|votre|leur] grande [surprise|tristesse]
    à [ma|ta|sa|notre|votre|leur] juste mesure
    à [mon|ton|son|notre|votre|leur] [avis|détriment|encontre|égard|gré|insu|sujet|tour]
    à [mon|ton|son|notre|votre|leur] [cœur|corps] défendant
    à [mon|ton|son|notre|votre|leur] grand [dam|désarroi|soulagement]
    à n’ en [pas|point] douter
    à n’ en plus finir
    à n’importe quel prix
    à nul autre pareil
    à nulle autre pareille
    à parler [franc|franchement|strictement]
    à part [entière|ça|cela|ceci]
    à parts égales
    à partir [de|d’]  rien
    à pas [de|d’] [géant|loup|tortue|velours]
    à pas feutrés
    à personne en danger
    à perte [de|d’] vue
    à petit feu
    à ?[si|très|trop|plus|moins]¿  petite [dose|échelle]
    à ?[si|très|trop]¿ peu [de|d’] choses près
    à ?[si|très|trop]¿ peu [de|d’] frais
    à peine
    à peu près
    à pied d’ œuvre
    à pieds joints
    à pile ou face
    à plat ventre
    à plate couture
    à plein [régime|temps|nez]
    à pleine gorge
    à pleins poumons
    à plus forte raison
    à plus d’ un titre
    à poil [court|dur|long|rêche]
    à poings fermés
    à point nommé
    à portée [de|d’] [main|tir|voix]
    à première vue
    à prix [coûtant|coutant|cassé+s|>modique]
    à [ma|ta|sa|notre|votre|leur] propre initiative
    à proprement parler
    à quatre pattes
    à qui [de|d’] droit
    à qui mieux mieux
    à qui [que|qu’] ce soit
    à quelque distance
    à quelques [degrés|exceptions|nuances|pourcents|variations|nanomètres|millimètres|centimètres|décimètres|mètres|kilomètres|parsecs|années-lumière] près
    à quelques-uns d’ entre [nous|vous|eux|iels]
    à quelques-unes d’ entre [nous|vous|elles|iels]
    à ras [de|d’] terre
    à ras [bord|bords]
    à ras [le|du] sol
    à rude épreuve
    à s’ y méprendre
    à somme nulle
    à spectre ?[assez|si|très|trop]¿ large
    à strictement parler
    à tarif réduit
    à tarifs réduits
    à taux [>fixe|>variable|zéro|nul+s]
    à tel point
    à temps  [plein|partiel|complet]
    à tête reposée
    à tire d’ [aile|ailes]
    à [tire-d’aile|tire-d’ailes]
    à titre [amical|bénévole|conservatoire|commercial|comparatif|confidentiel|consultatif|dérogatoire|exceptionnel|expérimental|fiduciaire|facultatif|indicatif|informatif|grâcieux|gratuit|honorifique|honoraire|humanitaire|informatif|indicatif|informel|juridique|liminaire|lucratif|nominatif|officieux|onéreux|personnel|posthume|préventif|provisoire|provisionnel|subsidiaire|temporaire|transitoire|universel|volontaire]
    à titre d’ [exemple|illustration|information]
    à titre [de|d’] comparaison
    à tombeau ouvert
    à tort ou à raison
    à tort et à travers
    à tour [de|d’] [bras|rôle]
    à tout [âge|coup|crin|instant|jamais|moment|prix]
    à tout bout [de|d’] champ
    à tout le [moins|monde]
    à tout point [de|d’] vue
    à tout un chacun
    à toute [allure|berzingue|bride|épreuve|force|reste|vapeur|vitesse|volée]
    à tous crins
    à tous points [de|d’] vue
    à toutes fins utiles
    à toutes jambes
    à travers terre et mer
    à tu et à toi
    à tue-tête
    à usage [interne|unique]
    à ?[moins|plus|si|très|trop]¿ vaste échelle
    à visage [découvert|humain]
    à vitesse constante
    à vitesse grand V
    à vive allure
    à voile et à vapeur
    à voix [haute|basse]
    à vol d’ oiseau
    à vrai dire
    à vue d’ œil
    à ?bien¿ y regarder [de|d’] plus près
    à ?bien¿ y [penser|réfléchir|songer|repenser]
    advienne [que|qu’] pourra
    après [moi|toi|soi|lui|eux]
    après coup
    après mûre réflexion
    après tout ,
    au bas mot
    au beau fixe
    au bon moment
    au bout du [compte|rouleau]
    au cas par cas
    au chômage partiel
    ?bien¿ au contraire
    au coude à coude
    au coup par coup
    au demeurant
    au doigt mouillé
    au doigt et à l’ [œil|oeil]
    au débotté
    au fait et au prendre
    au fil [de|d’] l’ épée
    au grand [complet|jamais]
    au hasard
    au jugé
    au lieu [de|d’] [cela|ceci|ça|quoi]
    au milieu [de|d’] nulle part
    au moment opportun
    au même titre [que|qu’] n’importe [laquelle|lequel] d’ entre [nous|vous|eux|elles|iels]
    au pas [de|d’] [charge|course]
    au petit bonheur la chance
    au plan [local|cantonal|départemental|régional|national|européen|américain|africaine|asiatique|continental|international|planétaire|galactique|universel]
    au plus [près|pressé|vite]
    au plus haut [degré|point]
    au premier abord
    au premier coup d’ œil
    au prime abord
    au propre comme au figuré
    au préalable
    au ras des pâquerettes
    au saut du lit
    au second plan
    au sens [figuré|large|littéral|propre]
    au sens figuré comme au sens [littéral|propre]
    au sens [littéral|propre] comme au sens figuré
    au sens [étroit|figuré|large|littéral] du terme
    au surplus
    au-delà du descriptible
    à la [mienne|tienne|sienne|nôtre|vôtre|leur]
    au [mien|tien|sien|nôtre|vôtre|leur]
    aussi [con|étonnant|habile|idiot|inattendu|insolite|invraisemblable|maladroit|stupide|surprenant] [que|qu’] que [cela|ceci|ça] puisse [paraitre|paraître]
    aux [abois|aguets|miens|miennes|tiens|tiennes|siens|siennes|nôtres|vôtres|leurs]
    autant [que|qu’] [nécessaire|possible|prévu]
    autant [que|qu’] faire se peut
    autrement dit
    avant tout le monde
    avant toute chose
    avant toutes choses
    avant d’ aller plus loin
    avant d’ en arriver là
    avant [de|d’] faire quoi [que|qu’] ce soit
    avant [de|d’] faire quoi [que|qu’] ce soit [de|d’] ?$:W¿ [absurde|stupide|crétin|con|idiot|inconsidéré]
    avant qu’ il ne soit trop tard
    avant un bon bout [de|d’] temps
    avec beaucoup [de|d’] [circonspection|prudence]
    avec [aplomb|brio|constance|emphase|joie|légèreté|insistance|peine]
    avec autre chose
    avec le plus grand soin
    avec pertes et fracas
    avec tout le respect [que|qu’] je [vous|te|leur|lui] dois
    avec tout le respect [que|qu’] nous [vous|te|leur|lui] devons
    avec tout un chacun
    avec un peu [de|d’] chance
    ayant pignon sur rue
    beaucoup [plus|moins]
    bel et bien
    bien assez tôt
    bien souvent
    bon gré ?,¿ mal gré
    bras dessus ?,¿ bras dessous
    çà et là
    ce faisant
    ce qui [ne|n’] [est|était|fut|sera|serait] [pas|jamais|guère] pour [me|m’|te|t’|lui|nous|vous|leur] déplaire
    ce qui [ne|n’] [a|aura|aurait|avait|eut|eût] [pas|jamais|guère] été pour [me|m’|te|t’|lui|nous|vous|leur] déplaire
    [cela|ça|ceci] mis à part
    [cela|ça|ceci] va sans dire
    [cela|ceci] étant dit
    chaque chose en son temps
    chose promise ?,¿ chose due
    comme [de|d’] juste
    comme bon [me|te|lui|leur|nous|vous] semble
    comme ci ?,¿ comme ça
    comme cul et chemise
    comme des fétus [de|d’] paille
    comme [frappé+ses] par la foudre
    comme gage [de|d’] bonne foi
    comme n’importe où ?ailleurs¿
    comme par [enchantement|magie]
    comme par un fait exprès
    comme pas deux
    comme peau [de|d’] chagrin
    comme prévu
    comme promis
    comme qui dirait
    comme si [de|d’] rien n’ était
    comme sur des roulettes
    comme un lion en cage
    comme un fétu [de|d’] paille
    comme une lettre à la poste
    contrairement aux apparences
    contre mauvaise fortune ?,¿ bon cœur
    contre nature
    contre toute [attente|vraisemblance]
    contre vents et marées
    contre [mon|ton|son|notre|votre|leur] gré
    côte à côte
    côté [face|pile]
    [coute|coûte] [que|qu’] [coute|coûte]
    [crois-le|croyons-le|croyez-le] ou [non|pas]
    cul par-dessus tête
    dans le cas contraire
    dans [ce|ces] [cas-là|cas-ci]
    dans ce cas [précis|particulier]
    dans ces cas [précis|particuliers]
    dans l’ état actuel
    dans l’ état actuel des choses
    dans l’ [idéal|immédiat]
    dans la mesure du possible
    dans la dernière ligne droite
    dans le feu [de|d’] l’ action
    dans leur globalité
    dans leur ?très¿ grande majorité
    dans tout [cela|ça|ceci]
    dans un cas comme dans l’autre
    dans une [certaine|large|moindre] mesure
    dans une mauvaise passe
    d’ abord
    d’ affilée
    d’ ailleurs
    d’ alors
    d’ [arrache-pied|arrachepied]
    d’ arrière en avant
    d’ autant [plus|moins]
    d’ autre part
    d’ avant en arrière
    d’ avant-guerre
    d’ à côté
    d’ âge mûr
    d’ emblée
    d’ empoigne
    d’ en [bas|dessous|face|haut]
    d’ entre [eux|elles|iels]
    d’ entrée [de|d’] jeu
    d’ est en ouest
    d’ extrême [droite|gauche] ?radicale¿
    d’ [extrême-droite|extrême-gauche] ?radicale¿
    d’ [égal|égale] à [égal|égale]
    d’ intérêt général
    d’ ordinaire
    d’ origine [inconnue|douteuse|étrangère|plébéienne|aristocratique]
    d’ ordre [général|public|privé]
    d’ où qu’ [il|elle|on|iel] vienne
    d’ où qu’ [ils|elles|iels] viennent
    d’ ouest en est
    d’ [ors|ores] et déjà
    d’ un autre côté
    d’ un [bout|jour] à l’ autre
    d’ un côté [comme|et] [de|d’] l’ autre
    d’ un commun accord
    d’ un pas [alerte|mesuré]
    d’ un peu partout
    d’ un revers [de|d’] main
    d’ un revers [de|d’] la main ?[droite|gauche]¿
    d’ un ?tout¿ autre ordre [de|d’] grandeur
    d’ une autre trempe
    d’ une [façon|manière] ou d’ une autre
    d’ une [façon|manière] aussi @:A.*:[fe]:[si] que possible
    d’ une certaine [façon|manière]
    d’ une tout autre ampleur
    d’ utilité publique
    de-ci ?,¿ de-là
    [de|d’] ?[assez|si|très|trop]¿ [faible|grande|médiocre|moindre|petite] [taille|envergure|stature|valeur]
    [de|d’] ?[assez|si|très|trop]¿ haute [lignée|lutte|naissance|stature|taille|valeur|volée]
    [de|d’] ?[assez|si|très|trop]¿ basse [condition|extraction|lignée|naissance]
    [de|d’] ?[assez|si|très|trop]¿ bon [aloi|cœur|goût|gout|gré|poil|sens|ton]
    [de|d’] ?[assez|si|très|trop]¿ mauvais [aloi|cœur|goût|gout|gré|poil]
    [de|d’] ?[assez|si|très|trop]¿ bonne [compagnie|facture|famille|foi|grâce|heure|humeur|qualité]
    [de|d’] ?[assez|si|très|trop]¿ haut [rang|vol]
    [de|d’] ?[assez|si|très|trop]¿ mauvaise [compagnie|facture|foi|grâce|humeur|qualité]
    [de|d’] *NUM %
    [de|d’] [conserve|fait|guingois|luxe|nouveau|permanence|partout|plain-pied|pacotille|préférence|rechange|routine|surcroît|surcroit|traviole|visu]
    [de|d’] A à Z
    [de|d’] bas en haut
    [de|d’] bas étage
    [de|d’] basse extraction
    [de|d’] belle [allure|prestance]
    [de|d’] bonne [compagnie|réputation]
    [de|d’] bouche en bouche
    [de|d’] bric et [de|d’] broc
    [de|d’] but en blanc
    [de|d’] ce fait ?[incontestable|irréfutable|même]¿
    [de|d’] ce seul fait
    [de|d’] ce point [de|d’] vue
    [de|d’] cette sorte
    [de|d’] cet acabit
    [de|d’] chaque côté
    [de|d’] côté
    [de|d’] courte vue
    [de|d’] deux choses l’ une
    [de|d’] droite à gauche
    [de|d’] droite comme [de|d’] gauche
    [de|d’] fâcheuse mémoire
    [de|d’] fil en aiguille
    [de|d’] fond en comble
    [de|d’] ?[assez|si|très|trop]¿ [fraîche|fraiche] date
    [de|d’] [gaieté|gaîté|gaité] [de|d’] cœur
    [de|d’] grand renom
    [de|d’] grande ampleur
    [de|d’] gauche à droite
    [de|d’] gauche comme [de|d’] droite
    [de|d’] génération en génération
    [de|d’] gré à gré
    [de|d’] gré ou [de|d’] force
    [de|d’] guerre lasse
    [de|d’] haut en bas
    [de|d’] haute main
    [de|d’] là-bas
    [de|d’] la meilleure [manière|façon] possible
    [de|d’] la même [façon|manière]
    [de|d’] la plus haute importance
    [de|d’] la sorte
    [de|d’] la tête aux pieds
    [de|d’] la veille
    [de|d’] long en large
    [de|d’] main [de|d’] [maître|maitre]
    [de|d’] mal en pis
    [de|d’] même nature
    [de|d’] mieux en mieux
    [de|d’] moindre [envergure|valeur]
    [de|d’] moins en moins
    [de|d’] nature [étrangère|inconnue|indéterminée|insolite]
    [de|d’] notoriété publique
    [de|d’] nulle part
    [de|d’] pire en pire
    [de|d’] par le monde ?entier¿
    [de|d’] part en part
    [de|d’] part et d’ autre
    [de|d’] ?presque¿ partout
    [de|d’] peu d’ importance
    [de|d’] pied ferme
    [de|d’] pire en pire
    [de|d’] pis en pis
    [de|d’] place en place
    [de|d’] plein [droit|fouet]
    [de|d’] plus belle ?[façon|manière]¿
    [de|d’] plus en plus
    [de|d’] point en point
    [de|d’] ?tout¿ premier [choix|ordre|plan]
    [de|d’] première [catégorie|main|nécessité]
    [de|d’] prime abord
    [de|d’] proche en proche
    [de|d’] [ma|ta|sa|notre|votre|leur] propre initiative
    [de|d’] pure forme
    [de|d’] sang-froid
    [de|d’] sang mêlé
    [de|d’] seconde [catégorie|importance|main|zone]
    [de|d’] sinistre mémoire
    [de|d’] source sûre
    [de|d’] taille [modeste|moyenne]
    [de|d’] telle sorte
    [de|d’] vive voix
    [de|d’] [nous|vous] tous
    [de|d’] tous [côtés|bords]
    [de|d’] tous les cas [de|d’] figure [possibles|imaginables|existants|rencontrés]
    [de|d’] tous les cas [de|d’] figure possibles et imaginables
    [de|d’] tous les cas [de|d’] figure imaginables et possibles
    [de|d’] tout poil
    [de|d’] tout premier [ordre|plan]
    [de|d’] tout [mon|ton|son|notre|votre|leur] cœur
    [de|d’] toute [évidence|façon|part|urgence]
    [de|d’] toutes [parts|pièces|sortes]
    [de|d’] toutes les possibilités [existantes|imaginables|rencontrées]
    [de|d’] toutes [mes|tes|ses|nos|vos|leurs] forces
    [de|d’] [mon|ton|son|notre|votre|leur] acabit
    [de|d’] [mon|ton|son|notre|votre|leur] mieux
    [de|d’] [mon|ton|son|notre|votre|leur] plein gré
    [de|d’] [mon|ton|son|notre|votre|leur] point [de|d’] vue
    [de|d’] [mon|ton|son|notre|votre|leur] propre [cru|chef|fait]
    [de|d’] [mon|ton|son|notre|votre|leur] vivant
    [de|d’] [ma|ta|sa|notre|votre|leur] part
    [de|d’] [ma|ta|sa|notre|votre|leur] propre volonté
    derrière tout [cela|ceci|ça]
    des pieds à la tête
    Dieu [m’|t’|l’|nous|vous|les] en [garde|préserve]
    Dieu [m’|t’|lui|nous|vous|leur] en soit témoin
    Dieu seul le sait
    dos à dos
    du bout des lèvres
    du coin [de|d’] l’ [œil|oeil]
    du fond du cœur
    du haut en bas
    du même [acabit|coup|ordre|tonneau]
    du moins ?,¿ pas
    du [nord|sud] au [nord|sud]
    du tac au tac
    du tout au tout
    eh bien
    en [aparté|apparence|arrière|avance|avant|catimini|cachette|ceci|cela|clair|commun|conséquence|continu|contrebas|contrepartie|dedans|définitive|détail|direct|distanciel|douce|effet|émoi|filigrane|général|goguette|hâte|loucedé|majorité|moyenne|outre|pâmoison|parallèle|partie|particulier|permanence|personne|pratique|présentiel|prime|privé|principe|priorité|public|retour|revanche|rien|rogne|route|secret|silence|somme|suspens|tapinois|théorie|trompe-l’œil|vain|vérité]
    en réalité ?[augmentée|virtuelle]¿
    en âge [de|d’] procréer
    en aucun cas
    en aucune [façon|manière]
    en ?[assez|si|très|trop]¿ bas âge
    en ?[assez|si|très|trop]¿ bon état ?général¿
    en ?[assez|si|très|trop]¿ bon état [de|d’] [fonctionnement|marche]
    en ?[assez|si|très|trop]¿ bonne [compagnie|logique|place|posture|voie]
    en bonne et due forme
    en ?[assez|si|très|trop]¿ bonne santé ?[générale|physique|mentale|psychique]¿
    en bout [de|d’] course
    en cas [de|d’] besoin ?[absolu|impérieux]¿
    en cas [de|d’] doute ?[légitime|suffisant]¿
    en cas [de|d’] nécessité ?[absolue|impérieuse]¿
    en cas d’ urgence ?[absolue|impérieuse]¿
    en [chacun|chacune] [de|d’] ?entre¿ [nous|vous|eux|elles|iels]
    en chair et en os
    en chômage partiel
    en chute libre
    en comparution immédiate
    en ?[parfaite|pleine]¿ connaissance [de|d’] cause
    en contrebas
    en contrepoint
    en coup [de|d’] vent
    en coupe réglée
    en cours [de|d’] route
    en d’ autres termes
    en définitive
    en dehors [de|d’] ?tout¿ [ça|cela|ceci]
    en dents [de|d’] scie
    en dernier [lieu|recours|ressort]
    en dépit du bon sens ?[commun|élémentaire]¿
    en dépit du bon sens le plus [commun|élémentaire]
    en désespoir [de|d’] cause
    en détention provisoire
    en direction [de|d’] l’ [est|ouest]
    en direction du [nord|nord-est|nord-ouest|sud|sud-est|sud-ouest]
    en double aveugle
    en eau ?peu¿ profonde
    en eaux troubles
    en état [de|d’] choc ?circulatoire¿
    en ?[excellent|mauvais|parfait]¿ état [de|d’] [fonctionnement|marche]
    en état d’ ébriété ?avancée¿
    en ?[assez|si|très|trop]¿ excellent état ?général¿
    en ?[assez|si|très|trop]¿ fâcheuse posture
    en file indienne
    en fin [de|d’] compte
    en formation ?[assez|moins|peu|plus|si|très|trop]¿ serrée
    en ?[assez|si|très|trop]¿ forte [baisse|hausse]
    en gage [de|d’] bonne foi
    en garde à vue ?prolongée¿
    en ?[assez|si|très|trop|plus|moins]¿ grand nombre
    en ?[assez|si|très|trop]¿            grande [difficulté|majorité|partie|pompe]
    en ?[assez|si|très|trop|plus|moins]¿ haut lieu
    en ?[assez|si|très|trop]¿            haute [estime|mer|montagne]
    en l’ absence [de|d’] preuve suffisante
    en l’ absence [de|d’] preuve suffisante du contraire
    en l’ absence [de|d’] preuves suffisantes
    en l’ absence [de|d’] preuves suffisantes du contraire
    en l’ état actuel
    en l’ état actuel des choses
    en l’ occurrence
    en lieu sûr
    en ligne [de|d’] [compte|mire]
    en main propre
    en mains propres
    en ?[assez|si|très|trop]¿ mauvais état
    en ?[assez|si|très|trop]¿ mauvais état [de|d’] [fonctionnement|marche]
    en ?[assez|si|très|trop]¿ mauvaise [posture|santé]
    en nombre ?[assez|si|très|trop|relativement]¿ [insuffisant|limité|suffisant]
    en nombre plus [que|qu’] suffisant
    en odeur [de|d’] sainteté
    en ordre [dispersé|serré]
    en partant [de|d’] zéro
    en partie ou en totalité
    en pente douce
    en ?[assez|si|très|trop]¿ petit nombre
    en place publique
    en plein [air|cœur|essor|marasme|jour|visage]
    en plein dans le mille
    en pleine [face|gueule|figure|forme|nuit|poire|tronche]
    en perte [de|d’] vitesse
    en ?[assez|si|très|trop]¿ [piteux|piètre] état
    en ?[assez|si|très|trop]¿ [piteux|piètre] état [de|d’] conservation
    en point [de|d’] [mire|orgue]
    en porte-à-faux
    en position [de|d’] [force|faiblesse]
    en premier lieu
    en première [instance|ligne]
    en [première|seconde|~ième$] [classe|instance|position]
    en [1ʳᵉ|2ᵉ|3ᵉ|4ᵉ|5ᵉ|6ᵉ|7ᵉ|8ᵉ|9ᵉ|10ᵉ|11ᵉ|12ᵉ|13ᵉ|14ᵉ|15ᵉ|16ᵉ|17ᵉ|18ᵉ|19ᵉ|20ᵉ] [classe|position]
    en provenance du monde entier
    en pure perte
    en quantité suffisante
    en quantité plus [que|qu’] suffisante
    en quelque sorte
    en queue [de|d’] peloton
    en rangs [dispersés|serrés]
    en rangs d’ oignons ?serrés¿
    en rase campagne
    en rase-mottes
    en règle générale
    en roue libre
    en second lieu
    en sens inverse
    en simultané
    en situation [irrégulière|régulière]
    en sous-main
    en sous-nombre ?[évident|flagrant]¿
    en sous nombre ?[évident|flagrant]¿
    en tant [que|qu’] >tel
    en tête à tête
    en tête-à-tête
    en si peu [de|d’] temps
    en terrain [découvert|miné]
    en termes choisis
    en terrain [accidenté|conquis]
    en terre battue ?[claire|ocre|jaune|rouge|noire|sombre|humide|sèche|maculée|sale|dégueulasse]¿
    en terre étrangère
    en toile [de|d’] fond
    en totalité ou en partie
    en tout cas
    en tous les cas
    en tous les sens
    en tout bien tout honneur
    en tout [cas|genre|lieu|sens|point|temps]
    en tout et pour tout
    en tout état [de|d’] cause
    en tout premier lieu
    en toute bonne foi
    en ?toute¿ connaissance [de|d’] cause
    en toute [confiance|discrétion|franchise|hâte|impartialité|impunité|innocence|légalité|liberté|logique|modestie|sécurité|simplicité]
    en travers [de|d’] la gorge
    en trompe-l’œil
    en ultime recours
    en vase clos
    en vigueur
    en vitesse ?[subsonique|supersonique|subluminique|superluminique]¿
    en voie [de|d’] développement
    en vrac
    en y [réfléchissant|songeant] bien
    en [mon|ton|son|leur|notre|votre] âme et conscience
    en [mon|ton|son|leur|notre|votre] for intérieur
    en [mon|ton|son|leur|notre|votre] nom propre
    en ce qui [me|te|le|la|les|nous|vous] [concerne|concernait]
    en voilà ?bien¿ [assez|trop|suffisamment]
    encore et [encore|toujours]
    entre chien et loup
    entre [de|d’] [bonnes|mauvaises] mains
    entre nous soit dit
    entre [quatre|quatr’|quat’] [zyeux|yeux]
    entre [quatre-zyeux|quatr’zyeux|quat’zyeux|quatre-yeux|quatr’yeux|quat’yeux]
    envers et contre tout
    épaule contre épaule
    et ainsi [de|d’] suite
    et pas qu’ un peu
    et tutti quanti
    et vice versa
    et vice-versa
    excepté le [mien|tien|sien|nôtre|vôtre|leur]
    excepté la [mienne|tienne|sienne|nôtre|vôtre|leur]
    excepté les [miens|miennes|siennes|nôtres|vôtres|leurs]
    face à face
    flanc contre flanc
    ?d’¿ hors d’ ici
    ?d’¿ hors [de|d’] [contrôle|portée|atteinte]
    ?d’¿ hors d’ état [de|d’] [fonctionner|nuire]
    ?d’¿ hors [de|d’] [ma|ta|sa|notre|votre|leur] portée
    ?d’¿ hors du commun
    ?d’¿ ici
    ?d’¿ ici [comme|ou] ailleurs
    ?d’¿ ici et [là|maintenant]
    ?d’¿ ici même
    ?d’¿ ici-bas
    illico ?presto¿
    d’ intra-muros
    j’ en [passe|passai+s] et des [meilleurs|meilleures]
    jusqu’ au bout des ongles
    jusqu’ à bac
    jusqu’ à plus soif
    jusqu’ à >preuve du contraire
    jusqu’ à satiété
    jusqu’ à un certain point
    jusqu’ à l’ écœurement
    jusqu’ au trognon
    jusque-là
    [de|d’] là
    [de|d’] là-bas
    [de|d’] là-haut
    [de|d’] là-dedans
    [de|d’] là-dehors
    [de|d’] là-derrière
    [de|d’] là-dessous
    [de|d’] là-dessus
    [de|d’] là-devant
    ?[de|d’]¿ là non plus
    ¿[de|d’]¿ la fleur au fusil
    ¿[de|d’]¿ la main dans la main
    ¿[de|d’]¿ la mort dans l’ âme
    ¿[de|d’]¿ la queue entre les jambes
    ¿[de|d’]¿ la peur au ventre
    l’ air [de|d’] rien
    la gorge [nouée|serrée]
    la mort dans l’ âme
    la tête entre [mes|tes|ses|nos|vos|leurs] mains
    ?le¿ dos au mur
    le cas échéant
    le cœur battant la chamade
    le cœur ?[plus|moins|si|très]¿ [léger|gros|serré]
    le moins du monde
    le moment venu
    les [choses|événements|évènements] suivant leur cours ?[endiablé|effréné|frénétique|implacable|inarrêtable]¿
    loin d’ être
    loin s’ en [faut|fallait]
    malgré [ça|cela|ceci|tout]
    manu militari
    mezza voce
    mieux [vaut|valait] tard [que|qu’] jamais
    moins [tôt|tard]
    moins [que|qu’] [nécessaire|prévu]
    moitié *WORD ?,¿ moitié *WORD
    mot [à|pour] mot
    ne [lui|leur|m’|t’|nous|vous] en déplaise
    nez à nez
    ?[de|d’]¿ n’importe où
    ni plus ?,¿ ni moins
    ni vu ?,¿ ni connu
    non [plus|seulement]
    non sans raison
    non sans mal
    ¿[de|d’|vers]¿ nulle part
    ô combien
    ou quelque chose d’ [approchant|identique]
    ou quelque chose [de|d’] similaire
    où bon [me|te|lui|nous|vous|leur] semble
    oui [ou|et] non
    outre mesure
    par [à-coups|ailleurs|avance|chance|conséquent|curiosité|contre|défaut|définition|endroits|essence|excellence|exemple|hasard|ici|inadvertance|là|mégarde|nature|principe|terre]
    par ?simple¿ acquit [de|d’] conscience
    par [beau|mauvais] temps
    par bien des [aspects|côtés]
    par ?[pure|simple]¿ bonté [de|d’] [âme|cœur]
    par ce biais
    par certains [aspects|côtés]
    par définition
    par ex .
    p. ex .
    par grand froid
    par gros temps
    par la force des choses
    par mesure [de|d’] sécurité
    par monts et par vaux
    par personne interposée
    par personnes interposées
    par tout le monde
    par voie [de|d’] [conséquence|mer|terre]
    par voie d’ exception
    par-ci ?,¿ par-là
    par-derrière
    par-dessus le marché
    par-dessus tout
    par-devant
    par là ?même¿
    par [un|le] simple effet du hasard
    partant [de|d’] là
    pas du tout
    pas [le|l’] moins du monde
    pas à pas
    petit à petit
    peu ou prou
    peu à peu
    pile poil
    plein [nord|sud|ouest]
    plus bas [que|qu’] terre
    plus du tout
    plus ou moins
    plus [que|qu’] [nécessaire|prévu|jamais]
    plus [que|qu’] tout au monde
    plus [que|qu’] toute autre chose
    pour [ce|c’] [que|qu’] [ça|cela|ceci] vaut
    pour [ce|c’] [que|qu’] j’ en [sais|savais|sus|saurai|saurais]
    pour [ce|c’] [que|qu’] tu en [sais|savais|sus|sauras|saurais]
    pour [ce|c’] [que|qu’] [il|elle|on|iel] en [sait|savait|sut|saura|saurait]
    pour [ce|c’] [que|qu’] nous en [savons|savions|sûmes|saurons|saurions]
    pour [ce|c’] [que|qu’] vous en [savez|saviez|sûtes|saurez|sauriez]
    pour [ce|c’] [que|qu’] [ils|elles|iels] en [savent|savaient|surent|sauront|sauraient]
    pour [celui|celle|ceux|celles] et [celui|celle|ceux|celles] [que|qu’] [ça|cela|ceci] intéresse
    pour [celui|celle|ceux|celles] [que|qu’] [ça|cela|ceci] intéresse
    pour [ma|ta|sa|notre|votre|leur] [gouverne|part]
    pour [mon|ton|son|notre|votre|leur] propre [compte|bien]
    pour [m’|t’|s’|nous|vous|leur] en rendre compte
    pour ainsi dire
    pour ce faire
    pour ce [que|qu’] [j’|tu] en [sais|savais]
    pour couronner le tout
    pour [de|d’] bon
    pour faire bonne mesure
    pour faire simple
    pour la plupart
    pour la suite
    pour [le|l’] [mieux|moment|moins]
    pour [le|l’] meilleur et pour [le|l’] pire
    pour l’ amour du ciel
    pour l’ [essentiel|instant|heure]
    pour quelque part
    pour >raison [de|d’] santé ?[défaillante|déficiente|fragile]¿
    pour rien au monde
    pour tout dire
    pour un oui ou pour un non
    pour une bonne part
    pour y parvenir
    pour ça [vaut|valait]
    quand bien même
    quand bon [me|te|lui|nous|vous|leur] [semble|semblera|semblait]
    quant à [ça|cela|ceci]
    qu’ à cela ne tienne
    [que|qu’] [ça|ceci|cela] [me|te|lui|leur|nous|vous] plaise ou non
    ##
    [que|qu’] je [le|l’] veuille ou non
    [que|qu’] tu [le|l’] veuilles ou non
    qu’ [il|elle|on|iel] [le|l’] veuille ou non
    [que|qu’] vous [le|l’] vouliez ou non
    [que|qu’] nous [le|l’] voulions ou non
    qu’ [ils|elles|iels] [le|l’] veuillent ou non
    ##
    [que|qu’] [je|j’] m’ en réjouisse ou que [je|j’] le déplore
    [que|qu’] tu t’ en réjouisses ou que tu le déplores
    qu’ [il|elle|iel|on] s’ en réjouisse ou qu’ [il|elle|iel|on] le déplore
    [que|qu’] nous nous en réjouissions ou que nous le déplorions
    [que|qu’] vous vous en réjouissez ou que vous le déploriez
    qu’ [ils|elles|iels] s’ en réjouissent ou qu’ [ils|elles|iels] le déplorent
    ##
    quel qu’ en soit [le|l’] [moyen|prix|danger]
    quel qu’ en soit [le|l’] risque ?[économique|financier|légal|juridique|militaire]¿
    quelle qu’ en soit la [cause|raison]
    quelque peu
    ?[de|d’]¿ quelque part
    qui plus est
    quoi qu’ il [arrive|arrivât|advienne|advînt]
    quoi qu’ il soit [arrivé|advenu]
    quoi qu’ il en [coûte|coûtât|coute|coutât]
    ric et rac
    rien [que|qu’] d’ y penser
    sauf >erreur [de|d’] [ma|ta|sa|notre|votre|leur] part
    sans ?grand¿ succès
    sans [broncher|déconner|réagir|tarder]
    sans [ambages|arrêt|cesse|conteste|doute|encombre|encombres|équivalent|fin|relâche|répit|trêve|vergogne]
    sans [grande|grosse] difficulté ?[apparente|aucune|financière|majeure|particulière]¿
    sans aucun doute
    sans autre forme [de|d’] procès
    sans commune mesure
    sans contredit
    sans coup férir
    sans crier gare
    sans difficulté ?[apparente|aucune|financière|majeure|particulière]¿
    sans dire mot
    sans en avoir conscience
    sans >état d’ âme
    sans [m’|t’|s’|nous|vous] en apercevoir
    sans [m’|t’|s’|nous|vous] en rendre compte
    sans [me|m’|te|t’|se|s’|nous|vous] faire [attendre|avoir|comprendre|désirer|entendre|prier|remarquer|repérer|surprendre|voir]
    sans [me|m’|te|t’|se|s’|nous|vous] douter [de|d’] rien
    sans faire [de|d’] vagues
    sans foi ?,¿ ni loi
    sans grand résultat
    sans [le|l’] faire exprès
    sans [le|l’] moindre scrupule
    sans [le|l’] vouloir
    sans l’ aide [de|d’] personne
    sans l’ ombre d’ un doute
    sans lever le petit doigt
    sans mot dire
    sans nul doute
    sans perdre [de|d’] temps
    sans pour autant y [parvenir|réussir|réfléchir|songer|penser]
    sans pour autant y [faire|prêter] attention
    sans pour autant y prendre [garde|goût|gout]
    sans [me|m’|te|t’|lui|nous|vous|leur|y] prêter attention
    sans [que|qu’] je [le|l’] [sache|susse]
    sans [que|qu’] tu [le|l’] [saches|susses]
    sans [que|qu’] [il|elle|on|$:M] [le|l’] [sache|sût]
    sans [que|qu’] nous [le|l’] [sachions|sussions]
    sans [que|qu’] vous [le|l’] [sachiez|sussiez]
    sans [que|qu’] [ils|elles|iels] [le|l’] [sachent|sussent]
    sans s’ en rendre compte
    sans que [je|j’] m’ en [rende|rendisse] compte
    sans que tu t’ en [rendes|rendisses] compte
    sans qu’ [il|elle|on|iel] s’ en [rende|rendît] compte
    sans que nous nous en [rendions|rendissions] compte
    sans que vous vous en [rendions|rendissiez] compte
    sans qu’ [ils|elles|iels] s’ en [rendent|rendissent] compte
    sans queue ni tête
    sans précédent
    sans raison apparente
    sans résultat probant
    sans tambour ?,¿ ni trompette
    sans [croiser|rencontrer|voir] personne
    sans [croiser|rencontrer|voir] âme qui vive
    sans ?jamais¿ [ciller|flancher|tergiverser]
    sans vouloir [me|m’|te|t’|lui|nous|vous|leur] manquer [de|d’] respect
    sans y [croire|parvenir|réussir|réfléchir|songer|penser]
    sans y [faire|prêter] attention
    sans y prendre [garde|goût|gout|ombrage]
    selon toute [apparence|vraisemblance]
    sens dessus dessous
    sens devant derrière
    >seul à >seul
    s’ il le [faut|fallait|fallut|faudra|faudrait]
    s’ il l’ [a|avait|eut|aura|aurait] fallu
    si [bas|haut|longtemps|nécessaire|peu|possible|soudain]
    si [cela|ça|ceci] ne tenait qu’ à [moi|toi|lui|eux|elle|elles|nous|vous|iel|iels]
    si besoin est
    si le besoin s’ en [fait|faisait] sentir
    si le besoin [doit|devait] s’en faire sentir
    si tel est le cas
    si tant est que ce ?[ne|n’]¿ [soit|fût] ?pas¿ @:A.*:[me]:[si]
    sine qua non
    sitôt dit ?,¿ sitôt fait
    six pieds sous terre
    soit dit en passant
    sous aucun prétexte
    sous bonne [escorte|garde]
    sous coupe réglée
    sous haute [surveillance|tension]
    stricto sensu
    sur [mon|ton|son|notre|votre|leur] [trente-et-un|31]
    sur [mon|ton|son|notre|votre|leur] trente et un
    sur ce ,
    sur ce plan-là
    sur la défensive
    sur le devant [de|d’] la scène
    sur la forme comme sur le fond
    sur la même longueur d’ onde
    sur la sellette
    sur le fil du rasoir
    sur le plan [local|cantonal|départemental|régional|national|européen|américain|africaine|asiatique|continental|international|planétaire|galactique|universel]
    sur le pied [de|d’] guerre
    sur le qui-vive
    s’ il [te|vous] [plaît|plait]
    tant bien que mal
    tant s’ en faut
    tour à tour
    tout aussi
    tous comptes faits
    tous ensemble
    tous frais payés
    tout [bonnement|simplement]
    tout au plus
    tout aussi bien
    tout bien [considéré|réfléchi|pesé]
    tout compte fait
    tout [de|d’] même ?[pas|jamais]¿
    tout du long
    tout feu ?,¿ tout >flamme
    tout à fait
    tout [de|d’] go
    toute honte bue
    toutes choses égales par ailleurs
    toutes ensemble
    toutes griffes dehors
    toutes proportions gardées
    toutes voiles dehors
    trait pour trait
    tremblant de tout [mon|ton|son|notre|votre|leur] corps
    très [bas|haut|bien|mal]
    un à un
    une à une
    un petit peu
    un peu
    un peu mieux
    un peu moins bien
    un peu partout
    un tant soit peu
    un tout petit peu
    urbi et orbi
    vaille que vaille
    ventre à terre
    vers nulle part
    vite fait ?,¿ bien fait
        <<- &>> :LW



!!
!!
!!!! Noms propres                                                                                 !!
!!
!!

#    <<- \1 == \2
#        and not value(\2, "|nous|vous|faire|en|la|lui|donnant|œuvre|ah|oh|eh|hé|ho|ha|hou|olé|joli|Bora|couvent|dément|sapiens|très|vroum|")
#        and not (value(\1, "|est|une|") and value(<1, "|l’|d’|"))
#        and not (\2 == "mieux" and value(<1, "|qui|"))
#    ->> \1                                                                                          && Doublon.
#
#TEST: Il y a un {{doublon doublon}}.                                                                ->> doublon



!!
!!
!!!! Élisions & euphonie                                                                          !!
!!
!!

!!!
!!!
!!! Processeur: épuration des adverbes, locutions adverbiales, interjections et expressions usuelles  !!
!!!
!!!


















































































































































































































































__purge_locutions_adverbiales__
    &:LW









        <<- ~>> *



































































































































































































































































































































































































































__purge_adverbes_temporels__


























































    après-demain


































































































































    aujourd’hui




    auparavant
    aussitôt









    avant-hier








































































































    déjà
    demain
    désormais
    dorénavant
    hier
    maintenant
    parfois
    quelquefois
    soudain
    souvent
    sur-le-champ
    tard
    toujours
    toutefois
        <<- ~>> *

    tôt
        <<- not (value(>1, "|fait|") and value(>2, "|de|d’|") and morph(<1, ">avoir/")) ~>> *
































































































































__purge_un_nombre__
    un  *NUM  @:A.*:s¬:G
        <<- ~2>> *

TEST: l’équipe veut aussi voir dans la lettre le nombre d’or, un symbole d’harmonie, ainsi qu’un 6 retourné.


__purge_début_phrase__
    <start>  car
    <start>  de plus
    <start>  et  ?puis¿
    <start>  mais
    <start>  m’  est   avis  [que|qu’]
    <start>  or  donc
    <start>  puis
    [<start>|,|(] grand bien lui fasse
        <<- ~2:0>> *



































__purge_locutions_incises__
    [<start>|,|(] [oui|non] [<end>|,|)]
    [<start>|,|(] ?oui¿ ou non [<end>|,|)]
    [<start>|,|(] et non l’ inverse [<end>|,|)]
    [<start>|,|(] fait remarquable [<end>|,|)]
    [<start>|,|(] entre autres ?choses¿ [<end>|,|)]
    [<start>|,|(] mieux encore [<end>|,|)]
    [<start>|,|(] n’ est-ce pas [<end>|)]
        <<- ~2:-2>> *















































__purge_adverbes__














































































































































































































































    ah
    ailleurs
    alors













































    aussi






























    bientôt



    cahin-caha



    cependant



    certes
    ci-dessous
    ci-dessus












































































































































































































    debout
    derechef

    donc



































































































































































    enfin





    entre-temps
    entretemps
    ensuite







    euh





    guère











    intra-muros









    là

    là-bas
    là-haut
    là-dedans
    là-dehors
    là-derrière
    là-dessous
    là-dessus
    là-devant

















    loin









    mouais
    naguère

    néanmoins









    oh

































    partout






    peut-être








    plutôt

































    pourtant
    près
    presque
    primo











































    soi-disant















































    secondo




































    surtout



    tantôt
    tertio






















    très














    volontiers
        <<- ~>> *


__purge_l_un_l_autre_les_uns_les_autres__
    à l’ un et ?à¿ l’ autre ?>sexe¿
    à l’ un comme à l’ autre ?>sexe¿

    village [après|par] village
    voiture [après|par] voiture
    wagon [après|par] wagon
        <<- not morph(<1, ":D") ~>> *


__gestion_mots_grammaticaux__






































































    tout au [bout|long] [de|du|d’|des]
        <<- not morph(<1, ":R") ~1>> *






    ainsi
        <<- not value(>1, "|que|qu’|") ~>> *

    alentour
        <<- not morph(<1, ":D") ~>> *

    au moins  @:[DB]

    pas [assez|trop]
        <<- not morph(<1, ":D.*:(?:m:s|[me]:p)") ~1>> *

    pour  toujours  @:[AQ]
        <<- ~1:2>> *


__purge_adverbes2__
    [assez|trop]  ~ment$
        <<- morph(\2, ":W", ":3p") ~>> *

    @:[NAQ]  [le|la]  [plus|moins]  ~.ment$  $:A
        <<- morph(\-2, ":W", ":A") ~2:-2>> *

    complètement

TEST: Les études révèlent un risque d’écrêtement du trafic ferroviaire dès 2025, lorsque la demande est la plus critique, c’est-à-dire le vendredi soir à l’heure de pointe.
TEST: Beaucoup de conciles émaneront des normes pour que soient nommés des curés idoines, qui soient vraiment au service de la paroisse, qui se distinguent par leur science et qui soient de vrais pasteurs au sein de la communauté de fidèles.
TEST: Les ailes de cet avion viennent de Grande-Bretagne.
TEST: La liberté passait sur le monde, l’internationale était sa voix criant par-dessus les frontières les revendications des déshérités.
TEST: La danse est d’ailleurs en ce sens salvatrice.
TEST: La gauche a fait main basse sur la plupart des villes vaudoises, les Verts bondissent aux législatifs.
TEST: un rien peut nous déconcentrer
TEST: cette organisation est à partir de 1945 composée de membres venus de…



@@@@
@@@@
@@@@
@@@@

        <<- /conf/ -3>> nues                                    && Confusion. Écrivez “nues” (ancien terme pour “nuages”).|https://fr.wiktionary.org/wiki/tomber_des_nues

TEST: Elle en est tombée des {{nus}}.                           ->> nues


# numérique / digital
__conf_numérique_digital__
    [>agence|>appareil|>banque|>caméra|>colonie|>colonisation|>communication|>compagnie|>connexion]     >digital
    [>document|>économie|>entreprise|>ère|>expérience|>fichier|>identité|>industrie|>présence|>prise]   >digital
    [>service|>solution|>stratégie|>télévision|>transformation|>transition|>révolution]                 >digital
        <<- /conf/ -2>> numérique|numériques
        && Confusion : “digital” est un adjectif se rapportant aux doigts (empreinte digitale, arthrose digitale, etc.). Écrivez “numérique”.

    [le|du|au] digital
        <<- /conf/ -2>> numérique
        && Confusion : “digital” est un adjectif se rapportant aux doigts (empreinte digitale, arthrose digitale, etc.). Écrivez “numérique”.

TEST: deux femmes, {{blessé}} par deux fois                                                 ->> blessées
TEST: trois hommes, {{blessée}} dans leur orgueil                                           ->> blessés


__gn_des_2m__
    des  *WORD  *WORD
        <<- /gn/ (morphx(\1, ":LR") or morph(<1, ":(?:[VRBXÉ]|Cs)|>comme/|<start>|>[(,]", "*") or morph(\3, ":N", ":[AQ]")) and not morph(\3, ">(?:seul|minimum|maximum)/") >>>
        <<- /gn/ ( (morph(\2, ":[NA].*:m", ":[fe]") and morph(\3, ":[NA].*:f", "*")) or (morph(\2, ":[NA].*:f", ":[me]") and morph(\3, ":[NA].*:m", "*")) ) and not apposition(\2, \3)
        -3>> =switchGender(\3, True)                                                                && Accord de genre erroné avec « \2 ».
        <<- /gn/ __also__ and hasFemForm(\2) -2>> =switchGender(\2)                                 && Accord de genre erroné avec « \3 ».
        <<- /gn/ morph(\2, ":[NA].*:[pi]", ":G") and morph(\3, ":[NA].*:s", "*") and not apposition(\2, \3) and not (value(>1, "|et|,|") and morph(>2, ":A"))
        -3>> =suggPlur(\3)                                                                          && Accord de nombre erroné avec « \1 \2 » : « \3 » devrait être au pluriel.
        <<- not morph(\3, ":G|>a/") and agreement(\2, \3) =>> =select(\3, "", ":V")

TEST: à {{grande}} {{enjambées}}                                ->> grandes|||enjambée
TEST: pour {{grande}} {{appartement}}                           ->> grand|||
TEST: une femme sans a priori


__gn_pfx_de_2m__
    [de|d’]  @:[NA]¬:[YG]  @:[NA]¬*
        <<- /gn/ (morphx(\1, ":LR") or not morph(<1, ":[NA]|>(?:et|ou)/")) and not apposition(\2, \3) >>>
        <<- /gn/ (morph(\2, ":m", ":[fe]") and morph(\3, ":f", "*")) or (morph(\2, ":f", ":[me]") and morph(\3, ":m", "*"))

        -3>> =switchGender(\3)                                                                      && Accord de genre erroné avec « \2 ».
        <<- /gn/ __also__ and hasFemForm(\2) -2>> =switchGender(\2)                                 && Accord de genre erroné avec « \3 ».
        <<- /gn/ (morph(\2, ":p", ":[si]") and morph(\3, ":s", "*")) or (morph(\2, ":s", ":[pi]") and morph(\3, ":p", "*"))

        -3>> =switchPlural(\3)                                                                      && Accord de nombre erroné avec « \2 ».
        <<- /gn/ __also__ -2>> =switchPlural(\2)                                                    && Accord de nombre erroné avec « \3 ».

TEST: Ils ont de {{grandes}} {{oreille}}                        ->> grande|||oreilles
TEST: de {{grands}} {{homme}}                                   ->> grand|||hommes
TEST: de {{petite}} {{homme}}                                   ->> petit|||
TEST: de {{pousse}} {{actif}}                                   ->> poussé|||active

    à deux doigts                               [de|d’]  ?[le|l’|la|leur|les|nous|vous|lui]¿  ~..(?:ée?s?|ez)$
        <<- /infi/ morph0(\-1, ":(?:Q|2p)", ":M") --1>> =suggVerbInfi(\-1)                          && Après “à deux doigts de”, le verbe devrait être à l’infinitif.

    à >seul >fin                                [de|d’]  ?[le|l’|la|leur|les|nous|vous|lui]¿  ~..(?:ée?s?|ez)$
        <<- /infi/ morph0(\-1, ":(?:Q|2p)", ":M") --1>> =suggVerbInfi(\-1)                          && Après “à seule fin de”, le verbe devrait être à l’infinitif.

    au lieu                                     [de|d’]  ?[le|les|nous|vous|lui]¿             ~..(?:ée?s?|ez)$
        <<- /infi/ morph0(\-1, ":(?:Q|2p)", ":M") --1>> =suggVerbInfi(\-1)                          && Après “au lieu de”, le verbe devrait être à l’infinitif.

    au lieu                                     [de|d’]  [l’|la|leur]                         ~..(?:ée?s?|ez)$
        <<- /infi/ morph0(\-1, ":(?:Q|2p)", ":[MN]") --1>> =suggVerbInfi(\-1)                       && Après “au lieu de”, le verbe devrait être à l’infinitif.

    >avoir l’ air                               [de|d’]  ?[le|l’|la|leur|les|nous|vous|lui]¿  ~..(?:ée?s?|ez)$
        <<- /infi/ morph0(\-1, ":(?:Q|2p)", ":M") --1>> =suggVerbInfi(\-1)                          && Après “avoir l’air de”, le verbe devrait être à l’infinitif.

    >avoir la chance                            [de|d’]  ?[le|l’|la|leur|les|nous|vous|lui]¿  ~..(?:ée?s?|ez)$
        <<- /infi/ morph0(\-1, ":(?:Q|2p)", ":M") --1>> =suggVerbInfi(\-1)                          && Après “avoir la chance de”, le verbe devrait être à l’infinitif.

    de  [la|l’|leur]  @:[NA]¬:Y  <end>
    de  [la|l’|leur]  @:[NA]¬:Y  ?,¿ [ne|n’|me|m’|te|t’|se|s’|nous|vous|y|c’|ça|ç’|je|j’|tu|il|elle|on|ils|elles|iel|iels|le|la|l’|les|mon|ma|ta|sa|notre|votre|leur|mes|tes|ses|nos|vos|leurs|ce|cet|cette|ces|quel|quels|quelle|quelles|est]
    de  [la|l’|leur]  @:[NA]¬:Y  @:[VR]¬:[NAP]
    de  [la|l’|leur]  @:[NA]¬:Y  , @¬:[NA]
    de  [la|l’|leur]  @:[NA]¬:Y  ?,¿  [/_VCint_|/_VCimp_]
        <<- ~1:3>> *

    &:LR  [la|l’|leur|un|une|ce|cet|cette|ces|mon|ton|son|ma|ta|sa|mes|tes|ses|notre|votre|nos|vos|leurs]  @:[NA]  <end>
    &:LR  [la|l’|leur|un|une|ce|cet|cette|ces|mon|ton|son|ma|ta|sa|mes|tes|ses|notre|votre|nos|vos|leurs]  @:[NA]  [ne|n’|me|m’|te|t’|se|s’|nous|vous|y|c’|ça|ç’|je|j’|tu|il|elle|on|ils|elles|iel|iels|le|la|l’|les|mon|ma|ta|sa|notre|votre|leur|mes|tes|ses|nos|vos|leurs|ce|cet|cette|ces|quel|quels|quelle|quelles|est]
    &:LR  [la|l’|leur|un|une|ce|cet|cette|ces|mon|ton|son|ma|ta|sa|mes|tes|ses|notre|votre|nos|vos|leurs]  @:[NA]  @:[VR]¬:[NAP]
    &:LR  [la|l’|leur|un|une|ce|cet|cette|ces|mon|ton|son|ma|ta|sa|mes|tes|ses|notre|votre|nos|vos|leurs]  @:[NA]  [/_VCint_|/_VCimp_]
        <<- ~1:-2>> *

    &:LR  [la|l’|leur|un|une|ce|cet|cette|ces|mon|ton|son|ma|ta|sa|mes|tes|ses|notre|votre|nos|vos|leurs]  @:[NA]  ,  @:¬:A
    &:LR  [la|l’|leur|un|une|ce|cet|cette|ces|mon|ton|son|ma|ta|sa|mes|tes|ses|notre|votre|nos|vos|leurs]  @:[NA]  ,  [/_VCint_|/_VCimp_]
        <<- ~1:-3>> *

    &:LR @:[NA] <end>
    &:LR @:[NA] [ne|n’|me|m’|te|t’|se|s’|nous|vous|y|c’|ça|ç’|je|j’|tu|il|elle|on|ils|elles|iel|iels|le|la|l’|les|mon|ma|ta|sa|notre|votre|leur|mes|tes|ses|nos|vos|leurs|ce|cet|cette|ces|quel|quels|quelle|quelles|est]
    &:LR @:[NA] @:[VR]¬:[NAP]
    &:LR @:[NA] [/_VCint_|/_VCimp_]
        <<- ~1:-2>> *

    &:LR @:[NA] ,  @:¬:A
    &:LR @:[NA] ,  [/_VCint_|/_VCimp_]
        <<- ~1:-3>> *

    en [plein|pleine] @:[NA]  <end>
    en [plein|pleine] @:[NA]  ?,¿ [ne|n’|me|m’|te|t’|se|s’|nous|vous|y|c’|ça|ç’|je|j’|tu|il|elle|on|ils|elles|iel|iels|le|la|l’|les|mon|ma|ta|sa|notre|votre|leur|mes|tes|ses|nos|vos|leurs|ce|cet|cette|ces|quel|quels|quelle|quelles|est]
    en [plein|pleine] @:[NA]  @:[VR]¬:[NAP]
    en [plein|pleine] @:[NA]  , @¬:[NA]
    en [plein|pleine] @:[NA]  ?,¿  [/_VCint_|/_VCimp_]
        <<- ~1:3>> *

    [<start>|,|(]  [ne|n’]  ?[le|la|l’|les|en|me|m’|te|t’|nous|vous|lui|leur|y]¿  vas
    [<start>|,|(]  [ne|n’]  [me|m’|te|t’|nous|vous]  [le|la|l’|les|en|y]          vas
    [<start>|,|(]  [ne|n’]  [le|la|l’|les]           [lui|leur|en|y]              vas
    [<start>|,|(]  [ne|n’]  [lui|leur]               en                           vas
    [<start>|,|(]  vas
        <<- /imp/ not tagbefore(\2, "_CUT_") and not value(>1, "|tu|") --1>> va     && S’il s’agit d’un impératif, pas de “s”.

TEST: {{Vas}} lui mettre une branlée.                                                       ->> Va
TEST: {{Vas}} au diable !                                                                   ->> Va
TEST: N’y {{vas}} pas                                                                       ->> va
TEST: Si vraiment tu es d’attaque et que Martine est d’accord, {{vas}} dans…                ->> va
TEST: — Va-t’en ! [Firefox]


# verbes du 1ᵉʳ et du 3ᵉ groupe en -e
__imp_verbe_groupe1__
    <start>  [ne|n’]  ?[le|la|l’|les|en|me|m’|te|t’|nous|vous|lui|leur|y]¿  ~\w\w+es$
    <start>  [ne|n’]  [me|m’|te|t’|nous|vous]  [le|la|l’|les|en|y]          ~\w\w+es$
    <start>  [ne|n’]  [le|la|l’|les]           [lui|leur|en|y]              ~\w\w+es$
    <start>  [ne|n’]  [lui|leur]               en                           ~\w\w+es$
        <<- /imp/ not tagbefore(\2, "_CUT_") and morph(\-1, ":V[13].*:Ip.*:2s", ":G") and not value(>1, "|tu|")
        --1>> =\-1[:-1]                                                             && S’il s’agit d’un impératif, pas de “s”.

    <start>  ~\w\w+es$
        <<- /imp/ not tagbefore(\2, "_CUT_") and morph(\-1, ":V[13].*:Ip.*:2s", ":[GNAM]") and not value(>1, "|tu|")
        --1>> =\-1[:-1]                                                             && S’il s’agit d’un impératif, pas de “s”.

TEST: {{Apportes}} ton fric à cet homme.                                                    ->> Apporte
TEST: N’{{abandonnes}} pas si vite.                                                         ->> abandonne
TEST: Ne {{demandes}} rien, tais-toi.                                                       ->> demande
TEST: — {{Abandonnes}}.                                                                     ->> Abandonne
TEST: {{Écartes}} de moi cette coupe.                                                       ->> Écarte
TEST: Ne {{donnes}} pas autant.                                                             ->> donne
TEST: N’{{insistes}} pas.                                                                   ->> insiste
TEST: Castres est une belle ville.
TEST: Limoges aussi.


# verbes du 2ᵉ et du 3ᵉ groupe en -t
__imp_verbe_groupe2_groupe3_t__
    <start>  [ne|n’]  ?[le|la|l’|les|en|me|m’|te|t’|nous|vous|lui|leur|y]¿  ~\w\w+t$
    <start>  [ne|n’]  [me|m’|te|t’|nous|vous]  [le|la|l’|les|en|y]          ~\w\w+t$
    <start>  [ne|n’]  [le|la|l’|les]           [lui|leur|en|y]              ~\w\w+t$
    <start>  [ne|n’]  [lui|leur]               en                           ~\w\w+t$
        <<- /imp/ not tagbefore(\2, "_CUT_") and not value(>1, "|il|elle|on|ils|elles|iel|iels|")
            and not value(\-1, "|provient|")
            and not (value(\-1, "|vient|dit|surgit|survient|périt|") and morph(>1, ":(?:[MD]|Oo)|>[A-Z]/"))
            and morph(\-1, ":V[23].*:Ip.*:3s", ":G|>(?:devoir|suffire|para[îi]tre)/") and analyse(\-1[:-1]+"s", ":E:2s")
        --1>> =\-1[:-1]+"s"                                                         && S’il s’agit d’un impératif, la terminaison est “s”, non “t”.

    <start>  ~\w\w+t$
        <<- /imp/ not tagbefore(\2, "_CUT_") and not value(>1, "|il|elle|on|ils|elles|iel|iels|")
            and not value(\-1, "|provient|")
            and not (value(\-1, "|vient|dit|surgit|survient|périt|") and morph(>1, ":(?:[MDR]|Oo)|>[A-Z]/"))
            and morph(\-1, ":V[23].*:Ip.*:3s", ":[GNA]|>(?:devoir|suffire|para[îi]tre)/") and analyse(\-1[:-1]+"s", ":E:2s")
        --1>> =\-1[:-1]+"s"                                                         && S’il s’agit d’un impératif, la terminaison est “s”, non “t”.

TEST: {{Finit}} ton assiette.                                           ->> Finis
TEST: Ne {{pourrit}} pas l’ambiance.                                    ->> pourris

# verbes du 3ᵉ groupe en -d
__imp_verbe_groupe3_d__
    <start>  [ne|n’]  ?[le|la|l’|les|en|me|m’|te|t’|nous|vous|lui|leur|y]¿  ~\w\w+d$
    <start>  [ne|n’]  [me|m’|te|t’|nous|vous]  [le|la|l’|les|en|y]          ~\w\w+d$
    <start>  [ne|n’]  [le|la|l’|les]           [lui|leur|en|y]              ~\w\w+d$
    <start>  [ne|n’]  [lui|leur]               en                           ~\w\w+d$
        <<- /imp/ not tagbefore(\2, "_CUT_") and not value(>1, "|il|elle|on|")
            and not ( value(\-1, "|répond|") and (morph(>1, ":[MD]|>[A-Z]/") or value(>1, "|l’|d’|")) )
            and morph(\-1, ":V3.*:Ip.*:3s", ":G")
        --1>> \-1s                                                                  && S’il s’agit d’un impératif, ajoutez un “s”.

    <start>  ~\w\w+d$
        <<- /imp/ not tagbefore(\2, "_CUT_") and not value(>1, "|il|elle|on|")
            and not ( value(\-1, "|répond|") and (morph(>1, ":[MD]|>[A-Z]/") or value(>1, "|l’|d’|")) )
            and morph(\-1, ":V3.*:Ip.*:3s", ":[GNA]")
        --1>> \-1s                                                                  && S’il s’agit d’un impératif, ajoutez un “s”.

TEST: {{Prend}} le chemin de droite.                                    ->> Prends
TEST: N’{{attend}} pas qu’elle vienne.                                  ->> attends
TEST: Ne me {{prend}} pas pour un idiot                                 ->> prends
TEST: Ne l’{{attend}} pas                                               ->> attends
TEST: Ne m’y {{attend}} pas                                             ->> attends
TEST: {{Attend}} la correction.                                         ->> Attends
TEST: {{Répond}}.                                                       ->> Réponds
TEST: — Pour ma part, répond P., je crois que tout va bien.
TEST: […] vient nous faire la morale


!!
!!
!!!! Impératif : traits d’union manquants                                                         !!
!!
!!

    ## _VCOD_
    [ne|n’] [le|l’|la|les] ?[lui|leur]¿                 @:V¬:[GQ]
    [ne|n’] [nous|vous] [le|l’|la|les]                  @:V¬:[GQ]
    [je|tu|il|ils|me|m’|te|t’|se|s’] [le|l’|la|les]     @:V¬:[GQ]
    [le|l’|la|les]                                      @:V¬:[GNAWQTML]
        <<- /-1>> _VCOD_

    [me|m’|te|t’] @:V...t¬:[GQ]
        <<- /-1>> _VCOD_

    [elle|elles|iel|iels|nous|vous]  [le|l’|la|les]    @:V¬:[GQ]
        <<- not morph(<1, ":R") /-1>> _VCOD_


__purge_préverbes2__
    nous              [le|la|l’|les|en|y]  @:(?:[123][sp]|P|Y)¬:(?:X|1p)

    >attendre  [que|qu’]  [les|ces|mes|tes|ses|nos|vos|leurs|plusieurs|quelques|certains|certaines|maints|maintes]   @:N.*:[pi]  @:I¬:[GYSA]
        <<- /vmode/ not morph(\1, ":Q") --1>> =suggVerbMode(\-1, ":S", ":3p")                       && Après “attendre que”, ce verbe devrait être au subjonctif.

TEST: j’attends que tu {{viens}}.                                                   ->> viennes|vinsses
TEST: Attends que Céline {{dort}}                                                   ->> dorme|dormît
TEST: nous attendions que les petits {{étaient}} partis                             ->> soient|fussent|étayent|étayassent
TEST: c’était si attendu qu’il avait renoncé avant même d’y aller


__vmode_il_importe_que_subjonctif__
    il  >importer  [que|qu’]  [je|j’|tu|il|elle|iel|nous|vous|ils|elles|iels]  @:I¬:[GYS]
        <<- /vmode/ --1>> =suggVerbMode(\-1, ":S", \-2)                                             && Après le syntagme “il importe que”, ce verbe devrait être au subjonctif.

    il  >importer  [que|qu’]  $:M  @:I¬:[GYS]

        {   "name": "Entity Valid",         "scope": "entity.valid",        "foreground": "hsl(150, 100%, 80%)",    "background": "hsl(150, 100%, 20%)",    "font_style": "bold",   },
        {   "name": "Entity Invalid",       "scope": "entity.invalid",      "foreground": "hsl(0, 100%, 80%)",      "background": "hsl(0, 100%, 20%)",      "font_style": "bold",   },
        {   "name": "Token meta",           "scope": "string.meta",         "foreground": "hsl(270, 100%, 90%)",    "background": "hsl(270, 100%, 40%)",  },
        {   "name": "Token token",          "scope": "string.token",        "foreground": "hsl(240, 50%, 90%)",     "background": "hsl(240, 50%, 40%)",  },
        {   "name": "Token Jumptoken",      "scope": "string.jumptoken",    "foreground": "hsl(0, 50%, 90%)",       "background": "hsl(10, 50%, 40%)",  },
        {   "name": "Token lemma",          "scope": "string.lemma",        "foreground": "hsl(210, 100%, 80%)",    "background": "hsl(210, 100%, 15%)",  },
        {   "name": "Token phonet",         "scope": "string.phonet",       "foreground": "hsl(90, 100%, 80%)",     "background": "hsl(90, 100%, 10%)",  },
        {   "name": "Token tag",            "scope": "string.tag",          "foreground": "hsl(30, 100%, 90%)",     "background": "hsl(30, 100%, 20%)",  },
        {   "name": "Token regex",          "scope": "string.regex",        "foreground": "hsl(60, 100%, 80%)",     "background": "hsl(60, 100%, 10%)",  },
        {   "name": "Token morph regex",    "scope": "string.morph.regex",  "foreground": "hsl(150, 80%, 90%)",     "background": "hsl(150, 80%, 10%)",  },
        {   "name": "Token morph negregex", "scope": "string.morph.negregex", "foreground": "hsl(0, 80%, 90%)",     "background": "hsl(0, 80%, 10%)",  },
        {   "name": "MulToken morph regex", "scope": "string.mt.morph.regex", "foreground": "hsl(180, 80%, 90%)",   "background": "hsl(180, 80%, 10%)",  },


        {   "name": "Keyword Python",       "scope": "keyword.python",      "foreground": "#A0A0A0",  },

        {   "name": "Keyword",              "scope": "keyword - (source.c keyword.operator | source.c++ keyword.operator | source.objc keyword.operator | source.objc++ keyword.operator), keyword.operator.word",  "foreground": "#F06070", },
        {   "name": "String",               "scope": "string",              "foreground": "hsl(40, 100%, 80%)",  },
        {   "name": "Number",               "scope": "constant.numeric",    "foreground": "hsl(270, 100%, 70%)",                                            "font_style": "bold",  },

    - match: '(@)([^@\s¬]*)'
      scope: string.morph
      captures:
        1: entity.valid
        2: string.morph.regex

    - match: '(\$)([^\s¬]*)'
      scope: string.morph
      captures:
        1: entity.valid
        2: string.morph.regex

    - match: '(&)([^\s¬]*)'
      scope: string.morph
      captures:
        1: entity.valid
        2: string.mt.morph.regex

    - match: '(/)[\w-]+'
      scope: string.tag
      captures:
        1: entity.valid

    - match: '(?<=[^\w])([*][a-zA-Z0-9_]+)'
      scope: string.morph