Index: gc_lang/fr/nodejs/core/api.js
==================================================================
--- gc_lang/fr/nodejs/core/api.js
+++ gc_lang/fr/nodejs/core/api.js
@@ -8,11 +8,10 @@
 /* global require, exports, console */
 
 "use strict";
 
 class GrammarChecker {
-
     constructor(aInit, sLangCode = "fr", sContext = "Javascript") {
         this.sLangCode = sLangCode;
         this.sContext = sContext;
 
         //Importation des fichiers nécessaire
@@ -25,22 +24,22 @@
             Tokenizer: false,
             TextFormatter: false,
             Lexicographer: false
         };
 
-        if (aInit){
+        if (aInit) {
             this.load(aInit);
         }
     }
 
     //Auto-chargement avec dépendence
-    load(aInit = ["Grammalecte", "Graphspell", "TextFormatter", "Lexicographer", "Tokenizer"]){
+    load(aInit = ["Grammalecte", "Graphspell", "TextFormatter", "Lexicographer", "Tokenizer"]) {
         //aInit permet de charger que certain composant
         // => évite de charger toutes données si par exemple on a besoin que du lexigraphe
         // => sorte de gestionnaire de dépendence (peut être amélioré)
         this.isInit = {};
-        if ( aInit.indexOf("Grammalecte") !== false ){
+        if (aInit.indexOf("Grammalecte") !== false) {
             //console.log('init Grammalecte');
             this._oGce = require(this.sPathRoot + "/fr/gc_engine.js");
             this._oGce.load(this.sContext);
             this.isInit.Grammalecte = true;
             this.oSpellChecker = this._oGce.getSpellChecker();
@@ -47,34 +46,34 @@
             this.isInit.Graphspell = true;
             this.oTokenizer = this.oSpellChecker.getTokenizer();
             this.isInit.Tokenizer = true;
         }
 
-        if ( !this.isInit.Graphspell && (aInit.indexOf("Graphspell") !== false || aInit.indexOf("Lexicographer") !== false)){
+        if (!this.isInit.Graphspell && (aInit.indexOf("Graphspell") !== false || aInit.indexOf("Lexicographer") !== false)) {
             //console.log('init Graphspell');
             this._SpellChecker = require(this.sPathRoot + "/graphspell/spellchecker.js");
             this.oSpellChecker = new this._SpellChecker.SpellChecker(this.sLangCode, this.sPathRoot + "/graphspell/_dictionaries");
             this.isInit.Graphspell = true;
             this.oTokenizer = this.oSpellChecker.getTokenizer();
             this.isInit.Tokenizer = true;
         }
 
-        if ( !this.isInit.Tokenizer && aInit.indexOf("Tokenizer") !== false ){
+        if (!this.isInit.Tokenizer && aInit.indexOf("Tokenizer") !== false) {
             //console.log('init Tokenizer');
             this._Tokenizer = require(this.sPathRoot + "/graphspell/tokenizer.js");
             this.oTokenizer = new this._Tokenizer.Tokenizer(this.sLangCode);
             this.isInit.Tokenizer = true;
         }
 
-        if ( aInit.indexOf("TextFormatter") !== false ){
+        if (aInit.indexOf("TextFormatter") !== false) {
             //console.log('init TextFormatter');
             this._oText = require(this.sPathRoot + "/fr/textformatter.js");
             this.oTextFormatter = new this._oText.TextFormatter();
             this.isInit.TextFormatter = true;
         }
 
-        if ( aInit.indexOf("Lexicographer") !== false ){
+        if (aInit.indexOf("Lexicographer") !== false) {
             //console.log('init Lexicographer');
             this._oLex = require(this.sPathRoot + "/fr/lexicographe.js");
             this.oLexicographer = new this._oLex.Lexicographe(
                 this.oSpellChecker,
                 this.oTokenizer,
@@ -83,39 +82,39 @@
             this.isInit.Lexicographer = true;
         }
     }
 
     //Fonctions concernant: Grammalecte
-    getGrammalecte(){
+    getGrammalecte() {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         return this._oGce;
     }
 
-    gramma(sText){
+    gramma(sText) {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         return Array.from(this._oGce.parse(sText, this.sLangCode));
     }
 
-    getGceOptions () {
+    getGceOptions() {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         return this._helpers.mapToObject(this._oGce.getOptions());
     }
 
-    getGceDefaultOptions () {
+    getGceDefaultOptions() {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         return this._helpers.mapToObject(this._oGce.getDefaultOptions());
     }
 
-    setGceOptions (dOptions) {
+    setGceOptions(dOptions) {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         if (!(dOptions instanceof Map)) {
             dOptions = this._helpers.objectToMap(dOptions);
@@ -122,11 +121,11 @@
         }
         this._oGce.setOptions(dOptions);
         return this._helpers.mapToObject(this._oGce.getOptions());
     }
 
-    setGceOption (sOptName, bValue) {
+    setGceOption(sOptName, bValue) {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         if (sOptName) {
             this._oGce.setOption(sOptName, bValue);
@@ -133,33 +132,33 @@
             return this._helpers.mapToObject(this._oGce.getOptions());
         }
         return false;
     }
 
-    resetGceOptions () {
+    resetGceOptions() {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         this._oGce.resetOptions();
         return this._helpers.mapToObject(this._oGce.getOptions());
     }
 
-    getGceRules (bParagraph) {
+    getGceRules(bParagraph) {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         return this._oGce.getRules(bParagraph);
     }
 
-    getGceIgnoreRules () {
+    getGceIgnoreRules() {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         return Array.from(this._oGce.getIgnoreRules());
     }
 
-    setGceIgnoreRules (dRules) {
+    setGceIgnoreRules(dRules) {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         if (!(dRules instanceof Set)) {
             dRules = new Set(dRules);
@@ -166,43 +165,53 @@
         }
         this._oGce._aIgnoredRules = dRules;
         return Array.from(this._oGce.getIgnoreRules());
     }
 
-    setGceIgnoreRule (sRuleId, bValue) {
+    setGceIgnoreRule(sRuleId, bValue) {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
-        if (bValue){ //Add
+        if (bValue) {
+            //Add
             this._oGce.ignoreRule(sRuleId);
-        } else {     //Delete
+        } else {
+            //Delete
             this._oGce.reactivateRule(sRuleId);
         }
         return Array.from(this._oGce.getIgnoreRules());
     }
 
-    resetGceIgnoreRules () {
+    resetGceIgnoreRules() {
         if (!this.isInit.Grammalecte) {
             this.load(["Grammalecte"]);
         }
         this._oGce.resetIgnoreRules();
         return Array.from(this._oGce.getIgnoreRules());
     }
 
     //Fonctions concernant: Graphspell
-    getGraphspell(){
+    getGraphspell() {
         if (!this.isInit.Graphspell) {
             this.load(["Graphspell"]);
         }
         return this.oSpellChecker;
     }
 
-    spellParagraph(sText, bSuggest = true){
+    setMainDictionary(dictionary, sPath = "") {
+        return this.oSpellChecker.setMainDictionary(dictionary, sPath);
+    }
+
+    setPersonalDictionary(dictionary, sPath = "", bActivate = true) {
+        return this.oSpellChecker.setPersonalDictionary(dictionary, sPath, bActivate);
+    }
+
+    spellParagraph(sText, bSuggest = true) {
         if (!this.isInit.Graphspell) {
             this.load(["Graphspell"]);
         }
-        if (bSuggest){
+        if (bSuggest) {
             let lError = this.oSpellChecker.parseParagraph(sText);
             for (let token of lError) {
                 token.aSuggestions = this.suggest(token.sValue);
             }
             return lError;
@@ -209,23 +218,23 @@
         } else {
             return this.oSpellChecker.parseParagraph(sText);
         }
     }
 
-    spell(sWord){
+    spell(sWord) {
         if (!this.isInit.Graphspell) {
             this.load(["Graphspell"]);
         }
         return this.oSpellChecker.isValid(sWord);
     }
 
-    suggest(sWord, nbLimit = 10, bMerge = true){
+    suggest(sWord, nbLimit = 10, bMerge = true) {
         if (!this.isInit.Graphspell) {
             this.load(["Graphspell"]);
         }
         let lSuggest = this.oSpellChecker.suggest(sWord, nbLimit);
-        if (bMerge){
+        if (bMerge) {
             let lSuggestRep = [];
             for (let lSuggestTmp of lSuggest) {
                 for (let word of lSuggestTmp) {
                     lSuggestRep.push(word);
                 }
@@ -232,51 +241,50 @@
             }
             return lSuggestRep;
         } else {
             return Array.from(lSuggest);
         }
-
     }
 
-    lemma(sWord){
+    lemma(sWord) {
         if (!this.isInit.Graphspell) {
             this.load(["Graphspell"]);
         }
         return this.oSpellChecker.getLemma(sWord);
     }
 
-    morph(sWord){
+    morph(sWord) {
         if (!this.isInit.Graphspell) {
             this.load(["Graphspell"]);
         }
         return this.oSpellChecker.getMorph(sWord);
     }
 
     //Fonctions concernant: Lexicographer
-    getLexicographer(){
+    getLexicographer() {
         if (!this.isInit.Lexicographer) {
             this.load(["Lexicographer"]);
         }
         return this.oLexicographer;
     }
 
-    lexique(sText){
+    lexique(sText) {
         if (!this.isInit.Lexicographer) {
             this.load(["Lexicographer"]);
         }
         return this.oLexicographer.getListOfTokensReduc(sText);
     }
 
     //Fonctions concernant: TextFormatter
-    getTextFormatter(){
+    getTextFormatter() {
         if (!this.isInit.TextFormatter) {
             this.load(["TextFormatter"]);
         }
         return this.oTextFormatter;
     }
 
-    formatText(sText){
+    formatText(sText) {
         if (!this.isInit.TextFormatter) {
             this.load(["TextFormatter"]);
         }
         return this.oTextFormatter.formatText(sText);
     }
@@ -309,20 +317,19 @@
         this.oTextFormatter.setOptions(optionsTF);
         return this._helpers.mapToObject(this.oTextFormatter.getOptions());
     }
 
     //fonctions concernant plussieurs parties
-    verifParagraph(sText, bSuggest = true){
+    verifParagraph(sText, bSuggest = true) {
         if (!this.isInit.Grammalecte || !this.isInit.Graphspell) {
             this.load(["Grammalecte"]);
         }
         return {
             lGrammarErrors: Array.from(this._oGce.parse(sText, this.sLangCode)),
             lSpellingErrors: this.spellParagraph(sText, bSuggest)
         };
     }
-
 }
 
 if (typeof exports !== "undefined") {
     exports.GrammarChecker = GrammarChecker;
 }