Index: gc_core/js/tests.js
==================================================================
--- gc_core/js/tests.js
+++ gc_core/js/tests.js
@@ -14,23 +14,24 @@
 }
 
 
 class TestGrammarChecking {
 
-    constructor (gce, spfTests="") {
-        this.gce = gce;
+    constructor (gc_engine, gc_options, spfTests="") {
+        this.gc_engine = gc_engine;
+        this.gc_options = gc_options;
         this.spfTests = spfTests;
         this._aRuleTested = new Set();
     }
 
     * testParse (bDebug=false) {
         const t0 = Date.now();
         let sURL;
         if(typeof(process) !== 'undefined') {
-            sURL = (this.spfTests !== "") ? this.spfTests : "./"+this.gce.lang+"/tests_data.json";
+            sURL = (this.spfTests !== "") ? this.spfTests : "./"+this.gc_engine.lang+"/tests_data.json";
         } else {
-            sURL = (this.spfTests !== "") ? this.spfTests : "resource://grammalecte/"+this.gce.lang+"/tests_data.json";
+            sURL = (this.spfTests !== "") ? this.spfTests : "resource://grammalecte/"+this.gc_engine.lang+"/tests_data.json";
         }
         const aData = JSON.parse(helpers.loadFile(sURL)).aData;
         let nInvalid = 0;
         let nTotal = 0;
         let sErrorText;
@@ -44,11 +45,11 @@
         let sUntestedRules = "";
         let bShowUntested = false;
         let zOption = /^__([a-zA-Z0-9]+)__ /;
         let sOption;
         let m;
-        yield "Tests [" + this.gce.lang + "]: " + aData.length.toString();
+        yield "Tests [" + this.gc_engine.lang + "]: " + aData.length.toString();
         try {
             for (let sLine of aData) {
                 sLineNum = sLine.slice(0,10).trim();
                 sLine = sLine.slice(10).trim();
                 if (sLine.length > 0 && !sLine.startsWith("#")) {
@@ -90,11 +91,11 @@
             console.error(e);
         }
 
         if (bShowUntested) {
             i = 0;
-            for (let [sOpt, sLineId, sRuleId] of this.gce.listRules()) {
+            for (let [sOpt, sLineId, sRuleId] of this.gc_engine.listRules()) {
                 if (sOpt !== "@@@@" && !this._aRuleTested.has(sLineId) && !/^[0-9]+[sp]$|^[pd]_/.test(sRuleId)) {
                     sUntestedRules += sLineId + "/" + sRuleId + ", ";
                     i += 1;
                 }
             }
@@ -136,15 +137,15 @@
 
     _getFoundErrors (sLine, bDebug, sOption) {
         try {
             let aErrs = [];
             if (sOption) {
-                this.gce.setOption(sOption, true);
-                aErrs = this.gce.parse(sLine, "FR", bDebug);
-                this.gce.setOption(sOption, false);
+                this.gc_options.setOption(sOption, true);
+                aErrs = this.gc_engine.parse(sLine, "FR", bDebug);
+                this.gc_options.setOption(sOption, false);
             } else {
-                aErrs = this.gce.parse(sLine, "FR", bDebug);
+                aErrs = this.gc_engine.parse(sLine, "FR", bDebug);
             }
             let sRes = " ".repeat(sLine.length);
             let sListErr = "";
             for (let dErr of aErrs) {
                 sRes = sRes.slice(0, dErr["nStart"]) + "~".repeat(dErr["nEnd"] - dErr["nStart"]) + sRes.slice(dErr["nEnd"]);

Index: gc_lang/fr/webext/gce_worker.js
==================================================================
--- gc_lang/fr/webext/gce_worker.js
+++ gc_lang/fr/webext/gce_worker.js
@@ -47,11 +47,10 @@
 importScripts("grammalecte/fr/gc_options.js");
 importScripts("grammalecte/fr/gc_rules.js");
 importScripts("grammalecte/fr/gc_rules_graph.js");
 importScripts("grammalecte/fr/gc_engine_func.js");
 importScripts("grammalecte/fr/gc_engine.js");
-importScripts("grammalecte/fr/lexicographe.js");
 importScripts("grammalecte/tests.js");
 /*
     Warning.
     Initialization can’t be completed at startup of the worker,
     for we need the path of the extension to load data stored in JSON files.
@@ -176,11 +175,11 @@
             phonet.init(helpers.loadFile(sExtensionPath + "/grammalecte/fr/phonet_data.json"));
             mfsp.init(helpers.loadFile(sExtensionPath + "/grammalecte/fr/mfsp_data.json"));
             //console.log("[Worker] Modules have been initialized…");
             gc_engine.load(sContext, "aHSL", sExtensionPath+"grammalecte/graphspell/_dictionaries");
             oSpellChecker = gc_engine.getSpellChecker();
-            oTest = new TestGrammarChecking(gc_engine, sExtensionPath+"/grammalecte/fr/tests_data.json");
+            oTest = new TestGrammarChecking(gc_engine, gc_options, sExtensionPath+"/grammalecte/fr/tests_data.json");
             oTokenizer = new Tokenizer("fr");
             oLocution =  helpers.loadFile(sExtensionPath + "/grammalecte/fr/locutions_data.json");
             lexgraph_fr.load(oSpellChecker, oTokenizer, oLocution);
             if (dOptions !== null) {
                 if (!(dOptions instanceof Map)) {
@@ -260,40 +259,40 @@
         postMessage(createResponse("getListOfTokens", createErrorResult(e, "no tokens"), oInfo, true, true));
     }
 }
 
 function getOptions (oInfo={}) {
-    let dOptions = helpers.mapToObject(gc_engine.getOptions());
+    let dOptions = helpers.mapToObject(gc_options.getOptions());
     postMessage(createResponse("getOptions", dOptions, oInfo, true));
 }
 
 function getDefaultOptions (oInfo={}) {
-    let dOptions = helpers.mapToObject(gc_engine.getDefaultOptions());
+    let dOptions = helpers.mapToObject(gc_options.getDefaultOptions());
     postMessage(createResponse("getDefaultOptions", dOptions, oInfo, true));
 }
 
 function setOptions (dOptions, oInfo={}) {
     if (!(dOptions instanceof Map)) {
         dOptions = helpers.objectToMap(dOptions);
     }
-    gc_engine.setOptions(dOptions);
-    dOptions = helpers.mapToObject(gc_engine.getOptions());
+    gc_options.setOptions(dOptions);
+    dOptions = helpers.mapToObject(gc_options.getOptions());
     postMessage(createResponse("setOptions", dOptions, oInfo, true));
 }
 
 function setOption (sOptName, bValue, oInfo={}) {
     console.log(sOptName+": "+bValue);
     if (sOptName) {
-        gc_engine.setOption(sOptName, bValue);
-        let dOptions = helpers.mapToObject(gc_engine.getOptions());
+        gc_options.setOption(sOptName, bValue);
+        let dOptions = helpers.mapToObject(gc_options.getOptions());
         postMessage(createResponse("setOption", dOptions, oInfo, true));
     }
 }
 
 function resetOptions (oInfo={}) {
-    gc_engine.resetOptions();
-    let dOptions = helpers.mapToObject(gc_engine.getOptions());
+    gc_options.resetOptions();
+    let dOptions = helpers.mapToObject(gc_options.getOptions());
     postMessage(createResponse("resetOptions", dOptions, oInfo, true));
 }
 
 function tests () {
     console.log(conj.getConj("devenir", ":E", ":2s"));
@@ -326,23 +325,23 @@
 function fullTests (oInfo={}) {
     if (!gc_engine) {
         postMessage(createResponse("fullTests", "# Grammar checker not loaded.", oInfo, true));
         return;
     }
-    let dMemoOptions = gc_engine.getOptions();
-    let dTestOptions = gc_engine.getDefaultOptions();
+    let dMemoOptions = gc_options.getOptions();
+    let dTestOptions = gc_options.getDefaultOptions();
     dTestOptions.set("nbsp", true);
     dTestOptions.set("esp", true);
     dTestOptions.set("unit", true);
     dTestOptions.set("num", true);
-    gc_engine.setOptions(dTestOptions);
+    gc_options.setOptions(dTestOptions);
     let sMsg = "";
     for (let sRes of oTest.testParse()) {
         sMsg += sRes + "\n";
         console.log(sRes);
     }
-    gc_engine.setOptions(dMemoOptions);
+    gc_options.setOptions(dMemoOptions);
     postMessage(createResponse("fullTests", sMsg, oInfo, true));
 }
 
 
 // SpellChecker