Grammalecte  Check-in [ae2968927f]

// list of similar chars
// useful for suggestion mechanism

${map}


function distanceDamerauLevenshtein (s1, s2) {
    // distance of Damerau-Levenshtein between <s1> and <s2>
    // https://fr.wikipedia.org/wiki/Distance_de_Damerau-Levenshtein
    let d = new Map();
    let nLen1 = s1.length;
    let nLen2 = s2.length;
    for (let i = -1;  i <= nLen1;  i++) {
        d.set([i, -1], i + 1);
    }
    for (let j = -1;  i <= nLen2;  i++) {
        d.set([-1, j], j + 1);
    }
    for (let i = 0;  i < nLen1;  i++) {
        for (let j =0;  j < nLen2;  i++) {
            let nCost = (s1[i] === s2[j]) ? 0 : 1;
            d.set([i, j], Math.min(
                d.get([i-1, j]) + 1,        // Deletion
                d.get([i,   j-1]) + 1,      // Insertion
                d.get([i-1, j-1]) + nCost,  // Substitution
            ));
            if (i && j && s1[i] == s2[j-1] && s1[i-1] == s2[j]) {
                d.set([i, j], Math.min(d.get([i, j]), d.get([i-2, j-2]) + nCost));  // Transposition
            }
        }
    }
    return d.get([nLen1-1, nLen2-1]);
}


// Method: Remove Useless Chars

const aVovels = new Set([
    'a', 'e', 'i', 'o', 'u', 'y',
    'à', 'é', 'î', 'ô', 'û', 'ÿ',
    'â', 'è', 'ï', 'ö', 'ù', 'ŷ',
    'ä', 'ê', 'í', 'ó', 'ü', 'ý',
    'á', 'ë', 'ì', 'ò', 'ú', 'ỳ',
    'ā', 'ē', 'ī', 'ō', 'ū', 'ȳ',
    'h', 'œ', 'æ'
]);


function clearWord (sWord) {
    // remove vovels and h
    let sRes = "";
    for (let cChar of sWord.slice(1)) {
        if (!aVovels.has(cChar)) {
            sRes += cChar;
        }
    }
    return sWord.slice(0, 1).replace("h", "") + sRes;
}


// Similar chars

