aotrautils 0.0.53 → 0.0.56

aotrautils/aotrautils.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils CLIENT library associated with aotra version : «1.0.0.000 (11/07/2022-23:49:31)»*/
+/*utils CLIENT library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -55,571 +55,298 @@ if(typeof monitorProgression === "undefined"){
 
 
 
+
+
+
 // NOT AOTESTABLE !
-//TODO : develop :
-//getHashedString=monitorProgression(100000,
-window.getHashedString=function(str,/*OPTIONAL*/isHeavyTreatment){
-	
-	//CAUTION : YOU MUST *NOT* CHANGE THIS VALUE, UNLESS THE HASH HEAVY TREATMENT VALUE IN YOUR AOTRA SERVER-SIDE CODEIS THE SAME !
-	const HEAVY_TREATMENT_LOOP_COUNT=100000;
-	
-	if(isHeavyTreatment){
 
-		// If needed, we make sure the hashing will take a long time, so that
-		// if the private salt key is leaked, it will be fairly difficult to crack
-		// password write protection and content encryption :
-		
-		let result=str;
-		for(var i=0;i<HEAVY_TREATMENT_LOOP_COUNT;i++){
-			result=getHashedString(result,false);
-		}
+//Works, but doesn't compile under PhoneGap...:
+//function getURLParameter(nameParam){
+//var name=encodeURIComponent(nameParam);
+//return decodeURIComponent(
+//(
+//new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)' )
+//.exec(window.location.search)
+//|| [,""]
+//)[1]
+//.replace(/\+/g, '%20')
+//)||null;
+//}
 
-		
-		return result;
-		
-	}else{
-	
-		
-		// SHA-256 hash (sucks less) :
-		// DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
-		if(typeof(sjcl)!="undefined"){
-			let result=sjcl.codec.hex.fromBits(sjcl.hash.sha256.hash(str));
-			
-			// TODO : develop :
-//			hash.progressionMonitor.progress(1);
-	
-			
-			return result;
-		}
-		
-		// if not found : MD5 hash (sucks) :
-		//TRACE
-		log("WARN : Could not find SHA hashing, using MD5. This sucks, and this very likely will prevent your aotra client to be able to write data to aotra server.");
-		
-		return hex_md5(str);
-	}
+//...so we replace it with another function that is supposed to do the same
+//thing :
+function getURLParameter(nameParam){
+	var name=nameParam;
+	if (name=new RegExp("[?&]" + encodeURIComponent(name) + "=([^&]*)").exec(location.search))
+		return decodeURIComponent(name[1]);
+	return null;
 }
-//);
 
-function encrypt(strToEncrypt,key,/*OPTIONAL*/mode){
-	if(!mode || typeof(sjcl)=="undefined")	mode="xor";
-	mode=mode.trim();
 
-	if(contains(mode,"aes") && contains(mode,"xor")){
 
-		// XOR :
-		var xorStr=btoa(encodeXORNoPattern(strToEncrypt,key));	
-		
-		var aesStr=
-			// AES
-			sjcl.encrypt(key,xorStr);
 
-		return aesStr;
-	}
+// A little method to help i18ning aotra user interface :
+const I18N_REPOSITORY_VARIABLE_NAME="I18N_KEYS";
+function i18n(languagesAndStrings, langParam=null){
 	
-	//	DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
-	if(mode==="aes")
-		return sjcl.encrypt(key,strToEncrypt);
-	return btoa(encodeXORNoPattern(strToEncrypt,key));
-
-}
-
-function decrypt(strToDecrypt,key,/*OPTIONAL*/mode){
-	if(!mode || typeof(sjcl)=="undefined")	mode="xor";
-	mode=mode.trim();
+	// ******************* CONFIG ******************* 
+	const PREFERED_LANGUAGE="fr"; // My Quebecer wife (love on her for ever and beyond) forced me to set this...(I'm French.)
+	
+	const NO_TRANSLATION_LABEL="NO TRANSLATION FOUND";
+	
+	const ADD_SYSTEMATICALLY_TO_REPOSITORY=true;
+	const MAX_CHARACTERS_FOR_TRANSLATION_KEY=64; // Really if you have more than 64 characters in commons, then it really should be the same string !
 
-	if(contains(mode,"aes") && contains(mode,"xor")){
-		
-		// AES
-		var aesStr=sjcl.decrypt(key,strToDecrypt);
-		
-		var xorStr=
-			// XOR :
-			encodeXORNoPattern(atob(aesStr),key);
+	// ***************** END CONFIG ***************** 
 
-		return xorStr;
-		
+	
+	if(!languagesAndStrings){
+		// TRACE
+		console.log("ERROR : No parameter for i18n provided!",languagesAndStrings);
+		return NO_TRANSLATION_LABEL;
 	}
 	
-	//	DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
-	if(mode==="aes")
-		return sjcl.decrypt(key,strToDecrypt);
-	return encodeXORNoPattern(atob(strToDecrypt),key);
+	let lang=null;
+	if(langParam){
+		lang=langParam;
+	}else{
+		// Parameters priority :
+		if(window){
+			if(window.getURLParameter){
+				lang=nonull(window.getURLParameter("language"), window.getURLParameter("lang"));
+			}
+			if(!lang && (window.language || window.lang)){
+				lang=nonull(window.language, window.lang);
+			}
+		}else if(global){	// (NodeJS compatibility)
+			if(global.getURLParameter){
+				lang=nonull(global.getURLParameter("language"), global.getURLParameter("lang"));
+			}
+			if(!lang && (global.language || global.lang)){
+				lang=nonull(global.language, global.lang);
+			}
+		}
+		lang=nonull(lang, PREFERED_LANGUAGE);
+	}
 	
+	if(contains(["capitalize","append"],lang)){
+		// TRACE
+		console.log("WARN : Language parameter has for value a reserved attribute keyword, using default language «"+PREFERED_LANGUAGE+"»");
+		lang=PREFERED_LANGUAGE;
+	}
 	
-}
-
-function encodeXORNoPattern(strToEncode,key){
-	let result="";
-	let keyChunk=key;
-	let keyLength=keyChunk.length;
-	let previousChars="";
-	let cnt=0;
-	for(let i=0;i<strToEncode.length;i++){
-		let char=strToEncode.charAt(i);
-		let keyByte=keyChunk.charAt(cnt);
+	
+	let result=null;
+	
+	
+	if(!isString(languagesAndStrings)){ // Case direct i18n translation, with no translation keys :
 		
-		result+=String.fromCharCode(char.charCodeAt(0)^keyByte.charCodeAt(0));
+		result=languagesAndStrings[lang];
+	
+		if (!result){
+			// TRACE
+			console.log("ERROR : No label found for language «"+lang+"»!",languagesAndStrings);
+		}
+	
+		if (!result){
+			for(key in languagesAndStrings){
+				if (!languagesAndStrings.hasOwnProperty(key))
+					continue;
+				// We take the first that we find, in the other languages:
+				result=languagesAndStrings[key];
+				break;
+			}
+		}
+
+		if (!result)	return NO_TRANSLATION_LABEL;
 		
-		if(cnt%keyLength===(keyLength-1)){
-			cnt=0;
-			// NO : TOO LONG TREATMENT !: We hash with all the previous blocks too :
-			// We hash with a character of the previous chunk (they add up at each new chunk):
-			keyChunk=getHashedString(previousChars+keyChunk);
 		
-			previousChars+=keyChunk.charAt(keyChunk.length-1);
-		}else{
-			cnt++;
+		// We add this «rogue» usage of i18n to the whole repository at all useful ends :
+		if(ADD_SYSTEMATICALLY_TO_REPOSITORY){
+//		let declarable={};
+			let maxLength=Math.min(result.length, MAX_CHARACTERS_FOR_TRANSLATION_KEY);
+			let key=toConvention("camel", result.substring(0,maxLength).toLowerCase() );
+//		let calculatedKey=radicalKey+"_"+getUUID("short");
+//		declarable[calculatedKey]=languagesAndStrings;
+			i18n.declareSingleEntry(key, languagesAndStrings);
 		}
+
+		// Eventual post-treatments :
+		if(languagesAndStrings.capitalize)	result=capitalize(result);
+		if(languagesAndStrings.append)			result+=languagesAndStrings.append;
+
+		return result;
 	}
-	return result;
-}
+	// else // Case we use translation keys : (here, languagesAndStrings parameter holds just the wished translation key)
 
-function generateRandomString(length,/*NULLABLE*/mode){
 	
-	// This list must be very conservative, because  we want to be able to pass it through GET URLs !
-	// OLD (not enough conservative ?) : const ALLOWED_CHARS="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0912346789_-£¢¤¬²³¼½¾";
-	const ALLOWED_CHARS="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0912346789!-:;";
+	let repository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
+	if(!repository){
+		// TRACE
+		console.log("ERROR : No repository variable found for repository «"+I18N_REPOSITORY_VARIABLE_NAME+"»!");
+		return NO_TRANSLATION_LABEL;
+	}
 	
+	// OLD (ie. splitted format :)
+//		let repositoryForLang=repository[lang];
+//		if (!repositoryForLang){
+//			// TRACE
+//			console.log("ERROR : No translation found for language «"+lang+"»!",languagesAndStrings);
+//			return NO_TRANSLATION_LABEL;
+//		}
+//		result=repositoryForLang[languagesAndStrings]; // Here, languagesAndStrings is just a bundle key.
+//		if (!result)	return NO_TRANSLATION_LABEL+" (for key «"+languagesAndStrings+"»)";
 	
-	if(typeof(length)==="string"){
-		if(contains(length,"->")){
-			length=Math.getRandomInRange(length);
-		}else{
-			length=64;
-		}
+	let languagesAndStringsForTranslationKey=repository[languagesAndStrings];
+	if (!languagesAndStringsForTranslationKey){
+		// SILENT ERROR :
+//		// TRACE
+//		console.log("ERROR : No translation found for key «"+languagesAndStrings+"» for language «"+lang+"»!");
+//	NO, OLD : return NO_TRANSLATION_LABEL;
+		return languagesAndStrings;
 	}
+	result=i18n(languagesAndStringsForTranslationKey, lang); // Since we use the same format !
 	
-	var result="";
+	return result;
+};
 
-	if(mode==="simple"){
-		
-		for(var i=0;i<length;i++){
-			var	value=Math.getRandomInArray(ALLOWED_CHARS);
-			result+=value;
-		}
-		
-		return result;
-	}else if(mode==="human"){
-		
-		const markovGraph={
-			// For simplicity sakes, we ignore the consonants and vowels doubling possibilities:
-			consonants:{// They always accept vowels at their following
-				// Indicate ^ to specify wich of the other group letter to exclude as direct follower of the given letter :
-				"b":["r","l"],
-				"c":["h","t","k","l","r"],
-				"d":["r"],
-				"f":["r","l"],
-				"g":["r","l"],
-				"h":[],
-				"j":["r"],
-				"k":["r","l","t","h"],
-				"l":["t"],
-				"m":["b","p"],
-				"n":["t","d"],
-				"p":["h","r","s","t","l"],
-				"q":["r","l"],
-				"r":["t","c","d","k","q","h"],
-				"s":["t","c","d","k","q","h"],
-				"t":["r","h"],
-				"v":["r","l"],
-				"w":["r"],
-				"x":["p"],
-				"z":["r","h"],
-			},
-			vowels:{// They always accept consonants at their following
-				"a":["i","u","y"],
-				"e":["i","u","y"],
-				"i":["e","o"],
-				"o":["i","u"],
-				"u":["i"],
-				"y":[],
-			},
-		};
-		
-		const LETTERS_TYPES=Object.keys(markovGraph);
-
-		const CURR_LETTER_MODE=Math.getRandomInArray(LETTERS_TYPES);
-		const POSSIBLE_LETTERS=Object.keys(markovGraph[CURR_LETTER_MODE]);
-		const CURR_LETTER=Math.getRandomInArray(POSSIBLE_LETTERS);
-		
-		var automataState={
-			currentLetterMode:CURR_LETTER_MODE,
-			possibleLetters:POSSIBLE_LETTERS,
-			currentLetter:CURR_LETTER,
-			
-			calculateLetter:function(){
-				
-				this.currentLetter=Math.getRandomInArray(this.possibleLetters);
-				
-				var sameLetters=Object.keys( markovGraph[this.currentLetterMode] );
-				if(!contains(sameLetters,this.currentLetter)){
-					// If we picked from the same group : we don't change of group to pick
-					// If we picked from the other group : we do change of group to pick
-					
-					var otherLetterMode=foreach(LETTERS_TYPES,(item)=>{
-						if(item!==this.currentLetterMode)	return item;
-					});
-					
-					this.currentLetterMode=otherLetterMode;
-				}
-
-			},
-			
-			updatePossibleLettersForLetter:function(){
-				
-				var nextPossibleLetters=[];
-				var nextNotPossibleLetters=[];
-
-				// We store those of the other group marked «^»
-				foreach(markovGraph[this.currentLetterMode][this.currentLetter],(letter)=>{
-					if(letter.charAt(0)==="^"){
-						nextNotPossibleLetters.push(letter.charAt(1));
-					}else{
-						nextPossibleLetters.push(letter);
-					}
-				});
-				
-				var otherLetterMode=foreach(LETTERS_TYPES,(item)=>{
-					if(item!==this.currentLetterMode)	return item;
-				});
-				var otherLetters=Object.keys(markovGraph[otherLetterMode]);
-				
-				// We exclude those marked «^»
-				foreach( otherLetters ,(letter)=>{
-					if(!contains(nextNotPossibleLetters,letter)){
-						nextPossibleLetters.push(letter);
-					}
-				});
-
-				this.possibleLetters=nextPossibleLetters;
-			}
-		};
-		
-		var i=0;
-		do{
 
-			result+=automataState.currentLetter;
-			
-			automataState.updatePossibleLettersForLetter();
-			automataState.calculateLetter();
-			
-			i++;
-		}while(i<length);
-		
-		return result;
+i18n.declareSingleEntry=function(key, languagesAndStringsEntry){
+	let newRepository;
+	let foundRepository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
+	if(!foundRepository){
+		// TRACE
+		console.log("ERROR : No repository variable found for repository «"+I18N_REPOSITORY_VARIABLE_NAME+"»!");
+		return;
 	}
 	
-	for(var i=0;i<length;i++){
-		var	value=Math.getRandomInt(255,0);
-		result+=String.fromCharCode(value);
+	let foundEntryForKey=foundRepository[key];
+	if(!foundEntryForKey){
+		foundRepository[key]=languagesAndStringsEntry;
+//	}else{
+//		// TRACE
+//		console.log("WARN : Duplicate entry for translation key «"+key+"», keeping only the first declared :",foundEntryForKey);
 	}
 	
-	if(mode==="base64"){
-		return btoa(result);
+};
+
+
+//USAGE :
+//Example :
+//i18n.declare({
+//	"commencer":{"fr":"Commencer","en":"Start"}
+//});
+i18n.declare=function(repositoryInfos){
+	let newRepository;
+	let foundRepository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
+	if(foundRepository){
+//		// TRACE
+//		console.log("WARN : A repository has already been declared, merging.",foundRepository);
+		newRepository=merge(foundRepository, repositoryInfos);
+	}else{
+		newRepository=repositoryInfos;
 	}
+	(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME]=newRepository;
+};
+
+// USAGE :
+// Example :
+//i18n.declareSplitted({
+//	"fr":{
+//		"commencer":"Commencer",
+//	},
+//	"en":{
+//		"commencer":"Start",
+//	},
+//});
+i18n.declareSplitted=function(repositoryInfos){
+	let nonSplittedFormat={};
 	
-	return result;
-}
+	foreach(repositoryInfos,(allKeys, lang)=>{
+		foreach(allKeys,(text, key)=>{
+			
+			let foundKeyInfos=nonSplittedFormat[key];
+			if(!foundKeyInfos){
+				nonSplittedFormat[key]={};
+				foundKeyInfos=nonSplittedFormat[key];
+			}
+			
+			let foundTextForLanguage=foundKeyInfos[lang];
+			if(foundTextForLanguage){
+				// TRACE
+				console.log("WARN : Duplicate entry for translation key «"+key+"» for language «"+lang+"», keeping only the first declared :",foundTextForLanguage);
+			}else{
+				foundKeyInfos[lang]=text;
+			}
+			
+		});
+	});
 
+	// Then we use the standard declaration method :	
+	i18n.declare(nonSplittedFormat);
+};
 
+// For generating languages files helping purposes :
+i18n.displayAll=function(displaySingleEntriesCalls=false){
+	let foundRepository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
+	if(!foundRepository){
+		// TRACE
+		console.log("ERROR : No repository found under the variable name «"+I18N_REPOSITORY_VARIABLE_NAME+"»");
+	}else{
+		console.log("TRACE : Variable under the name of «"+I18N_REPOSITORY_VARIABLE_NAME+"»:", foundRepository);
+		console.log("\n\n");
 
-// NOT AOTESTABLE !
-function getUniqueIdWithDate(){
-	return getHashedString(getNow() + "");
+		let message="";
+		foreach(foundRepository, (entry, entryKey)=>{
+			let normalizedEntry={};
+			if(entry.capitalize)	normalizedEntry.capitalize=entry.capitalize;
+			if(entry.append)			normalizedEntry.append=entry.append;
+			foreach(entry,(e,k)=>{
+				normalizedEntry[k]=e;
+			}
+			,(i,key)=>{ return (!contains(["append","capitalize"],key));	}
+			,(i1,i2)=>{ return (i1.key==i2.key?0:(i1.key=="fr"?-1:1));/*(Sorry, French always comes first !)*/}
+			);
+			let entryStr=stringifyObject(normalizedEntry);
+			message+="\""+entryKey+"\":"+entryStr+",\n";
+			if(displaySingleEntriesCalls)	message+="// i18n("+entryStr+");\n";
+		});
+		
+		console.log("\n"+message);
+		
+	}
 }
 
 
 
-// NOT AOTESTABLE !
 
-//Works, but doesn't compile under PhoneGap...:
-//function getURLParameter(nameParam){
-//var name=encodeURIComponent(nameParam);
-//return decodeURIComponent(
-//(
-//new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)' )
-//.exec(window.location.search)
-//|| [,""]
-//)[1]
-//.replace(/\+/g, '%20')
-//)||null;
-//}
 
-//...so we replace it with another function that is supposed to do the same
-//thing :
-function getURLParameter(nameParam){
-	var name=nameParam;
-	if (name=new RegExp("[?&]" + encodeURIComponent(name) + "=([^&]*)").exec(location.search))
-		return decodeURIComponent(name[1]);
-	return null;
-}
+// -------------------------------------------------------------------------------------------
 
+// Mouse management :
 
+// Code from (www.adomas.org/javascript-mouse-wheel)
+function initMouseWheel(handle,/* OPTIONAL */filterFunction){
 
+	var wheel=function(event){
 
-// A little method to help i18ning aotra user interface :
-const I18N_REPOSITORY_VARIABLE_NAME="I18N_KEYS";
-function i18n(languagesAndStrings, langParam=null){
-	
-	// ******************* CONFIG ******************* 
-	const PREFERED_LANGUAGE="fr"; // My Quebecer wife (love on her for ever and beyond) forced me to set this...(I'm French.)
-	
-	const NO_TRANSLATION_LABEL="NO TRANSLATION FOUND";
-	
-	const ADD_SYSTEMATICALLY_TO_REPOSITORY=true;
-	const MAX_CHARACTERS_FOR_TRANSLATION_KEY=64; // Really if you have more than 64 characters in commons, then it really should be the same string !
+		if (filterFunction && !filterFunction(event.target))
+			return;
 
-	// ***************** END CONFIG ***************** 
-
-	
-	if(!languagesAndStrings){
-		// TRACE
-		console.log("ERROR : No parameter for i18n provided!",languagesAndStrings);
-		return NO_TRANSLATION_LABEL;
-	}
-	
-	let lang=null;
-	if(langParam){
-		lang=langParam;
-	}else{
-		// Parameters priority :
-		if(window){
-			if(window.getURLParameter){
-				lang=nonull(window.getURLParameter("language"), window.getURLParameter("lang"));
-			}
-			if(!lang && (window.language || window.lang)){
-				lang=nonull(window.language, window.lang);
-			}
-		}else if(global){	// (NodeJS compatibility)
-			if(global.getURLParameter){
-				lang=nonull(global.getURLParameter("language"), global.getURLParameter("lang"));
-			}
-			if(!lang && (global.language || global.lang)){
-				lang=nonull(global.language, global.lang);
-			}
-		}
-		lang=nonull(lang, PREFERED_LANGUAGE);
-	}
-	
-	if(contains(["capitalize","append"],lang)){
-		// TRACE
-		console.log("WARN : Language parameter has for value a reserved attribute keyword, using default language «"+PREFERED_LANGUAGE+"»");
-		lang=PREFERED_LANGUAGE;
-	}
-	
-	
-	let result=null;
-	
-	
-	if(!isString(languagesAndStrings)){ // Case direct i18n translation, with no translation keys :
-		
-		result=languagesAndStrings[lang];
-	
-		if (!result){
-			// TRACE
-			console.log("ERROR : No label found for language «"+lang+"»!",languagesAndStrings);
-		}
-	
-		if (!result){
-			for(key in languagesAndStrings){
-				if (!languagesAndStrings.hasOwnProperty(key))
-					continue;
-				// We take the first that we find, in the other languages:
-				result=languagesAndStrings[key];
-				break;
-			}
-		}
-
-		if (!result)	return NO_TRANSLATION_LABEL;
-		
-		
-		// We add this «rogue» usage of i18n to the whole repository at all useful ends :
-		if(ADD_SYSTEMATICALLY_TO_REPOSITORY){
-//		let declarable={};
-			let maxLength=Math.min(result.length, MAX_CHARACTERS_FOR_TRANSLATION_KEY);
-			let key=toConvention("camel", result.substring(0,maxLength).toLowerCase() );
-//		let calculatedKey=radicalKey+"_"+getUUID("short");
-//		declarable[calculatedKey]=languagesAndStrings;
-			i18n.declareSingleEntry(key, languagesAndStrings);
-		}
-
-		// Eventual post-treatments :
-		if(languagesAndStrings.capitalize)	result=capitalize(result);
-		if(languagesAndStrings.append)			result+=languagesAndStrings.append;
-
-		return result;
-	}
-	// else // Case we use translation keys : (here, languagesAndStrings parameter holds just the wished translation key)
-
-	
-	let repository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
-	if(!repository){
-		// TRACE
-		console.log("ERROR : No repository variable found for repository «"+I18N_REPOSITORY_VARIABLE_NAME+"»!");
-		return NO_TRANSLATION_LABEL;
-	}
-	
-	// OLD (ie. splitted format :)
-//		let repositoryForLang=repository[lang];
-//		if (!repositoryForLang){
-//			// TRACE
-//			console.log("ERROR : No translation found for language «"+lang+"»!",languagesAndStrings);
-//			return NO_TRANSLATION_LABEL;
-//		}
-//		result=repositoryForLang[languagesAndStrings]; // Here, languagesAndStrings is just a bundle key.
-//		if (!result)	return NO_TRANSLATION_LABEL+" (for key «"+languagesAndStrings+"»)";
-	
-	let languagesAndStringsForTranslationKey=repository[languagesAndStrings];
-	if (!languagesAndStringsForTranslationKey){
-		// SILENT ERROR :
-//		// TRACE
-//		console.log("ERROR : No translation found for key «"+languagesAndStrings+"» for language «"+lang+"»!");
-//	NO, OLD : return NO_TRANSLATION_LABEL;
-		return languagesAndStrings;
-	}
-	result=i18n(languagesAndStringsForTranslationKey, lang); // Since we use the same format !
-	
-	return result;
-};
-
-
-i18n.declareSingleEntry=function(key, languagesAndStringsEntry){
-	let newRepository;
-	let foundRepository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
-	if(!foundRepository){
-		// TRACE
-		console.log("ERROR : No repository variable found for repository «"+I18N_REPOSITORY_VARIABLE_NAME+"»!");
-		return;
-	}
-	
-	let foundEntryForKey=foundRepository[key];
-	if(!foundEntryForKey){
-		foundRepository[key]=languagesAndStringsEntry;
-//	}else{
-//		// TRACE
-//		console.log("WARN : Duplicate entry for translation key «"+key+"», keeping only the first declared :",foundEntryForKey);
-	}
-	
-};
-
-
-//USAGE :
-//Example :
-//i18n.declare({
-//	"commencer":{"fr":"Commencer","en":"Start"}
-//});
-i18n.declare=function(repositoryInfos){
-	let newRepository;
-	let foundRepository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
-	if(foundRepository){
-//		// TRACE
-//		console.log("WARN : A repository has already been declared, merging.",foundRepository);
-		newRepository=merge(foundRepository, repositoryInfos);
-	}else{
-		newRepository=repositoryInfos;
-	}
-	(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME]=newRepository;
-};
-
-// USAGE :
-// Example :
-//i18n.declareSplitted({
-//	"fr":{
-//		"commencer":"Commencer",
-//	},
-//	"en":{
-//		"commencer":"Start",
-//	},
-//});
-i18n.declareSplitted=function(repositoryInfos){
-	let nonSplittedFormat={};
-	
-	foreach(repositoryInfos,(allKeys, lang)=>{
-		foreach(allKeys,(text, key)=>{
-			
-			let foundKeyInfos=nonSplittedFormat[key];
-			if(!foundKeyInfos){
-				nonSplittedFormat[key]={};
-				foundKeyInfos=nonSplittedFormat[key];
-			}
-			
-			let foundTextForLanguage=foundKeyInfos[lang];
-			if(foundTextForLanguage){
-				// TRACE
-				console.log("WARN : Duplicate entry for translation key «"+key+"» for language «"+lang+"», keeping only the first declared :",foundTextForLanguage);
-			}else{
-				foundKeyInfos[lang]=text;
-			}
-			
-		});
-	});
-
-	// Then we use the standard declaration method :	
-	i18n.declare(nonSplittedFormat);
-};
-
-// For generating languages files helping purposes :
-i18n.displayAll=function(displaySingleEntriesCalls=false){
-	let foundRepository=(window?window:global)[I18N_REPOSITORY_VARIABLE_NAME];
-	if(!foundRepository){
-		// TRACE
-		console.log("ERROR : No repository found under the variable name «"+I18N_REPOSITORY_VARIABLE_NAME+"»");
-	}else{
-		console.log("TRACE : Variable under the name of «"+I18N_REPOSITORY_VARIABLE_NAME+"»:", foundRepository);
-		console.log("\n\n");
-
-		let message="";
-		foreach(foundRepository, (entry, entryKey)=>{
-			let normalizedEntry={};
-			if(entry.capitalize)	normalizedEntry.capitalize=entry.capitalize;
-			if(entry.append)			normalizedEntry.append=entry.append;
-			foreach(entry,(e,k)=>{
-				normalizedEntry[k]=e;
-			}
-			,(i,key)=>{ return (!contains(["append","capitalize"],key));	}
-			,(i1,i2)=>{ return (i1.key==i2.key?0:(i1.key=="fr"?-1:1));/*(Sorry, French always comes first !)*/}
-			);
-			let entryStr=stringifyObject(normalizedEntry);
-			message+="\""+entryKey+"\":"+entryStr+",\n";
-			if(displaySingleEntriesCalls)	message+="// i18n("+entryStr+");\n";
-		});
-		
-		console.log("\n"+message);
-		
-	}
-}
-
-
-
-
-
-// -------------------------------------------------------------------------------------------
-
-// Mouse management :
-
-// Code from (www.adomas.org/javascript-mouse-wheel)
-function initMouseWheel(handle,/* OPTIONAL */filterFunction){
-
-	var wheel=function(event){
-
-		if (filterFunction && !filterFunction(event.target))
-			return;
-
-		var delta=0;
-		if (!event)
-			event=window.event;
-		if (event.wheelDelta){
-			delta=event.wheelDelta / 120;
-		} else if (event.detail){
-			delta=-event.detail / 3;
-		}
-		if (delta)
-			handle(delta);
-		if (event.preventDefault)
-			event.preventDefault();
-		event.returnValue=false;
-	};
+		var delta=0;
+		if (!event)
+			event=window.event;
+		if (event.wheelDelta){
+			delta=event.wheelDelta / 120;
+		} else if (event.detail){
+			delta=-event.detail / 3;
+		}
+		if (delta)
+			handle(delta);
+		if (event.preventDefault)
+			event.preventDefault();
+		event.returnValue=false;
+	};
 
 	/* Initialization code. */
 	if (window.addEventListener){
@@ -6782,6 +6509,9 @@ initClient=function(isNodeContext=true, useSocketIOImplementation=false, doOnSer
 	aotraClient.client={};
 	aotraClient.client.start=function(){
 	
+		// DBG
+		lognow("INFO : Setting up Websocket implementation server :...");
+		
 		
 		let socketToServer=WebsocketImplementation.getStatic(isNodeContext,useSocketIOImplementation).connectToServer(url, port, isSecure, timeout);
 		if(!socketToServer){
@@ -7121,7 +6851,7 @@ createFusrodaClient=function(doOnClientReady, doOnDataReception, urlParam=null,
 
 
 
-/*utils GEOMETRY library associated with aotra version : «1.0.0.000 (11/07/2022-23:49:31)»*/
+/*utils GEOMETRY library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -7955,368 +7685,1670 @@ Math.compareDistances=function(p1, p2, distance, comparison){
 	return false;
 };
 
-Math.getSquaredDistance=function(p1, p2){
-	return Math.pow(Math.abs(p2.x-p1.x), 2) + Math.pow(Math.abs(p2.y-p1.y), 2) + ((p1.z!=null && p2.z!=null)?Math.pow(Math.abs(p2.z-p1.z), 2):0);
-};
+Math.getSquaredDistance=function(p1, p2){
+	return Math.pow(Math.abs(p2.x-p1.x), 2) + Math.pow(Math.abs(p2.y-p1.y), 2) + ((p1.z!=null && p2.z!=null)?Math.pow(Math.abs(p2.z-p1.z), 2):0);
+};
+
+Math.getDistance=function(p1, p2){
+	return Math.sqrt(Math.getSquaredDistance(p1,p2));
+};
+
+
+
+
+Math.getBarycenter=function(coordsArray){
+	
+	let coordsX=[];
+	let coordsY=[];
+	foreach(coordsArray,(coords)=>{
+		coordsX.push(coords.x);
+		coordsY.push(coords.y);
+	});
+
+	// Barycenters calculation :
+	let bx=Math.floor(Math.averageInArray(coordsX));
+	let by=Math.floor(Math.averageInArray(coordsY));
+
+	
+	return {x:bx,y:by};
+}
+
+
+Math.getBarycentersFromZonesWithColors=function(zonesWithColors, withColors=true){
+	let barycenters=[];
+	
+	foreach(zonesWithColors,(singleContigousZonePixelsCoords)=>{
+		let barycenter=Math.getBarycenter(singleContigousZonePixelsCoords);
+		barycenters.push(barycenter);
+		
+		let zoneLength=singleContigousZonePixelsCoords.length;
+		
+		if(withColors){
+			// barycenter color :
+			let avgR=0;
+			let avgG=0;
+			let avgB=0;
+			foreach(singleContigousZonePixelsCoords,(coords)=>{
+				let color=coords.color;
+				avgR+=color.r;
+				avgG+=color.g;
+				avgB+=color.b;
+			});
+			barycenter.color={r:avgR/zoneLength, g:avgG/zoneLength, b:avgB/zoneLength};
+		}else{
+			barycenter.color={r:128, g:128, b:128};
+		}
+		
+	});
+
+	return barycenters;
+}
+
+
+Math.getBidimensional8Direction=(currentPosition,destination,invertYAxis=false)=>{
+
+	let x=currentPosition.x;
+	let y=currentPosition.y;
+	
+	let deltaX=(destination.x-x);
+	let deltaY=(invertYAxis?-1:1)*(destination.y-y);
+
+	if(deltaX===0 && deltaY===0)	return null;
+
+	let directionXAxis=(deltaX<0?"W":"E");
+	let directionYAxis=(deltaY<0?"S":"N");
+	if(deltaX===0)	return directionYAxis;
+	if(deltaY===0)	return directionXAxis;
+	
+	let tanRatio=(deltaY/deltaX);
+	
+	if(0<deltaX && 0<deltaY){ // 0 -> PI/2 quarter :
+		if(tanRatio<=Math.TAN_RATIOS_DEGREES[22.5])	return "E";
+		if(Math.TAN_RATIOS_DEGREES[22.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[67.5])	return "NE";
+		if(Math.TAN_RATIOS_DEGREES[67.5]<=tanRatio)	return "N";
+	}else if(deltaX<0 && 0<deltaY){ // PI/2 -> PI quarter : 
+		if(tanRatio<=Math.TAN_RATIOS_DEGREES[112.5])	return "N";
+		if(Math.TAN_RATIOS_DEGREES[112.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[157.5])	return "NW";
+		if(Math.TAN_RATIOS_DEGREES[157.5]<=tanRatio)	return "W";
+	}else if(deltaX<0 && deltaY<0){ // PI -> (3/2)*PI quarter : 
+		if(tanRatio<=Math.TAN_RATIOS_DEGREES[202.5])	return "W";
+		if(Math.TAN_RATIOS_DEGREES[202.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[247.5])	return "SW";
+		if(Math.TAN_RATIOS_DEGREES[247.5]<=tanRatio)	return "S";
+	}else{ // (3/2)*PI -> 2*PI quarter :
+		if(tanRatio<=Math.TAN_RATIOS_DEGREES[292.5])	return "S";
+		if(Math.TAN_RATIOS_DEGREES[292.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[337.5])	return "SE";
+		if(Math.TAN_RATIOS_DEGREES[337.5]<=tanRatio)	return "E";
+	}
+	return null;
+};
+
+
+
+/*public static*/window.getRandomPositionInZone=function(positionZone, xOffset=0, yOffset=0, zOffset=0, avoidOverlap=null, size=null, randomizeAngles=false){
+	
+	let w=nonull(positionZone.w,0);
+	let h=nonull(positionZone.h,0);
+	let d=nonull(positionZone.d,0);
+
+	let demiW=w*.5;
+	let demiH=h*.5;
+	let demiD=d*.5;
+	
+	let xOrZero=nonull(positionZone.x,0);
+	let yOrZero=nonull(positionZone.y,0);
+	let zOrZero=nonull(positionZone.z,0);
+	
+	// If respectively width or height is 0, then there is no need to use a randomization !
+	let x= ( w<=0 ? xOrZero : (xOrZero + Math.getRandomInt(Math.floor(demiW), -Math.ceil(demiW)))) + xOffset;
+	let y= ( h<=0 ? yOrZero : (yOrZero + Math.getRandomInt(Math.floor(demiH), -Math.ceil(demiH)))) + yOffset;
+	let z= ( d<=0 ? zOrZero : (zOrZero + Math.getRandomInt(Math.floor(demiD), -Math.ceil(demiD)))) + zOffset;
+	
+	if(avoidOverlap && size){
+		
+		let itemW=nonull(size.w,0);
+		let itemH=nonull(size.h,0);
+		let itemD=nonull(size.d,0);
+		
+		if(xOrZero/*includes case==0*/ && 0<itemW && contains(avoidOverlap,"x")) x=Math.floor(x/itemW)*itemW;
+		if(yOrZero/*includes case==0*/ && 0<itemH && contains(avoidOverlap,"y")) y=Math.floor(y/itemH)*itemH;
+		if(zOrZero/*includes case==0*/ && 0<itemD && contains(avoidOverlap,"z")) z=Math.floor(z/itemD)*itemD;
+
+	}
+
+	let b=positionZone.b;
+	let g=positionZone.g;
+	let a=positionZone.a;
+	if(randomizeAngles){
+		b=Math.random()*Math.PI*2;
+		g=Math.random()*Math.PI*2;
+		a=Math.random()*Math.PI*2;
+	}
+
+	return {x:x, y:y, z:z, b:b, g:g, a:a, parallax:positionZone.parallax};
+}
+
+
+// CAUTION : ONLY HANDLES «center-positionned» ZONES !
+/*public static*/window.isZoneCollidingWithZone=function(zone1, zone2){
+
+	let demiWidth1=zone1.w*.5;
+	let demiWidth2=zone2.w*.5;
+
+	let xMin1=zone1.x-demiWidth1;
+	let xMax1=zone1.x+demiWidth1;
+	let xMin2=zone2.x-demiWidth2;
+	let xMax2=zone2.x+demiWidth2;
+
+//OLD :	let widthsOverlap=((xMin2<xMin1 && xMin1<xMax2) || (xMin2<xMax1 && xMax1<xMax2)
+//						|| (xMin1<xMin2 && xMin2<xMax1) || (xMin1<xMax2 && xMax2<xMax1));
+
+	let widthsOverlap=(xMin1<xMax2 && xMin2<xMax1);
+
+
+	let demiHeight1=zone1.h*.5;
+	let demiHeight2=zone2.h*.5;
+
+	let yMin1=zone1.y-demiHeight1;
+	let yMax1=zone1.y+demiHeight1;
+	let yMin2=zone2.y-demiHeight2;
+	let yMax2=zone2.y+demiHeight2;
+
+//OLD : let heightsOverlap=((yMin1<yMin2 && yMin2<yMax1) || (yMin1<yMax2 && yMax2<yMax1)
+//					 || (yMin2<yMin1 && yMin1<yMax2) || (yMin2<yMax1 && yMax1<yMax2));
+
+	let heightsOverlap=(yMin1<yMax2 && yMin2<yMax1);
+	
+	return widthsOverlap && heightsOverlap;
+}
+
+
+
+// CAUTION : ONLY HANDLES «center-positionned» ZONES !
+/*public static*/window.getIntersectionZone=function(zone1, zone2){
+	if(!isZoneCollidingWithZone(zone1, zone2))	return null;
+	
+	let edges=[];
+	
+	
+	// Horizontal axis :
+	let hasXAxisWholeZone1=false;
+	let hasXAxisWholeZone2=false;
+	
+	let demiWidth1=zone1.w*.5;
+	let demiWidth2=zone2.w*.5;
+	let xMin1=zone1.x-demiWidth1;
+	let xMax1=zone1.x+demiWidth1;
+	let xMin2=zone2.x-demiWidth2;
+	let xMax2=zone2.x+demiWidth2;	
+
+	let deltaXMins=xMin2-xMin1;
+	let deltaXMaxs=xMax2-xMax1;
+	
+	let deltaXMinsSign=(deltaXMins<0?-1:1);
+	let deltaXMaxsSign=(deltaXMaxs<0?-1:1);
+	let intersectionXMin=0;
+	let intersectionXMax=0;
+	if(deltaXMinsSign==deltaXMaxsSign){ // case «parallelogram»
+		if(deltaXMinsSign<0){ // case /=/ parallelogram
+			intersectionXMin=xMin1;
+			intersectionXMax=xMax2;
+			// We calculate edges :
+			edges.push("left");
+		}else{	 // case \=\ parallelogram
+			intersectionXMin=xMin2;
+			intersectionXMax=xMax1;
+			// We calculate edges :
+			edges.push("right");
+		}
+	}else{  // case «trapeze»
+		if(deltaXMinsSign<0){ // case /=\ trapeze
+			intersectionXMin=xMin1;		// Basically zone1 x !
+			intersectionXMax=xMax1;
+			// We calculate edges :
+			hasXAxisWholeZone1=true;
+		}else{	 // case \=/ trapeze
+			intersectionXMin=xMin2;		// Basically zone2 x !
+			intersectionXMax=xMax2;
+			// We calculate edges :
+			hasXAxisWholeZone2=true;
+		}
+	}
+
+	let w=intersectionXMax-intersectionXMin;
+	let x=(intersectionXMax+intersectionXMin)*.5; // (The average)
+
+
+	// Vertical axis :
+
+	let hasYAxisWholeZone1=false;
+	let hasYAxisWholeZone2=false;
+
+	let demiHeight1=zone1.h*.5;
+	let demiHeight2=zone2.h*.5;
+
+	let yMin1=zone1.y-demiHeight1;
+	let yMax1=zone1.y+demiHeight1;
+	let yMin2=zone2.y-demiHeight2;
+	let yMax2=zone2.y+demiHeight2;
+	
+
+	let deltaYMins=yMin2-yMin1;
+	let deltaYMaxs=yMax2-yMax1;
+	
+	let deltaYMinsSign=(deltaYMins<0?-1:1);
+	let deltaYMaxsSign=(deltaYMaxs<0?-1:1);
+	let intersectionYMin=0;
+	let intersectionYMax=0;
+	if(deltaYMinsSign==deltaYMaxsSign){ // case «parallelogram»
+		if(deltaYMinsSign<0){ // case /=/ parallelogram
+			intersectionYMin=yMin1;
+			intersectionYMax=yMax2;
+			// We calculate edges :
+			edges.push("bottom");		// Here the Y axis is NOT inverted !
+		}else{	 // case \=\ parallelogram
+			intersectionYMin=yMin2;
+			intersectionYMax=yMax1;
+			// We calculate edges :
+			edges.push("top");	// Here the Y axis is NOT inverted !
+		}
+	}else{  // case «trapeze»
+		if(deltaYMinsSign<0){ // case /=\ trapeze
+			intersectionYMin=yMin1;		// Basically zone2 y !
+			intersectionYMax=yMax1;
+			// We calculate edges :
+			hasYAxisWholeZone1=true;
+		}else{	 // case \=/ trapeze
+			intersectionYMin=yMin2;		// Basically zone2 y !
+			intersectionYMax=yMax2;
+			// We calculate edges :
+			hasYAxisWholeZone2=true;
+		}
+	}
+
+	let h=intersectionYMax-intersectionYMin;
+	let y=(intersectionYMax+intersectionYMin)*.5; // (The average)
+	
+	// We calculate edges :
+	if(hasXAxisWholeZone1 && hasYAxisWholeZone1)	edges.push("wholeZone1");
+	if(hasXAxisWholeZone2 && hasYAxisWholeZone2)	edges.push("wholeZone2");
+	
+	return {x:x,y:y,w:w,h:h,edges:edges};
+}
+
+/*public static*/window.areZonesIdentical=function(zone1, zone2){
+	return (zone1==zone2 || (zone1.x==zone2.x || zone1.y==zone2.y || zone1.w==zone2.w || zone1.h==zone2.h));
+}
+
+
+
+// 3D :
+
+
+/*
+// (needs the jsgl library file !)
+// UNUSED
+function screenToSpherePt(mouseX, mouseY) {
+	var p = { x: camera_mat.e12, y: camera_mat.e13, z: camera_mat.e14 + 1 };
+	// camera dir
+	var r = { x: camera_mat.e0, y: camera_mat.e1, z: camera_mat.e2 };
+	var up = { x: camera_mat.e4, y: camera_mat.e5, z: camera_mat.e6 };
+	var right = { x: camera_mat.e8, y: camera_mat.e9, z: camera_mat.e10 };
+	var tan_half = Math.tan(horizontal_fov_radians / 2);
+	r = jsgl.vectorAdd(r, jsgl.vectorScale(right, mouseX * tan_half));
+	r = jsgl.vectorAdd(r, jsgl.vectorScale(up, mouseY * tan_half));
+	r = jsgl.vectorNormalize(r);
+
+	return rayVsUnitSphereClosestPoint(p, r);
+}
+*/
+
+/*
+// (needs the jsgl library file !)
+// UNUSED
+// Return the first exterior hit or closest point between the unit
+// sphere and the ray starting at p and going in the r direction.
+function rayVsUnitSphereClosestPoint(p, r) {
+	var p_len2 = jsgl.dotProduct(p, p);
+	if (p_len2 < 1) {
+		// Ray is inside sphere, no exterior hit.
+		return null;
+	}
+
+	var along_ray = -jsgl.dotProduct(p, r);
+	if (along_ray < 0) {
+		// Behind ray start-point.
+		return null;
+	}
+
+	var perp = jsgl.vectorAdd(p, jsgl.vectorScale(r, along_ray));
+	var perp_len2 = jsgl.dotProduct(perp, perp);
+	if (perp_len2 >= 0.999999) {
+		// Return the closest point.
+		return jsgl.vectorNormalize(perp);
+	}
+
+	// Compute intersection.
+	var e = Math.sqrt(1 - jsgl.dotProduct(perp, perp));
+	var hit = jsgl.vectorAdd(p, jsgl.vectorScale(r, (along_ray - e)));
+	return jsgl.vectorNormalize(hit);
+}
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// MUST REMAIN AT THE END OF THIS LIBRARY FILE !
+
+AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
+/*utils SERVER library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
+/*-----------------------------------------------------------------------------*/
+
+
+/* ## Utility global methods in a javascript, console (nodejs) server, or vanilla javascript with no browser environment.
+ *
+ * This set of methods gathers utility generic-purpose methods usable in any JS project.
+ * Several authors of snippets published freely on the Internet contributed to this library.
+ * Feel free to use/modify-enhance/publish them under the terms of its license.
+ * 
+ * # Library name : «aotrautils» 
+ * # Library license : HGPL(Help Burma) (see aotra README information for details : https://alqemia.com/aotra.js )
+ * # Author name : Jérémie Ratomposon (massively helped by his native country free education system)
+ * # Author email : info@alqemia.com
+ * # Organization name : Alqemia
+ * # Organization email : admin@alqemia.com
+ * # Organization website :  https://alqemia.com
+ * 
+ *  
+ */
+
+
+
+// COMPATIBILITY browser javascript / nodejs environment :
+
+if(typeof(window)==="undefined")	window=global;	
+
+
+
+
+// =================================================================================
+// NODEJS UTILS
+
+const FILE_ENCODING="utf8";
+
+
+// Nodejs filesystem utils :
+if(typeof(fs)==="undefined"){
+	// TRACE
+	console.log("WARN : Could not find the nodejs dependency «fs», aborting persister setup.");
+	window.getPersister=()=>{	return null;	};
+	
+}else{
+	
+	
+	window.getPersister=function(dataDirPath,suffix=""){
+		
+		let self={
+		
+			dataDirPath:dataDirPath,
+			suffix:suffix,
+			
+			//FILE_NAME_PATTERN:"data.clientId.repositoryName.json",
+			/*private*/getPath:function(clientId,repositoryName){
+		//	let path=self.FILE_NAME_PATTERN.replace(new RegExp("@clientId@","g"),clientId);
+				let path=`${self.dataDirPath}`
+								+ (blank(self.suffix)?"":(self.suffix+"."))
+								+`${clientId}.${repositoryName}.json`;
+				return path;
+			},
+			
+			readTreeObjectFromFile:function(clientId, repositoryName, CLASSNAME_ATTR_NAME=DEFAULT_CLASSNAME_ATTR_NAME){
+				
+				let path=self.getPath(clientId,repositoryName);
+				
+				let resultFlat=null;
+		
+				try{
+					resultFlat=fs.readFileSync(path, FILE_ENCODING);
+					
+				}catch(error){
+					// TRACE
+					console.log("ERROR : Could not read file «"+path+"».");
+		
+					return null;
+				}
+				
+				
+				let resultData={};
+				if(!empty(resultFlat))	resultData=JSON.parse(resultFlat);
+			
+				
+				if(!empty(resultData) && isFlatMap(resultData)){
+					
+					resultData=getAsTreeStructure(resultData,true
+							// We have to keep the type information, here too ! (in the sub-objects)
+							,false);
+		
+				}
+				
+				return resultData;
+			},
+
+			
+			saveDataToFileForClient:function(clientId,repositoryName,dataFlatForClient,forceKeepUnflatten=false,doOnSuccess=null){
+				
+				
+				
+				if(!empty(dataFlatForClient) && !isFlatMap(dataFlatForClient) && !forceKeepUnflatten){
+					dataFlatForClient=getAsFlatStructure(dataFlatForClient,true);
+				}
+				
+				// reserved characters : -/\^$*+?.()|[]{}
+				// CANNOT USE stringifyObject(...) function because we are in a common, lower-level library !
+				let dataFlatStr=JSON.stringify(dataFlatForClient)
+					// We «aerate» the produced JSON :
+					.replace(/":[\w]*\{/gim,"\":{\n").replace(/,"/gim,",\n\"")
+					// ...except for inline, escaped JSON string representations :
+					.replace(/\\\":[\w]*\{\n/gim,"\\\":{");
+					// NO : .replace(/}/gim,"}\n");
+				
+				
+				let path=self.getPath(clientId,repositoryName);
+				
+				fs.writeFile(path, dataFlatStr, FILE_ENCODING, (error) => {
+			    if(error){
+			    	// TRACE
+						console.log("ERROR : Could not write file «"+path+"»:",error);
+			    	throw error;
+			    }
+			    if(doOnSuccess)	doOnSuccess(dataFlatForClient);
+				});
+			}
+			
+		};
+		
+		
+		return self;
+	};
+	
+}
+
+
+
+// Nodejs server launching helper functions :
+//Networking management :
+//- WEBSOCKETS AND NODEJS :
+
+// -Server :
+
+// UNUSED : (BUT KEEP CODE!!)
+//getServerParams=function(portParam,isSecureParam,certPathParam,keyPathParam){
+//	
+//	// Node dependencies :
+//	// https=require("https");
+//	// fs=require("fs");
+//	
+//	if(!https){
+//		// TRACE
+//		console.log("WARN : Could not find the nodejs dependency «https», aborting SSL setup.");
+//		return null;
+//	}
+//	if(!fs){
+//		// TRACE
+//		console.log("WARN : Could not find the nodejs dependency «fs», aborting SSL setup.");
+//		return null;
+//	}
+//
+//	var result={};
+//	
+//	// We read the command-line arguments if needed :
+//	var argCLPort;
+//	var argCLCertPath;
+//	var argCLKeyPath;
+//	process.argv.forEach(function (val, i){
+//		if(i<=1)	return;
+//		else if(i==2)	argCLPort=val;
+//		else if(i==3)	argCLCertPath=val;
+//		else if(i==4)	argCLKeyPath=val;
+//	});
+//	
+//	// Console, command-line arguments OVERRIDE parameters values :
+//	
+//	result.port=nonull(argCLPort,portParam);
+//	result.certPath=null;
+//	result.keyPath=null;
+//	result.isSecure=isSecureParam;
+//	
+//	if(isSecureParam){
+//		result.certPath=nonull(argCLCertPath,certPathParam);
+//		result.keyPath=nonull(argCLKeyPath,keyPathParam);
+//	}
+//	
+//	// Eventual encryption options :
+//	result.sslOptions=null;
+//	if(isSecureParam){
+//		result.sslOptions={
+//			cert: fs.readFileSync(certPath),
+//			key: fs.readFileSync(keyPath),
+//		};
+//	}
+//	
+//	return result;
+//}
+
+
+// NODE ONLY SERVER / CLIENTS : 
+WebsocketImplementation={
+		
+		isNodeContext:true,
+		useSocketIOImplementation:false,
+		useFlatStrings:false,
+		
+		// COMMON METHODS
+		/*private static*/isInRoom(clientSocket, clientsRoomsTag){
+			return !clientsRoomsTag || empty(clientsRoomsTag) || contains(clientsRoomsTag, clientSocket.clientRoomTag);
+		},
+		
+		
+		//
+		// NODE SERVER
+		//
+		getStatic:(isNodeContext=true, useSocketIOImplementation=false)=>{
+			
+			WebsocketImplementation.isNodeContext=isNodeContext;
+			
+			// cf. https://socket.io/docs/v4/client-socket-instance/
+			WebsocketImplementation.useSocketIOImplementation=useSocketIOImplementation;
+
+			// OLD : socket.io :
+			// https://stackoverflow.com/questions/31156884/how-to-use-https-on-node-js-using-express-socket-io
+			// https://stackoverflow.com/questions/6599470/node-js-socket-io-with-ssl
+			// https://nodejs.org/api/https.html#https_https_createserver_options_requestlistener
+			
+//			if(typeof(socketIO)==="undefined"){
+//				// TRACE
+//				console.log("«socket.io» SERVER library not called yet, calling it now.");
+//				socketIO=require("socket.io");
+//				return socketIO;
+//			}
+//			if(typeof(socketIO)==="undefined"){
+//				// TRACE
+//				console.log("ERROR : «socket.io» SERVER library not found. Cannot launch nodejs server. Aborting.");
+//				return null;
+//			}
+
+			// *********************************************************************************
+			
+			// NEW : ws :
+			// https://github.com/websockets/ws#installing
+			// https://github.com/websockets/ws/blob/master/doc/ws.md#event-message
+			// ON BROWSER SIDE : Native Websockets :
+			// https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+			// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
+			if(typeof(WebSocket)==="undefined"){
+				WebSocket=require("ws");
+				// TRACE
+				console.log("«ws» SERVER library not called yet, calling it now.");
+				return WebsocketImplementation;
+			}
+			if(typeof(WebSocket)==="undefined"){
+				// TRACE
+				console.log("ERROR : «ws» SERVER library not found. Cannot launch nodejs server. Aborting.");
+				return null;
+			}
+			
+			return WebsocketImplementation;
+		},
+		
+		
+		getServer:(listenableServer)=>{
+			
+			if(!WebsocketImplementation.isNodeContext){
+				// TRACE
+				throw new Error("ERROR : SERVER : Server launch is not supported in a non-nodejs context for any implementation.");
+			}
+			
+			// TODO : FIXME : Use one single interface !
+			// NODE SERVER MODE ONLY :
+			let serverSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				serverSocket=new WebSocket.Server({ "server":listenableServer });
+			}else{
+				// NOW : socket.io :
+				// Loading socket.io
+				serverSocket=socketIO.listen(listenableServer);
+				
+				// Setting up the disctonnect event :
+				serverSocket.on("endConnection",()=>{
+					serverSocket.disconnect();
+				});
+				
+			}
+
+			// NODE SERVER INSTANCE :
+			const nodeServerInstance={
+					
+					onClientLostListeners:[],
+					
+					clientTimeoutMillis:20000,
+//				clientsSockets:[],
+					serverSocket:serverSocket,
+					receptionEntryPoints:[],
+					
+					receive:(channelName, doOnIncomingMessage, clientsRoomsTag=null)=>{
+						
+						const receptionEntryPoint={
+							channelName:channelName,
+							clientsRoomsTag:clientsRoomsTag, 
+							execute:(clientSocketParam)=>{
+
+								
+							// With «ws» library we have no choive than register message events inside a «connection» event !
+//						nodeServerInstance.onConnectionToClient((serverParam, clientSocketParam)=>{
+	
+							// TODO : Find a way to remove this !
+							const doOnMessage=(message)=>{
+								
+//							dataWrapped=JSON.parse(dataWrapped);
+//							dataWrapped=getAt(dataWrapped,0);// We get the root element
+								const dataWrapped=(WebsocketImplementation.useFlatStrings?JSON.parse(message):message);
+
+								
+								// Channel information is stored in exchanged data :
+								if(dataWrapped.channelName!==receptionEntryPoint.channelName) return;
+
+								
+								const clientSocket=clientSocketParam;
+
+								// TODO : FIXME : Use one single interface !
+								// Room information is stored in client socket object :
+								if(!WebsocketImplementation.isInRoom(clientSocket, receptionEntryPoint.clientsRoomsTag)) return;
+								
+								doOnIncomingMessage(dataWrapped.data, clientSocket);
+									
+						   };
+
+
+							 if(!WebsocketImplementation.useSocketIOImplementation)	clientSocketParam.addEventListener("message", doOnMessage);
+							 else																										clientSocketParam.on(channelName, doOnMessage);
+
+
+								
+								
+							},
+						};
+						
+						
+						nodeServerInstance.receptionEntryPoints.push(receptionEntryPoint);
+						
+						
+						// DBG
+						console.log("ADD RECEPTION ENTRY POINT channelName:«"+channelName+"»! nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
+						
+						
+						return nodeServerInstance;
+					},
+					
+					
+					send:(channelName, data, clientsRoomsTag=null, clientSocketParam=null)=>{
+						
+						
+						if(!clientSocketParam){
+							
+								// TODO : FIXME : Use one single interface !
+								let serverClients;
+								if(!WebsocketImplementation.useSocketIOImplementation)	serverClients=nodeServerInstance.serverSocket.clients;
+								else																										serverClients=nodeServerInstance.serverSocket.sockets.clients();
+						    
+						    serverClients.forEach((clientSocket)=>{
+						    	
+						    	
+				    				// TODO : FIXME : Use one single interface !
+									if(!WebsocketImplementation.useSocketIOImplementation)	if(clientSocket.readyState!==WebSocket.OPEN)	return;
+									else																										if(clientSocket.connected)	return;
+
+						    	
+		
+									// Room information is stored in client socket object :
+							   	if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+			
+						      // Channel information is stored in exchanged data :
+							   	let dataWrapped={channelName:channelName, data:data};
+					      	
+						      
+									dataWrapped=JSON.stringify(dataWrapped);
+									
+							// TODO : FIXME : Use one single interface !
+					      	if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+						      else																										clientSocket.emit(channelName,dataWrapped);
+
+						    });
+						
+						}else{
+							
+							// TODO : FIXME : Use one single interface !
+							let clientSocket=clientSocketParam;
+							if(!WebsocketImplementation.useSocketIOImplementation)	if(clientSocket.readyState!==WebSocket.OPEN)	return;
+							else																										if(clientSocket.connected)	return;
 
-Math.getDistance=function(p1, p2){
-	return Math.sqrt(Math.getSquaredDistance(p1,p2));
-};
 
+							// Room information is stored in client socket object :
+				      if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
 
+			      	// Channel information is stored in exchanged data :
+				      let dataWrapped={channelName:channelName, data:data};
+			      	
+							dataWrapped=JSON.stringify(dataWrapped);
+							
+							// TODO : FIXME : Use one single interface !
+							if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+			      	else																										clientSocket.emit(channelName,dataWrapped);
+			      	
+			      	
+						}
+				    
+						
+						return nodeServerInstance;
+					},
+					
+					
+					onConnectionToClient:(doOnConnection)=>{
+						// «connection» is the only event fired by the serverSocket :
+						nodeServerInstance.serverSocket.on("connection", (clientSocket)=>{
+						
+							// DBG
+							console.log("SERVER : ON CONNECTION !");
+							
+							
+//						if(contains(nodeServerInstance.clientsSockets, clientSocket))	return;
+//						nodeServerInstance.clientsSockets.push(clientSocket);
 
 
-Math.getBarycenter=function(coordsArray){
-	
-	let coordsX=[];
-	let coordsY=[];
-	foreach(coordsArray,(coords)=>{
-		coordsX.push(coords.x);
-		coordsY.push(coords.y);
-	});
+							// DBG
+							console.log("nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
 
-	// Barycenters calculation :
-	let bx=Math.floor(Math.averageInArray(coordsX));
-	let by=Math.floor(Math.averageInArray(coordsY));
 
-	
-	return {x:bx,y:by};
-}
+		
+							// We execute the events registration listeners entry points:
+							foreach(nodeServerInstance.receptionEntryPoints,(receptionEntryPoint)=>{
+							
+								// DBG
+								console.log("ENTRY POINT !");
+							
+								receptionEntryPoint.execute(clientSocket);
+							});
 
 
-Math.getBarycentersFromZonesWithColors=function(zonesWithColors, withColors=true){
-	let barycenters=[];
-	
-	foreach(zonesWithColors,(singleContigousZonePixelsCoords)=>{
-		let barycenter=Math.getBarycenter(singleContigousZonePixelsCoords);
-		barycenters.push(barycenter);
-		
-		let zoneLength=singleContigousZonePixelsCoords.length;
-		
-		if(withColors){
-			// barycenter color :
-			let avgR=0;
-			let avgG=0;
-			let avgB=0;
-			foreach(singleContigousZonePixelsCoords,(coords)=>{
-				let color=coords.color;
-				avgR+=color.r;
-				avgG+=color.g;
-				avgB+=color.b;
+							doOnConnection(nodeServerInstance, clientSocket);
+							
+							
+							
+							
+							// To make the server aware of the clients connections states :
+							clientSocket.stateCheckInterval=setInterval(()=>{
+								
+								
+							    if (clientSocket.isAlive===false){
+			    				 	clearInterval(clientSocket.stateCheckInterval);
+			    				 	
+	    				 			// TODO : FIXME : DUPLICATED CODE :
+	    				 			// TODO : FIXME : Use one single interface !
+										if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.terminate();
+										else																										clientSocket.emit("endConnection");
+
+	    				 			// TODO : FIXME : DUPLICATED CODE :
+							    	if(!empty(nodeServerInstance.onClientLostListeners))
+							    		foreach(nodeServerInstance.onClientLostListeners,l=>{l.execute(clientSocket);});
+							    	
+							    	return;
+							    }
+							    
+							    clientSocket.isAlive=false;
+							    try{
+							    	clientSocket.ping();
+							    }catch(error){
+							    	lognow("ERROR : A problem occurred when tried to ping client socket : ",error);
+							    	// We effectively end the client connection to this server :
+
+										// TODO : FIXME : DUPLICATED CODE :
+										// TODO : FIXME : Use one single interface !
+										if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.terminate();
+										else																										clientSocket.emit("endConnection");
+
+	    				 			// TODO : FIXME : DUPLICATED CODE :
+							    	if(!empty(nodeServerInstance.onClientLostListeners))
+							    		foreach(nodeServerInstance.onClientLostListeners,l=>{l.execute(clientSocket);});
+
+							    	return;
+							    }
+							    
+							    
+							}, nodeServerInstance.clientTimeoutMillis);
+							clientSocket.on("pong",()=>{
+								clientSocket.isAlive=true;
+							});
+							
+							
+							
+						});
+						
+						
+						return nodeServerInstance;
+					},
+					
+					onFinalize:(doOnFinalizeServer)=>{
+					
+						doOnFinalizeServer(nodeServerInstance);
+					
+						// TRACE
+						console.log("INFO : SERVER : Node server setup complete.");
+						
+						return nodeServerInstance;
+					},
+					
+					addToRoom:(clientSocket,clientRoomTag)=>{
+						clientSocket.clientRoomTag=clientRoomTag;
+					},
+					
+					
+					
+			};
+			
+			// Join room server part protocol :
+			nodeServerInstance.receive("protocol",(message, clientSocket)=>{
+				
+				if(message.type!=="joinRoom" || !clientSocket)	return;
+
+				nodeServerInstance.addToRoom(clientSocket, message.clientRoomTag);
+
 			});
-			barycenter.color={r:avgR/zoneLength, g:avgG/zoneLength, b:avgB/zoneLength};
-		}else{
-			barycenter.color={r:128, g:128, b:128};
-		}
+			
+			
+			
+			// To make the server aware of the clients connections states :
+			nodeServerInstance.serverSocket.on("close", function close() {
+				
+				// TODO : FIXME : Use one single interface !
+				if(!WebsocketImplementation.useSocketIOImplementation)	serverClients=nodeServerInstance.serverSocket.clients;
+				else																										serverClients=nodeServerInstance.serverSocket.sockets.clients();
+				
+				serverClients.forEach((clientSocket)=>{
+				 	clearInterval(clientSocket.stateCheckInterval);
+				});
+			});
+			
+			
+			
+			return nodeServerInstance;
+		},
 		
-	});
+		
+		// NODE / BROWSER CLIENT CONNECTS TO SERVER MAIN ENTRYPOINT:
+		connectToServer:(serverURL, port, isSecure=false, timeout)=>{
 
-	return barycenters;
-}
+			// TRACE
+			lognow("INFO : Using websocket implementation : "+(WebsocketImplementation.isNodeContext?"node (server-side)":"browser (client-side)"));
+
+			if(WebsocketImplementation.isNodeContext)
+				return WebsocketImplementation.connectToServerFromNode(serverURL, port, isSecure, timeout);
+			else
+				return WebsocketImplementation.connectToServerFromBrowser(serverURL, port, isSecure, timeout);
+		},
+		
+		
+	
+		//
+		// NODE CLIENT
+		//
+		/*private*/connectToServerFromNode:(serverURL, port, isSecure, timeout)=>{
+			
+			
+			
+			// NEW : ws :
+			if(typeof(WebSocket)==="undefined"){
+				// TRACE
+				lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
+				return null;
+			}
+			
+			// NODE CLIENT MODE ONLY :
+			let clientSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				clientSocket=new WebSocket(serverURL+":"+port,/*WORKAROUND:*/{ rejectUnauthorized:false, secure: isSecure });
+			}else{
+				// NOW : socket.io :
+				//client on server-side:
+				if(WebsocketImplementation.isNodeContext && typeof(socketIO)!=="undefined"){
+				//		// Node client :
+				//		connectToServer=function (serverURL, port, isSecure, timeout=10000){
+				//			return socketIO.connect(serverURL + ":" + port,{timeout: timeout});
+				//		}
+					clientSocket=socketIO.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+				}
+			}
 
+			// NODE CLIENT INSTANCE :
+			const nodeClientInstance={
+					clientSocket:clientSocket,
+			
+					receptionEntryPoints:[],
+					
+					receive:(channelName, doOnIncomingMessage, clientsRoomsTag=null)=>{
+						
+						const receptionEntryPoint={
+								channelName:channelName,
+								clientsRoomsTag:clientsRoomsTag, 
+								execute:(clientSocketParam)=>{
+									
+									const doOnMessage=(message)=>{
+										
+//									dataWrapped=JSON.parse(dataWrapped);
+//									dataWrapped=getAt(dataWrapped,0);// We get the root element
+																		
+										const dataWrapped=(WebsocketImplementation.useFlatStrings?JSON.parse(message):message);
+										
+										
+										// Channel information is stored in exchanged data :
+										if(dataWrapped.channelName && dataWrapped.channelName!==channelName) return;
+										
+										let clientSocket=nodeClientInstance.clientSocket;
+										
+										// Room information is stored in client socket object :
+										if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+										
+										doOnIncomingMessage(dataWrapped.data, clientSocket);
+										
+									};
+									
+									if(!WebsocketImplementation.useSocketIOImplementation)	nodeClientInstance.clientSocket.addEventListener("message", doOnMessage);
+									else																										nodeClientInstance.clientSocket.on(channelName, doOnMessage);
 
-Math.getBidimensional8Direction=(currentPosition,destination,invertYAxis=false)=>{
+									
+								}
+						};
+						
+						
+						nodeClientInstance.receptionEntryPoints.push(receptionEntryPoint);
+						
+						return nodeClientInstance;
+					},
+					
+					
+					send:(channelName, data, clientsRoomsTag=null)=>{
+						
+						let clientSocket=nodeClientInstance.clientSocket;
+						
+						
+//			    // DBG
+//			    console.log("(NODE CLIENT) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
 
-	let x=currentPosition.x;
-	let y=currentPosition.y;
-	
-	let deltaX=(destination.x-x);
-	let deltaY=(invertYAxis?-1:1)*(destination.y-y);
+						// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	if(clientSocket.readyState!==WebSocket.OPEN)	return;
+						else																										if(clientSocket.connected)	return;
 
-	if(deltaX===0 && deltaY===0)	return null;
 
-	let directionXAxis=(deltaX<0?"W":"E");
-	let directionYAxis=(deltaY<0?"S":"N");
-	if(deltaX===0)	return directionYAxis;
-	if(deltaY===0)	return directionXAxis;
-	
-	let tanRatio=(deltaY/deltaX);
-	
-	if(0<deltaX && 0<deltaY){ // 0 -> PI/2 quarter :
-		if(tanRatio<=Math.TAN_RATIOS_DEGREES[22.5])	return "E";
-		if(Math.TAN_RATIOS_DEGREES[22.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[67.5])	return "NE";
-		if(Math.TAN_RATIOS_DEGREES[67.5]<=tanRatio)	return "N";
-	}else if(deltaX<0 && 0<deltaY){ // PI/2 -> PI quarter : 
-		if(tanRatio<=Math.TAN_RATIOS_DEGREES[112.5])	return "N";
-		if(Math.TAN_RATIOS_DEGREES[112.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[157.5])	return "NW";
-		if(Math.TAN_RATIOS_DEGREES[157.5]<=tanRatio)	return "W";
-	}else if(deltaX<0 && deltaY<0){ // PI -> (3/2)*PI quarter : 
-		if(tanRatio<=Math.TAN_RATIOS_DEGREES[202.5])	return "W";
-		if(Math.TAN_RATIOS_DEGREES[202.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[247.5])	return "SW";
-		if(Math.TAN_RATIOS_DEGREES[247.5]<=tanRatio)	return "S";
-	}else{ // (3/2)*PI -> 2*PI quarter :
-		if(tanRatio<=Math.TAN_RATIOS_DEGREES[292.5])	return "S";
-		if(Math.TAN_RATIOS_DEGREES[292.5]<=tanRatio && tanRatio<Math.TAN_RATIOS_DEGREES[337.5])	return "SE";
-		if(Math.TAN_RATIOS_DEGREES[337.5]<=tanRatio)	return "E";
-	}
-	return null;
-};
+						// Room information is stored in client socket object :
+						if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+						
+						// Channel information is stored in exchanged data :
+						let dataWrapped={channelName:channelName, data:data};
 
 
+//					// DBG
+//			    console.log("(NODE CLIENT) SENDING DATA ! dataWrapped:",dataWrapped);
 
-/*public static*/window.getRandomPositionInZone=function(positionZone, xOffset=0, yOffset=0, zOffset=0, avoidOverlap=null, size=null, randomizeAngles=false){
-	
-	let w=nonull(positionZone.w,0);
-	let h=nonull(positionZone.h,0);
-	let d=nonull(positionZone.d,0);
 
-	let demiW=w*.5;
-	let demiH=h*.5;
-	let demiD=d*.5;
+						dataWrapped=JSON.stringify(dataWrapped);
 	
-	let xOrZero=nonull(positionZone.x,0);
-	let yOrZero=nonull(positionZone.y,0);
-	let zOrZero=nonull(positionZone.z,0);
 	
-	// If respectively width or height is 0, then there is no need to use a randomization !
-	let x= ( w<=0 ? xOrZero : (xOrZero + Math.getRandomInt(Math.floor(demiW), -Math.ceil(demiW)))) + xOffset;
-	let y= ( h<=0 ? yOrZero : (yOrZero + Math.getRandomInt(Math.floor(demiH), -Math.ceil(demiH)))) + yOffset;
-	let z= ( d<=0 ? zOrZero : (zOrZero + Math.getRandomInt(Math.floor(demiD), -Math.ceil(demiD)))) + zOffset;
+//			            // DBG
+//			            console.log("(NODE CLIENT) SENDING DATA ! channelName:«"+channelName+"» ; clientsRoomsTag:«"+clientsRoomsTag+"»");
+//			            console.log("(NODE CLIENT) SENDING DATA ! dataWrapped:",dataWrapped);
 	
-	if(avoidOverlap && size){
-		
-		let itemW=nonull(size.w,0);
-		let itemH=nonull(size.h,0);
-		let itemD=nonull(size.d,0);
-		
-		if(xOrZero/*includes case==0*/ && 0<itemW && contains(avoidOverlap,"x")) x=Math.floor(x/itemW)*itemW;
-		if(yOrZero/*includes case==0*/ && 0<itemH && contains(avoidOverlap,"y")) y=Math.floor(y/itemH)*itemH;
-		if(zOrZero/*includes case==0*/ && 0<itemD && contains(avoidOverlap,"z")) z=Math.floor(z/itemD)*itemD;
-
-	}
-
-	let b=positionZone.b;
-	let g=positionZone.g;
-	let a=positionZone.a;
-	if(randomizeAngles){
-		b=Math.random()*Math.PI*2;
-		g=Math.random()*Math.PI*2;
-		a=Math.random()*Math.PI*2;
-	}
+						// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+		      	else																										clientSocket.emit(channelName,dataWrapped);
+						
+						return nodeClientInstance;
+					},
+					
+					
+					join:(clientRoomTag)=>{
+						// Join room client part protocol :
+						const message={type:"joinRoom",clientRoomTag:clientRoomTag};
+						
+						nodeClientInstance.send("protocol",message);
+						
+					},
+					
+					
+					onConnectionToServer:(doOnConnection)=>{
+						
+						const doAllOnConnection=()=>{
+							
+							// To avoid triggering this event several times, depending on the implementation : 
+							if(nodeClientInstance.hasConnectEventFired)	return;
+							nodeClientInstance.hasConnectEventFired=true;
+							
+							let clientSocket=nodeClientInstance.clientSocket;
+							
+							doOnConnection(nodeClientInstance, clientSocket);
+							
+							// We execute the listeners entry points:
+							foreach(nodeClientInstance.receptionEntryPoints,(receptionEntryPoint)=>{
+								receptionEntryPoint.execute(clientSocket);
+							});
+							
+						};
 
-	return {x:x, y:y, z:z, b:b, g:g, a:a, parallax:positionZone.parallax};
-}
+						if(!WebsocketImplementation.useSocketIOImplementation)	nodeClientInstance.clientSocket.addEventListener("open",doAllOnConnection);
+						else																										nodeClientInstance.clientSocket.on("connect",doAllOnConnection);
+						
+					},
+					
+				
+			};
+			
+			
+			return nodeClientInstance;
+		},
+		
 
+		
+		// BROWSER CLIENT
+		
+		/*private*/connectToServerFromBrowser:(serverURL, port, isSecure, timeout)=>{
+			
+			// NEW : ws :
+			if(typeof(WebSocket)==="undefined"){
+				// TRACE
+				lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
+				return null;
+			}
+			
+			// TODO : FIXME : Use one single interface !
+			// BROWSER CLIENT MODE ONLY :
+			let clientSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				clientSocket=new WebSocket(serverURL+":"+port,["ws","wss"]);
+			}else if(typeof(io)!=="undefined"){
+				// NOW : socket.io :
+				//				// Browser client :
+				//				connectToServer=function (server, port, isSecure, timeout=10000){
+				//					return io.connect(serverURL + ":" + port,{timeout: timeout});
+				////				ALTERNATIVE : return io(serverURL + ":" + port,{timeout: timeout});
+				//				};
+				//			}else{
+				//				// TRACE
+				//				console.log("ERROR : Could not initialize socket !");
+					clientSocket=io.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+			}
+			
+			
+			// BROWSER CLIENT INSTANCE :
+			const browserInstance={
+					clientSocket:clientSocket,
+					
+					receive:(channelName, doOnIncomingMessage, clientsRoomsTag=null)=>{
 
-// CAUTION : ONLY HANDLES «center-positionned» ZONES !
-/*public static*/window.isZoneCollidingWithZone=function(zone1, zone2){
+						// DBG
+						lognow("!!! SETTING UP RECEIVE for :",channelName);
+						
+						const doOnMessage=(message)=>{
+							
+//							// DBG
+//							lognow("!!! RECEIVED : message",message);
+								
+								// OLD : let dataWrapped=JSON.parse(event.data);
+//							const dataWrapped=JSON.parse(message);
+//							dataWrapped=getAt(dataWrapped,0);// We get the root element
 
-	let demiWidth1=zone1.w*.5;
-	let demiWidth2=zone2.w*.5;
+								const dataWrapped=(WebsocketImplementation.useFlatStrings?JSON.parse(message):message);
+							
+								
+								// Channel information is stored in exchanged data :
+								if(dataWrapped.channelName && dataWrapped.channelName!==channelName) return;
+	
+								let clientSocket=browserInstance.clientSocket;
+	
+								// Room information is stored in client socket object :
+								if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+	
+								doOnIncomingMessage(dataWrapped.data, clientSocket);
+					    	
+					    };
+					   
+					    
+					   if(!WebsocketImplementation.useSocketIOImplementation)	browserInstance.clientSocket.addEventListener("message", doOnMessage);
+						 else																										browserInstance.clientSocket.on(channelName, doOnMessage);
 
-	let xMin1=zone1.x-demiWidth1;
-	let xMax1=zone1.x+demiWidth1;
-	let xMin2=zone2.x-demiWidth2;
-	let xMax2=zone2.x+demiWidth2;
+						
+						 return browserInstance;
+					},
+					
+					
+					send:(channelName, data, clientsRoomsTag=null)=>{
+						
+						let clientSocket=browserInstance.clientSocket;
+			    	
+								
+//					// DBG
+//					console.log("(BROWSER) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
 
-//OLD :	let widthsOverlap=((xMin2<xMin1 && xMin1<xMax2) || (xMin2<xMax1 && xMax1<xMax2)
-//						|| (xMin1<xMin2 && xMin2<xMax1) || (xMin1<xMax2 && xMax2<xMax1));
+						// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	if(clientSocket.readyState!==WebSocket.OPEN)	return;
+						else																										if(clientSocket.connected)	return;
 
-	let widthsOverlap=(xMin1<xMax2 && xMin2<xMax1);
+						
+						// Room information is stored in client socket object :
+						if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
 
+						// Channel information is stored in exchanged data :
+					  let dataWrapped={channelName:channelName, data:data};
+		      	
+		      	
+//			    // DBG
+//			    console.log("(BROWSER) SENDING... : dataWrapped :",dataWrapped);
 
-	let demiHeight1=zone1.h*.5;
-	let demiHeight2=zone2.h*.5;
+            
+						dataWrapped=JSON.stringify(dataWrapped);
 
-	let yMin1=zone1.y-demiHeight1;
-	let yMax1=zone1.y+demiHeight1;
-	let yMin2=zone2.y-demiHeight2;
-	let yMax2=zone2.y+demiHeight2;
+				   	
+		   				// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+		      	else																										clientSocket.emit(channelName,dataWrapped);
 
-//OLD : let heightsOverlap=((yMin1<yMin2 && yMin2<yMax1) || (yMin1<yMax2 && yMax2<yMax1)
-//					 || (yMin2<yMin1 && yMin1<yMax2) || (yMin2<yMax1 && yMax1<yMax2));
+						
+						return browserInstance;
+					},
+					
+					
+					join:(clientRoomTag)=>{
+						// Join room client part protocol :
+						const message={type:"joinRoom",clientRoomTag:clientRoomTag};
+						browserInstance.send("protocol",message);
+					},
+					
+					
+					onConnectionToServer:(doOnConnection)=>{
+						
+						// To avoid triggering this event several times, depending on the implementation : 
+						if(browserInstance.hasConnectEventFired)	return;
+						browserInstance.hasConnectEventFired=true;
+						
+						if(!WebsocketImplementation.useSocketIOImplementation)	browserInstance.clientSocket.addEventListener("open",doOnConnection);
+						else																										browserInstance.clientSocket.on("connect",doOnConnection);
+						
+						
+					},
+					
+				
+			};
+			
+			
+			return browserInstance;
+		},
 
-	let heightsOverlap=(yMin1<yMax2 && yMin2<yMax1);
-	
-	return widthsOverlap && heightsOverlap;
-}
+};
 
 
 
-// CAUTION : ONLY HANDLES «center-positionned» ZONES !
-/*public static*/window.getIntersectionZone=function(zone1, zone2){
-	if(!isZoneCollidingWithZone(zone1, zone2))	return null;
+launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /*OPTIONAL*/sslOptions=null){
 	
-	let edges=[];
+	const EXCLUDED_FILENAMES_PARTS=[".saltkey."];
 	
 	
-	// Horizontal axis :
-	let hasXAxisWholeZone1=false;
-	let hasXAxisWholeZone2=false;
+	if(typeof(https)==="undefined"){
+		// TRACE
+		console.log("«https» SERVER library not called yet, calling it now.");
+		https=require("https");
+	}
+	if(typeof(http)==="undefined"){
+		// TRACE
+		console.log("«http» SERVER library not called yet, calling it now.");
+		http=require("http");
+	}
 	
-	let demiWidth1=zone1.w*.5;
-	let demiWidth2=zone2.w*.5;
-	let xMin1=zone1.x-demiWidth1;
-	let xMax1=zone1.x+demiWidth1;
-	let xMin2=zone2.x-demiWidth2;
-	let xMax2=zone2.x+demiWidth2;	
-
-	let deltaXMins=xMin2-xMin1;
-	let deltaXMaxs=xMax2-xMax1;
 	
-	let deltaXMinsSign=(deltaXMins<0?-1:1);
-	let deltaXMaxsSign=(deltaXMaxs<0?-1:1);
-	let intersectionXMin=0;
-	let intersectionXMax=0;
-	if(deltaXMinsSign==deltaXMaxsSign){ // case «parallelogram»
-		if(deltaXMinsSign<0){ // case /=/ parallelogram
-			intersectionXMin=xMin1;
-			intersectionXMax=xMax2;
-			// We calculate edges :
-			edges.push("left");
-		}else{	 // case \=\ parallelogram
-			intersectionXMin=xMin2;
-			intersectionXMax=xMax1;
-			// We calculate edges :
-			edges.push("right");
-		}
-	}else{  // case «trapeze»
-		if(deltaXMinsSign<0){ // case /=\ trapeze
-			intersectionXMin=xMin1;		// Basically zone1 x !
-			intersectionXMax=xMax1;
-			// We calculate edges :
-			hasXAxisWholeZone1=true;
-		}else{	 // case \=/ trapeze
-			intersectionXMin=xMin2;		// Basically zone2 x !
-			intersectionXMax=xMax2;
-			// We calculate edges :
-			hasXAxisWholeZone2=true;
-		}
-	}
-
-	let w=intersectionXMax-intersectionXMin;
-	let x=(intersectionXMax+intersectionXMin)*.5; // (The average)
-
-
-	// Vertical axis :
-
-	let hasYAxisWholeZone1=false;
-	let hasYAxisWholeZone2=false;
-
-	let demiHeight1=zone1.h*.5;
-	let demiHeight2=zone2.h*.5;
+	const handler=function(request, response){
+		
+		const url=request.url;
 
-	let yMin1=zone1.y-demiHeight1;
-	let yMax1=zone1.y+demiHeight1;
-	let yMin2=zone2.y-demiHeight2;
-	let yMax2=zone2.y+demiHeight2;
+		let isURLInExclusionZone=!!foreach(EXCLUDED_FILENAMES_PARTS,(excludedStr)=>{
+			if(contains(url,excludedStr)){
+				return true;
+			}
+		});
+		
+		if(isURLInExclusionZone){
+      	// TRACE
+      	console.log("ERROR 403 forbidden access error :");
+      	console.log(error);
+      	
+      	response.writeHead(403);
+        response.end("Sorry, cannot access resource : error: "+error.code+" ..\n");
+        response.end();
+        return;
+		}
+		
+
+		const urlFile="." + url;
+		
+		let filePath=urlFile.indexOf("?")!==-1?urlFile.split("?")[0]:urlFile;
+    	if(filePath == "./") filePath="./index.html";
+
+   	 	let extname=path.extname(filePath);
+    	let contentType="text/html";
+			
+	    
+	    fs.readFile(filePath, function(error, fileContent){
+	      if(error){
+	          if(error.code == "ENOENT"){
+	          	// TRACE
+	          	console.log("ERROR 404 file not found :"+filePath);
+	          	
+	            fs.readFile("./404.html", function(error, fileContent){
+	            	response.writeHead(200, { "Content-Type": contentType });
+	                response.end(fileContent, "utf-8");
+	            });
+	              
+	          }else {
+	
+	        	// TRACE
+	          	console.log("ERROR 500 server error :");
+	          	console.log(error);
+	          	
+	          	response.writeHead(500);
+	            response.end("Sorry, check with the site admin for error: "+error.code+" ..\n");
+	            response.end(); 
+	            
+	          }
+	      }else {
+	    	
+	    	// TRACE
+	      	console.log("INFO 200 OK :"+filePath);
+	
+	      	response.writeHead(200, { "Content-Type": contentType });
+	        response.end(fileContent, "utf-8");
+	        
+    		// res.writeHead(200);
+    		// res.end("hello world\n");
+    		// res.sendFile(__dirname + "/public/index.html");
+	    		
+	      }
+	    });
+      
+	};
 	
-
-	let deltaYMins=yMin2-yMin1;
-	let deltaYMaxs=yMax2-yMax1;
 	
-	let deltaYMinsSign=(deltaYMins<0?-1:1);
-	let deltaYMaxsSign=(deltaYMaxs<0?-1:1);
-	let intersectionYMin=0;
-	let intersectionYMax=0;
-	if(deltaYMinsSign==deltaYMaxsSign){ // case «parallelogram»
-		if(deltaYMinsSign<0){ // case /=/ parallelogram
-			intersectionYMin=yMin1;
-			intersectionYMax=yMax2;
-			// We calculate edges :
-			edges.push("bottom");		// Here the Y axis is NOT inverted !
-		}else{	 // case \=\ parallelogram
-			intersectionYMin=yMin2;
-			intersectionYMax=yMax1;
-			// We calculate edges :
-			edges.push("top");	// Here the Y axis is NOT inverted !
-		}
-	}else{  // case «trapeze»
-		if(deltaYMinsSign<0){ // case /=\ trapeze
-			intersectionYMin=yMin1;		// Basically zone2 y !
-			intersectionYMax=yMax1;
-			// We calculate edges :
-			hasYAxisWholeZone1=true;
-		}else{	 // case \=/ trapeze
-			intersectionYMin=yMin2;		// Basically zone2 y !
-			intersectionYMax=yMax2;
-			// We calculate edges :
-			hasYAxisWholeZone2=true;
-		}
+	let listenableServer;
+	if(sslOptions){
+		let httpsServer=https.createServer(sslOptions, handler).listen(port);
+		// TRACE
+		console.log("INFO : SERVER : HTTPS Server launched and listening on port " + port + "!");
+		listenableServer=httpsServer;
+	}else{
+		let httpServer=http.createServer(handler).listen(port);
+		// TRACE
+		console.log("INFO : SERVER : HTTP Server launched and listening on port " + port + "!");
+		listenableServer=httpServer;
 	}
 
-	let h=intersectionYMax-intersectionYMin;
-	let y=(intersectionYMax+intersectionYMin)*.5; // (The average)
 	
-	// We calculate edges :
-	if(hasXAxisWholeZone1 && hasYAxisWholeZone1)	edges.push("wholeZone1");
-	if(hasXAxisWholeZone2 && hasYAxisWholeZone2)	edges.push("wholeZone2");
+	const server=WebsocketImplementation.getStatic(true).getServer(listenableServer);
 	
-	return {x:x,y:y,w:w,h:h,edges:edges};
-}
+	// When a client connects, we execute the callback :
+	// CAUTION : MUST BE CALLED ONLY ONCE !
+	server.onConnectionToClient((serverParam, clientSocketParam)=>{
+		if(doOnConnect) doOnConnect(serverParam, clientSocketParam);
+	});
 
-/*public static*/window.areZonesIdentical=function(zone1, zone2){
-	return (zone1==zone2 || (zone1.x==zone2.x || zone1.y==zone2.y || zone1.w==zone2.w || zone1.h==zone2.h));
-}
 
+	server.onFinalize((serverParam)=>{
+		if(doOnFinalizeServer)	doOnFinalizeServer(serverParam);
+	});
+	
 
+	// TRACE
+	console.log("INFO : SERVER : Generic Nodejs server launched and listening on port:" + port + "!");
 
-// 3D :
 
+	return server;
+}
 
-/*
-// (needs the jsgl library file !)
-// UNUSED
-function screenToSpherePt(mouseX, mouseY) {
-	var p = { x: camera_mat.e12, y: camera_mat.e13, z: camera_mat.e14 + 1 };
-	// camera dir
-	var r = { x: camera_mat.e0, y: camera_mat.e1, z: camera_mat.e2 };
-	var up = { x: camera_mat.e4, y: camera_mat.e5, z: camera_mat.e6 };
-	var right = { x: camera_mat.e8, y: camera_mat.e9, z: camera_mat.e10 };
-	var tan_half = Math.tan(horizontal_fov_radians / 2);
-	r = jsgl.vectorAdd(r, jsgl.vectorScale(right, mouseX * tan_half));
-	r = jsgl.vectorAdd(r, jsgl.vectorScale(up, mouseY * tan_half));
-	r = jsgl.vectorNormalize(r);
 
-	return rayVsUnitSphereClosestPoint(p, r);
-}
-*/
+initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OPTIONAL*/portParam, /*OPTIONAL*/certPathParam, /*OPTIONAL*/keyPathParam){
 
-/*
-// (needs the jsgl library file !)
-// UNUSED
-// Return the first exterior hit or closest point between the unit
-// sphere and the ray starting at p and going in the r direction.
-function rayVsUnitSphereClosestPoint(p, r) {
-	var p_len2 = jsgl.dotProduct(p, p);
-	if (p_len2 < 1) {
-		// Ray is inside sphere, no exterior hit.
-		return null;
-	}
+	// TRACE
+	console.log("Server launched.");
+	console.log("Usage :													node <server.js> conf {port:[port], sslCertPath:[ssl certificate path | unsecure ], sslKeyPath:[ssl key path], serverConfig:[JSON server configuration]}");
+	console.log("Or (to generate password hash) :	node <server.js> hash <clientId@repositoryName> <clearTextSecretString>");
+	// 			EXAMPLE : 							node orita-srv.js hash orita.global@saltkey 1234567890
+	console.log("Server launched.");
+	
+	// We read the command-line arguments if needed :
+
+	let argCLPort;
+	let argCLCertPath;
+	let argCLKeyPath;
+	let serverConfig={};
+	let isForceUnsecure;
+
+	let isHashAsked=false;
+	let clearTextParam=null;
+	let persisterId=null;
+	
+	
+	process.argv.forEach(function (val, i){
+		if(!val)	return;
+		// 0 corresponds to «node / nodejs»
+		if(i<=1)	return; // 1 corresponds to « <server.js> »
+		else if(i==2){
+			if(val==="hash")		isHashAsked=true;
+		}else if(i==3){
+			if(!isHashAsked){
+				try{
+					const jsonConf=JSON.parse(val);	
+					argCLPort=jsonConf.port;
+					argCLCertPath=jsonConf.sslCertPath;
+					argCLKeyPath=jsonConf.sslKeyPath;
+					serverConfig=nonull({},jsonConf.serverConfig);
+				}catch(err1){
+					lognow("ERROR : Cannot parse argument JSON string «"+val+"».",err1);
+				}
+			}	else						persisterId=val;
+		}else if(i==4){
+			if(isHashAsked)		clearTextParam=val;
+		}
+	});
+	isForceUnsecure=(argCLCertPath==="unsecure");
 
-	var along_ray = -jsgl.dotProduct(p, r);
-	if (along_ray < 0) {
-		// Behind ray start-point.
-		return null;
-	}
+	
+	const aotraNodeServer={config:serverConfig};
+	aotraNodeServer.serverManager={ start:()=>{/*DEFAULT START FUNCTION, WILL BE OVERRIDEN LATER*/}};
 
-	var perp = jsgl.vectorAdd(p, jsgl.vectorScale(r, along_ray));
-	var perp_len2 = jsgl.dotProduct(perp, perp);
-	if (perp_len2 >= 0.999999) {
-		// Return the closest point.
-		return jsgl.vectorNormalize(perp);
+	if(isHashAsked){
+		// We isntanciate a temporary persister just to read the saltkey file:
+		const persister=getPersister("./");
+		let persisterIdSplits=persisterId.split("@");
+		if(empty(persisterIdSplits) || persisterIdSplits.length!=2){
+			// TRACE
+			console.log("ERROR : No persister repository IDs provided correctly. Cannot read saltkey. Aborting hash generation.");
+			return aotraNodeServer;
+		}
+		const persisterClientId=persisterIdSplits[0];
+		const persisterRepositoryName=persisterIdSplits[1];
+		let globalSaltkeyObject=persister.readTreeObjectFromFile(persisterClientId, persisterRepositoryName);
+		if(!globalSaltkeyObject || !globalSaltkeyObject.saltkey){
+			// TRACE
+			console.log("WARN : No saltkey found. Generating one now.");
+			globalSaltkeyObject={saltkey:getUUID(), hashes:[]};
+			persister.saveDataToFileForClient(persisterClientId,persisterRepositoryName,globalSaltkeyObject,false,()=>{
+				// TRACE
+				console.log("INFO : Saltkey generated and saved successfully.");
+			});
+		}
+		const globalSaltkey=globalSaltkeyObject.saltkey;
+		
+		let firstHash=getHashedString(clearTextParam);
+		
+		let generatedHash=getHashedString( firstHash + globalSaltkey, true);// (we use the heavy treatment thing.)
+		globalSaltkeyObject.hashes.push(generatedHash);
+
+		// We update the repository :
+		persister.saveDataToFileForClient(persisterClientId,persisterRepositoryName,globalSaltkeyObject,false,()=>{
+			// TRACE
+			console.log("INFO : Hash added to repository and saved successfully.");
+		});
+		
+		// OUTPUT
+		console.log("Here is your key : share it with your clients but DO NOT LEAK IT !\n********************\n"+clearTextParam+"\n********************\n");
+		
+		return aotraNodeServer;
 	}
 
-	// Compute intersection.
-	var e = Math.sqrt(1 - jsgl.dotProduct(perp, perp));
-	var hit = jsgl.vectorAdd(p, jsgl.vectorScale(r, (along_ray - e)));
-	return jsgl.vectorNormalize(hit);
-}
-*/
+	
+	const DEFAULT_PORT=nonull(argCLPort,25000);
+	const DEFAULT_CERT_PATH=nonull(argCLCertPath,"cert.pem");
+	const DEFAULT_KEY_PATH=nonull(argCLKeyPath,"key.key");
 
+	
+	let port=portParam ? portParam : DEFAULT_PORT;
+	let certPath=null;
+	let keyPath=null;
 
+	if(!isForceUnsecure){
+		certPath=certPathParam?certPathParam:DEFAULT_CERT_PATH;
+		keyPath=keyPathParam?keyPathParam:DEFAULT_KEY_PATH;
+	}
 
+	
+	// UNUSEFUL :
+//aotraNodeServer.serverManager.microClientsSockets=[];
+	// UNUSEFUL :
+//aotraNodeServer.serverManager.mainClientsSockets=[];
+	aotraNodeServer.serverManager.start=function(){
 
+		// Eventual encryption options : 
+		let sslOptions=null; 
+		if(!isForceUnsecure){
+			if(!fs){
+				// TRACE
+				lognow("ERROR : «fs» node subsystem not present, cannot access files. Aborting SSL configuration of server.");
+			}else{
+				try{
+		  		sslOptions={
+		  			cert: fs.readFileSync(certPath),
+		  			key: fs.readFileSync(keyPath),
+		  		};
+				}catch(exception){
+					// TRACE
+					lognow("ERROR : Could not open SSL files certPath:«"+certPath+"» or keyPath:«"+keyPath+"». Aborting SSL configuration of server.");
+				}
+			}
+		}
+		
+		aotraNodeServer.server=launchNodeHTTPServer(port, doOnClientConnection, doOnFinalizeServer, sslOptions);
+		
 
+		return aotraNodeServer;
+	};
 
+	return aotraNodeServer;
+}
 
+// ========================= FUSRODA SERVER : =========================
 
+//
+// DOES NOT WORK : USE Java FusrodaServer instead :
+//
+///*FUSRODA server stands from FSRD SERVER, for Fucking Simple Remote Desktop SERVER*/
+//createFusrodaServer=function(certPathParam=null,keyPathParam=null,portParam=6080){
+//	
+//	// https://www.npmjs.com/package/screenshot-desktop
+//	// https://github.com/octalmage/robotjs
+//	// npm install --save screenshot-desktop
+//	//
+//	// sudo apt-get install libxtst-dev libx11-dev
+//	// npm install --save robotjs
+//	
+//	// http://getrobot.net/docs/usage.html
+//	// 
+//	// apt-get install build-essential python libxt-dev libxtst-dev libxinerama-dev -y 
+//	
+//	const screenshot=require("screenshot-desktop");
+//
+//	const REFRESH_SCREENSHOTS_MILLIS=500;
+//
+//	
+//	const server=initNodeServer(
+//		// On client connection :
+////	(serverParam, clientSocketParam)=>{},
+//		null,
+//		// On server finalization :
+//		(serverParam)=>{
+//
+//			serverParam.receive("protocol_fusroda", (message, clientSocket)=> {
+//				serverParam.addToRoom(clientSocket,"clients");
+//			});
+//			
+//			
+//			serverParam.sendScreenshotsRoutine=setInterval(()=>{
+//				if(serverParam.isScreenshotStarted)	return;
+//				
+//				serverParam.isScreenshotStarted=true;		
+//			
+//				screenshot().then((img) => {
+//	
+//					const data={image:img,messageType:"imageData"};
+//					serverParam.send("message", data, "clients");
+//					
+//					serverParam.isScreenshotStarted=false;		
+//
+//				}).catch((error) => {
+//				  // TRACE
+//					lognow("ERROR : Error during screenshot :",error);
+//				});
+//				
+//			},REFRESH_SCREENSHOTS_MILLIS);
+//			
+//			
+//		},portParam,certPathParam,keyPathParam);
+//
+//
+////	const doOnConnect=(serverParam, clientSocketParam)=>{
+////	};
+////	const doOnFinalizeServer=(serverParam)=>{
+////		/*DO NOTHING*/
+////	};
+////	const server={};
+////	server.start=(port=6080)=>{
+////		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
+////	};
+//
+//	return server;
+//}
 
 
+// ========================= UTILITY SERVERSIDE METHODS : =========================
 
+class ListManager{
+	constructor(config){
+		this.config=config;
+		this.maxItemsNumber=nonull(this.config.max,999);
+		this.simultaneousItemsNumber=nonull(this.config.simultaneous,1);
+		this.sessionDurationSeconds=nonull(this.config.duration,null);
+		this.mode=nonull(this.config.mode,"startAtConnexion");
+		
+		this.itemsInfos={};
+		this.time=null;
+		this.started=false;
+	}
+	
+	addItem(id,item){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot add item with no id.");
+			return;
+		}
+		if(!item){
+			// TRACE
+			lognow("ERROR : Cannot add null item.");
+			return;
+		}
+		const numberOfItemsCurrently=countKeys(this.itemsInfos);
+		if(this.maxItemsNumber<=numberOfItemsCurrently){
+			// TRACE
+			lognow("ERROR : Cannot add item with id «"+id+"», list already full.");
+			return;
+		}
+		if(numberOfItemsCurrently==0 && this.mode==="startAtConnexion"){
+			this.startSession();
+		}
+		this.itemsInfos[id]={
+			item:item,
+			time:getNow(),
+		};
+	}
+	
+	startSession(){
+		this.time==getNow();
+		this.started=true;
+	}
+	
+	stopSession(){
+		this.started=false;
+	}
+	
+	isSessionActive(){
+		if(!this.sessionDurationSeconds)	return true;
+		if(!this.started)									return false;
+		return !hasDelayPassed(this.time, this.sessionDurationSeconds*1000);
+	}
+	
+	isClientActive(clientId){
+		if(!clientsListManager.isSessionActive())	return false;
+		const clientPosition=this.getItemPosition(clientId);
+		const result=(clientPosition<=this.maxItemsNumber);
+		return result;
+	}
+	
+	removeItem(id){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot remove item, no id specified.");
+			return;
+		}
+		if(!this.itemsInfos[id]){
+			// TRACE
+			lognow("ERROR : Cannot remove item, item not found for id «"+id+"».");
+			return;
+		}
+		delete this.itemsInfos[id];
+	}
 
+	// Goes from 1 to <length>:
+	getItemPosition(id){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot calculate item position, no id specified.");
+			return;
+		}
+		if(!this.itemsInfos[id]){
+			// TRACE
+			lognow("ERROR : Cannot calculate item position, item not found for id «"+id+"».");
+			return;
+		}
+		let result=0;
+		foreach(this.itemsInfos,(itemInfo,key)=>{
+			result++;
+			if(id==key)	return "break";
+		},null,(itemInfo1,itemInfo2)=>item1.time<item2.time);
+		return result;
+	}
 
+	
+}
 
+function getListManager(config){
+	return new ListManager(config);
+}
 
 
 
@@ -8324,10 +9356,8 @@ function rayVsUnitSphereClosestPoint(p, r) {
 
 
 
-// MUST REMAIN AT THE END OF THIS LIBRARY FILE !
 
-AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
-/*utils COMMONS library associated with aotra version : «1.0.0.000 (11/07/2022-23:49:31)»*/
+/*utils COMMONS library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -9668,105 +10698,398 @@ aotest.run=function(testName=null,scenarioName=null){
 	
 	var buildHRReport=function(resultObj){
 
-		let str="";
-		
-		let resultsFailed=getCumulatedInt(resultObj,"childrenFailed");
-		let resultsRunned=getCumulatedInt(resultObj,"childrenRunned");
-		
+		let str="";
+		
+		let resultsFailed=getCumulatedInt(resultObj,"childrenFailed");
+		let resultsRunned=getCumulatedInt(resultObj,"childrenRunned");
+		
+		
+		// TRACE
+		str+="@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
+		str+=" 									AOTEST REPORT								 \n";
+		str+="REPORT: "+resultsFailed + "/" + resultsRunned + " scenarii failed.\n";
+		str+="REPORT: "+(resultsRunned - resultsFailed) + "/" + resultsRunned + " scenarii succeeded.\n";
+		str+="REPORT: "+resultsRunned + " scenarii runned.\n";
+		str+="@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
+		
+		if(0<resultsRunned){
+			if(!resultObj.global.isFailed){
+				// TRACE
+				str+="LOG: RESULT :>>>>>> All tests SUCCEEDED ! :D\n";
+			} else {
+				// TRACE
+				str+="LOG: RESULT :>>>>>> Some tests FAILED... :(\n";
+			}
+		} else {
+			// TRACE
+			str+="LOG: RESULT :>>>>>> No tests runned... :|\n";
+		}
+		
+		return str;
+	};
+	
+
+	var getCumulatedInt=function(resultObj, attrName){
+
+		let result=0;
+		
+		result+=resultObj.global[attrName];
+		
+		foreach(resultObj.children,(child)=>{
+			result+=getCumulatedInt(child, attrName);
+		});
+		
+		return result;
+	};
+
+	
+	
+	
+	// TRACE
+	console.log(	buildHRReport(allTestsResultObj));
+	
+	
+	// DBG
+	console.log("TOTAL RESULT :",allTestsResultObj);
+
+	
+	aotest.isRunning=false;
+	
+	return allTestsResultObj;
+};
+
+
+
+aotest.profile=function(rootObject,methodName,visited=[]){
+	
+	
+//if(!rootObject || !isObject(rootObject) || contains(visited,rootObject))	return;
+	if(			!rootObject || isPrimitive(rootObject)	|| isFunction(rootObject) 
+			||  contains(visited,rootObject))	return;
+
+	const THRESHOLD_MILLIS=10;
+
+	visited.push(rootObject);
+	
+	let method=rootObject[methodName];
+	if(method && isFunction(method)){
+		rootObject[methodName]=function(){
+			
+			let time=getNow();
+			
+			method.apply(rootObject, arguments);
+			
+			let deltaMillis=(getNow()-time);
+			
+			// TRACE
+			if(THRESHOLD_MILLIS<=deltaMillis)	lognow("Duration ["+deltaMillis+"ms] of «"+methodName+"» on object:"+getClassName(rootObject),rootObject);
+		};
+	}
+	
+	foreach(rootObject,(attr,attrName)=>{
+		
+		// DBG
+		if(attrName==="currentContainer")	lognow("currentContainer:",attr);
+		
+		aotest.profile(attr,methodName,visited);
+		
+	});
+	
+	
+};
+
+
+
+
+
+//================================================================
+//================= Cryptography utility methods =================
+//================================================================
+
+
+// NOT AOTESTABLE !
+//TODO : develop :
+//getHashedString=monitorProgression(100000,
+window.getHashedString=function(str,/*OPTIONAL*/isHeavyTreatment){
+	
+	//CAUTION : YOU MUST *NOT* CHANGE THIS VALUE, UNLESS THE HASH HEAVY TREATMENT VALUE IN YOUR AOTRA SERVER-SIDE CODEIS THE SAME !
+	const HEAVY_TREATMENT_LOOP_COUNT=100000;
+	
+	if(isHeavyTreatment){
+
+		// If needed, we make sure the hashing will take a long time, so that
+		// if the private salt key is leaked, it will be fairly difficult to crack
+		// password write protection and content encryption :
+		
+		let result=str;
+		for(var i=0;i<HEAVY_TREATMENT_LOOP_COUNT;i++){
+			result=getHashedString(result,false);
+		}
+
+		
+		return result;
+		
+	}else{
+	
+		
+		// SHA-256 hash (sucks less) :
+		// DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
+		if(typeof(sjcl)!="undefined"){
+			let result=sjcl.codec.hex.fromBits(sjcl.hash.sha256.hash(str));
+			
+			// TODO : develop :
+//			hash.progressionMonitor.progress(1);
+	
+			
+			return result;
+		}
+		
+		// if not found : MD5 hash (sucks) :
+		//TRACE
+		log("WARN : Could not find SHA hashing, using MD5. This sucks, and this very likely will prevent your aotra client to be able to write data to aotra server.");
+		
+		return hex_md5(str);
+	}
+}
+//);
+
+function encrypt(strToEncrypt,key,/*OPTIONAL*/mode){
+	if(!mode || typeof(sjcl)=="undefined")	mode="xor";
+	mode=mode.trim();
+
+	if(contains(mode,"aes") && contains(mode,"xor")){
+
+		// XOR :
+		var xorStr=btoa(encodeXORNoPattern(strToEncrypt,key));	
+		
+		var aesStr=
+			// AES
+			sjcl.encrypt(key,xorStr);
+
+		return aesStr;
+	}
+	
+	//	DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
+	if(mode==="aes")
+		return sjcl.encrypt(key,strToEncrypt);
+	return btoa(encodeXORNoPattern(strToEncrypt,key));
+
+}
+
+function decrypt(strToDecrypt,key,/*OPTIONAL*/mode){
+	if(!mode || typeof(sjcl)=="undefined")	mode="xor";
+	mode=mode.trim();
+
+	if(contains(mode,"aes") && contains(mode,"xor")){
 		
-		// TRACE
-		str+="@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
-		str+=" 									AOTEST REPORT								 \n";
-		str+="REPORT: "+resultsFailed + "/" + resultsRunned + " scenarii failed.\n";
-		str+="REPORT: "+(resultsRunned - resultsFailed) + "/" + resultsRunned + " scenarii succeeded.\n";
-		str+="REPORT: "+resultsRunned + " scenarii runned.\n";
-		str+="@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
+		// AES
+		var aesStr=sjcl.decrypt(key,strToDecrypt);
 		
-		if(0<resultsRunned){
-			if(!resultObj.global.isFailed){
-				// TRACE
-				str+="LOG: RESULT :>>>>>> All tests SUCCEEDED ! :D\n";
-			} else {
-				// TRACE
-				str+="LOG: RESULT :>>>>>> Some tests FAILED... :(\n";
-			}
-		} else {
-			// TRACE
-			str+="LOG: RESULT :>>>>>> No tests runned... :|\n";
-		}
+		var xorStr=
+			// XOR :
+			encodeXORNoPattern(atob(aesStr),key);
+
+		return xorStr;
 		
-		return str;
-	};
+	}
 	
+	//	DEPENDENCY : SJCL JS libray (Stanford Javascript Crypto Library)
+	if(mode==="aes")
+		return sjcl.decrypt(key,strToDecrypt);
+	return encodeXORNoPattern(atob(strToDecrypt),key);
+	
+	
+}
 
-	var getCumulatedInt=function(resultObj, attrName){
-
-		let result=0;
+function encodeXORNoPattern(strToEncode,key){
+	let result="";
+	let keyChunk=key;
+	let keyLength=keyChunk.length;
+	let previousChars="";
+	let cnt=0;
+	for(let i=0;i<strToEncode.length;i++){
+		let char=strToEncode.charAt(i);
+		let keyByte=keyChunk.charAt(cnt);
 		
-		result+=resultObj.global[attrName];
+		result+=String.fromCharCode(char.charCodeAt(0)^keyByte.charCodeAt(0));
 		
-		foreach(resultObj.children,(child)=>{
-			result+=getCumulatedInt(child, attrName);
-		});
+		if(cnt%keyLength===(keyLength-1)){
+			cnt=0;
+			// NO : TOO LONG TREATMENT !: We hash with all the previous blocks too :
+			// We hash with a character of the previous chunk (they add up at each new chunk):
+			keyChunk=getHashedString(previousChars+keyChunk);
 		
-		return result;
-	};
+			previousChars+=keyChunk.charAt(keyChunk.length-1);
+		}else{
+			cnt++;
+		}
+	}
+	return result;
+}
 
+function generateRandomString(length,/*NULLABLE*/mode){
 	
+	// This list must be very conservative, because  we want to be able to pass it through GET URLs !
+	// OLD (not enough conservative ?) : const ALLOWED_CHARS="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0912346789_-£¢¤¬²³¼½¾";
+	const ALLOWED_CHARS="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0912346789!-:;";
 	
 	
-	// TRACE
-	console.log(	buildHRReport(allTestsResultObj));
-	
+	if(typeof(length)==="string"){
+		if(contains(length,"->")){
+			length=Math.getRandomInRange(length);
+		}else{
+			length=64;
+		}
+	}
 	
-	// DBG
-	console.log("TOTAL RESULT :",allTestsResultObj);
+	var result="";
 
-	
-	aotest.isRunning=false;
-	
-	return allTestsResultObj;
-};
+	if(mode==="simple"){
+		
+		for(var i=0;i<length;i++){
+			var	value=Math.getRandomInArray(ALLOWED_CHARS);
+			result+=value;
+		}
+		
+		return result;
+	}else if(mode==="human"){
+		
+		const markovGraph={
+			// For simplicity sakes, we ignore the consonants and vowels doubling possibilities:
+			consonants:{// They always accept vowels at their following
+				// Indicate ^ to specify wich of the other group letter to exclude as direct follower of the given letter :
+				"b":["r","l"],
+				"c":["h","t","k","l","r"],
+				"d":["r"],
+				"f":["r","l"],
+				"g":["r","l"],
+				"h":[],
+				"j":["r"],
+				"k":["r","l","t","h"],
+				"l":["t"],
+				"m":["b","p"],
+				"n":["t","d"],
+				"p":["h","r","s","t","l"],
+				"q":["r","l"],
+				"r":["t","c","d","k","q","h"],
+				"s":["t","c","d","k","q","h"],
+				"t":["r","h"],
+				"v":["r","l"],
+				"w":["r"],
+				"x":["p"],
+				"z":["r","h"],
+			},
+			vowels:{// They always accept consonants at their following
+				"a":["i","u","y"],
+				"e":["i","u","y"],
+				"i":["e","o"],
+				"o":["i","u"],
+				"u":["i"],
+				"y":[],
+			},
+		};
+		
+		const LETTERS_TYPES=Object.keys(markovGraph);
 
+		const CURR_LETTER_MODE=Math.getRandomInArray(LETTERS_TYPES);
+		const POSSIBLE_LETTERS=Object.keys(markovGraph[CURR_LETTER_MODE]);
+		const CURR_LETTER=Math.getRandomInArray(POSSIBLE_LETTERS);
+		
+		var automataState={
+			currentLetterMode:CURR_LETTER_MODE,
+			possibleLetters:POSSIBLE_LETTERS,
+			currentLetter:CURR_LETTER,
+			
+			calculateLetter:function(){
+				
+				this.currentLetter=Math.getRandomInArray(this.possibleLetters);
+				
+				var sameLetters=Object.keys( markovGraph[this.currentLetterMode] );
+				if(!contains(sameLetters,this.currentLetter)){
+					// If we picked from the same group : we don't change of group to pick
+					// If we picked from the other group : we do change of group to pick
+					
+					var otherLetterMode=foreach(LETTERS_TYPES,(item)=>{
+						if(item!==this.currentLetterMode)	return item;
+					});
+					
+					this.currentLetterMode=otherLetterMode;
+				}
 
+			},
+			
+			updatePossibleLettersForLetter:function(){
+				
+				var nextPossibleLetters=[];
+				var nextNotPossibleLetters=[];
 
-aotest.profile=function(rootObject,methodName,visited=[]){
-	
-	
-//if(!rootObject || !isObject(rootObject) || contains(visited,rootObject))	return;
-	if(			!rootObject || isPrimitive(rootObject)	|| isFunction(rootObject) 
-			||  contains(visited,rootObject))	return;
+				// We store those of the other group marked «^»
+				foreach(markovGraph[this.currentLetterMode][this.currentLetter],(letter)=>{
+					if(letter.charAt(0)==="^"){
+						nextNotPossibleLetters.push(letter.charAt(1));
+					}else{
+						nextPossibleLetters.push(letter);
+					}
+				});
+				
+				var otherLetterMode=foreach(LETTERS_TYPES,(item)=>{
+					if(item!==this.currentLetterMode)	return item;
+				});
+				var otherLetters=Object.keys(markovGraph[otherLetterMode]);
+				
+				// We exclude those marked «^»
+				foreach( otherLetters ,(letter)=>{
+					if(!contains(nextNotPossibleLetters,letter)){
+						nextPossibleLetters.push(letter);
+					}
+				});
 
-	const THRESHOLD_MILLIS=10;
+				this.possibleLetters=nextPossibleLetters;
+			}
+		};
+		
+		var i=0;
+		do{
 
-	visited.push(rootObject);
-	
-	let method=rootObject[methodName];
-	if(method && isFunction(method)){
-		rootObject[methodName]=function(){
-			
-			let time=getNow();
-			
-			method.apply(rootObject, arguments);
+			result+=automataState.currentLetter;
 			
-			let deltaMillis=(getNow()-time);
+			automataState.updatePossibleLettersForLetter();
+			automataState.calculateLetter();
 			
-			// TRACE
-			if(THRESHOLD_MILLIS<=deltaMillis)	lognow("Duration ["+deltaMillis+"ms] of «"+methodName+"» on object:"+getClassName(rootObject),rootObject);
-		};
+			i++;
+		}while(i<length);
+		
+		return result;
 	}
 	
-	foreach(rootObject,(attr,attrName)=>{
-		
-		// DBG
-		if(attrName==="currentContainer")	lognow("currentContainer:",attr);
-		
-		aotest.profile(attr,methodName,visited);
-		
-	});
+	for(var i=0;i<length;i++){
+		var	value=Math.getRandomInt(255,0);
+		result+=String.fromCharCode(value);
+	}
 	
+	if(mode==="base64"){
+		return btoa(result);
+	}
 	
-};
+	return result;
+}
+
+
+
+// NOT AOTESTABLE !
+function getUniqueIdWithDate(){
+	return getHashedString(getNow() + "");
+}
+
+
+
+
+
+
+//================================================================
+//================= Miscelanneous utility methods =================
+//================================================================
+