Grammalecte  Check-in [3dc271d5dd]

Overview
Comment:[js][graphspell][fr] move lexicographer to graphspell (and merge with adhoc suggestion file)
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | fr | graphspell
Files: files | file ages | folders
SHA3-256: 3dc271d5dde2a8a54154acf2d92a7d6a09d487d55f6a4318ae077caef1ce6085
User & Date: olr on 2020-07-31 15:35:43
Other Links: manifest | tags
Context
2020-08-01
11:44
[fr] ajustements check-in: 3ba39670b7 user: olr tags: fr, trunk
2020-07-31
15:35
[js][graphspell][fr] move lexicographer to graphspell (and merge with adhoc suggestion file) check-in: 3dc271d5dd user: olr tags: fr, graphspell, trunk
15:08
[cli] fix call to lexicographer check-in: db66f7b4dd user: olr tags: cli, trunk
Changes

Deleted gc_lang/fr/modules-js/lexicographe.js version [8a0d79b100].

     1         -// Grammalecte - Lexicographe
     2         -// License: MPL 2
     3         -
     4         -/* jshint esversion:6, -W097 */
     5         -/* jslint esversion:6 */
     6         -/* global require, exports, console */
     7         -
     8         -"use strict";
     9         -
    10         -${string}
    11         -${map}
    12         -
    13         -
    14         -const _dTag = new Map([
    15         -    [':N', [" nom,", "Nom"]],
    16         -    [':A', [" adjectif,", "Adjectif"]],
    17         -    [':M1', [" prénom,", "Prénom"]],
    18         -    [':M2', [" patronyme,", "Patronyme, matronyme, nom de famille…"]],
    19         -    [':MP', [" nom propre,", "Nom propre"]],
    20         -    [':W', [" adverbe,", "Adverbe"]],
    21         -    [':J', [" interjection,", "Interjection"]],
    22         -    [':B', [" nombre,", "Nombre"]],
    23         -    [':T', [" titre,", "Titre de civilité"]],
    24         -
    25         -    [':e', [" épicène", "épicène"]],
    26         -    [':m', [" masculin", "masculin"]],
    27         -    [':f', [" féminin", "féminin"]],
    28         -    [':s', [" singulier", "singulier"]],
    29         -    [':p', [" pluriel", "pluriel"]],
    30         -    [':i', [" invariable", "invariable"]],
    31         -
    32         -    [':V1', [" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"]],
    33         -    [':V2', [" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"]],
    34         -    [':V3', [" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"]],
    35         -    [':V0e', [" verbe,", "Verbe auxiliaire être"]],
    36         -    [':V0a', [" verbe,", "Verbe auxiliaire avoir"]],
    37         -
    38         -    [':Y', [" infinitif,", "infinitif"]],
    39         -    [':P', [" participe présent,", "participe présent"]],
    40         -    [':Q', [" participe passé,", "participe passé"]],
    41         -    [':Ip', [" présent,", "indicatif présent"]],
    42         -    [':Iq', [" imparfait,", "indicatif imparfait"]],
    43         -    [':Is', [" passé simple,", "indicatif passé simple"]],
    44         -    [':If', [" futur,", "indicatif futur"]],
    45         -    [':K', [" conditionnel présent,", "conditionnel présent"]],
    46         -    [':Sp', [" subjonctif présent,", "subjonctif présent"]],
    47         -    [':Sq', [" subjonctif imparfait,", "subjonctif imparfait"]],
    48         -    [':E', [" impératif,", "impératif"]],
    49         -
    50         -    [':1s', [" 1ʳᵉ p. sg.,", "verbe : 1ʳᵉ personne du singulier"]],
    51         -    [':1ŝ', [" présent interr. 1ʳᵉ p. sg.,", "verbe : 1ʳᵉ personne du singulier (présent interrogatif)"]],
    52         -    [':1ś', [" présent interr. 1ʳᵉ p. sg.,", "verbe : 1ʳᵉ personne du singulier (présent interrogatif)"]],
    53         -    [':2s', [" 2ᵉ p. sg.,", "verbe : 2ᵉ personne du singulier"]],
    54         -    [':3s', [" 3ᵉ p. sg.,", "verbe : 3ᵉ personne du singulier"]],
    55         -    [':1p', [" 1ʳᵉ p. pl.,", "verbe : 1ʳᵉ personne du pluriel"]],
    56         -    [':2p', [" 2ᵉ p. pl.,", "verbe : 2ᵉ personne du pluriel"]],
    57         -    [':3p', [" 3ᵉ p. pl.,", "verbe : 3ᵉ personne du pluriel"]],
    58         -    [':3p!', [" 3ᵉ p. pl.,", "verbe : 3ᵉ personne du pluriel (prononciation distinctive)"]],
    59         -
    60         -    [':G', ["[mot grammatical]", "Mot grammatical"]],
    61         -    [':X', [" adverbe de négation,", "Adverbe de négation"]],
    62         -    [':U', [" adverbe interrogatif,", "Adverbe interrogatif"]],
    63         -    [':R', [" préposition,", "Préposition"]],
    64         -    [':Rv', [" préposition verbale,", "Préposition verbale"]],
    65         -    [':D', [" déterminant,", "Déterminant"]],
    66         -    [':Dd', [" déterminant démonstratif,", "Déterminant démonstratif"]],
    67         -    [':De', [" déterminant exclamatif,", "Déterminant exclamatif"]],
    68         -    [':Dp', [" déterminant possessif,", "Déterminant possessif"]],
    69         -    [':Di', [" déterminant indéfini,", "Déterminant indéfini"]],
    70         -    [':Dn', [" déterminant négatif,", "Déterminant négatif"]],
    71         -    [':Od', [" pronom démonstratif,", "Pronom démonstratif"]],
    72         -    [':Oi', [" pronom indéfini,", "Pronom indéfini"]],
    73         -    [':On', [" pronom indéfini négatif,", "Pronom indéfini négatif"]],
    74         -    [':Ot', [" pronom interrogatif,", "Pronom interrogatif"]],
    75         -    [':Or', [" pronom relatif,", "Pronom relatif"]],
    76         -    [':Ow', [" pronom adverbial,", "Pronom adverbial"]],
    77         -    [':Os', [" pronom personnel sujet,", "Pronom personnel sujet"]],
    78         -    [':Oo', [" pronom personnel objet,", "Pronom personnel objet"]],
    79         -    [':Ov', [" préverbe,", "Préverbe (pronom personnel objet, +ne)"]],
    80         -    [':O1', [" 1ʳᵉ pers.,", "Pronom : 1ʳᵉ personne"]],
    81         -    [':O2', [" 2ᵉ pers.,", "Pronom : 2ᵉ personne"]],
    82         -    [':O3', [" 3ᵉ pers.,", "Pronom : 3ᵉ personne"]],
    83         -    [':C', [" conjonction,", "Conjonction"]],
    84         -    [':Ĉ', [" conjonction (él.),", "Conjonction (élément)"]],
    85         -    [':Cc', [" conjonction de coordination,", "Conjonction de coordination"]],
    86         -    [':Cs', [" conjonction de subordination,", "Conjonction de subordination"]],
    87         -    [':Ĉs', [" conjonction de subordination (él.),", "Conjonction de subordination (élément)"]],
    88         -
    89         -    [':ÉN', [" locution nominale (él.),", "Locution nominale (élément)"]],
    90         -    [':ÉA', [" locution adjectivale (él.),", "Locution adjectivale (élément)"]],
    91         -    [':ÉV', [" locution verbale (él.),", "Locution verbale (élément)"]],
    92         -    [':ÉW', [" locution adverbiale (él.),", "Locution adverbiale (élément)"]],
    93         -    [':ÉR', [" locution prépositive (él.),", "Locution prépositive (élément)"]],
    94         -    [':ÉJ', [" locution interjective (él.),", "Locution interjective (élément)"]],
    95         -
    96         -    [':Zp', [" préfixe,", "Préfixe"]],
    97         -    [':Zs', [" suffixe,", "Suffixe"]],
    98         -
    99         -    [':H', ["", "<Hors-norme, inclassable>"]],
   100         -
   101         -    [':@',  ["", "<Caractère non alpha-numérique>"]],
   102         -    [':@p', ["signe de ponctuation", "Signe de ponctuation"]],
   103         -    [':@s', ["signe", "Signe divers"]],
   104         -
   105         -    [';S', [" : symbole (unité de mesure)", "Symbole (unité de mesure)"]],
   106         -
   107         -    ['/*', ["", "Sous-dictionnaire <Commun>"]],
   108         -    ['/C', [" <classique>", "Sous-dictionnaire <Classique>"]],
   109         -    ['/M', ["", "Sous-dictionnaire <Moderne>"]],
   110         -    ['/R', [" <réforme>", "Sous-dictionnaire <Réforme 1990>"]],
   111         -    ['/A', ["", "Sous-dictionnaire <Annexe>"]],
   112         -    ['/X', ["", "Sous-dictionnaire <Contributeurs>"]]
   113         -]);
   114         -
   115         -
   116         -const _dLocTag = new Map([
   117         -    [':L', "locution"],
   118         -    [':LN', "locution nominale"],
   119         -    [':LA', "locution adjectivale"],
   120         -    [':LV', "locution verbale"],
   121         -    [':LW', "locution adverbiale"],
   122         -    [':LR', "locution prépositive"],
   123         -    [':LRv', "locution prépositive verbale"],
   124         -    [':LO', "locution pronominale"],
   125         -    [':LC', "locution conjonctive"],
   126         -    [':LJ', "locution interjective"],
   127         -
   128         -    [':B', " cardinale"],
   129         -    [':e', " épicène"],
   130         -    [':m', " masculine"],
   131         -    [':f', " féminine"],
   132         -    [':s', " singulière"],
   133         -    [':p', " plurielle"],
   134         -    [':i', " invariable"],
   135         -    ['/L', " (latin)"]
   136         -]);
   137         -
   138         -const _dLocVerb = new Map([
   139         -    ['i', " intransitive"],
   140         -    ['n', " transitive indirecte"],
   141         -    ['t', " transitive directe"],
   142         -    ['p', " pronominale"],
   143         -    ['m', " impersonnelle"],
   144         -]);
   145         -
   146         -const _dElidedPrefix = new Map([
   147         -    ['d', "(de), déterminant épicène invariable"],
   148         -    ['l', "(le/la), déterminant masculin/féminin singulier"],
   149         -    ['j', "(je), pronom personnel sujet, 1ʳᵉ pers., épicène singulier"],
   150         -    ['m', "(me), pronom personnel objet, 1ʳᵉ pers., épicène singulier"],
   151         -    ['t', "(te), pronom personnel objet, 2ᵉ pers., épicène singulier"],
   152         -    ['s', "(se), pronom personnel objet, 3ᵉ pers., épicène singulier/pluriel"],
   153         -    ['n', "(ne), adverbe de négation"],
   154         -    ['c', "(ce), pronom démonstratif, masculin singulier/pluriel"],
   155         -    ['ç', "(ça), pronom démonstratif, masculin singulier"],
   156         -    ['qu', "(que), conjonction de subordination"],
   157         -    ['lorsqu', "(lorsque), conjonction de subordination"],
   158         -    ['puisqu', "(lorsque), conjonction de subordination"],
   159         -    ['quoiqu', "(quoique), conjonction de subordination"],
   160         -    ['jusqu', "(jusque), préposition"]
   161         -]);
   162         -
   163         -const _dPronoms = new Map([
   164         -    ['je', " pronom personnel sujet, 1ʳᵉ pers. sing."],
   165         -    ['tu', " pronom personnel sujet, 2ᵉ pers. sing."],
   166         -    ['il', " pronom personnel sujet, 3ᵉ pers. masc. sing."],
   167         -    ['on', " pronom personnel sujet, 3ᵉ pers. sing. ou plur."],
   168         -    ['elle', " pronom personnel sujet, 3ᵉ pers. fém. sing."],
   169         -    ['nous', " pronom personnel sujet/objet, 1ʳᵉ pers. plur."],
   170         -    ['vous', " pronom personnel sujet/objet, 2ᵉ pers. plur."],
   171         -    ['ils', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
   172         -    ['elles', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
   173         -
   174         -    ["là", " particule démonstrative"],
   175         -    ["ci", " particule démonstrative"],
   176         -
   177         -    ['le', " COD, masc. sing."],
   178         -    ['la', " COD, fém. sing."],
   179         -    ['les', " COD, plur."],
   180         -
   181         -    ['moi', " COI (à moi), sing."],
   182         -    ['toi', " COI (à toi), sing."],
   183         -    ['lui', " COI (à lui ou à elle), sing."],
   184         -    ['nous2', " COI (à nous), plur."],
   185         -    ['vous2', " COI (à vous), plur."],
   186         -    ['leur', " COI (à eux ou à elles), plur."],
   187         -
   188         -    ['y', " pronom adverbial"],
   189         -    ["m'y", " (me) pronom personnel objet + (y) pronom adverbial"],
   190         -    ["t'y", " (te) pronom personnel objet + (y) pronom adverbial"],
   191         -    ["s'y", " (se) pronom personnel objet + (y) pronom adverbial"],
   192         -
   193         -    ['en', " pronom adverbial"],
   194         -    ["m'en", " (me) pronom personnel objet + (en) pronom adverbial"],
   195         -    ["t'en", " (te) pronom personnel objet + (en) pronom adverbial"],
   196         -    ["s'en", " (se) pronom personnel objet + (en) pronom adverbial"]
   197         -]);
   198         -
   199         -const _dChar = new Map([
   200         -    ['.', "point"],
   201         -    ['·', "point médian"],
   202         -    ['…', "points de suspension"],
   203         -    [':', "deux-points"],
   204         -    [';', "point-virgule"],
   205         -    [',', "virgule"],
   206         -    ['?', "point d’interrogation"],
   207         -    ['!', "point d’exclamation"],
   208         -    ['(', "parenthèse ouvrante"],
   209         -    [')', "parenthèse fermante"],
   210         -    ['[', "crochet ouvrant"],
   211         -    [']', "crochet fermant"],
   212         -    ['{', "accolade ouvrante"],
   213         -    ['}', "accolade fermante"],
   214         -    ['-', "tiret"],
   215         -    ['—', "tiret cadratin"],
   216         -    ['–', "tiret demi-cadratin"],
   217         -    ['«', "guillemet ouvrant (chevrons)"],
   218         -    ['»', "guillemet fermant (chevrons)"],
   219         -    ['“', "guillemet ouvrant double"],
   220         -    ['”', "guillemet fermant double"],
   221         -    ['‘', "guillemet ouvrant"],
   222         -    ['’', "guillemet fermant"],
   223         -    ['"', "guillemets droits (déconseillé en typographie)"],
   224         -    ['/', "signe de la division"],
   225         -    ['+', "signe de l’addition"],
   226         -    ['*', "signe de la multiplication"],
   227         -    ['=', "signe de l’égalité"],
   228         -    ['<', "inférieur à"],
   229         -    ['>', "supérieur à"],
   230         -    ['⩽', "inférieur ou égal à"],
   231         -    ['⩾', "supérieur ou égal à"],
   232         -    ['%', "signe de pourcentage"],
   233         -    ['‰', "signe pour mille"],
   234         -]);
   235         -
   236         -
   237         -class Lexicographe {
   238         -
   239         -    constructor (oSpellChecker, oTokenizer, oLocGraph) {
   240         -        this.oSpellChecker = oSpellChecker;
   241         -        this.oTokenizer = oTokenizer;
   242         -        this.oLocGraph = JSON.parse(oLocGraph);
   243         -
   244         -        this._zPartDemForm = new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-(là|ci)$", "i");
   245         -        this._aPartDemExceptList = new Set(["celui", "celle", "ceux", "celles", "de", "jusque", "par", "marie-couche-toi"]);
   246         -        this._zInterroVerb = new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-(t-(?:il|elle|on)|je|tu|ils?|elles?|on|[nv]ous)$", "i");
   247         -        this._zImperatifVerb = new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-((?:les?|la)-(?:moi|toi|lui|[nv]ous|leur)|y|en|[mts][’'](?:y|en)|les?|la|[mt]oi|leur|lui)$", "i");
   248         -        this._zTag = new RegExp("[:;/][a-zA-Z0-9ÑÂĴĈŔÔṼŴ!][^:;/]*", "g");
   249         -    }
   250         -
   251         -    getInfoForToken (oToken) {
   252         -        // Token: .sType, .sValue, .nStart, .nEnd
   253         -        // return a object {sType, sValue, aLabel}
   254         -        let m = null;
   255         -        try {
   256         -            switch (oToken.sType) {
   257         -                case 'PUNC':
   258         -                case 'SIGN':
   259         -                    return {
   260         -                        sType: oToken.sType,
   261         -                        sValue: oToken.sValue,
   262         -                        aLabel: [_dChar.gl_get(oToken.sValue, "caractère indéterminé")]
   263         -                    };
   264         -                    break;
   265         -                case 'NUM':
   266         -                    return {
   267         -                        sType: oToken.sType,
   268         -                        sValue: oToken.sValue,
   269         -                        aLabel: ["nombre"]
   270         -                    };
   271         -                    break;
   272         -                case 'LINK':
   273         -                    return {
   274         -                        sType: oToken.sType,
   275         -                        sValue: oToken.sValue.slice(0, 40) + "…",
   276         -                        aLabel: ["hyperlien"]
   277         -                    };
   278         -                    break;
   279         -                case 'TAG':
   280         -                    return {
   281         -                        sType: oToken.sType,
   282         -                        sValue: oToken.sValue,
   283         -                        aLabel: ["étiquette (hashtag)"]
   284         -                    };
   285         -                    break;
   286         -                case 'HTML':
   287         -                    return {
   288         -                        sType: oToken.sType,
   289         -                        sValue: oToken.sValue.slice(0, 40) + "…",
   290         -                        aLabel: ["balise HTML"]
   291         -                    };
   292         -                    break;
   293         -                case 'PSEUDOHTML':
   294         -                    return {
   295         -                        sType: oToken.sType,
   296         -                        sValue: oToken.sValue,
   297         -                        aLabel: ["balise pseudo-HTML"]
   298         -                    };
   299         -                    break;
   300         -                case 'HTMLENTITY':
   301         -                    return {
   302         -                        sType: oToken.sType,
   303         -                        sValue: oToken.sValue,
   304         -                        aLabel: ["entité caractère XML/HTML"]
   305         -                    };
   306         -                    break;
   307         -                case 'HOUR':
   308         -                    return {
   309         -                        sType: oToken.sType,
   310         -                        sValue: oToken.sValue,
   311         -                        aLabel: ["heure"]
   312         -                    };
   313         -                    break;
   314         -                case 'WORD_ELIDED':
   315         -                    let sTemp = oToken.sValue.replace("’", "").replace("'", "").replace("`", "").toLowerCase();
   316         -                    return {
   317         -                        sType: oToken.sType,
   318         -                        sValue: oToken.sValue,
   319         -                        aLabel: [_dElidedPrefix.gl_get(sTemp, "préfixe élidé inconnu")]
   320         -                    };
   321         -                    break;
   322         -                case 'WORD_ORDINAL':
   323         -                    return {
   324         -                        sType: oToken.sType,
   325         -                        sValue: oToken.sValue,
   326         -                        aLabel: ["nombre ordinal"]
   327         -                    };
   328         -                    break;
   329         -                case 'FOLDERUNIX':
   330         -                    return {
   331         -                        sType: oToken.sType,
   332         -                        sValue: oToken.sValue.slice(0, 40) + "…",
   333         -                        aLabel: ["dossier UNIX (et dérivés)"]
   334         -                    };
   335         -                    break;
   336         -                case 'FOLDERWIN':
   337         -                    return {
   338         -                        sType: oToken.sType,
   339         -                        sValue: oToken.sValue.slice(0, 40) + "…",
   340         -                        aLabel: ["dossier Windows"]
   341         -                    };
   342         -                    break;
   343         -                case 'WORD_ACRONYM':
   344         -                    return {
   345         -                        sType: oToken.sType,
   346         -                        sValue: oToken.sValue,
   347         -                        aLabel: ["Sigle ou acronyme"]
   348         -                    };
   349         -                    break;
   350         -                case 'WORD':
   351         -                    if (oToken.sValue.gl_count("-") > 4) {
   352         -                        return {
   353         -                            sType: "COMPLEX",
   354         -                            sValue: oToken.sValue,
   355         -                            aLabel: ["élément complexe indéterminé"]
   356         -                        };
   357         -                    } else if (m = this._zPartDemForm.exec(oToken.sValue)) {
   358         -                        // mots avec particules démonstratives
   359         -                        if (this._aPartDemExceptList.has(m[1].toLowerCase())) {
   360         -                            return {
   361         -                                sType: "WORD",
   362         -                                sValue: oToken.sValue,
   363         -                                aLabel: this._getMorph(oToken.sValue)
   364         -                            };
   365         -                        }
   366         -                        return {
   367         -                            sType: oToken.sType,
   368         -                            sValue: oToken.sValue,
   369         -                            aLabel: ["mot avec particule démonstrative"],
   370         -                            aSubElem: [
   371         -                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
   372         -                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
   373         -                            ]
   374         -                        };
   375         -                    } else if (m = this._zImperatifVerb.exec(oToken.sValue)) {
   376         -                        // formes interrogatives
   377         -                        return {
   378         -                            sType: oToken.sType,
   379         -                            sValue: oToken.sValue,
   380         -                            aLabel: ["forme verbale impérative"],
   381         -                            aSubElem: [
   382         -                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
   383         -                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
   384         -                            ]
   385         -                        };
   386         -                    } else if (m = this._zInterroVerb.exec(oToken.sValue)) {
   387         -                        // formes interrogatives
   388         -                        return {
   389         -                            sType: oToken.sType,
   390         -                            sValue: oToken.sValue,
   391         -                            aLabel: ["forme verbale interrogative"],
   392         -                            aSubElem: [
   393         -                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
   394         -                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
   395         -                            ]
   396         -                        };
   397         -                    } else if (this.oSpellChecker.isValidToken(oToken.sValue)) {
   398         -                        return {
   399         -                            sType: oToken.sType,
   400         -                            sValue: oToken.sValue,
   401         -                            aLabel: this._getMorph(oToken.sValue)
   402         -                        };
   403         -                    } else {
   404         -                        return {
   405         -                            sType: "UNKNOWN_WORD",
   406         -                            sValue: oToken.sValue,
   407         -                            aLabel: ["mot inconnu du dictionnaire"]
   408         -                        };
   409         -                    }
   410         -                    break;
   411         -                default:
   412         -                    return {
   413         -                        sType: oToken.sType,
   414         -                        sValue: oToken.sValue,
   415         -                        aLabel: ["token inconnu"]
   416         -                    }
   417         -            }
   418         -        } catch (e) {
   419         -            console.error(e);
   420         -        }
   421         -        return null;
   422         -    }
   423         -
   424         -    _getMorph (sWord) {
   425         -        let aElem = [];
   426         -        for (let s of this.oSpellChecker.getMorph(sWord)) {
   427         -            if (s.includes(":")) aElem.push(this._formatTags(s));
   428         -        }
   429         -        if (aElem.length == 0) {
   430         -            aElem.push("mot inconnu du dictionnaire");
   431         -        }
   432         -        return aElem;
   433         -    }
   434         -
   435         -    _formatTags (sTags) {
   436         -        let sRes = "";
   437         -        sTags = sTags.replace(/V([0-3][ea]?)[itpqnmr_eaxz]+/, "V$1");
   438         -        let m;
   439         -        while ((m = this._zTag.exec(sTags)) !== null) {
   440         -            sRes += _dTag.get(m[0])[0];
   441         -        }
   442         -        if (sRes.startsWith(" verbe") && !sRes.includes("infinitif")) {
   443         -            sRes += " [" + sTags.slice(1, sTags.indexOf("/")) + "]";
   444         -        }
   445         -        if (!sRes) {
   446         -            return "#Erreur. Étiquette inconnue : [" + sTags + "]";
   447         -        }
   448         -        return sRes.gl_trimRight(",");
   449         -    }
   450         -
   451         -    _formatTagsLoc (sTags) {
   452         -        let sRes = "";
   453         -        let m;
   454         -        while ((m = this._zTag.exec(sTags)) !== null) {
   455         -            if (m[0].startsWith(":LV")) {
   456         -                sRes += _dLocTag.get(":LV");
   457         -                for (let c of m[0].slice(3)) {
   458         -                    sRes += _dLocVerb.get(c);
   459         -                }
   460         -            } else {
   461         -                sRes += _dLocTag.get(m[0]);
   462         -            }
   463         -        }
   464         -        if (!sRes) {
   465         -            return "#Erreur. Étiquette inconnue : [" + sTags + "]";
   466         -        }
   467         -        return sRes.gl_trimRight(",");
   468         -    }
   469         -
   470         -    _formatSuffix (s) {
   471         -        if (s.startsWith("t-")) {
   472         -            return "“t” euphonique +" + _dPronoms.get(s.slice(2));
   473         -        }
   474         -        if (!s.includes("-")) {
   475         -            return _dPronoms.get(s.replace("’", "'"));
   476         -        }
   477         -        if (s.endsWith("ous")) {
   478         -            s += '2';
   479         -        }
   480         -        let nPos = s.indexOf("-");
   481         -        return _dPronoms.get(s.slice(0, nPos)) + " +" + _dPronoms.get(s.slice(nPos + 1));
   482         -    }
   483         -
   484         -    getListOfTokens (sText, bInfo=true) {
   485         -        let aElem = [];
   486         -        if (sText !== "") {
   487         -            for (let oToken of this.oTokenizer.genTokens(sText)) {
   488         -                if (bInfo) {
   489         -                    let aRes = this.getInfoForToken(oToken);
   490         -                    if (aRes) {
   491         -                        aElem.push(aRes);
   492         -                    }
   493         -                } else if (oToken.sType !== "SPACE") {
   494         -                    aElem.push(oToken);
   495         -                }
   496         -            }
   497         -        }
   498         -        return aElem;
   499         -    }
   500         -
   501         -    * generateInfoForTokenList (lToken) {
   502         -        for (let oToken of lToken) {
   503         -            let aRes = this.getInfoForToken(oToken);
   504         -            if (aRes) {
   505         -                yield aRes;
   506         -            }
   507         -        }
   508         -    }
   509         -
   510         -    getListOfTokensReduc (sText, bInfo=true) {
   511         -        let lToken = this.getListOfTokens(sText.replace("'", "’").trim(), false);
   512         -        let iToken = 0;
   513         -        let aElem = [];
   514         -        if (lToken.length == 0) {
   515         -            return aElem;
   516         -        }
   517         -        do {
   518         -            let oToken = lToken[iToken];
   519         -            let sMorphLoc = '';
   520         -            let aTokenTempList = [oToken];
   521         -            if (oToken.sType == "WORD" || oToken.sType == "WORD_ELIDED"){
   522         -                let iLocEnd = iToken + 1;
   523         -                let oLocNode = this.oLocGraph[oToken.sValue.toLowerCase()];
   524         -                while (oLocNode) {
   525         -                    let oTokenNext = lToken[iLocEnd];
   526         -                    iLocEnd++;
   527         -                    if (oTokenNext) {
   528         -                        oLocNode = oLocNode[oTokenNext.sValue.toLowerCase()];
   529         -                    }
   530         -                    if (oLocNode && iLocEnd <= lToken.length) {
   531         -                        sMorphLoc = oLocNode["_:_"];
   532         -                        aTokenTempList.push(oTokenNext);
   533         -                    } else {
   534         -                        break;
   535         -                    }
   536         -                }
   537         -            }
   538         -
   539         -            if (sMorphLoc) {
   540         -                // we have a locution
   541         -                let sValue = '';
   542         -                for (let oTokenWord of aTokenTempList) {
   543         -                    sValue += oTokenWord.sValue+' ';
   544         -                }
   545         -                let oTokenLocution = {
   546         -                    'nStart': aTokenTempList[0].nStart,
   547         -                    'nEnd': aTokenTempList[aTokenTempList.length-1].nEnd,
   548         -                    'sType': "LOC",
   549         -                    'sValue': sValue.replace('’ ','’').trim(),
   550         -                    'aSubToken': aTokenTempList
   551         -                };
   552         -                if (bInfo) {
   553         -                    let aSubElem = null;
   554         -                    if (sMorphLoc.startsWith("*|")) {
   555         -                        // cette suite de tokens n’est une locution que dans certains cas minoritaires
   556         -                        oTokenLocution.sType = "LOCP";
   557         -                        for (let oElem of this.generateInfoForTokenList(aTokenTempList)) {
   558         -                            aElem.push(oElem);
   559         -                        }
   560         -                        sMorphLoc = sMorphLoc.slice(2);
   561         -                    } else {
   562         -                        aSubElem = [...this.generateInfoForTokenList(aTokenTempList)];
   563         -                    }
   564         -                    // cette suite de tokens est la plupart du temps une locution
   565         -                    let aFormatedTag = [];
   566         -                    for (let sTagLoc of sMorphLoc.split('|') ){
   567         -                        aFormatedTag.push(this._formatTagsLoc(sTagLoc));
   568         -                    }
   569         -                    aElem.push({
   570         -                        sType: oTokenLocution.sType,
   571         -                        sValue: oTokenLocution.sValue,
   572         -                        aLabel: aFormatedTag,
   573         -                        aSubElem: aSubElem
   574         -                    });
   575         -                } else {
   576         -                    aElem.push(oTokenLocution);
   577         -                }
   578         -                iToken = iToken + aTokenTempList.length;
   579         -            } else {
   580         -                // No locution, we just add information
   581         -                if (bInfo) {
   582         -                    let aRes = this.getInfoForToken(oToken);
   583         -                    if (aRes) {
   584         -                        aElem.push(aRes);
   585         -                    }
   586         -                } else {
   587         -                    aElem.push(oToken);
   588         -                }
   589         -                iToken++;
   590         -            }
   591         -        } while (iToken < lToken.length);
   592         -        return aElem;
   593         -    }
   594         -}
   595         -
   596         -
   597         -if (typeof(exports) !== 'undefined') {
   598         -    exports.Lexicographe = Lexicographe;
   599         -}

Modified gc_lang/fr/webext/gce_worker.js from [67fa9791af] to [5fe0431850].

    31     31   
    32     32   //console.log("[Worker] GC Engine Worker [start]");
    33     33   //console.log(self);
    34     34   
    35     35   importScripts("grammalecte/graphspell/helpers.js");
    36     36   importScripts("grammalecte/graphspell/str_transform.js");
    37     37   importScripts("grammalecte/graphspell/char_player.js");
    38         -importScripts("grammalecte/graphspell/suggest.js");
           38  +importScripts("grammalecte/graphspell/lexgraph_fr.js");
    39     39   importScripts("grammalecte/graphspell/ibdawg.js");
    40     40   importScripts("grammalecte/graphspell/spellchecker.js");
    41     41   importScripts("grammalecte/text.js");
    42     42   importScripts("grammalecte/graphspell/tokenizer.js");
    43     43   importScripts("grammalecte/fr/conj.js");
    44     44   importScripts("grammalecte/fr/mfsp.js");
    45     45   importScripts("grammalecte/fr/phonet.js");
................................................................................
   150    150   
   151    151   
   152    152   
   153    153   let bInitDone = false;
   154    154   
   155    155   let oSpellChecker = null;
   156    156   let oTokenizer = null;
   157         -let oLxg = null;
   158    157   let oTest = null;
   159    158   let oLocution = null;
   160    159   
   161    160   
   162    161   /*
   163    162       Technical note:
   164    163       This worker don’t work as a PromiseWorker (which returns a promise),  so when we send request
................................................................................
   177    176               mfsp.init(helpers.loadFile(sExtensionPath + "/grammalecte/fr/mfsp_data.json"));
   178    177               //console.log("[Worker] Modules have been initialized…");
   179    178               gc_engine.load(sContext, "aHSL", sExtensionPath+"grammalecte/graphspell/_dictionaries");
   180    179               oSpellChecker = gc_engine.getSpellChecker();
   181    180               oTest = new TestGrammarChecking(gc_engine, sExtensionPath+"/grammalecte/fr/tests_data.json");
   182    181               oTokenizer = new Tokenizer("fr");
   183    182               oLocution =  helpers.loadFile(sExtensionPath + "/grammalecte/fr/locutions_data.json");
   184         -            oLxg = new Lexicographe(oSpellChecker, oTokenizer, oLocution);
          183  +            lexgraph_fr.load(oSpellChecker, oTokenizer, oLocution);
   185    184               if (dOptions !== null) {
   186    185                   if (!(dOptions instanceof Map)) {
   187    186                       dOptions = helpers.objectToMap(dOptions);
   188    187                   }
   189    188                   gc_engine.setOptions(dOptions);
   190    189               }
   191    190               //tests();
................................................................................
   246    245   
   247    246   function getListOfTokens (sText, oInfo={}) {
   248    247       // lexicographer
   249    248       try {
   250    249           sText = sText.replace(/­/g, "").normalize("NFC");
   251    250           for (let sParagraph of text.getParagraph(sText)) {
   252    251               if (sParagraph.trim() !== "") {
   253         -                postMessage(createResponse("getListOfTokens", oLxg.getListOfTokensReduc(sParagraph, true), oInfo, false));
          252  +                postMessage(createResponse("getListOfTokens", lexgraph_fr.getListOfTokensReduc(sParagraph, true), oInfo, false));
   254    253               }
   255    254           }
   256    255           postMessage(createResponse("getListOfTokens", null, oInfo, true));
   257    256       }
   258    257       catch (e) {
   259    258           console.error(e);
   260    259           postMessage(createResponse("getListOfTokens", createErrorResult(e, "no tokens"), oInfo, true, true));

Added graphspell-js/lexgraph_fr.js version [7474bcdd06].

            1  +// JavaScript
            2  +
            3  +"use strict";
            4  +
            5  +
            6  +${string}
            7  +${map}
            8  +
            9  +
           10  +//// Default Suggestions
           11  +
           12  +const _dSugg = new Map ([
           13  +    ["bcp", "beaucoup"],
           14  +    ["ca", "ça"],
           15  +    ["cad", "c’est-à-dire"],
           16  +    ["cb", "combien|CB"],
           17  +    ["cdlt", "cordialement"],
           18  +    ["construirent", "construire|construisirent|construisent|construiront"],
           19  +    ["càd", "c’est-à-dire"],
           20  +    ["chai", "j’sais|je sais"],
           21  +    ["chais", "j’sais|je sais"],
           22  +    ["chui", "j’suis|je suis"],
           23  +    ["chuis", "j’suis|je suis"],
           24  +    ["dc", "de|donc"],
           25  +    ["done", "donc|donne"],
           26  +    ["email", "courriel|e-mail|émail"],
           27  +    ["emails", "courriels|e-mails"],
           28  +    ["ete", "êtes|été"],
           29  +    ["Etes-vous", "Êtes-vous"],
           30  +    ["Etiez-vous", "Étiez-vous"],
           31  +    ["Etions-vous", "Étions-nous"],
           32  +    ["loins", "loin"],
           33  +    ["mn", "min"],
           34  +    ["mns", "min"],
           35  +    ["parce-que", "parce que"],
           36  +    ["pcq", "parce que"],
           37  +    ["pd", "pendant|pédé"],
           38  +    ["pdq", "pendant que"],
           39  +    ["pdt", "pendant"],
           40  +    ["pdtq", "pendant que"],
           41  +    ["pécunier", "pécuniaire"],
           42  +    ["pécuniers", "pécuniaires"],
           43  +    ["pk", "pourquoi"],
           44  +    ["pkoi", "pourquoi"],
           45  +    ["pq", "pourquoi|PQ"],
           46  +    ["prq", "presque"],
           47  +    ["prsq", "presque"],
           48  +    ["qcq", "quiconque"],
           49  +    ["qd", "quand"],
           50  +    ["qq", "quelque"],
           51  +    ["qqch", "quelque chose"],
           52  +    ["qqn", "quelqu’un"],
           53  +    ["qqne", "quelqu’une"],
           54  +    ["qqs", "quelques"],
           55  +    ["qqunes", "quelques-unes"],
           56  +    ["qquns", "quelques-uns"],
           57  +    ["tdq", "tandis que"],
           58  +    ["tj", "toujours"],
           59  +    ["tjs", "toujours"],
           60  +    ["tq", "tant que|tandis que"],
           61  +    ["ts", "tous"],
           62  +    ["tt", "tant|tout"],
           63  +    ["tte", "toute"],
           64  +    ["ttes", "toutes"],
           65  +
           66  +    ["Iier", "Iᵉʳ"],
           67  +    ["Iière", "Iʳᵉ"],
           68  +    ["IIième", "IIᵉ"],
           69  +    ["IIIième", "IIIᵉ"],
           70  +    ["IVième", "IVᵉ"],
           71  +    ["Vième", "Vᵉ"],
           72  +    ["VIième", "VIᵉ"],
           73  +    ["VIIième", "VIIᵉ"],
           74  +    ["VIIIième", "VIIIᵉ"],
           75  +    ["IXième", "IXᵉ"],
           76  +    ["Xième", "Xᵉ"],
           77  +    ["XIième", "XIᵉ"],
           78  +    ["XIIième", "XIIᵉ"],
           79  +    ["XIIIième", "XIIIᵉ"],
           80  +    ["XIVième", "XIVᵉ"],
           81  +    ["XVième", "XVᵉ"],
           82  +    ["XVIième", "XVIᵉ"],
           83  +    ["XVIIième", "XVIIᵉ"],
           84  +    ["XVIIIième", "XVIIIᵉ"],
           85  +    ["XIXième", "XIXᵉ"],
           86  +    ["XXième", "XXᵉ"],
           87  +    ["XXIième", "XXIᵉ"],
           88  +    ["XXIIième", "XXIIᵉ"],
           89  +    ["XXIIIième", "XXIIIᵉ"],
           90  +    ["XXIVième", "XXIVᵉ"],
           91  +    ["XXVième", "XXVᵉ"],
           92  +    ["XXVIième", "XXVIᵉ"],
           93  +    ["XXVIIième", "XXVIIᵉ"],
           94  +    ["XXVIIIième", "XXVIIIᵉ"],
           95  +    ["XXIXième", "XXIXᵉ"],
           96  +    ["XXXième", "XXXᵉ"],
           97  +
           98  +    ["Ier", "Iᵉʳ"],
           99  +    ["Ière", "Iʳᵉ"],
          100  +    ["IIème", "IIᵉ"],
          101  +    ["IIIème", "IIIᵉ"],
          102  +    ["IVème", "IVᵉ"],
          103  +    ["Vème", "Vᵉ"],
          104  +    ["VIème", "VIᵉ"],
          105  +    ["VIIème", "VIIᵉ"],
          106  +    ["VIIIème", "VIIIᵉ"],
          107  +    ["IXème", "IXᵉ"],
          108  +    ["Xème", "Xᵉ"],
          109  +    ["XIème", "XIᵉ"],
          110  +    ["XIIème", "XIIᵉ"],
          111  +    ["XIIIème", "XIIIᵉ"],
          112  +    ["XIVème", "XIVᵉ"],
          113  +    ["XVème", "XVᵉ"],
          114  +    ["XVIème", "XVIᵉ"],
          115  +    ["XVIIème", "XVIIᵉ"],
          116  +    ["XVIIIème", "XVIIIᵉ"],
          117  +    ["XIXème", "XIXᵉ"],
          118  +    ["XXème", "XXᵉ"],
          119  +    ["XXIème", "XXIᵉ"],
          120  +    ["XXIIème", "XXIIᵉ"],
          121  +    ["XXIIIème", "XXIIIᵉ"],
          122  +    ["XXIVème", "XXIVᵉ"],
          123  +    ["XXVème", "XXVᵉ"],
          124  +    ["XXVIème", "XXVIᵉ"],
          125  +    ["XXVIIème", "XXVIIᵉ"],
          126  +    ["XXVIIIème", "XXVIIIᵉ"],
          127  +    ["XXIXème", "XXIXᵉ"],
          128  +    ["XXXème", "XXXᵉ"]
          129  +]);
          130  +
          131  +
          132  +
          133  +//// Lexicographer
          134  +
          135  +var lexgraph_fr = {
          136  +
          137  +    dSugg: _dSugg,
          138  +
          139  +    dTag: new Map([
          140  +            [':N', [" nom,", "Nom"]],
          141  +            [':A', [" adjectif,", "Adjectif"]],
          142  +            [':M1', [" prénom,", "Prénom"]],
          143  +            [':M2', [" patronyme,", "Patronyme, matronyme, nom de famille…"]],
          144  +            [':MP', [" nom propre,", "Nom propre"]],
          145  +            [':W', [" adverbe,", "Adverbe"]],
          146  +            [':J', [" interjection,", "Interjection"]],
          147  +            [':B', [" nombre,", "Nombre"]],
          148  +            [':T', [" titre,", "Titre de civilité"]],
          149  +
          150  +            [':e', [" épicène", "épicène"]],
          151  +            [':m', [" masculin", "masculin"]],
          152  +            [':f', [" féminin", "féminin"]],
          153  +            [':s', [" singulier", "singulier"]],
          154  +            [':p', [" pluriel", "pluriel"]],
          155  +            [':i', [" invariable", "invariable"]],
          156  +
          157  +            [':V1', [" verbe (1ᵉʳ gr.),", "Verbe du 1ᵉʳ groupe"]],
          158  +            [':V2', [" verbe (2ᵉ gr.),", "Verbe du 2ᵉ groupe"]],
          159  +            [':V3', [" verbe (3ᵉ gr.),", "Verbe du 3ᵉ groupe"]],
          160  +            [':V0e', [" verbe,", "Verbe auxiliaire être"]],
          161  +            [':V0a', [" verbe,", "Verbe auxiliaire avoir"]],
          162  +
          163  +            [':Y', [" infinitif,", "infinitif"]],
          164  +            [':P', [" participe présent,", "participe présent"]],
          165  +            [':Q', [" participe passé,", "participe passé"]],
          166  +            [':Ip', [" présent,", "indicatif présent"]],
          167  +            [':Iq', [" imparfait,", "indicatif imparfait"]],
          168  +            [':Is', [" passé simple,", "indicatif passé simple"]],
          169  +            [':If', [" futur,", "indicatif futur"]],
          170  +            [':K', [" conditionnel présent,", "conditionnel présent"]],
          171  +            [':Sp', [" subjonctif présent,", "subjonctif présent"]],
          172  +            [':Sq', [" subjonctif imparfait,", "subjonctif imparfait"]],
          173  +            [':E', [" impératif,", "impératif"]],
          174  +
          175  +            [':1s', [" 1ʳᵉ p. sg.,", "verbe : 1ʳᵉ personne du singulier"]],
          176  +            [':1ŝ', [" présent interr. 1ʳᵉ p. sg.,", "verbe : 1ʳᵉ personne du singulier (présent interrogatif)"]],
          177  +            [':1ś', [" présent interr. 1ʳᵉ p. sg.,", "verbe : 1ʳᵉ personne du singulier (présent interrogatif)"]],
          178  +            [':2s', [" 2ᵉ p. sg.,", "verbe : 2ᵉ personne du singulier"]],
          179  +            [':3s', [" 3ᵉ p. sg.,", "verbe : 3ᵉ personne du singulier"]],
          180  +            [':1p', [" 1ʳᵉ p. pl.,", "verbe : 1ʳᵉ personne du pluriel"]],
          181  +            [':2p', [" 2ᵉ p. pl.,", "verbe : 2ᵉ personne du pluriel"]],
          182  +            [':3p', [" 3ᵉ p. pl.,", "verbe : 3ᵉ personne du pluriel"]],
          183  +            [':3p!', [" 3ᵉ p. pl.,", "verbe : 3ᵉ personne du pluriel (prononciation distinctive)"]],
          184  +
          185  +            [':G', ["[mot grammatical]", "Mot grammatical"]],
          186  +            [':X', [" adverbe de négation,", "Adverbe de négation"]],
          187  +            [':U', [" adverbe interrogatif,", "Adverbe interrogatif"]],
          188  +            [':R', [" préposition,", "Préposition"]],
          189  +            [':Rv', [" préposition verbale,", "Préposition verbale"]],
          190  +            [':D', [" déterminant,", "Déterminant"]],
          191  +            [':Dd', [" déterminant démonstratif,", "Déterminant démonstratif"]],
          192  +            [':De', [" déterminant exclamatif,", "Déterminant exclamatif"]],
          193  +            [':Dp', [" déterminant possessif,", "Déterminant possessif"]],
          194  +            [':Di', [" déterminant indéfini,", "Déterminant indéfini"]],
          195  +            [':Dn', [" déterminant négatif,", "Déterminant négatif"]],
          196  +            [':Od', [" pronom démonstratif,", "Pronom démonstratif"]],
          197  +            [':Oi', [" pronom indéfini,", "Pronom indéfini"]],
          198  +            [':On', [" pronom indéfini négatif,", "Pronom indéfini négatif"]],
          199  +            [':Ot', [" pronom interrogatif,", "Pronom interrogatif"]],
          200  +            [':Or', [" pronom relatif,", "Pronom relatif"]],
          201  +            [':Ow', [" pronom adverbial,", "Pronom adverbial"]],
          202  +            [':Os', [" pronom personnel sujet,", "Pronom personnel sujet"]],
          203  +            [':Oo', [" pronom personnel objet,", "Pronom personnel objet"]],
          204  +            [':Ov', [" préverbe,", "Préverbe (pronom personnel objet, +ne)"]],
          205  +            [':O1', [" 1ʳᵉ pers.,", "Pronom : 1ʳᵉ personne"]],
          206  +            [':O2', [" 2ᵉ pers.,", "Pronom : 2ᵉ personne"]],
          207  +            [':O3', [" 3ᵉ pers.,", "Pronom : 3ᵉ personne"]],
          208  +            [':C', [" conjonction,", "Conjonction"]],
          209  +            [':Ĉ', [" conjonction (él.),", "Conjonction (élément)"]],
          210  +            [':Cc', [" conjonction de coordination,", "Conjonction de coordination"]],
          211  +            [':Cs', [" conjonction de subordination,", "Conjonction de subordination"]],
          212  +            [':Ĉs', [" conjonction de subordination (él.),", "Conjonction de subordination (élément)"]],
          213  +
          214  +            [':Ñ', [" locution nominale (él.),", "Locution nominale (élément)"]],
          215  +            [':Â', [" locution adjectivale (él.),", "Locution adjectivale (élément)"]],
          216  +            [':Ṽ', [" locution verbale (él.),", "Locution verbale (élément)"]],
          217  +            [':Ŵ', [" locution adverbiale (él.),", "Locution adverbiale (élément)"]],
          218  +            [':Ŕ', [" locution prépositive (él.),", "Locution prépositive (élément)"]],
          219  +            [':Ĵ', [" locution interjective (él.),", "Locution interjective (élément)"]],
          220  +
          221  +            [':Zp', [" préfixe,", "Préfixe"]],
          222  +            [':Zs', [" suffixe,", "Suffixe"]],
          223  +
          224  +            [':H', ["", "<Hors-norme, inclassable>"]],
          225  +
          226  +            [':@',  ["", "<Caractère non alpha-numérique>"]],
          227  +            [':@p', ["signe de ponctuation", "Signe de ponctuation"]],
          228  +            [':@s', ["signe", "Signe divers"]],
          229  +
          230  +            [';S', [" : symbole (unité de mesure)", "Symbole (unité de mesure)"]],
          231  +
          232  +            ['/*', ["", "Sous-dictionnaire <Commun>"]],
          233  +            ['/C', [" <classique>", "Sous-dictionnaire <Classique>"]],
          234  +            ['/M', ["", "Sous-dictionnaire <Moderne>"]],
          235  +            ['/R', [" <réforme>", "Sous-dictionnaire <Réforme 1990>"]],
          236  +            ['/A', ["", "Sous-dictionnaire <Annexe>"]],
          237  +            ['/X', ["", "Sous-dictionnaire <Contributeurs>"]]
          238  +        ]),
          239  +
          240  +    dLocTag: new Map([
          241  +            [':L', "locution"],
          242  +            [':LN', "locution nominale"],
          243  +            [':LA', "locution adjectivale"],
          244  +            [':LV', "locution verbale"],
          245  +            [':LW', "locution adverbiale"],
          246  +            [':LR', "locution prépositive"],
          247  +            [':LRv', "locution prépositive verbale"],
          248  +            [':LO', "locution pronominale"],
          249  +            [':LC', "locution conjonctive"],
          250  +            [':LJ', "locution interjective"],
          251  +
          252  +            [':B', " cardinale"],
          253  +            [':e', " épicène"],
          254  +            [':m', " masculine"],
          255  +            [':f', " féminine"],
          256  +            [':s', " singulière"],
          257  +            [':p', " plurielle"],
          258  +            [':i', " invariable"],
          259  +            ['/L', " (latin)"]
          260  +        ]),
          261  +
          262  +    dLocVerb: new Map([
          263  +            ['i', " intransitive"],
          264  +            ['n', " transitive indirecte"],
          265  +            ['t', " transitive directe"],
          266  +            ['p', " pronominale"],
          267  +            ['m', " impersonnelle"],
          268  +        ]),
          269  +
          270  +    dElidedPrefix: new Map([
          271  +            ['d', "(de), déterminant épicène invariable"],
          272  +            ['l', "(le/la), déterminant masculin/féminin singulier"],
          273  +            ['j', "(je), pronom personnel sujet, 1ʳᵉ pers., épicène singulier"],
          274  +            ['m', "(me), pronom personnel objet, 1ʳᵉ pers., épicène singulier"],
          275  +            ['t', "(te), pronom personnel objet, 2ᵉ pers., épicène singulier"],
          276  +            ['s', "(se), pronom personnel objet, 3ᵉ pers., épicène singulier/pluriel"],
          277  +            ['n', "(ne), adverbe de négation"],
          278  +            ['c', "(ce), pronom démonstratif, masculin singulier/pluriel"],
          279  +            ['ç', "(ça), pronom démonstratif, masculin singulier"],
          280  +            ['qu', "(que), conjonction de subordination"],
          281  +            ['lorsqu', "(lorsque), conjonction de subordination"],
          282  +            ['puisqu', "(lorsque), conjonction de subordination"],
          283  +            ['quoiqu', "(quoique), conjonction de subordination"],
          284  +            ['jusqu', "(jusque), préposition"]
          285  +        ]),
          286  +
          287  +    dPronoms: new Map([
          288  +            ['je', " pronom personnel sujet, 1ʳᵉ pers. sing."],
          289  +            ['tu', " pronom personnel sujet, 2ᵉ pers. sing."],
          290  +            ['il', " pronom personnel sujet, 3ᵉ pers. masc. sing."],
          291  +            ['on', " pronom personnel sujet, 3ᵉ pers. sing. ou plur."],
          292  +            ['elle', " pronom personnel sujet, 3ᵉ pers. fém. sing."],
          293  +            ['nous', " pronom personnel sujet/objet, 1ʳᵉ pers. plur."],
          294  +            ['vous', " pronom personnel sujet/objet, 2ᵉ pers. plur."],
          295  +            ['ils', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
          296  +            ['elles', " pronom personnel sujet, 3ᵉ pers. masc. plur."],
          297  +
          298  +            ["là", " particule démonstrative"],
          299  +            ["ci", " particule démonstrative"],
          300  +
          301  +            ['le', " COD, masc. sing."],
          302  +            ['la', " COD, fém. sing."],
          303  +            ['les', " COD, plur."],
          304  +
          305  +            ['moi', " COI (à moi), sing."],
          306  +            ['toi', " COI (à toi), sing."],
          307  +            ['lui', " COI (à lui ou à elle), sing."],
          308  +            ['nous2', " COI (à nous), plur."],
          309  +            ['vous2', " COI (à vous), plur."],
          310  +            ['leur', " COI (à eux ou à elles), plur."],
          311  +
          312  +            ['y', " pronom adverbial"],
          313  +            ["m'y", " (me) pronom personnel objet + (y) pronom adverbial"],
          314  +            ["t'y", " (te) pronom personnel objet + (y) pronom adverbial"],
          315  +            ["s'y", " (se) pronom personnel objet + (y) pronom adverbial"],
          316  +
          317  +            ['en', " pronom adverbial"],
          318  +            ["m'en", " (me) pronom personnel objet + (en) pronom adverbial"],
          319  +            ["t'en", " (te) pronom personnel objet + (en) pronom adverbial"],
          320  +            ["s'en", " (se) pronom personnel objet + (en) pronom adverbial"]
          321  +        ]),
          322  +
          323  +    dChar: new Map([
          324  +            ['.', "point"],
          325  +            ['·', "point médian"],
          326  +            ['…', "points de suspension"],
          327  +            [':', "deux-points"],
          328  +            [';', "point-virgule"],
          329  +            [',', "virgule"],
          330  +            ['?', "point d’interrogation"],
          331  +            ['!', "point d’exclamation"],
          332  +            ['(', "parenthèse ouvrante"],
          333  +            [')', "parenthèse fermante"],
          334  +            ['[', "crochet ouvrant"],
          335  +            [']', "crochet fermant"],
          336  +            ['{', "accolade ouvrante"],
          337  +            ['}', "accolade fermante"],
          338  +            ['-', "tiret"],
          339  +            ['—', "tiret cadratin"],
          340  +            ['–', "tiret demi-cadratin"],
          341  +            ['«', "guillemet ouvrant (chevrons)"],
          342  +            ['»', "guillemet fermant (chevrons)"],
          343  +            ['“', "guillemet ouvrant double"],
          344  +            ['”', "guillemet fermant double"],
          345  +            ['‘', "guillemet ouvrant"],
          346  +            ['’', "guillemet fermant"],
          347  +            ['"', "guillemets droits (déconseillé en typographie)"],
          348  +            ['/', "signe de la division"],
          349  +            ['+', "signe de l’addition"],
          350  +            ['*', "signe de la multiplication"],
          351  +            ['=', "signe de l’égalité"],
          352  +            ['<', "inférieur à"],
          353  +            ['>', "supérieur à"],
          354  +            ['⩽', "inférieur ou égal à"],
          355  +            ['⩾', "supérieur ou égal à"],
          356  +            ['%', "signe de pourcentage"],
          357  +            ['‰', "signe pour mille"],
          358  +        ]),
          359  +
          360  +    oSpellChecker: null,
          361  +    oTokenizer: null,
          362  +    oLocGraph: null,
          363  +
          364  +    _zPartDemForm: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-(là|ci)$", "i"),
          365  +    _aPartDemExceptList: new Set(["celui", "celle", "ceux", "celles", "de", "jusque", "par", "marie-couche-toi"]),
          366  +    _zInterroVerb: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-(t-(?:il|elle|on)|je|tu|ils?|elles?|on|[nv]ous)$", "i"),
          367  +    _zImperatifVerb: new RegExp("([a-zA-Zà-ö0-9À-Öø-ÿØ-ßĀ-ʯ]+)-((?:les?|la)-(?:moi|toi|lui|[nv]ous|leur)|y|en|[mts][’'](?:y|en)|les?|la|[mt]oi|leur|lui)$", "i"),
          368  +    _zTag: new RegExp("[:;/][a-zA-Z0-9ÑÂĴĈŔÔṼŴ!][^:;/]*", "g"),
          369  +
          370  +
          371  +    load: function (oSpellChecker, oTokenizer, oLocGraph) {
          372  +        this.oSpellChecker = oSpellChecker;
          373  +        this.oTokenizer = oTokenizer;
          374  +        this.oLocGraph = JSON.parse(oLocGraph);
          375  +    },
          376  +
          377  +    getInfoForToken: function (oToken) {
          378  +        // Token: .sType, .sValue, .nStart, .nEnd
          379  +        // return a object {sType, sValue, aLabel}
          380  +        let m = null;
          381  +        try {
          382  +            switch (oToken.sType) {
          383  +                case 'PUNC':
          384  +                case 'SIGN':
          385  +                    return {
          386  +                        sType: oToken.sType,
          387  +                        sValue: oToken.sValue,
          388  +                        aLabel: [this.dChar.gl_get(oToken.sValue, "caractère indéterminé")]
          389  +                    };
          390  +                    break;
          391  +                case 'NUM':
          392  +                    return {
          393  +                        sType: oToken.sType,
          394  +                        sValue: oToken.sValue,
          395  +                        aLabel: ["nombre"]
          396  +                    };
          397  +                    break;
          398  +                case 'LINK':
          399  +                    return {
          400  +                        sType: oToken.sType,
          401  +                        sValue: oToken.sValue.slice(0, 40) + "…",
          402  +                        aLabel: ["hyperlien"]
          403  +                    };
          404  +                    break;
          405  +                case 'TAG':
          406  +                    return {
          407  +                        sType: oToken.sType,
          408  +                        sValue: oToken.sValue,
          409  +                        aLabel: ["étiquette (hashtag)"]
          410  +                    };
          411  +                    break;
          412  +                case 'HTML':
          413  +                    return {
          414  +                        sType: oToken.sType,
          415  +                        sValue: oToken.sValue.slice(0, 40) + "…",
          416  +                        aLabel: ["balise HTML"]
          417  +                    };
          418  +                    break;
          419  +                case 'PSEUDOHTML':
          420  +                    return {
          421  +                        sType: oToken.sType,
          422  +                        sValue: oToken.sValue,
          423  +                        aLabel: ["balise pseudo-HTML"]
          424  +                    };
          425  +                    break;
          426  +                case 'HTMLENTITY':
          427  +                    return {
          428  +                        sType: oToken.sType,
          429  +                        sValue: oToken.sValue,
          430  +                        aLabel: ["entité caractère XML/HTML"]
          431  +                    };
          432  +                    break;
          433  +                case 'HOUR':
          434  +                    return {
          435  +                        sType: oToken.sType,
          436  +                        sValue: oToken.sValue,
          437  +                        aLabel: ["heure"]
          438  +                    };
          439  +                    break;
          440  +                case 'WORD_ELIDED':
          441  +                    let sTemp = oToken.sValue.replace("’", "").replace("'", "").replace("`", "").toLowerCase();
          442  +                    return {
          443  +                        sType: oToken.sType,
          444  +                        sValue: oToken.sValue,
          445  +                        aLabel: [this.dElidedPrefix.gl_get(sTemp, "préfixe élidé inconnu")]
          446  +                    };
          447  +                    break;
          448  +                case 'WORD_ORDINAL':
          449  +                    return {
          450  +                        sType: oToken.sType,
          451  +                        sValue: oToken.sValue,
          452  +                        aLabel: ["nombre ordinal"]
          453  +                    };
          454  +                    break;
          455  +                case 'FOLDERUNIX':
          456  +                    return {
          457  +                        sType: oToken.sType,
          458  +                        sValue: oToken.sValue.slice(0, 40) + "…",
          459  +                        aLabel: ["dossier UNIX (et dérivés)"]
          460  +                    };
          461  +                    break;
          462  +                case 'FOLDERWIN':
          463  +                    return {
          464  +                        sType: oToken.sType,
          465  +                        sValue: oToken.sValue.slice(0, 40) + "…",
          466  +                        aLabel: ["dossier Windows"]
          467  +                    };
          468  +                    break;
          469  +                case 'WORD_ACRONYM':
          470  +                    return {
          471  +                        sType: oToken.sType,
          472  +                        sValue: oToken.sValue,
          473  +                        aLabel: ["Sigle ou acronyme"]
          474  +                    };
          475  +                    break;
          476  +                case 'WORD':
          477  +                    if (oToken.sValue.gl_count("-") > 4) {
          478  +                        return {
          479  +                            sType: "COMPLEX",
          480  +                            sValue: oToken.sValue,
          481  +                            aLabel: ["élément complexe indéterminé"]
          482  +                        };
          483  +                    } else if (m = this._zPartDemForm.exec(oToken.sValue)) {
          484  +                        // mots avec particules démonstratives
          485  +                        if (this._aPartDemExceptList.has(m[1].toLowerCase())) {
          486  +                            return {
          487  +                                sType: "WORD",
          488  +                                sValue: oToken.sValue,
          489  +                                aLabel: this._getMorph(oToken.sValue)
          490  +                            };
          491  +                        }
          492  +                        return {
          493  +                            sType: oToken.sType,
          494  +                            sValue: oToken.sValue,
          495  +                            aLabel: ["mot avec particule démonstrative"],
          496  +                            aSubElem: [
          497  +                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
          498  +                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
          499  +                            ]
          500  +                        };
          501  +                    } else if (m = this._zImperatifVerb.exec(oToken.sValue)) {
          502  +                        // formes interrogatives
          503  +                        return {
          504  +                            sType: oToken.sType,
          505  +                            sValue: oToken.sValue,
          506  +                            aLabel: ["forme verbale impérative"],
          507  +                            aSubElem: [
          508  +                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
          509  +                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
          510  +                            ]
          511  +                        };
          512  +                    } else if (m = this._zInterroVerb.exec(oToken.sValue)) {
          513  +                        // formes interrogatives
          514  +                        return {
          515  +                            sType: oToken.sType,
          516  +                            sValue: oToken.sValue,
          517  +                            aLabel: ["forme verbale interrogative"],
          518  +                            aSubElem: [
          519  +                                { sType: oToken.sType, sValue: m[1],       aLabel: this._getMorph(m[1]) },
          520  +                                { sType: oToken.sType, sValue: "-" + m[2], aLabel: [this._formatSuffix(m[2].toLowerCase())] }
          521  +                            ]
          522  +                        };
          523  +                    } else if (this.oSpellChecker.isValidToken(oToken.sValue)) {
          524  +                        return {
          525  +                            sType: oToken.sType,
          526  +                            sValue: oToken.sValue,
          527  +                            aLabel: this._getMorph(oToken.sValue)
          528  +                        };
          529  +                    } else {
          530  +                        return {
          531  +                            sType: "UNKNOWN_WORD",
          532  +                            sValue: oToken.sValue,
          533  +                            aLabel: ["mot inconnu du dictionnaire"]
          534  +                        };
          535  +                    }
          536  +                    break;
          537  +                default:
          538  +                    return {
          539  +                        sType: oToken.sType,
          540  +                        sValue: oToken.sValue,
          541  +                        aLabel: ["token inconnu"]
          542  +                    }
          543  +            }
          544  +        } catch (e) {
          545  +            console.error(e);
          546  +        }
          547  +        return null;
          548  +    },
          549  +
          550  +    _getMorph (sWord) {
          551  +        let aElem = [];
          552  +        for (let s of this.oSpellChecker.getMorph(sWord)) {
          553  +            if (s.includes(":")) aElem.push(this._formatTags(s));
          554  +        }
          555  +        if (aElem.length == 0) {
          556  +            aElem.push("mot inconnu du dictionnaire");
          557  +        }
          558  +        return aElem;
          559  +    },
          560  +
          561  +    _formatTags (sTags) {
          562  +        let sRes = "";
          563  +        sTags = sTags.replace(/V([0-3][ea]?)[itpqnmr_eaxz]+/, "V$1");
          564  +        let m;
          565  +        while ((m = this._zTag.exec(sTags)) !== null) {
          566  +            sRes += this.dTag.get(m[0])[0];
          567  +        }
          568  +        if (sRes.startsWith(" verbe") && !sRes.includes("infinitif")) {
          569  +            sRes += " [" + sTags.slice(1, sTags.indexOf("/")) + "]";
          570  +        }
          571  +        if (!sRes) {
          572  +            return "#Erreur. Étiquette inconnue : [" + sTags + "]";
          573  +        }
          574  +        return sRes.gl_trimRight(",");
          575  +    },
          576  +
          577  +    _formatTagsLoc (sTags) {
          578  +        let sRes = "";
          579  +        let m;
          580  +        while ((m = this._zTag.exec(sTags)) !== null) {
          581  +            if (m[0].startsWith(":LV")) {
          582  +                sRes += this.dLocTag.get(":LV");
          583  +                for (let c of m[0].slice(3)) {
          584  +                    sRes += this.dLocVerb.get(c);
          585  +                }
          586  +            } else {
          587  +                sRes += this.dLocTag.get(m[0]);
          588  +            }
          589  +        }
          590  +        if (!sRes) {
          591  +            return "#Erreur. Étiquette inconnue : [" + sTags + "]";
          592  +        }
          593  +        return sRes.gl_trimRight(",");
          594  +    },
          595  +
          596  +    _formatSuffix (s) {
          597  +        if (s.startsWith("t-")) {
          598  +            return "“t” euphonique +" + this.dPronoms.get(s.slice(2));
          599  +        }
          600  +        if (!s.includes("-")) {
          601  +            return this.dPronoms.get(s.replace("’", "'"));
          602  +        }
          603  +        if (s.endsWith("ous")) {
          604  +            s += '2';
          605  +        }
          606  +        let nPos = s.indexOf("-");
          607  +        return this.dPronoms.get(s.slice(0, nPos)) + " +" + this.dPronoms.get(s.slice(nPos + 1));
          608  +    },
          609  +
          610  +    getListOfTokens (sText, bInfo=true) {
          611  +        let aElem = [];
          612  +        if (sText !== "") {
          613  +            for (let oToken of this.oTokenizer.genTokens(sText)) {
          614  +                if (bInfo) {
          615  +                    let aRes = this.getInfoForToken(oToken);
          616  +                    if (aRes) {
          617  +                        aElem.push(aRes);
          618  +                    }
          619  +                } else if (oToken.sType !== "SPACE") {
          620  +                    aElem.push(oToken);
          621  +                }
          622  +            }
          623  +        }
          624  +        return aElem;
          625  +    },
          626  +
          627  +    * generateInfoForTokenList (lToken) {
          628  +        for (let oToken of lToken) {
          629  +            let aRes = this.getInfoForToken(oToken);
          630  +            if (aRes) {
          631  +                yield aRes;
          632  +            }
          633  +        }
          634  +    },
          635  +
          636  +    getListOfTokensReduc (sText, bInfo=true) {
          637  +        let lToken = this.getListOfTokens(sText.replace("'", "’").trim(), false);
          638  +        let iToken = 0;
          639  +        let aElem = [];
          640  +        if (lToken.length == 0) {
          641  +            return aElem;
          642  +        }
          643  +        do {
          644  +            let oToken = lToken[iToken];
          645  +            let sMorphLoc = '';
          646  +            let aTokenTempList = [oToken];
          647  +            if (oToken.sType == "WORD" || oToken.sType == "WORD_ELIDED"){
          648  +                let iLocEnd = iToken + 1;
          649  +                let oLocNode = this.oLocGraph[oToken.sValue.toLowerCase()];
          650  +                while (oLocNode) {
          651  +                    let oTokenNext = lToken[iLocEnd];
          652  +                    iLocEnd++;
          653  +                    if (oTokenNext) {
          654  +                        oLocNode = oLocNode[oTokenNext.sValue.toLowerCase()];
          655  +                    }
          656  +                    if (oLocNode && iLocEnd <= lToken.length) {
          657  +                        sMorphLoc = oLocNode["_:_"];
          658  +                        aTokenTempList.push(oTokenNext);
          659  +                    } else {
          660  +                        break;
          661  +                    }
          662  +                }
          663  +            }
          664  +
          665  +            if (sMorphLoc) {
          666  +                // we have a locution
          667  +                let sValue = '';
          668  +                for (let oTokenWord of aTokenTempList) {
          669  +                    sValue += oTokenWord.sValue+' ';
          670  +                }
          671  +                let oTokenLocution = {
          672  +                    'nStart': aTokenTempList[0].nStart,
          673  +                    'nEnd': aTokenTempList[aTokenTempList.length-1].nEnd,
          674  +                    'sType': "LOC",
          675  +                    'sValue': sValue.replace('’ ','’').trim(),
          676  +                    'aSubToken': aTokenTempList
          677  +                };
          678  +                if (bInfo) {
          679  +                    let aSubElem = null;
          680  +                    if (sMorphLoc.startsWith("*|")) {
          681  +                        // cette suite de tokens n’est une locution que dans certains cas minoritaires
          682  +                        oTokenLocution.sType = "LOCP";
          683  +                        for (let oElem of this.generateInfoForTokenList(aTokenTempList)) {
          684  +                            aElem.push(oElem);
          685  +                        }
          686  +                        sMorphLoc = sMorphLoc.slice(2);
          687  +                    } else {
          688  +                        aSubElem = [...this.generateInfoForTokenList(aTokenTempList)];
          689  +                    }
          690  +                    // cette suite de tokens est la plupart du temps une locution
          691  +                    let aFormatedTag = [];
          692  +                    for (let sTagLoc of sMorphLoc.split('|') ){
          693  +                        aFormatedTag.push(this._formatTagsLoc(sTagLoc));
          694  +                    }
          695  +                    aElem.push({
          696  +                        sType: oTokenLocution.sType,
          697  +                        sValue: oTokenLocution.sValue,
          698  +                        aLabel: aFormatedTag,
          699  +                        aSubElem: aSubElem
          700  +                    });
          701  +                } else {
          702  +                    aElem.push(oTokenLocution);
          703  +                }
          704  +                iToken = iToken + aTokenTempList.length;
          705  +            }
          706  +            else {
          707  +                // No locution, we just add information
          708  +                if (bInfo) {
          709  +                    let aRes = this.getInfoForToken(oToken);
          710  +                    if (aRes) {
          711  +                        aElem.push(aRes);
          712  +                    }
          713  +                } else {
          714  +                    aElem.push(oToken);
          715  +                }
          716  +                iToken++;
          717  +            }
          718  +        } while (iToken < lToken.length);
          719  +        return aElem;
          720  +    }
          721  +}
          722  +
          723  +
          724  +
          725  +if (typeof(exports) !== 'undefined') {
          726  +    exports.lexgraph_fr = lexgraph_fr;
          727  +}

Modified graphspell-js/spellchecker.js from [88587ea88f] to [af4645de50].

     9      9   
    10     10   /* jshint esversion:6, -W097 */
    11     11   /* jslint esversion:6 */
    12     12   /* global require, exports, console, IBDAWG, Tokenizer */
    13     13   
    14     14   "use strict";
    15     15   
    16         -if(typeof(process) !== 'undefined') {
           16  +if (typeof(process) !== 'undefined') {
    17     17       var ibdawg = require("./ibdawg.js");
    18     18       var tokenizer = require("./tokenizer.js");
    19         -    var suggest = require("./suggest.js");
    20         -} else if (typeof(require) !== 'undefined') {
           19  +}
           20  +else if (typeof(require) !== 'undefined') {
    21     21       var ibdawg = require("resource://grammalecte/graphspell/ibdawg.js");
    22     22       var tokenizer = require("resource://grammalecte/graphspell/tokenizer.js");
    23         -    var suggest = require("resource://grammalecte/graphspell/suggest.js");
    24     23   }
    25     24   
    26     25   ${map}
    27     26   
    28     27   
    29     28   const dDefaultDictionaries = new Map([
    30     29       ["fr", "fr-allvars.json"],
................................................................................
    42     41           }
    43     42           this.oMainDic = this._loadDictionary(mainDic, sPath, true);
    44     43           this.oCommunityDic = this._loadDictionary(communityDic, sPath);
    45     44           this.oPersonalDic = this._loadDictionary(personalDic, sPath);
    46     45           this.bCommunityDic = Boolean(this.oCommunityDic);
    47     46           this.bPersonalDic = Boolean(this.oPersonalDic);
    48     47           this.oTokenizer = null;
    49         -        // Default suggestions
    50         -        this.dDefaultSugg = null;
    51         -        this.loadSuggestions(sLangCode)
           48  +        // Lexicographer
           49  +        this.lexicographer = null;
           50  +        this.loadLexicographer(sLangCode)
    52     51           // storage
    53     52           this.bStorage = false;
    54     53           this._dMorphologies = new Map();            // key: flexion, value: list of morphologies
    55     54           this._dLemmas = new Map();                  // key: flexion, value: list of lemmas
    56     55       }
    57     56   
    58     57       _loadDictionary (dictionary, sPath="", bNecessary=false) {
................................................................................
   127    126       }
   128    127   
   129    128       deactivatePersonalDictionary () {
   130    129           this.bPersonalDic = false;
   131    130       }
   132    131   
   133    132   
   134         -    // Default suggestions
          133  +    // Lexicographer
   135    134   
   136         -    loadSuggestions (sLangCode) {
          135  +    loadLexicographer (sLangCode) {
   137    136           // load default suggestion module for <sLangCode>
   138         -        // When “import” works everywhere, do like with Python
   139         -        try {
   140         -            if (typeof(suggest) !== 'undefined') {
   141         -                this.dDefaultSugg = suggest[sLangCode];
   142         -            }
          137  +        if (typeof(process) !== 'undefined') {
          138  +            this.lexicographer = require(`./lexgraph_${sLangCode}.js`);
   143    139           }
   144         -        catch (e) {
   145         -            console.error(e);
          140  +        else if (typeof(require) !== 'undefined') {
          141  +            this.lexicographer = require(`resource://grammalecte/graphspell/lexgraph_${sLangCode}.js`);
   146    142           }
   147    143       }
   148    144   
   149    145   
   150    146       // Storage
   151    147   
   152    148       activateStorage () {
................................................................................
   251    247               return this._dLemmas.get(sWord);
   252    248           }
   253    249           return Array.from(new Set(this.getMorph(sWord).map((sMorph) => { return sMorph.slice(1, sMorph.indexOf("/")); })));
   254    250       }
   255    251   
   256    252       * suggest (sWord, nSuggLimit=10) {
   257    253           // generator: returns 1, 2 or 3 lists of suggestions
   258         -        if (this.dDefaultSugg) {
   259         -            if (this.dDefaultSugg.has(sWord)) {
   260         -                yield this.dDefaultSugg.get(sWord).split("|");
   261         -            } else if (sWord.gl_isTitle() && this.dDefaultSugg.has(sWord.toLowerCase())) {
   262         -                let lRes = this.dDefaultSugg.get(sWord.toLowerCase()).split("|");
          254  +        if (this.lexicographer) {
          255  +            if (this.lexicographer.dSugg.has(sWord)) {
          256  +                yield this.lexicographer.dSugg.get(sWord).split("|");
          257  +            } else if (sWord.gl_isTitle() && this.lexicographer.dSugg.has(sWord.toLowerCase())) {
          258  +                let lRes = this.lexicographer.dSugg.get(sWord.toLowerCase()).split("|");
   263    259                   yield lRes.map((sSugg) => { return sSugg.slice(0,1).toUpperCase() + sSugg.slice(1); });
   264    260               } else {
   265    261                   yield this.oMainDic.suggest(sWord, nSuggLimit, true);
   266    262               }
   267    263           } else {
   268    264               yield this.oMainDic.suggest(sWord, nSuggLimit, true);
   269    265           }

Deleted graphspell-js/suggest.js version [e077b6573b].

     1         -// JavaScript
     2         -
     3         -"use strict";
     4         -
     5         -var suggest = {
     6         -    fr: new Map ([
     7         -        ["bcp", "beaucoup"],
     8         -        ["ca", "ça"],
     9         -        ["cad", "c’est-à-dire"],
    10         -        ["cb", "combien|CB"],
    11         -        ["cdlt", "cordialement"],
    12         -        ["construirent", "construire|construisirent|construisent|construiront"],
    13         -        ["càd", "c’est-à-dire"],
    14         -        ["chai", "j’sais|je sais"],
    15         -        ["chais", "j’sais|je sais"],
    16         -        ["chui", "j’suis|je suis"],
    17         -        ["chuis", "j’suis|je suis"],
    18         -        ["dc", "de|donc"],
    19         -        ["done", "donc|donne"],
    20         -        ["email", "courriel|e-mail|émail"],
    21         -        ["emails", "courriels|e-mails"],
    22         -        ["ete", "êtes|été"],
    23         -        ["Etes-vous", "Êtes-vous"],
    24         -        ["Etiez-vous", "Étiez-vous"],
    25         -        ["Etions-vous", "Étions-nous"],
    26         -        ["loins", "loin"],
    27         -        ["mn", "min"],
    28         -        ["mns", "min"],
    29         -        ["parce-que", "parce que"],
    30         -        ["pcq", "parce que"],
    31         -        ["pd", "pendant|pédé"],
    32         -        ["pdq", "pendant que"],
    33         -        ["pdt", "pendant"],
    34         -        ["pdtq", "pendant que"],
    35         -        ["pécunier", "pécuniaire"],
    36         -        ["pécuniers", "pécuniaires"],
    37         -        ["pk", "pourquoi"],
    38         -        ["pkoi", "pourquoi"],
    39         -        ["pq", "pourquoi|PQ"],
    40         -        ["prq", "presque"],
    41         -        ["prsq", "presque"],
    42         -        ["qcq", "quiconque"],
    43         -        ["qd", "quand"],
    44         -        ["qq", "quelque"],
    45         -        ["qqch", "quelque chose"],
    46         -        ["qqn", "quelqu’un"],
    47         -        ["qqne", "quelqu’une"],
    48         -        ["qqs", "quelques"],
    49         -        ["qqunes", "quelques-unes"],
    50         -        ["qquns", "quelques-uns"],
    51         -        ["tdq", "tandis que"],
    52         -        ["tj", "toujours"],
    53         -        ["tjs", "toujours"],
    54         -        ["tq", "tant que|tandis que"],
    55         -        ["ts", "tous"],
    56         -        ["tt", "tant|tout"],
    57         -        ["tte", "toute"],
    58         -        ["ttes", "toutes"],
    59         -
    60         -        ["Iier", "Iᵉʳ"],
    61         -        ["Iière", "Iʳᵉ"],
    62         -        ["IIième", "IIᵉ"],
    63         -        ["IIIième", "IIIᵉ"],
    64         -        ["IVième", "IVᵉ"],
    65         -        ["Vième", "Vᵉ"],
    66         -        ["VIième", "VIᵉ"],
    67         -        ["VIIième", "VIIᵉ"],
    68         -        ["VIIIième", "VIIIᵉ"],
    69         -        ["IXième", "IXᵉ"],
    70         -        ["Xième", "Xᵉ"],
    71         -        ["XIième", "XIᵉ"],
    72         -        ["XIIième", "XIIᵉ"],
    73         -        ["XIIIième", "XIIIᵉ"],
    74         -        ["XIVième", "XIVᵉ"],
    75         -        ["XVième", "XVᵉ"],
    76         -        ["XVIième", "XVIᵉ"],
    77         -        ["XVIIième", "XVIIᵉ"],
    78         -        ["XVIIIième", "XVIIIᵉ"],
    79         -        ["XIXième", "XIXᵉ"],
    80         -        ["XXième", "XXᵉ"],
    81         -        ["XXIième", "XXIᵉ"],
    82         -        ["XXIIième", "XXIIᵉ"],
    83         -        ["XXIIIième", "XXIIIᵉ"],
    84         -        ["XXIVième", "XXIVᵉ"],
    85         -        ["XXVième", "XXVᵉ"],
    86         -        ["XXVIième", "XXVIᵉ"],
    87         -        ["XXVIIième", "XXVIIᵉ"],
    88         -        ["XXVIIIième", "XXVIIIᵉ"],
    89         -        ["XXIXième", "XXIXᵉ"],
    90         -        ["XXXième", "XXXᵉ"],
    91         -        ["Ier", "Iᵉʳ"],
    92         -        ["Ière", "Iʳᵉ"],
    93         -        ["IIème", "IIᵉ"],
    94         -        ["IIIème", "IIIᵉ"],
    95         -        ["IVème", "IVᵉ"],
    96         -        ["Vème", "Vᵉ"],
    97         -        ["VIème", "VIᵉ"],
    98         -        ["VIIème", "VIIᵉ"],
    99         -        ["VIIIème", "VIIIᵉ"],
   100         -        ["IXème", "IXᵉ"],
   101         -        ["Xème", "Xᵉ"],
   102         -        ["XIème", "XIᵉ"],
   103         -        ["XIIème", "XIIᵉ"],
   104         -        ["XIIIème", "XIIIᵉ"],
   105         -        ["XIVème", "XIVᵉ"],
   106         -        ["XVème", "XVᵉ"],
   107         -        ["XVIème", "XVIᵉ"],
   108         -        ["XVIIème", "XVIIᵉ"],
   109         -        ["XVIIIème", "XVIIIᵉ"],
   110         -        ["XIXème", "XIXᵉ"],
   111         -        ["XXème", "XXᵉ"],
   112         -        ["XXIème", "XXIᵉ"],
   113         -        ["XXIIème", "XXIIᵉ"],
   114         -        ["XXIIIème", "XXIIIᵉ"],
   115         -        ["XXIVème", "XXIVᵉ"],
   116         -        ["XXVème", "XXVᵉ"],
   117         -        ["XXVIème", "XXVIᵉ"],
   118         -        ["XXVIIème", "XXVIIᵉ"],
   119         -        ["XXVIIIème", "XXVIIIᵉ"],
   120         -        ["XXIXème", "XXIXᵉ"],
   121         -        ["XXXème", "XXXᵉ"]
   122         -    ])
   123         -};
   124         -
   125         -
   126         -if (typeof(exports) !== 'undefined') {
   127         -    exports.fr = suggest.fr;
   128         -}