const d1to1 = new Map([
    ["1", "liîLIÎ"],
    ["2", "zZ"],
    ["3", "eéèêEÉÈÊ"],
    ["4", "aàâAÀÂ"],
    ["5", "sgSG"],
    ["6", "bdgBDG"],
    ["7", "ltLT"],
    ["8", "bB"],
    ["9", "gbdGBD"],
    ["0", "oôOÔ"],

    ["a", "aàâáäæ"],
    ["A", "AÀÂÁÄÆ"],
    ["à", "aàâáäæ"],
    ["À", "AÀÂÁÄÆ"],
    ["â", "aàâáäæ"],
    ["Â", "AÀÂÁÄÆ"],
    ["á", "aàâáäæ"],
    ["Á", "AÀÂÁÄÆ"],
    ["ä", "aàâáäæ"],
    ["Ä", "AÀÂÁÄÆ"],

    ["æ", "æéa"],
    ["Æ", "ÆÉA"],

    ["c", "cçskqśŝ"],
    ["C", "CÇSKQŚŜ"],
    ["ç", "cçskqśŝ"],
    ["Ç", "CÇSKQŚŜ"],

    ["e", "eéèêëœ"],
    ["E", "EÉÈÊËŒ"],
    ["é", "eéèêëœ"],
    ["É", "EÉÈÊËŒ"],
    ["ê", "eéèêëœ"],
    ["Ê", "EÉÈÊËŒ"],
    ["è", "eéèêëœ"],
    ["È", "EÉÈÊËŒ"],
    ["ë", "eéèêëœ"],
    ["Ë", "EÉÈÊËŒ"],

    ["g", "gj"],
    ["G", "GJ"],
    
    ["i", "iîïyíìÿ"],
    ["I", "IÎÏYÍÌŸ"],
    ["î", "iîïyíìÿ"],
    ["Î", "IÎÏYÍÌŸ"],
    ["ï", "iîïyíìÿ"],
    ["Ï", "IÎÏYÍÌŸ"],
    ["í", "iîïyíìÿ"],
    ["Í", "IÎÏYÍÌŸ"],
    ["ì", "iîïyíìÿ"],
    ["Ì", "IÎÏYÍÌŸ"],

    ["j", "jg"],
    ["J", "JG"],

    ["k", "kcq"],
    ["K", "KCQ"],

    ["n", "nñ"],
    ["N", "NÑ"],

    ["o", "oôóòöœ"],
    ["O", "OÔÓÒÖŒ"],
    ["ô", "oôóòöœ"],
    ["Ô", "OÔÓÒÖŒ"],
    ["ó", "oôóòöœ"],
    ["Ó", "OÔÓÒÖŒ"],
    ["ò", "oôóòöœ"],
    ["Ò", "OÔÓÒÖŒ"],
    ["ö", "oôóòöœ"],
    ["Ö", "OÔÓÒÖŒ"],

    ["œ", "œoôeéèêë"],
    ["Œ", "ŒOÔEÉÈÊË"],

    ["q", "qck"],
    ["Q", "QCK"],

    ["s", "sśŝcç"],
    ["S", "SŚŜCÇ"],
    ["ś", "sśŝcç"],
    ["Ś", "SŚŜCÇ"],
    ["ŝ", "sśŝcç"],
    ["Ŝ", "SŚŜCÇ"],

    ["u", "uûùüú"],
    ["U", "UÛÙÜÚ"],
    ["û", "uûùüú"],
    ["Û", "UÛÙÜÚ"],
    ["ù", "uûùüú"],
    ["Ù", "UÛÙÜÚ"],
    ["ü", "uûùüú"],
    ["Ü", "UÛÙÜÚ"],
    ["ú", "uûùüú"],
    ["Ú", "UÛÙÜÚ"],

    ["v", "vw"],
    ["V", "VW"],

    ["w", "wv"],
    ["W", "WV"],

    ["x", "xck"],
    ["X", "XCK"],

    ["y", "yÿiîŷýỳ"],
    ["Y", "YŸIÎŶÝỲ"],
    ["ÿ", "yÿiîŷýỳ"],
    ["Ÿ", "YŸIÎŶÝỲ"],
    ["ŷ", "yÿiîŷýỳ"],
    ["Ŷ", "YŸIÎŶÝỲ"],
    ["ý", "yÿiîŷýỳ"],
    ["Ý", "YŸIÎŶÝỲ"],
    ["ỳ", "yÿiîŷýỳ"],
    ["Ỳ", "YŸIÎŶÝỲ"],

    ["z", "zs"],
    ["Z", "ZS"],
]);

const d1toX = new Map([
    ["æ", ["ae",]],
    ["Æ", ["AE",]],
    ["b", ["bb",]],
    ["B", ["BB",]],
    ["c", ["cc", "ss", "qu", "ch"]],
    ["C", ["CC", "SS", "QU", "CH"]],
    ["ç", ["ss", "cc", "qh", "ch"]],
    ["Ç", ["SS", "CC", "QH", "CH"]],
    ["d", ["dd",]],
    ["D", ["DD",]],
    ["f", ["ff", "ph"]],
    ["F", ["FF", "PH"]],
    ["g", ["gu", "ge", "gg", "gh"]],
    ["G", ["GU", "GE", "GG", "GH"]],
    ["i", ["ii",]],
    ["I", ["II",]],
    ["j", ["jj", "dj"]],
    ["J", ["JJ", "DJ"]],
    ["k", ["qu", "ck", "ch", "cu", "kk", "kh"]],
    ["K", ["QU", "CK", "CH", "CU", "KK", "KH"]],
    ["l", ["ll",]],
    ["L", ["LL",]],
    ["m", ["mm", "mn"]],
    ["M", ["MM", "MN"]],
    ["n", ["nn", "nm", "mn"]],
    ["N", ["NN", "NM", "MN"]],
    ["o", ["au", "eau", "aut"]],
    ["O", ["AU", "EAU", "AUT"]],
    ["œ", ["oe", "eu"]],
    ["Œ", ["OE", "EU"]],
    ["p", ["pp", "ph"]],
    ["P", ["PP", "PH"]],
    ["q", ["qu", "ch", "cq", "ck", "kk"]],
    ["Q", ["QU", "CH", "CQ", "CK", "KK"]],
    ["r", ["rr",]],
    ["R", ["RR",]],
    ["s", ["ss", "sh"]],
    ["S", ["SS", "SH"]],
    ["t", ["tt", "th"]],
    ["T", ["TT", "TH"]],
    ["x", ["cc", "ct", "xx"]],
    ["X", ["CC", "CT", "XX"]],
    ["z", ["ss", "zh"]],
    ["Z", ["SS", "ZH"]],
]);

const d2toX = new Map([
    ["an", ["en",]],
    ["AN", ["EN",]],
    ["en", ["an",]],
    ["EN", ["AN",]],
    ["ai", ["ei", "é", "è", "ê", "ë"]],
    ["AI", ["EI", "É", "È", "Ê", "Ë"]],
    ["ei", ["ai", "é", "è", "ê", "ë"]],
    ["EI", ["AI", "É", "È", "Ê", "Ë"]],
    ["ch", ["sh", "c", "ss"]],
    ["CH", ["SH", "C", "SS"]],
    ["ct", ["x", "cc"]],
    ["CT", ["X", "CC"]],
    ["oa", ["oi",]],
    ["OA", ["OI",]],
    ["oi", ["oa", "oie"]],
    ["OI", ["OA", "OIE"]],
    ["qu", ["q", "cq", "ck", "c", "k"]],
    ["QU", ["Q", "CQ", "CK", "C", "K"]],
    ["ss", ["c", "ç"]],
    ["SS", ["C", "Ç"]],
]);


// End of word

const dFinal1 = new Map([
    ["a", ["as", "at", "ant", "ah"]],
    ["A", ["AS", "AT", "ANT", "AH"]],
    ["c", ["ch",]],
    ["C", ["CH",]],
    ["e", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait", "ent", "eh"]],
    ["E", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT", "ENT", "EH"]],
    ["é", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["É", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["è", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["È", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["ê", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["Ê", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["ë", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["Ë", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["g", ["gh",]],
    ["G", ["GH",]],
    ["i", ["is", "it", "ie", "in"]],
    ["I", ["IS", "IT", "IE", "IN"]],
    ["n", ["nt", "nd", "ns", "nh"]],
    ["N", ["NT", "ND", "NS", "NH"]],
    ["o", ["aut", "ot", "os"]],
    ["O", ["AUT", "OT", "OS"]],
    ["ô", ["aut", "ot", "os"]],
    ["Ô", ["AUT", "OT", "OS"]],
    ["ö", ["aut", "ot", "os"]],
    ["Ö", ["AUT", "OT", "OS"]],
    ["p", ["ph",]],
    ["P", ["PH",]],
    ["s", ["sh",]],
    ["S", ["SH",]],
    ["t", ["th",]],
    ["T", ["TH",]],
    ["u", ["ut", "us", "uh"]],
    ["U", ["UT", "US", "UH"]],
]);

const dFinal2 = new Map([
    ["ai", ["aient", "ais", "et"]],
    ["AI", ["AIENT", "AIS", "ET"]],
    ["an", ["ant", "ent"]],
    ["AN", ["ANT", "ENT"]],
    ["en", ["ent", "ant"]],
    ["EN", ["ENT", "ANT"]],
    ["ei", ["ait", "ais"]],
    ["EI", ["AIT", "AIS"]],
    ["on", ["ons", "ont"]],
    ["ON", ["ONS", "ONT"]],
    ["oi", ["ois", "oit", "oix"]],
    ["OI", ["OIS", "OIT", "OIX"]],
]);


// Préfixes

aPfx1 = new Set([
    "anti", "archi", "contre", "hyper", "mé", "méta", "im", "in", "ir", "par", "proto",
    "pseudo", "pré", "re", "ré", "sans", "sous", "supra", "sur", "ultra"
]);

aPfx2 = new Set([
    "belgo", "franco", "génito", "gynéco", "médico", "russo"
]);

//// IBDAWG
/*jslint esversion: 6*/
/*global console,require,exports*/

"use strict";


if (typeof(require) !== 'undefined') {
    var str_transform = require("resource://grammalecte/str_transform.js");
    var helpers = require("resource://grammalecte/helpers.js");
}



// Don’t remove <string>. Necessary in TB.
${string}
${map}
${set}


class IBDAWG {
    // INDEXABLE BINARY DIRECT ACYCLIC WORD GRAPH

    constructor (sDicName, sPath="") {
        try {

        // Configuring DAWG functions according to nVersion
        switch (this.nVersion) {
            case 1:
                this.morph = this._morph1;
                this.stem = this._stem1;
                this._lookupArcNode = this._lookupArcNode1;
                this._getArcs = this._getArcs1;
                this._writeNodes = this._writeNodes1;
                break;
            case 2:
                this.morph = this._morph2;
                this.stem = this._stem2;
                this._lookupArcNode = this._lookupArcNode2;
                this._getArcs = this._getArcs2;
                this._writeNodes = this._writeNodes2;
                break;
            case 3:
                this.morph = this._morph3;
                this.stem = this._stem3;
                this._lookupArcNode = this._lookupArcNode3;
                this._getArcs = this._getArcs3;
                this._writeNodes = this._writeNodes3;
                break;
            default:
                throw ValueError("# Error: unknown code: " + this.nVersion);
        }
        //console.log(this.getInfo());
        this.bOptNumSigle = true;

            l = l.concat(this.morph(sWord.toLowerCase()));
            if (sWord.gl_isUpperCase() && sWord.length > 1) {
                l = l.concat(this.morph(sWord.gl_toCapitalize()));
            }
        }
        return l;
    }

    suggest (sWord, nMaxSugg=10) {
        // returns a set of suggestions for <sWord>
        let aSugg = this._suggest(sWord, nMaxDel=Math.floor(sWord.length / 5));
        if (sWord.gl_isTitle()) {
            aSugg.gl_update(this._suggest(sWord.lower(), nMaxDel=Math.floor(sWord.length / 5)));
            aSugg = new Set(aSugg.map((sSugg) => { return sSugg.title(); }));
        }
        else if (sWord.gl_isLowerCase()) {
            aSugg.gl_update(this._suggest(sWord.title(), nMaxDel=Math.floor(sWord.length / 5)));
        }
        if (aSugg.size == 0) {
            aSugg.gl_update(this._suggestWithCrushedUselessChars(cp.clearWord(sWord)));
        }
        aSugg = aSugg.filter((sSugg) => { return !sSugg.endsWith("è") && !sSugg.endsWith("È"); }); // fr language 
        return aSugg.sort((sSugg) => { return cp.distanceDamerauLevenshtein(sWord, sSugg); }).slice(0, nMaxSugg);
    }

    _suggest (sRemain, nMaxDel=0, nDeep=0, iAddr=0, sNewWord="", bAvoidLoop=False) {
        // returns a set of suggestions
        // recursive function
        //show(nDeep, sNewWord + ":" + sRemain)
        let aSugg = new Set();
        if (sRemain == "") {
            if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
                //show(nDeep, "___" + sNewWord + "___");
                aSugg.add(sNewWord);
            }
            for (let sTail of this._getTails(iAddr)) {
                aSugg.add(sNewWord+sTail);
            }
            return aSugg;
        }
        let cCurrent = sRemain.slice(0, 1);
        for (let [cChar, jAddr] of this._getSimilarArcs(cCurrent, iAddr)) {
            aSugg.gl_update(this._suggest(sRemain.slice(1), nMaxDel, nDeep+1, jAddr, sNewWord+cChar));
        }
        if (!bAvoidLoop) { // avoid infinite loop
            if (cCurrent == sRemain.slice(1, 2)) {
                // same char, we remove 1 char without adding 1 to <sNewWord>
                aSugg.gl_update(this._suggest(sRemain.slice(1), nMaxDel, nDeep+1, iAddr, sNewWord));
            }
            else {
                // switching chars
                aSugg.gl_update(this._suggest(sRemain.slice(1, 2)+sRemain.slice(0, 1)+sRemain.slice(2), nMaxDel, nDeep+1, iAddr, sNewWord, true));
                // delete char
                if (nMaxDel > 0) {
                    aSugg.gl_update(this._suggest(sRemain.slice(1), nMaxDel-1, nDeep+1, iAddr, sNewWord, true));
                }
            }
            // Replacements
            for (let sRepl of cp.d1toX.gl_get(cCurrent, [])) {
                aSugg.gl_update(this._suggest(sRepl + sRemain.slice(1), nMaxDel, nDeep+1, iAddr, sNewWord, true));
            }
            for (let sRepl of cp.d2toX.gl_get(sRemain[0:2], [])) {
                aSugg.gl_update(this._suggest(sRepl + sRemain.slice(2), nMaxDel, nDeep+1, iAddr, sNewWord, true));
            }
            // end of word
            if (sRemain.length == 2) {
                for (let sRepl of cp.dFinal2.gl_get(sRemain, [])) {
                    aSugg.gl_update(this._suggest(sRepl, nMaxDel, nDeep+1, iAddr, sNewWord, true));
                }
            }
            else if (sRemain.length == 1) {
                aSugg.gl_update(this._suggest("", nMaxDel, nDeep+1, iAddr, sNewWord, true)); // remove last char and go on
                for (let sRepl of cp.dFinal1.gl_get(sRemain, [])) {
                    aSugg.gl_update(this._suggest(sRepl, nMaxDel, nDeep+1, iAddr, sNewWord, true));
                }
            }
        }
        return aSugg;
    }

    * _getSimilarArcs (cChar, iAddr) {
        // generator: yield similar char of <cChar> and address of the following node
        for (let c of cp.d1to1.gl_get(cChar, [cChar])) {
            if (this.dChar.has(c)) {
                let jAddr = this._lookupArcNode(this.dChar.get(c), iAddr);
                if (jAddr) {
                    yield [c, jAddr];
                }
            }
        }
    }

    _getTails (iAddr, sTail="", n=2) {
        // return a list of suffixes ending at a distance of <n> from <iAddr>
        let aTails = new Set();
        for (let [nVal, jAddr] of this._getArcs(iAddr)) {
            if (nVal < this.nChar) {
                if (this._convBytesToInteger(this.byDic.slice(jAddr, jAddr+this.nBytesArc)) & this._finalNodeMask) {
                    aTails.add(sTail + this.dCharVal.get(nVal));
                }
                if (n && aTails.size == 0) {
                    aTails.update(this._getTails(jAddr, sTail+this.dCharVal.get(nVal), n-1));
                }
            }
        }
        return aTails;
    }

    _suggestWithCrushedUselessChars (sWord, nDeep=0, iAddr=0, sNewWord="", bAvoidLoop=False) {
        let aSugg = new Set();
        if (sWord.length == 0) {
            if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
                show(nDeep, "!!! " + sNewWord + " !!!");
                aSugg.add(sNewWord);
            }
            return aSugg;
        }
        let cCurrent = sWord.slice(0, 1);
        for (let [cChar, jAddr] of this._getSimilarArcsAndCrushedChars(cCurrent, iAddr)) {
            show(nDeep, cChar);
            aSugg.gl_update(this._suggestWithCrushedUselessChars(sWord[1:], nDeep+1, jAddr, sNewWord+cChar));
        }
        return aSugg;
    }

    * _getSimilarArcsAndCrushedChars (cChar, iAddr) {
        // generator: yield similar char of <cChar> and address of the following node
        for (let [nVal, jAddr] of this._getArcs(iAddr)) {
            if (this.dCharVal.get(nVal, null) in cp.aVovels) {
                yield [this.dCharVal[nVal], jAddr];
            }
        }
        yield* this._getSimilarArcs(cChar, iAddr);
    }

    // morph (sWord) {
    //     is defined in constructor
    // }
    
    // VERSION 1
    _morph1 (sWord) {

                return [];
            }
        }
        if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
            let l = [];
            let nRawArc = 0;
            while (!(nRawArc & this._lastArcMask)) {
                let iEndArcAddr = iAddr + this.nBytesArc;
                nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr));
                let nArc = nRawArc & this._arcMask;
                if (nArc >= this.nChar) {
                    // This value is not a char, this is a stemming code 
                    let sStem = ">" + this.funcStemming(sWord, this.lArcVal[nArc]);
                    // Now , we go to the next node and retrieve all following arcs values, all of them are tags
                    let iAddr2 = this._convBytesToInteger(this.byDic.slice(iEndArcAddr, iEndArcAddr+this.nBytesNodeAddress));
                    let nRawArc2 = 0;
                    while (!(nRawArc2 & this._lastArcMask)) {
                        let iEndArcAddr2 = iAddr2 + this.nBytesArc;
                        nRawArc2 = this._convBytesToInteger(this.byDic.slice(iAddr2, iEndArcAddr2));
                        l.push(sStem + " " + this.lArcVal[nRawArc2 & this._arcMask]);
                        iAddr2 = iEndArcAddr2+this.nBytesNodeAddress;
                    }
                }
                iAddr = iEndArcAddr + this.nBytesNodeAddress;
            }

                return [];
            }
        }
        if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
            let l = [];
            let nRawArc = 0;
            while (!(nRawArc & this._lastArcMask)) {
                let iEndArcAddr = iAddr + this.nBytesArc;
                nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr));
                let nArc = nRawArc & this._arcMask;
                if (nArc >= this.nChar) {
                    // This value is not a char, this is a stemming code 
                    l.push(this.funcStemming(sWord, this.lArcVal[nArc]));
                }
                iAddr = iEndArcAddr + this.nBytesNodeAddress;
            }
            return l;

                if (nRawArc & this._lastArcMask) {
                    return null;
                }
                iAddr = iEndArcAddr + this.nBytesNodeAddress;
            }
        }
    }

    _getArcs1 (iAddr) {
        "generator: return all arcs at <iAddr> as tuples of (nVal, iAddr)"
        while (true) {
            let iEndArcAddr = iAddr+this.nBytesArc;
            let nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr));
            yield [nRawArc & this._arcMask, this._convBytesToInteger(this.byDic.slice(iEndArcAddr, iEndArcAddr+this.nBytesNodeAddress))];
            if (nRawArc & this._lastArcMask) {
                break;
            }
            iAddr = iEndArcAddr+this.nBytesNodeAddress;
        }
    }

    // VERSION 2
    _morph2 (sWord) {
        // to do
    }

    _stem2 (sWord) {

// Set
/*jslint esversion: 6*/

if (Set.prototype.grammalecte === undefined) {
    Set.prototype.gl_update = function (aSet) {
        for (let elem of aSet) {
            this.add(elem);
        }
    };

    Set.prototype.grammalecte = true;
}

            self.stem = self._stem2
            self._lookupArcNode = self._lookupArcNode2
            self._getArcs = self._getArcs2
            self._writeNodes = self._writeNodes2
        elif self.nVersion == 3:
            self.morph = self._morph3
            self.stem = self._stem3

            self._lookupArcNode = self._lookupArcNode3
            self._getArcs = self._getArcs3
            self._writeNodes = self._writeNodes3
        else:
            raise ValueError("  # Error: unknown code: {}".format(self.nVersion))

        self.bOptNumSigle = False
        self.bOptNumAtLast = False

            l.extend(self.morph(sWord.lower()))
            if sWord.isupper() and len(sWord) > 1:
                l.extend(self.morph(sWord.capitalize()))
        return l

    def suggest (self, sWord, nMaxSugg=10):
        "returns a set of suggestions for <sWord>"

        aSugg = set()
        if sWord.istitle():
            aSugg.update(self._suggest(sWord, nMaxDel=len(sWord) // 5))
            aSugg.update(self._suggest(sWord.lower(), nMaxDel=len(sWord) // 5))
            aSugg = set(map(lambda sSugg: sSugg.title(), aSugg))
        elif sWord.islower():
            aSugg.update(self._suggest(sWord, nMaxDel=len(sWord) // 5))