aotrautils 0.0.44 → 0.0.45

aotrautils/aotrautils.build.js

@@ -1,5 +1,6 @@
 
-/*utils CLIENT library associated with aotra version : «1.0.0.000 (11/01/2022-00:18:33)»*/
+
+/*utils CLIENT library associated with aotra version : «1.0.0.000 (11/07/2022-00:48:13)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -35,6 +36,9 @@ if(typeof(window)==="undefined")	window=global;
 const APOSTROPHE="’";
 PERFORM_TESTS_ON_LIBRARY=false;
 
+const isUserMediaAvailable=!!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia && navigator.mediaDevices.enumerateDevices);
+
+
 // Dependances-optionalizing mechanisms :
 if(typeof aotest === "undefined"){
 	aotest=function(testcase,testedFunction){ return testedFunction; };
@@ -1960,11 +1964,11 @@ if(typeof(window)!=="undefined")	window.URL=window.URL || window.webkitURL;
 //navigator.getUserMedia=navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia;
 //window.AudioContext=window.AudioContext || window.webkitAudioContext;
 
-function hasGetUserMedia(){
-	// OLD : (DEPRECATED)
-//	return !!/*<-=to force a boolean result*/(navigator.getUserMedia);
-	return !!/*<-=to force a boolean result*/(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
-}
+//function hasGetUserMedia(){
+//	// OLD : (DEPRECATED)
+////	return !!/*<-=to force a boolean result*/(navigator.getUserMedia);
+//	return !!/*<-=to force a boolean result*/(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+//}
 
 
 
@@ -3082,6 +3086,7 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 
 
 
+
 //Deprecated : use getMediaHandler directly
 /*public*/getWebcamHandler=function(
 //	videoTagId
@@ -3101,6 +3106,12 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 		/*OPTIONAL*/doFinallyWhenMultipleDevices=null
 ){
 	
+	if(!isUserMediaAvailable){
+		// TRACE
+		log("ERROR : User medias is not supported in your browser (or are you running in a non-https context ?). Aborting");
+		return null;
+	}
+	
 	const cameras=[];
 	const microphones=[];
 	navigator.mediaDevices.enumerateDevices().then(function(devices){
@@ -3110,14 +3121,10 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 			else if(d.kind==="audioinput")	microphones.push(d);
 	  });
 			
-
-		// DBG
-		//alert(JSON.stringify(cameras));
-
 		// CAUTION : On today this method only handles media handlers with a single track :
 
 		let constraints={video:(videoConfigParam!=null), audio:(audioConfigParam!=null)}; // Default constraints
-		if(videoConfigParam){
+		if(!empty(cameras) && videoConfigParam){
 			let webcamIndex=videoConfigParam.webcamIndex;
 			if(webcamIndex!=null){
 				const deviceIndex=Math.min(cameras.length-1, webcamIndex);
@@ -3127,7 +3134,7 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 						}
 					};
 			}
-		}else if(audioConfigParam){
+		}else if(!empty(microphones) && audioConfigParam){
 			let microphoneIndex=audioConfigParam.microphoneIndex;
 			if(microphoneIndex!=null){
 				const deviceIndex=Math.min(microphones.length-1, microphoneIndex);
@@ -3195,9 +3202,10 @@ function filterPoints(allPoints ,ctx/*DBG*/){
 		return null;
 	}
 	
-	if (!hasGetUserMedia()){
+	
+	if(!isUserMediaAvailable){
 		// TRACE
-		log("ERROR : Method getUserMedia() is not supported in your browser, your browser doesn't have a getUserMedia() usable method.");
+		log("ERROR : User medias is not supported in your browser (or are you running in a non-https context ?). Aborting");
 		return null;
 	}
 
@@ -3747,34 +3755,51 @@ getColorFingersPointer=(mediaHandler,colorsPattern="rgb")=>{
 //Sound handling :
 
 
-function playAudioData(audioData,/*OPTIONAL*/audioCtxParam,/*OPTIONAL*/audioBufferSizeParam,/*OPTIONAL*/numberOfAudioChannelsParam){
+function playAudioData(audioData,audioCtxParam=null,audioBufferSizeParam=null,numberOfAudioChannelsParam=null,sampleRateParam=null,
+//sourceParam=null, bufferParam=null, 
+	doOnEndPlayingSample=null,
+	playbackRateParam=2
+){
 	
 	const DEFAULT_AUDIO_BUFFER_SIZE=4096;
-	let audioBufferSize=audioBufferSizeParam?audioBufferSizeParam:DEFAULT_AUDIO_BUFFER_SIZE;
-	let numberOfAudioChannelsOUT=numberOfAudioChannelsParam?numberOfAudioChannelsParam:1;//default is «mono»
 	
 //	 To read the audio data :
 //   simply perform a reading of mediaHandler.audioData
 //   To play the sound :
 	
 	let audioCtx=nonull(audioCtxParam,new AudioContext());
-
-	let sampleRate=audioCtx.sampleRate;
-	
-    let source=audioCtx.createBufferSource();
-    
-    let buffer=audioCtx.createBuffer(numberOfAudioChannelsOUT, audioBufferSize, sampleRate); // Only one channel for «mono»
-    let data=buffer.getChannelData(0);
-  	for(let i=0; i<audioBufferSize; i++){
-  	 data[i]=audioData[i];
-  	}
-  	source.buffer=buffer;
-  	source.connect(audioCtx.destination);
+	let audioBufferSize=nonull(audioBufferSizeParam,DEFAULT_AUDIO_BUFFER_SIZE);
+	let numberOfAudioChannels=nonull(numberOfAudioChannelsParam,1);//default is «mono»
+	let sampleRate=nonull(sampleRateParam,audioCtx.sampleRate);
+  
+  // We have to recreate them each time ! :
+  let source=audioCtx.createBufferSource();
+  let buffer=audioCtx.createBuffer(numberOfAudioChannels, audioBufferSize, sampleRate); // Only one channel for «mono»
+
+  let data=buffer.getChannelData(0);
+	for(let i=0; i<audioBufferSize; i++){
+	 data[i]=audioData[i];
+	}
+	if(!source.buffer){
+		source.playbackRate.value=playbackRateParam;
+		source.buffer=buffer;
+		source.connect(audioCtx.destination);
+	// TODO : FIXME : DOES NOT CURRENTLY WORK :  	
+	// BECAUSE OF INTERACTION-FIRST RESTRICTIONS WILL MAKE IT NOT WORK !
+	  // OLD : source.start(0);
+	  source.start();
+	  
+//	  // DBG
+//	  lognow("audioSource STARTED : ",source);
+	}
   	
-// TODO : FIXME : DOES NOT CURRENTLY WORK :  	
-// BECAUSE OF INTERACTION-FIRST RESTRICTIONS WILL MAKE IT NOT WORK !
-  	source.start(0);
-    
+  
+  if(doOnEndPlayingSample){
+	  const playingDurationMillis=(audioBufferSize/sampleRate);
+	  // DBG
+//	setTimeout(doOnEndPlayingSample,playingDurationMillis*1000); (because Hertz)
+		doOnEndPlayingSample();
+	}
   
   // OLD :
   //	// Fill the buffer with data from array;
@@ -3934,6 +3959,7 @@ function loadSound(filePath,doOnLoaded=null,doOnEnded=null){
 		isReady:false,
 		speed:1,
 		volume:1,
+		isPlaying:false,
 		mainLoopSound:null,
 		setVolume:function(newVolume=null){
 			if(newVolume)	self.volume=newVolume;
@@ -3947,12 +3973,15 @@ function loadSound(filePath,doOnLoaded=null,doOnEnded=null){
 		},
 		play:function(){
 			if(!self.nativeAudioElement.paused)	return self;
-			self.nativeAudioElement.play();
+			self.nativeAudioElement.play().then(()=>{
+				self.isPlaying=true;
+			});
 			return self;
 		},
 		pause:function(){
-			if(self.nativeAudioElement.paused)	return self;
+			if(self.nativeAudioElement.paused || !self.isPlaying)	return self;
 			self.nativeAudioElement.pause();
+			self.isPlaying=false;
 			return self;
 		},
 		resumeLoop:function(){
@@ -3962,7 +3991,7 @@ function loadSound(filePath,doOnLoaded=null,doOnEnded=null){
 			return self;
 		},
 		pauseLoop:function(){
-			if(!self.isLoop || !self.mainLoopSound)	return self;
+			if(!self.isLoop || !self.mainLoopSound || !self.isPlaying)	return self;
 			self.mainLoopSound.pause();
 			self.pause();
 			return self;
@@ -4170,7 +4199,7 @@ function getCenteredZoneCoords(xParam,yParam,width,height,center={x:"left",y:"to
 }
 
 
-function drawImageAndCenter(ctx,image,xParam,yParam,center={x:"left",y:"top"},
+function drawImageAndCenter(ctx,image,xParam=0,yParam=0,zooms={zx:1,zy:1},center={x:"left",y:"top"},
 			scaleFactorW=1,scaleFactorH=1,
 			sizeW=null,sizeH=null,
 			opacity=1,
@@ -4193,6 +4222,8 @@ function drawImageAndCenter(ctx,image,xParam,yParam,center={x:"left",y:"top"},
 		ctx.globalAlpha=opacity;
 	}
 	
+	// TODO : FIXME : use zooms parameter !
+	
 	if(opacity!==0){
 
 		if(alphaAngleRadians==null){
@@ -4353,8 +4384,12 @@ function getSpriteMonoThreaded(imagesPool,/*OPTIONAL*/refreshMillis=null,
 //					drawingWidth, drawingHeight);
 					
 
-			drawImageAndCenter(ctx,nonull(img, self.imagesPool),
-				xParam+self.xOffset, yParam+self.yOffset, 
+			const xImage=xParam+self.xOffset;
+			const yImage=yParam+self.yOffset;
+			
+			drawImageAndCenter(ctx, nonull(img,self.imagesPool),
+				xImage, yImage, 
+				{zx:1,zy:1},
 				self.center, 
 				(self.scaleFactorW*self.zoom),
 				(self.scaleFactorH*self.zoom),
@@ -4387,9 +4422,11 @@ function getSpriteMonoThreaded(imagesPool,/*OPTIONAL*/refreshMillis=null,
 					}
 				}
 
+				// DOES NOT WORK :
+//				return ctx.getImageData(clipX,clipY,drawingWidth,drawingHeight);
+//			}else{
+//				return ctx.getImageData(0,0,drawingWidth,drawingHeight);
 			}
-			
-			
 		},
 		
 	};
@@ -4451,20 +4488,22 @@ function getMonoThreadedTimeout(doOnStop=null, delayMillis=null){
 
 
 
-function getMonoThreadedRoutine(doOnEachStepCallback,terminateFunction=null,doOnStop=null,refreshMillis=null,startDependsOnParentOnly=false){
+function getMonoThreadedRoutine(doOnEachStepCallback,terminateFunction=null,doOnStop=null,refreshMillis=null,startDependsOnParentOnly=false,doOnSuspend=null,doOnResume=null){
 	
-	// Three-states : started, suspended, stopped.
+	// Three-states : started, paused, stopped.
 	
 	let self={
 			
 		startDependsOnParentOnly:startDependsOnParentOnly,
 		started:false,
-		suspended:false,
+		paused:false,
 		time:getNow(),
 		refreshMillis:refreshMillis,
 		doOnEachStepCallback:doOnEachStepCallback,
 		terminateFunction:terminateFunction,
 		doOnStop:doOnStop,
+		doOnSuspend:doOnSuspend,
+		doOnResume:doOnResume,
 		durationTimeFactorHolder:{durationTimeFactor:1},
 		setDurationTimeFactorHolder:function(durationTimeFactorHolder){
 			self.durationTimeFactorHolder=durationTimeFactorHolder;
@@ -4473,44 +4512,50 @@ function getMonoThreadedRoutine(doOnEachStepCallback,terminateFunction=null,doOn
 		isStarted:function(){
 			return self.started || self.startDependsOnParentOnly;
 		},
-		start:function(callingObject=null){
+		start:function(callingObject=null,args=null){
 			
 			// if(self.isStarted()) return;
-			if(self.terminateFunction && self.terminateFunction(callingObject)){
+			if(self.terminateFunction && self.terminateFunction(callingObject,args)){
 				
 				// CAUTION : Even if the routine is «pre-terminated» before even starting 
 				// (ie. its stop conditions are fullfilled even before it has started)
 				// we all the same have to trigger its stop treatments :
-				if(self.doOnStop)	self.doOnStop(callingObject);
+				if(self.doOnStop)	self.doOnStop(callingObject,args);
 
 				return;
 			}
 			
 			self.started=true;
 			
-			self.suspended=false;
+			self.paused=false;
 
 			return self;
 		},
-		stop:function(callingObject=null){
+		stop:function(callingObject=null,args=null){
 			
 			if(!self.isStarted())	return;
 			self.started=false;
 
-			if(self.doOnStop)	self.doOnStop(callingObject);
+			if(self.doOnStop)	self.doOnStop(callingObject,args);
+			
+		},
+		pause:function(callingObject=null,args=null){
+			self.paused=true;
 			
+			if(self.doOnSuspend)	self.doOnSuspend(callingObject,args);
 		},
-		suspend:function(){
-			self.suspended=true;
+		resume:function(callingObject=null,args=null){
+			self.paused=false;
+			
+			if(self.doOnResume)	self.doOnResume(callingObject,args);
 		},
-		resume:function(){
-			self.suspended=false;
+		isPaused:function(){
+			return self.paused;
 		},
-
 		doStep:function(callingObject=null,args=null){
 			
 
-			if(!self.isStarted() || self.suspended)	return;
+			if(!self.isStarted() || self.paused)	return;
 
 			// Looping index with a delay :
 			
@@ -4521,8 +4566,8 @@ function getMonoThreadedRoutine(doOnEachStepCallback,terminateFunction=null,doOn
 				}
 				
 				// We perform the step :
-				if(self.terminateFunction && self.terminateFunction(callingObject)){
-					self.stop(callingObject);
+				if(self.terminateFunction && self.terminateFunction(callingObject,args)){
+					self.stop(callingObject,args);
 					return;
 				}
 				
@@ -4545,7 +4590,7 @@ function getMonoThreadedRoutine(doOnEachStepCallback,terminateFunction=null,doOn
 function getMonoThreadedGoToGoal(actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear",doOnEachStepCallback=null,doOnStop=null){
 	
 //	const STEP_PRECISION=4;
-	// Three-states : started, suspended, stopped.
+	// Three-states : started, paused, stopped.
 	
 	let self={
 			
@@ -4555,7 +4600,7 @@ function getMonoThreadedGoToGoal(actualValue,goalValue,refreshMillis=null,totalT
 		value:actualValue,
 		goalValue:goalValue,
 		started:false,
-		suspended:false,
+		paused:false,
 		time:getNow(),
 		refreshMillis:refreshMillis,
 		doOnEachStepCallback:doOnEachStepCallback,
@@ -4591,39 +4636,39 @@ function getMonoThreadedGoToGoal(actualValue,goalValue,refreshMillis=null,totalT
 				
 			return self;
 		},
-		start:function(callingObject){
+		start:function(callingObject=null,args=null){
 			
 			if(    self.value===self.goalValue
 			//  || self.isStarted();
-					|| self.terminateFunction(callingObject)){
+					|| self.terminateFunction(callingObject,args)){
 
 				// CAUTION : Even if the routine is «pre-terminated» before even starting 
 				// (ie. its stop conditions are fullfilled even before it has started)
 				// we all the same have to trigger its stop treatments :
-				if(self.doOnStop)	self.doOnStop(callingObject);
+				if(self.doOnStop)	self.doOnStop(callingObject,args);
 
 				return;
 			}
 			
 			self.started=true;
 			
-			self.suspended=false;
+			self.paused=false;
 			
 			return self;
 		},
-		stop:function(callingObject=null){
+		stop:function(callingObject=null,args=null){
 			
 			if(!self.isStarted())	return;
 			self.started=false;
 
-			if(self.doOnStop)	self.doOnStop(callingObject);
+			if(self.doOnStop)	self.doOnStop(callingObject,args);
 			
 		},
-		suspend:function(){
-			self.suspended=true;
+		pause:function(){
+			self.paused=true;
 		},
 		resume:function(){
-			self.suspended=false;
+			self.paused=false;
 		},
 		terminateFunction:function(){
 			
@@ -4643,7 +4688,7 @@ function getMonoThreadedGoToGoal(actualValue,goalValue,refreshMillis=null,totalT
 		
 		doStep:function(callingObject=null,args=null){
 			
-			if(!self.isStarted() || self.suspended)	return self.value;
+			if(!self.isStarted() || self.paused)	return self.value;
 
 			// Looping index with a delay :
 			
@@ -5951,15 +5996,26 @@ function normalizeDisplayQuotesForJSONParsing(str){
 
 //A polyvalent popup :
 //CAUTION : Non-blocking of execution ! (uses callbacks)
-function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=null,config={displayMode:"popup",backgroundColor1:"#B3DCED",font:"helvetica"}){
+function promptWindow(label,type=null,defaultValue=null,
+	doOnOK=null,doOnCancel=null,
+	config={displayMode:"popup",backgroundColor1:"#B3DCED",font:"helvetica",width:"80%",height:"80%"}){
 	
+	const LABEL_AND_DEFAULT_VALUE_SEPARATOR=":";
 	const MAX_Z_INDEX_OVERLAY_LOCAL=9999;// (Repeated because must be stand-alone constant...)
-	const WIDTH="90%";
-	const HEIGHT="90%";
+	const promptWindowWidth=(config && config.width?config.width:"80%");
+	const promptWindowHeight=(config && config.height?config.height:"80%");
+	// DOES NOT WORK : const promptWindowWidth="auto", promptWindowHeight="auto";
+
+
 //	const POSITION_X="7.5%";
 //	const POSITION_Y="5%";
 	const SPECIAL_SEPARATOR="@@@";
 	
+	
+	let resultPromiseOK=null;
+	let resultPromiseCancel=null;
+	
+	
 	let displayMode=config && config.displayMode ? config.displayMode:"popup";
 	let backgroundColor1=config && config.backgroundColor1 ? config.backgroundColor1:"#B3DCED";
 	let backgroundColor2=config && config.backgroundColor2 ? config.backgroundColor2:"#29B8E5";
@@ -5975,12 +6031,11 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 	};
 	
 	//Each field rendering :
-	/* private */let getRenderedInputElement=function(inputType, defaultValueParam=null,/* OPTIONAL */labelParam=null){
+	/* private */const getRenderedInputElement=function(inputType, defaultValueParam=null,/* OPTIONAL */labelParam=null){
 	
-		const LABEL_AND_DEFAULT_VALUE_SEPARATOR=":";
 		const DISABLED_OPACITY=0.6;
 	
-		var inputElement=null;
+		let inputElement=null;
 		if(contains(inputType, "password")){
 			inputElement=document.createElement("input");
 			if(defaultValueParam)		inputElement.value=defaultValueParam;
@@ -6000,7 +6055,7 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 			
 		} else if(contains(inputType, "uniqueChoice") || contains(inputType, "multipleChoice")){ // If we have a group of inputs for (a) value(s) outcome :
 	
-			var choicesLabelsStrs=defaultValueParam;
+			let choicesLabelsStrs=defaultValueParam;
 			if(typeof(defaultValueParam) === "string"){
 				choicesLabelsStrs=parseJSON(defaultValueParam);
 			}
@@ -6008,97 +6063,99 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 			inputElement=document.createElement("p");
 			inputElement.style.display="flex";
 			
-			
 	
 			// Represents a list with a unique or a multiple outcome value(s) :
-			foreach(choicesLabelsStrs,(choiceLabelStr,i)=>{
-	
-				let radioButtonContainer=document.createElement("div");
-				radioButtonContainer.style.width="200px";
-				// radioButtonContainer.style.height="400px";
-				radioButtonContainer.style["padding-right"]="10px";
-				radioButtonContainer.style["text-align"]="center";
-				radioButtonContainer.style["font-size"]="10px";
-				radioButtonContainer.style["line-height"]="10px";
-				
-	
-				let radio=document.createElement("input");
+
+			resultPromiseOK=new Promise((resolve, reject)=>{
 				
-				if(contains(inputType, "multipleChoice")){ // multipleChoice :
-					radio.type="checkbox";
-					radio.id="checkboxMultipleChoice_" + i;
-				} else { // uniqueChoice :
-					
-					
-					if(contains(inputType, "icons")){
-	
-						radio.type="image";
-						if(typeof(choiceLabelStr) === "string"){
-							radio.src=choiceLabelStr.trim();
-						}else{
+					foreach(choicesLabelsStrs,(choiceLabelStr,i)=>{
+						
+						// Radio image card :
+						const radioButtonContainer=document.createElement("div");
+						radioButtonContainer.style.width="200px";
+						// radioButtonContainer.style.height="400px";
+						radioButtonContainer.style["padding-right"]="10px";
+						radioButtonContainer.style["text-align"]="center";
+						radioButtonContainer.style["font-size"]="10px";
+						radioButtonContainer.style["line-height"]="10px";
+						inputElement.appendChild(radioButtonContainer);
+						
+						
+		
+						let radio=document.createElement("input");
+						if(contains(inputType, "multipleChoice")){ // multipleChoice :
+							radio.type="checkbox";
+							radio.id="checkboxMultipleChoice_" + i;
 							
-							if(choiceLabelStr.width)
-								radioButtonContainer.style.width=choiceLabelStr.width;
-							if(choiceLabelStr.height)
-								radioButtonContainer.style.height=choiceLabelStr.height;
+						} else { // uniqueChoice :
 							
+							if(contains(inputType, "icons")){
+			
+								radio.type="image";
+								if(typeof(choiceLabelStr) === "string"){
+									radio.src=choiceLabelStr.trim();
+								}else{
+									
+									if(choiceLabelStr.width)	radioButtonContainer.style.width=choiceLabelStr.width;
+									if(choiceLabelStr.height)	radioButtonContainer.style.height=choiceLabelStr.height;
+									
+									radio.src=choiceLabelStr.src.trim();
+									
+									if(choiceLabelStr.inactive){
+										radio.disabled=true;
+										radio.style.opacity=DISABLED_OPACITY;
+									}
+								}
+								
+								// Icon substitutes itself to the OK button :
+								
+								radio.onclick=function(event){
+									let promptedValue=event.target.indexValue;
+								
+									if(!validationFunction(promptedValue)){
+										// TRACE
+										alert(validationFunction.errorMessage);
+										return;
+									}
+								
+									if(doOnOK){
+									  const doOnOKResult=doOnOK(promptedValue);
+									  resolve({value:promptedValue,result:doOnOKResult});
+									}
+									closeWindow();
+									
+								};
+								
+								
+							}else{
+								radio.type="radio";
+							}
 							
-							radio.src=choiceLabelStr.src.trim();
+							radio.id="radioButtonUniqueChoice_" + i;
+							radio.name="radioButtonsUniqueChoice";
 							
-							if(choiceLabelStr.inactive){
-								radio.disabled=true;
-								radio.style.opacity=DISABLED_OPACITY;
-							}
 						}
 						
-						// Icon substitutes itself to the OK button :
-						radio.onclick=function(event){
-							var promptedValue=event.target.indexValue;
-						
-							if(!validationFunction(promptedValue)){
-								// TRACE
-								alert(validationFunction.errorMessage);
-								return;
-							}
-						
-							if(doOnOK){
-								doOnOK(promptedValue);
-							}
-							closeWindow();
-						};
-						
-						
-						
-						
-					}else{
 						
-						radio.type="radio";
-					}
-					
-					radio.id="radioButtonUniqueChoice_" + i;
-					radio.name="radioButtonsUniqueChoice";
-					
-					
-				}
-				
-				
-				radio.indexValue=i;
-				radioButtonContainer.appendChild(radio);
-	
-				var choiceLabel=document.createElement("label");
-				if(typeof(choiceLabelStr) === "string"){
-					choiceLabel.innerHTML=choiceLabelStr.trim();
-				}else{
-					choiceLabel.innerHTML=choiceLabelStr.html.trim();
-				}
-				choiceLabel.htmlFor=radio.id;
-				radioButtonContainer.appendChild(choiceLabel);
-				
-				
-				inputElement.appendChild(radioButtonContainer);
+						radio.indexValue=i;
+						radioButtonContainer.appendChild(radio);
+			
+						let choiceLabel=document.createElement("label");
+						if(typeof(choiceLabelStr)==="string"){
+							choiceLabel.innerHTML=choiceLabelStr.trim();
+						}else{
+							choiceLabel.innerHTML=choiceLabelStr.html.trim();
+						}
+						choiceLabel.htmlFor=radio.id;
+						radioButtonContainer.appendChild(choiceLabel);
 
-				
+
+						
+					});
+			
 			});
+			
+			
 	
 			// We redefine the function used to retrieve entered value :
 			if(contains(inputType, "icons")){
@@ -6108,11 +6165,11 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 			}else{
 	
 				inputElement.getResultValue=function(){
-					var result="";
+					let result="";
 					
 					// OLD :
 //				jQuery(inputElement).find("input:checked").each(function(){
-//					var radioSlct=jQuery(this);
+//					let radioSlct=jQuery(this);
 //					result+=(nothing(result) ? "" : ",") + radioSlct.get(0).indexValue;
 //				});
 					
@@ -6127,9 +6184,7 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 			}
 	
 			
-		
-			
-		} else { // DEFAULT TYPE IS TEXT AREA :
+		} else if(contains(inputType, "textarea")){
 			
 			inputElement=document.createElement("textarea");
 			if(defaultValueParam)
@@ -6138,14 +6193,16 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 			inputElement.rows="20";
 	
 		}
+		// DEFAULT TYPE IS "yesno"
 		
+
 		inputElement.style.padding="4px";
 		inputElement.style.margin="0";
 	
 		// The default function used to retrieve entered value :
 		if(!inputElement.getResultValue){
 			inputElement.getResultValue=function(){
-				var result=inputElement.value;
+				let result=inputElement.value;
 				return result;
 			};
 		}
@@ -6180,10 +6237,12 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 		if(contains(displayMode,":")){
 			let s=displayMode.split(":");
 			divModal.style.opacity=s[1];	
+		}else{
+			divModal.style.opacity="0.85";// Default modal transparency value
 		}
 		
 		divModal.appendChild(divWindow);
-//		parent.appendChild(divModal);
+//	parent.appendChild(divModal);
 		
 		appendAsFirstChildOf(divModal, parent);
 	}else{
@@ -6198,12 +6257,12 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 	
 	divWindow.className="promptWindowClass";
 	
-	var style="";
-	style+="position:sticky;";
-//style+="left:" + POSITION_X + ";top:" + POSITION_Y + ";z-index:" + (MAX_Z_INDEX_OVERLAY_LOCAL) + ";";
-	style+="margin:auto;";
+	let style="";
+	style+="position:absolute;";
+	style+="left:50%;top:50%;";
 	style+="z-index:" + (MAX_Z_INDEX_OVERLAY_LOCAL) + ";";
-	style+="width:"+WIDTH+";height:"+HEIGHT+"; ";
+	style+="z-index:" + (MAX_Z_INDEX_OVERLAY_LOCAL) + ";";
+	style+="width:"+promptWindowWidth+";height:"+promptWindowHeight+"; ";
 	style+="border:#888888 8px dotted;padding:10px;opacity:1;";
 	style+="font-family:"+font+";";
 	style+="color:"+textColor+";";
@@ -6219,10 +6278,12 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 	
 	divWindow.style=style;
 	
-	
+	divWindow.style["margin-left"]=(-divWindow.offsetWidth/2)+"px";
+	divWindow.style["margin-top"]= (-divWindow.offsetHeight/2)+"px";
+
 	
 	// The label for the title of the window :
-	var labelElement=document.createElement("div");
+	let labelElement=document.createElement("div");
 	labelElement.innerHTML=label;
 	labelElement.style="padding-top:0;padding-bottom:10px;";
 	// Positioning :
@@ -6232,21 +6293,21 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 	// The container containing all the elements :
 	let divContainer=document.createElement("div");
 	divContainer.id="divPromptContainer";
-	divContainer.style="overflow-y:auto;width:100%;height:80%;";
+	divContainer.style="overflow-y:auto;width:100%;max-height:83%;";
 	divWindow.appendChild(divContainer);
 	
 	
 
 	
 	// Eventual validation :
-	var validationFunction=function(value){
+	let validationFunction=function(value){
 		return true;/* DO NOTHING */
 	};
 	validationFunction.errorMessage="";
 	if(!nothing(type) && contains(type, ":")){
-		var typeParams=type.split(":");
+		let typeParams=type.split(":");
 		if(typeParams.length > 1){
-			var validationType=typeParams[1];
+			let validationType=typeParams[1];
 	
 			if(validationType === "email"){
 				validationFunction=function(value){
@@ -6259,19 +6320,20 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 	
 	
 	// We define the global function used to retrieve entered value :
-	var getGlobalResultValue=null;
-	var inputElements=new Array();
+	let getGlobalResultValue=null;
+	const inputElements=[];
 	
 	 // Case the window is actually a form of several fields :
 	if(!nothing(type) && containsIgnoreCase(type, "form{")){
-		var namesWithTypesAndDefaultValuesStr=type.replace("form{", "{");
+		
+		let namesWithTypesAndDefaultValuesStr=type.replace("form{", "{");
 		try {
 	
-			var defaultValues=new Array();
+			let defaultValues=new Array();
 			if(!nothing(defaultValue))	defaultValues=defaultValue.split(SPECIAL_SEPARATOR);
 	
-			var namesWithTypesAndDefaultValues=parseJSON(namesWithTypesAndDefaultValuesStr);
-			var j=0;
+			let namesWithTypesAndDefaultValues=parseJSON(namesWithTypesAndDefaultValuesStr);
+			let j=0;
 			foreach(namesWithTypesAndDefaultValues,(inputItemDescriptionString,key)=>{
 	
 				let typeInputItem=inputItemDescriptionString;
@@ -6293,9 +6355,9 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 	
 			// We redefine the global function used to retrieve entered value :
 			getGlobalResultValue=function(){
-				var result="";
+				let result="";
 	
-				for(var k=0; k<inputElements.length; k++){
+				for(let k=0; k<inputElements.length; k++){
 					result+=(nothing(result) ? "" : SPECIAL_SEPARATOR) + inputElements[k].getResultValue();
 				}
 	
@@ -6303,22 +6365,22 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 			};
 	
 		} catch (e1){
-			var errorDiv=document.createElement("div");
+			let errorDiv=document.createElement("div");
 			errorDiv.innerHTML="Error parsing JSON «" + namesWithTypesAndDefaultValuesStr + "» : ERROR «:" + e1 + "»";
 			inputElements.push(errorDiv);
 		}
 	
 	
-// UNUSED, AND DOES NOT WORK :	
-//	}else if(type==="yesno"){ // Case yes/no
-//
-//		// We redefine the global function used to retrieve entered value :
-//		getGlobalResultValue=function(){
-//			return null;
-//		};
-	}else { // Case of a single field :
+	} else if(type==="yesno"){ // Case yes/no
+
+		// We redefine the global function used to retrieve entered value :
+		getGlobalResultValue=function(){
+			return null;
+		};
+
+	} else { // Case of a single field :
 	
-		var singleInputElement=getRenderedInputElement(type, defaultValue);
+		let singleInputElement=getRenderedInputElement(type, defaultValue);
 		inputElements.push(singleInputElement);
 	
 		// Focus on password field :
@@ -6335,50 +6397,65 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 	// TODO : FIXME : Focus on text field is not working.... :,-(
 //	inputElements[inputElements.length - 1].focus();
 	
-	var buttonCancel=document.createElement("button");
+	// This button is displayed in all cases :
+	let buttonCancel=document.createElement("button");
 	buttonCancel.innerHTML="Cancel";
-	buttonCancel.style="display:block;float:right;margin-top:8px;";
-	buttonCancel.onclick=function(){
-		var promptedValue=getGlobalResultValue();
-		if(doOnCancel){
-			doOnCancel(promptedValue);
-		}
-		closeWindow();
-	};
-	
-	// TODO : FISME : There should be a way to hide this OK button,
-	// when we are in a "radio-image" unique selection case,
-	// since the doOnOK() is triggered when we click on the "radio-image" icon,
-	// thus rendering this OK button unuseful !! :
-	
-	var buttonOK=document.createElement("button");
-	buttonOK.innerHTML="OK";
-	buttonOK.style="display:block;margin-top:8px;margin-bottom:10px;";
-	buttonOK.onclick=function(){
-		var promptedValue=getGlobalResultValue();
-	
-		if(promptedValue!=null && !validationFunction(promptedValue)){
-			// TRACE
-			alert(validationFunction.errorMessage);
-			return;
-		}
+	buttonCancel.style="display:block;float:right;";
+	resultPromiseCancel=new Promise((resolve, reject)=>{ 
+			buttonCancel.onclick=function(){
+				let promptedValue=getGlobalResultValue();
+				if(doOnCancel){
+					const doOnCancelResult=doOnCancel(promptedValue);
+					resolve({value:promptedValue,result:doOnCancelResult});
+				}
+				closeWindow();
+			};
+	});
+	divWindow.appendChild(buttonCancel);
+
 	
-		if(doOnOK){
-			doOnOK(promptedValue);
-		}
-		closeWindow();
-	};
 	
-	for(var i=0; i<inputElements.length; i++){
-		
+	// We hide this OK button, when we are in a "radio-image" unique selection case,
+	// since the doOnOK() is triggered when we click on the "radio-image" icon,
+	// thus rendering this OK button unuseful ! :
+	 if(nothing(type) || !contains(type, "uniqueChoice")){
+	 
+			let buttonOK=document.createElement("button");
+			buttonOK.innerHTML="OK";
+			buttonOK.style="display:block;margin-bottom:10px;";
+			
+			resultPromiseOK=new Promise((resolve, reject)=>{
+				
+					buttonOK.onclick=function(){
+						let promptedValue=getGlobalResultValue();
+					
+						if(promptedValue!=null && !validationFunction(promptedValue)){
+							// TRACE
+							alert(validationFunction.errorMessage);
+							return;
+						}
+					
+						if(doOnOK){
+							const doOnOKResult=doOnOK(promptedValue);
+							resolve({value:promptedValue,result:doOnOKResult});
+						}
+						closeWindow();
+					};
+
+			});		
+			divWindow.appendChild(buttonOK);
+	}
+
+	// Final integration of the generated input elements :
+	for(let i=0; i<inputElements.length; i++){
 		if(0<i){
-			var br=document.createElement("br");
+			const br=document.createElement("br");
 			divContainer.appendChild(br);
 		}
 	
 		// The label :
 		if(inputElements[i].label){
-			var divLabel=document.createElement("div");
+			const divLabel=document.createElement("div");
 			divLabel.innerHTML=inputElements[i].label;
 			divContainer.appendChild(divLabel);
 		}
@@ -6386,14 +6463,16 @@ function promptWindow(label,type=null,defaultValue=null,doOnOK=null,doOnCancel=n
 		divContainer.appendChild(inputElements[i]);
 	}
 	
-	// Positioning :
-	divWindow.appendChild(buttonCancel);
-	divWindow.appendChild(buttonOK);
-	
 
+	return {
+			toPromise:(issue="OK")=>(issue=="OK"?resultPromiseOK:resultPromiseCancel),
+			toPromises:()=>{ return {OK:resultPromiseOK,cancel:resultPromiseCancel}; }
+		};
 }
 
 
+
+
 getInputCoords=function(event){
 	return (((event.clientX && event.clientY) || !event.touches) ? event : event.touches.item(0) );
 }
@@ -6689,66 +6768,419 @@ function getPointsFromSVGDString(str){
 
 
 
-/*utils GEOMETRY library associated with aotra version : «1.0.0.000 (11/01/2022-00:18:33)»*/
-/*-----------------------------------------------------------------------------*/
-
-
-/* ## Utility global methods in a javascript, at least 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 its programming egos legions)
- * # 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;	
-
-
 
-//=========================================================================
-// GLOBAL CONSTANTS :
 
 
-Math.TAU=6.28318530718; // == Math.PI*2
-Math.PSI=1.57079632679; // == Math.PI/2
-Math.TAN_RATIOS_DEGREES={
-	22.5:0.4142135624,
-	45:1,
-	67.5:2.4142135624,
-	112.5:-2.4142135624,
-	135:-1,
-	157.5:-0.4142135624,
-	202.5:0.4142135624,
-	225:1,
-	247.5:2.4142135624,
-	292.5:-2.4142135624,
-	315:-1,
-	337.5:-0.4142135624
-};
-Math.LN_2_INVERTED=1.44269504089; // == 1/ln(2)
 
-Math.INVERSE_OF_SQUARE_OF_TWO=0.707106781;  // == 1/sqrt(2)
-Math.RATIO_TO_DEGREES=57.295779513;  		// == 180/PI
-Math.RATIO_TO_RADIANS=0.017453293;  		// == PI/180
 
+// -Client :
 
+// TODO : Use everywhere it's applicable !
+initClient=function(isNodeContext=true, useSocketIOImplementation=false, doOnServerConnection=null, url, /*OPTIONAL*/port=25000, isSecure=true, /*OPTIONAL*/timeout=10000, /*OPTIONAL*/selfParam=null){
+	let aotraClient={};
+	
+	aotraClient.client={};
+	aotraClient.client.start=function(){
+	
+		
+		let socketToServer=WebsocketImplementation.getStatic(isNodeContext,useSocketIOImplementation).connectToServer(url, port, isSecure, timeout);
+		if(!socketToServer){
+			// TRACE
+			lognow("ERROR : CLIENT : Could not get socketToServer, aborting client connection.");
+			return null;
+		}
+		
+		// When client is connected, we execute the callback :
+		// CAUTION : MUST BE CALLED ONLY ONCE !
+		socketToServer.onConnectionToServer(()=>{
+			if(doOnServerConnection){
+				if(selfParam)	doOnServerConnection.apply(selfParam,[socketToServer]);
+				else				  doOnServerConnection(socketToServer);
+			}
+		});
 
-//=========================================================================
+//		// Errors handling :
+//		if(doOnError && useSocketIOImplementation /*TODO : FIXME: FOR NOW, ONLY WORKS FOR SOCKET.IO IMPLEMENTATION !'*/){
+//			
+////			// DBG
+////			lognow(">>> serverSocket.connected:"+serverSocket.connected);
+////			lognow(">>> serverSocket:",serverSocket);
+//
+//
+//			const errorMethod=function(){
+//				// TRACE
+//				lognow("ERROR : CLIENT : Client encountered an error while trying to connect to server.");
+//				
+//				if(selfParam)	doOnError.apply(selfParam);
+//				else					doOnError();
+//			};
+//			
+//			socketToServer.clientSocket.on("connect_error", errorMethod);
+//				
+////			// DOES NOT SEEM TO WORK :
+////			socketToServer.on("connect_failed", errorMethod);
+////			// DOES NOT SEEM TO WORK :
+////			socketToServer.on("error", errorMethod);
+//			
+//		}
+//
+//		// Data messages handling :
+//		if(doOnMessage){
+//			socketToServer.onIncomingMessage((message)=>{
+//				if(selfParam)	doOnMessage.apply(selfParam,[message]);
+//				else				  doOnMessage(message);
+//			});
+//		}
+		
+		// DBG
+		lognow("aotraClient.clientSocket:",aotraClient.clientSocket);
+		
+		// DBG
+//		aotraClient.clientSocket.addEventListener("close",()=>{
+//			// TRACE
+//			lognow("WARN : CONNECTION CLOSED !");		
+//		});
 
+		
+		aotraClient.client.socketToServer=socketToServer;
+		
+		return aotraClient;
+	};
+	
+	
+	return aotraClient;
+}
 
-// ==================== COMMONS Geometry ====================
+
+
+
+// ========================= FUSRODA CLIENT : =========================
+
+class VNCFrame2D{
+	
+	constructor(url, port=6080, isSecure=true, htmlConfig={parentElement:null,imageMode:"CSSBackground"}, mouseEventsRefreshMillis=100){
+		
+		
+		this.url=url;
+		this.port=port;
+		this.isSecure=isSecure;
+		this.parentElement=nonull(htmlConfig.parentElement, document.body);
+		this.imageMode=htmlConfig.imageMode;
+		this.mouseEventsRefreshMillis=mouseEventsRefreshMillis;
+
+		
+		this.fusrodaClient=null;
+		
+		
+		this.screenAndAudioConfig=null;
+		this.image=null;
+		self.audioCtx=null;
+		
+		if(this.imageMode=="canvas"){
+			this.canvas=document.createElement("canvas");
+			this.parentElement.appendChild(this.canvas);
+		}
+		
+		this.lastPointerMoveTime=null;
+		
+	}
+	
+	
+	start(){
+
+		const self=this;
+		this.fusrodaClient=createFusrodaClient(
+			// doOnClientReady:
+			(messageConfig)=>{
+				
+					self.screenAndAudioConfig=messageConfig;
+
+					if(self.imageMode=="canvas"){
+						self.image=new Image();
+						self.image.addEventListener("load",(event)=>{
+							
+							
+							
+							const image=event.target;
+							image.isImageLoading=false;
+							
+							if(!self.canvasSizeHasBeenSet){
+								self.canvas.width=image.width;
+								self.canvas.height=image.height;
+								self.canvasSizeHasBeenSet=true;
+							}
+
+							self.canvas.getContext("2d").drawImage(image,0,0);
+
+							
+							self.fusrodaClient.client.socketToServer.send("screenFrameRequest", {});
+
+						});
+						
+					}
+
+					
+					self.audioCtx=new AudioContext({sampleRate: self.screenAndAudioConfig.sampleRate});
+					
+				
+			},// doOnDataReception:
+				{
+				"image":(imageDataStr)=>{
+					
+					
+					const base64String="data:image/png;base64,"+imageDataStr;
+					if(self.imageMode=="canvas"){
+						if(self.image.complete){
+							self.image.src=base64String;
+							self.image.isImageLoading=true;
+						}
+					}else{
+						self.parentElement.style["background-image"]="url('"+base64String+"');";
+					}
+					
+					
+				},
+				"sound":(soundDataStr)=>{
+					const soundData=getDecodedArrayFromSoundDataString(soundDataStr);
+					playAudioData(soundData,self.audioCtx,self.screenAndAudioConfig.audioBufferSize,1,self.screenAndAudioConfig.sampleRate,()=>{
+						// doOnEndedPlaying
+						
+						self.fusrodaClient.client.socketToServer.send("soundSampleRequest", {});
+
+					});
+				}
+		}, this.url, this.port, this.isSecure);
+
+
+		// TODO : FIXME : DUPLICATED CODE !
+		this.parentElement.addEventListener("pointermove",(event)=>{
+			
+			const config=self.screenAndAudioConfig;
+			if(!config || !self.canvas.width)	return;
+			
+			
+			if(!hasDelayPassed(self.lastPointerMoveTime,self.mouseEventsRefreshMillis))	return;
+			self.lastPointerMoveTime=getNow();
+			
+		
+			const width=config.width;
+			const height=config.height;
+			
+			const x=Math.floor((event.clientX/self.canvas.width)*width);
+			const y=Math.floor((event.clientY/self.canvas.height)*height);
+			
+			
+			self.fusrodaClient.sendMouseMoveEvent({x:x,y:y});
+			
+			// DBG
+			lognow("sendMouseMoveEvent:"+x+";"+y);
+			
+		});
+		// TODO : FIXME : DUPLICATED CODE !
+		this.parentElement.addEventListener("mousedown",(event)=>{
+			const mouseButton=event.button;
+			self.fusrodaClient.sendMouseClickEvent({mouseButton:mouseButton});
+			
+			// DBG
+			lognow("mousedown:",event);
+		});
+		// TODO : FIXME : DUPLICATED CODE !
+		this.parentElement.addEventListener("mouseup",(event)=>{
+			const mouseButton=event.button;
+			self.fusrodaClient.sendMouseReleasedEvent({mouseButton:mouseButton});
+		});
+		// TODO : FIXME : DUPLICATED CODE !
+		const WHEEL_EVENT_FACTOR=.01;
+		this.parentElement.addEventListener("wheel",(event)=>{
+			const wheelAmount=event.deltaY*WHEEL_EVENT_FACTOR;
+			self.fusrodaClient.sendWheelEvent({wheelAmount:wheelAmount});
+			
+			// DBG
+			lognow("wheel:",event);
+		});
+		// TODO : FIXME : DUPLICATED CODE !
+		// To remove the local contextual menu :
+		this.parentElement.addEventListener("contextmenu",(event)=>{event.preventDefault();});
+		
+		// TODO : FIXME : DUPLICATED CODE !
+		this.parentElement.addEventListener("keydown",(event)=>{
+			let keyChar=event.key;
+			const keyCode=event.keyCode;
+			
+			// To avoid server-side «A JSONObject text must end with '}'» errors :
+			if(keyChar==="{")	keyChar="left_brace";
+			if(keyChar==="}")	keyChar="right_brace";
+			self.fusrodaClient.sendKeyboardPressedEvent({keyChar:keyChar,keyCode:keyCode});
+		});
+		// TODO : FIXME : DUPLICATED CODE !
+		this.parentElement.addEventListener("keyup",(event)=>{
+			let keyChar=event.key;
+			const keyCode=event.keyCode;
+			// DBG
+			lognow("!!! keydown KEYUP event:[event.key:"+event.key+"][keyCode:"+keyCode+"][keyChar:"+keyChar+"]",event);
+
+			// To avoid server-side «A JSONObject text must end with '}'» errors :
+			if(keyChar==="{")	keyChar="left_brace";
+			if(keyChar==="}")	keyChar="right_brace";
+			self.fusrodaClient.sendKeyboardReleasedEvent({keyChar:keyChar,keyCode:keyCode});
+		});
+		
+
+
+		this.fusrodaClient.client.start();
+
+
+		return this;
+	}
+	
+}
+
+
+
+/*private*/getDecodedArrayFromSoundDataString=function(soundDataStr){
+	const decodedIntsArray=[];
+					
+	const decodedString=atob(soundDataStr);
+					
+//// DBG
+//const decodedString=soundDataStr;
+
+	for(let i=0;i<decodedString.length;i++){
+		const dataInt=decodedString.charCodeAt(i)-127;
+		
+		// CAUTION : audio needs to be in [-1.0; 1.0]
+		decodedIntsArray.push(dataInt/127);
+	}
+
+	return decodedIntsArray;
+}
+
+
+
+createFusrodaClient=function(doOnClientReady, doOnDataReception, urlParam=null, portParam=6080){
+ 	// CAUTION : WORKS BETTER WHEN UNSECURE, BUT 'NEEDS CLIENT BROWSER TO ALLOW MIXED (SECURE/UNSECURE) CONTENT !
+	
+	const isSecure=(contains(urlParam.toLowerCase(),"https") || contains(urlParam.toLowerCase(),"wss"));
+	
+	
+	const fusrodaClient=initClient(false,true, (browserClientInstance)=>{
+		
+		// DBG
+		lognow("SETTING UP");
+		
+		//0)
+		fusrodaClient.client.socketToServer.send("protocol", { type:"hello" });
+		//1)
+		browserClientInstance.receive("protocolConfig", (messageConfig)=>{
+			//2)			
+			fusrodaClient.client.socketToServer.send("screenFrameRequest", {});
+			browserClientInstance.receive("imagePacket", (doOnDataReception && doOnDataReception["image"]?doOnDataReception["image"]:()=>{/*DO NOTHING*/}));
+
+			//2)			
+			fusrodaClient.client.socketToServer.send("soundSampleRequest", {});
+			browserClientInstance.receive("soundPacket", (doOnDataReception && doOnDataReception["sound"]?doOnDataReception["sound"]:()=>{/*DO NOTHING*/}));
+
+
+			doOnClientReady(messageConfig);
+		});
+
+		
+	}, urlParam, portParam, isSecure);
+	
+	fusrodaClient.sendMouseMoveEvent=(mouseEvent)=>{
+		fusrodaClient.client.socketToServer.send("mouseMoveEvent", mouseEvent);
+	};
+		
+	fusrodaClient.sendMouseClickEvent=(mouseEvent)=>{
+		fusrodaClient.client.socketToServer.send("mouseClickEvent", mouseEvent);
+	};
+	fusrodaClient.sendMouseReleasedEvent=(mouseEvent)=>{
+		fusrodaClient.client.socketToServer.send("mouseReleasedEvent", mouseEvent);
+	};
+	fusrodaClient.sendWheelEvent=(wheelEvent)=>{
+		fusrodaClient.client.socketToServer.send("wheelEvent", wheelEvent);
+	};
+
+	fusrodaClient.sendKeyboardPressedEvent=(keyboardEvent)=>{
+		fusrodaClient.client.socketToServer.send("keyboardPressedEvent", keyboardEvent);
+	};
+	fusrodaClient.sendKeyboardReleasedEvent=(keyboardEvent)=>{
+		fusrodaClient.client.socketToServer.send("keyboardReleasedEvent", keyboardEvent);
+	};
+
+	
+
+//	// DBG
+//	fusrodaClient.clientSocket.addEventListener("close",()=>{
+//		lognow("CONNECTION CLOSED !");		
+//	});
+	
+	return fusrodaClient;
+}
+
+
+
+
+/*utils GEOMETRY library associated with aotra version : «1.0.0.000 (11/07/2022-00:48:13)»*/
+/*-----------------------------------------------------------------------------*/
+
+
+/* ## Utility global methods in a javascript, at least 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 its programming egos legions)
+ * # 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;	
+
+
+
+//=========================================================================
+// GLOBAL CONSTANTS :
+
+
+Math.TAU=6.28318530718; // == Math.PI*2
+Math.PSI=1.57079632679; // == Math.PI/2
+Math.TAN_RATIOS_DEGREES={
+	22.5:0.4142135624,
+	45:1,
+	67.5:2.4142135624,
+	112.5:-2.4142135624,
+	135:-1,
+	157.5:-0.4142135624,
+	202.5:0.4142135624,
+	225:1,
+	247.5:2.4142135624,
+	292.5:-2.4142135624,
+	315:-1,
+	337.5:-0.4142135624
+};
+Math.LN_2_INVERTED=1.44269504089; // == 1/ln(2)
+
+Math.INVERSE_OF_SQUARE_OF_TWO=0.707106781;  // == 1/sqrt(2)
+Math.RATIO_TO_DEGREES=57.295779513;  		// == 180/PI
+Math.RATIO_TO_RADIANS=0.017453293;  		// == PI/180
+
+
+
+//=========================================================================
+
+
+// ==================== COMMONS Geometry ====================
 
 
 
@@ -6893,6 +7325,14 @@ Math.polarPositionRadiansToCartesianPosition3D=(distance,gamma,alpha,xOffset=0,y
 	return {x:x,y:y,z:z};
 }
 
+// DOES NOT SEEM TO WORK :
+//Math.getArcCoordinatesOnSphereFromCartesianVector=function(vector3D,sphereRadius=1){
+//	const zAxisAngle=(vector3D.x==0?Math.PI*.5:Math.atan(vector3D.y/vector3D.x));
+//	const yAxisAngle=(vector3D.z==0?0:Math.atan(vector3D.x/vector3D.z));
+//	const y=yAxisAngle*sphereRadius;
+//	const x=zAxisAngle*sphereRadius;
+//	return {x:x,y:y};
+//}
 
 
 Math.expApprox=function(x){
@@ -7005,9 +7445,9 @@ window.calculateAngleRadians2D=function(p1, p2, approximate=false){
 //}
 
 window.calculateAngleRadians3D=function(p1, p2, approximate=false){
-	let a=calculateAngleRadians2D({x:p1.x, y:p1.z}, {x:p2.x, y:p2.z}, approximate);
-	let b=calculateAngleRadians2D({x:p1.x, y:p1.y}, {x:p2.x, y:p2.y}, approximate);
-	let g=calculateAngleRadians2D({x:p1.z, y:p1.y}, {x:p2.z, y:p2.y}, approximate);
+	let a=calculateAngleRadians2D({x:p1.x, y:p1.y}, {x:p2.x, y:p2.y}, approximate); // alpha => angle [x,y]
+	let b=calculateAngleRadians2D({x:p1.z, y:p1.y}, {x:p2.z, y:p2.y}, approximate); // beta  => angle [z,y]
+	let g=calculateAngleRadians2D({x:p1.x, y:p1.z}, {x:p2.x, y:p2.z}, approximate); // gamma => angle [x,z]
 	return {a:a, b:b, g:g};
 }
 
@@ -7017,15 +7457,21 @@ window.calculateLinearlyMovedPoint2DPolar=function(currentPoint, angleRadians, l
 	return {x:x, y:y};
 }
 
+
+// NEW : WE ACTUALL ONLY NEED 2 ANGLES ! BETA angle in plan [Z,Y] AND GAMMA angle in plan [X,Z] !
 window.calculateLinearlyMovedPoint3DPolar=function(currentPoint, anglesRadians, linearMotion){
+
+// IN THIS NORM (MOBILE NORM:)
+// alpha => angle [x,y]
+// beta  => angle [z,y]
+// gamma => angle [x,z]
+
+	let translatedBeta= calculateLinearlyMovedPoint2DPolar({x:currentPoint.z, y:currentPoint.y}, anglesRadians.b, linearMotion);
+	let translatedGamma=calculateLinearlyMovedPoint2DPolar({x:currentPoint.x, y:currentPoint.z}, anglesRadians.g, linearMotion);
 	
-	let translatedAlpha=calculateLinearlyMovedPoint2DPolar({x:currentPoint.x, y:currentPoint.z}, anglesRadians.a, linearMotion);
-	let translatedBeta= calculateLinearlyMovedPoint2DPolar({x:currentPoint.x, y:currentPoint.y}, anglesRadians.b, linearMotion);
-	let translatedGamma=calculateLinearlyMovedPoint2DPolar({x:currentPoint.z, y:currentPoint.y}, anglesRadians.g, linearMotion);
-	
-	let x=translatedAlpha.x+translatedBeta.x;
-	let y=									translatedBeta.y+translatedGamma.y;
-	let z=translatedAlpha.y									+translatedGamma.x;
+	let x=translatedGamma.x;
+	let y=translatedBeta.y;
+	let z=translatedBeta.x;
 	
 	return {x:x, y:y, z:z};
 }
@@ -7493,12 +7939,6 @@ Math.getQuadrant=function(centerPoint,point){
 
 
 
-
-
-
-
-
-
 Math.compareDistances=function(p1, p2, distance, comparison){
 	let distanceSquare=Math.pow(distance, 2);
 	let diffSquare=Math.getSquaredDistance(p1, p2);
@@ -7516,7 +7956,7 @@ Math.compareDistances=function(p1, p2, distance, comparison){
 };
 
 Math.getSquaredDistance=function(p1, p2){
-	return Math.pow(Math.abs(p1.x - p2.x), 2) + Math.pow(Math.abs(p1.y - p2.y), 2);
+	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){
@@ -7886,7 +8326,8 @@ function rayVsUnitSphereClosestPoint(p, r) {
 
 // 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 (11/01/2022-00:18:33)»*/
+AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
+/*utils SERVER library associated with aotra version : «1.0.0.000 (11/07/2022-00:48:13)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -8084,23 +8525,31 @@ getServerParams=function(portParam,isSecureParam,certPathParam,keyPathParam){
 // NODE ONLY SERVER / CLIENTS : 
 WebsocketImplementation={
 		
-		isNode:true,
+		isNodeContext:true,
+		useSocketIOImplementation:false,
+		useFlatStrings:false,
 		
 		// COMMON METHODS
 		/*private static*/isInRoom(clientSocket, clientsRoomsTag){
 			return !clientsRoomsTag || empty(clientsRoomsTag) || contains(clientsRoomsTag, clientSocket.clientRoomTag);
 		},
 		
-		// NODE SERVER
 		
-		getStatic:(isNode=true)=>{
+		//
+		// NODE SERVER
+		//
+		getStatic:(isNodeContext=true, useSocketIOImplementation=false)=>{
 			
-			WebsocketImplementation.isNode=isNode;
+			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.");
@@ -8139,30 +8588,38 @@ WebsocketImplementation={
 		
 		getServer:(listenableServer)=>{
 			
-			if(!WebsocketImplementation.isNode){
+			if(!WebsocketImplementation.isNodeContext){
 				// TRACE
-				throw new Error("ERROR : SERVER : Server launch is not supported in a non-nodejs context.");
+				throw new Error("ERROR : SERVER : Server launch is not supported in a non-nodejs context for any implementation.");
 			}
 			
-			// OLD : socket.io :
-//			// Loading socket.io
-//			let serverSocket=socketIO.listen(listenableServer);
-			
-			const serverSocket=new WebSocket.Server({ "server":listenableServer });
+			// 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={
 					
-					clientTimeoutMillis:20000,
-					
-//					clientsSockets:[],
+					onClientLostListeners:[],
 					
+					clientTimeoutMillis:20000,
+//				clientsSockets:[],
 					serverSocket:serverSocket,
-					
 					receptionEntryPoints:[],
 					
-					
-					
 					receive:(channelName, doOnIncomingMessage, clientsRoomsTag=null)=>{
 						
 						const receptionEntryPoint={
@@ -8172,41 +8629,40 @@ WebsocketImplementation={
 
 								
 							// With «ws» library we have no choive than register message events inside a «connection» event !
-//							nodeServerInstance.onConnectionToClient((serverParam, clientSocketParam)=>{
+//						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);
 
-								// TODO : Find a way to remove this !
+								
+								// Channel information is stored in exchanged data :
+								if(dataWrapped.channelName!==receptionEntryPoint.channelName) return;
 
-								clientSocketParam.on("message", (dataWrapped)=>{
-									
-									dataWrapped=JSON.parse(dataWrapped);
-									
-									
-									// 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);
 									
-//									nodeServerInstance.serverSocket.clients.forEach((clientSocket)=>{
-									
-									const clientSocket=clientSocketParam;
+						   };
 
-									// 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);
+
 
 								
 								
 							},
 						};
 						
-						
 						// DBG
 						console.log("ADD RECEPTION ENTRY POINT channelName:«"+channelName+"»! nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
 						
@@ -8219,11 +8675,22 @@ WebsocketImplementation={
 					
 					send:(channelName, data, clientsRoomsTag=null, clientSocketParam=null)=>{
 						
+						
 						if(!clientSocketParam){
 							
-						    nodeServerInstance.serverSocket.clients.forEach((clientSocket)=>{
+								// 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;
+
 						    	
-						    	if(clientSocket.readyState!==WebSocket.OPEN)	return;
 		
 									// Room information is stored in client socket object :
 							   	if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
@@ -8234,14 +8701,19 @@ WebsocketImplementation={
 						      
 									dataWrapped=JSON.stringify(dataWrapped);
 									
-					      	clientSocket.send(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(clientSocket.readyState!==WebSocket.OPEN)	return;
+							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;
@@ -8249,10 +8721,12 @@ WebsocketImplementation={
 			      	// Channel information is stored in exchanged data :
 				      let dataWrapped={channelName:channelName, data:data};
 			      	
-				      
 							dataWrapped=JSON.stringify(dataWrapped);
 							
-			      	clientSocket.send(dataWrapped);
+							// TODO : FIXME : Use one single interface !
+							if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+			      	else																										clientSocket.emit(channelName,dataWrapped);
+			      	
 			      	
 						}
 				    
@@ -8293,23 +8767,45 @@ WebsocketImplementation={
 							
 							
 							
-							
-							
 							// To make the server aware of the clients connections states :
 							clientSocket.stateCheckInterval=setInterval(()=>{
+								
+								
 							    if (clientSocket.isAlive===false){
 			    				 	clearInterval(clientSocket.stateCheckInterval);
 			    				 	
-							    	return clientSocket.terminate();
+	    				 			// 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 :
-							    	clientSocket.terminate();
+
+										// 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;
@@ -8354,7 +8850,12 @@ WebsocketImplementation={
 			
 			// To make the server aware of the clients connections states :
 			nodeServerInstance.serverSocket.on("close", function close() {
-				nodeServerInstance.serverSocket.clients.forEach((clientSocket)=>{
+				
+				// 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);
 				});
 			});
@@ -8365,39 +8866,26 @@ WebsocketImplementation={
 		},
 		
 		
-		// CLIENT
-		connectToServer:(serverURL, port, timeout)=>{
-			if(WebsocketImplementation.isNode)
-				return WebsocketImplementation.connectToServerFromNode(serverURL, port, timeout);
-			// else
-			return WebsocketImplementation.connectToServerFromBrowser(serverURL, port, timeout);
-		},
-		
-		
+		// NODE / BROWSER CLIENT CONNECTS TO SERVER MAIN ENTRYPOINT:
+		connectToServer:(serverURL, port, isSecure=false, timeout)=>{
 
+			// 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, timeout)=>{
+		//
+		/*private*/connectToServerFromNode:(serverURL, port, isSecure, timeout)=>{
+			
 			
-			// OLD : socket.io :
-			//client on server-side:
-			//if(typeof(socketIO)!=="undefined"){
-//		// Node client :
-//		connectToServer=function (server, port, timeout=10000){
-//			return socketIO.connect(server + ":" + port,{timeout: timeout});;
-//		}
-			//}else
-//			if(typeof(io)!=="undefined"){
-//				// Browser client :
-//				connectToServer=function (server, port, timeout=10000){
-//					return io.connect(server + ":" + port,{timeout: timeout});
-////				ALTERNATIVE : return io(server + ":" + port,{timeout: timeout});
-//				};
-//			}else{
-//				// TRACE
-//				console.log("ERROR : Could not initialize socket !");
-//			}
 			
 			// NEW : ws :
 			if(typeof(WebSocket)==="undefined"){
@@ -8405,32 +8893,46 @@ WebsocketImplementation={
 				lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
 				return null;
 			}
-				
-			const clientSocket=new WebSocket(serverURL+":"+port,/*WORKAROUND:*/{ rejectUnauthorized:false });
-			
 			
+			// 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)=>{
 									
-									
-									nodeClientInstance.clientSocket.on("message", (dataWrapped)=>{
+									const doOnMessage=(message)=>{
 										
-										dataWrapped=JSON.parse(dataWrapped);
+//									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!==channelName) return;
+										if(dataWrapped.channelName && dataWrapped.channelName!==channelName) return;
 										
 										let clientSocket=nodeClientInstance.clientSocket;
 										
@@ -8439,8 +8941,11 @@ WebsocketImplementation={
 										
 										doOnIncomingMessage(dataWrapped.data, clientSocket);
 										
-										
-									});
+									};
+									
+									if(!WebsocketImplementation.useSocketIOImplementation)	nodeClientInstance.clientSocket.addEventListener("message", doOnMessage);
+									else																										nodeClientInstance.clientSocket.on(channelName, doOnMessage);
+
 									
 								}
 						};
@@ -8448,7 +8953,6 @@ WebsocketImplementation={
 						
 						nodeClientInstance.receptionEntryPoints.push(receptionEntryPoint);
 						
-						
 						return nodeClientInstance;
 					},
 					
@@ -8461,8 +8965,10 @@ WebsocketImplementation={
 //			    // DBG
 //			    console.log("(NODE CLIENT) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
 
-			    	
-			    	if(clientSocket.readyState!==WebSocket.OPEN)	return;
+						// 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;
@@ -8482,8 +8988,9 @@ WebsocketImplementation={
 //			            console.log("(NODE CLIENT) SENDING DATA ! channelName:«"+channelName+"» ; clientsRoomsTag:«"+clientsRoomsTag+"»");
 //			            console.log("(NODE CLIENT) SENDING DATA ! dataWrapped:",dataWrapped);
 	
-	
-				     clientSocket.send(dataWrapped);
+						// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+		      	else																										clientSocket.emit(channelName,dataWrapped);
 						
 						return nodeClientInstance;
 					},
@@ -8492,14 +8999,19 @@ WebsocketImplementation={
 					join:(clientRoomTag)=>{
 						// Join room client part protocol :
 						const message={type:"joinRoom",clientRoomTag:clientRoomTag};
+						
 						nodeClientInstance.send("protocol",message);
 						
 					},
 					
 					
 					onConnectionToServer:(doOnConnection)=>{
-
-						nodeClientInstance.clientSocket.on("open", ()=>{
+						
+						const doAllOnConnection=()=>{
+							
+							// To avoid triggering this event several times, depending on the implementation : 
+							if(nodeClientInstance.hasConnectEventFired)	return;
+							nodeClientInstance.hasConnectEventFired=true;
 							
 							let clientSocket=nodeClientInstance.clientSocket;
 							
@@ -8510,7 +9022,11 @@ WebsocketImplementation={
 								receptionEntryPoint.execute(clientSocket);
 							});
 							
-						});
+						};
+
+						if(!WebsocketImplementation.useSocketIOImplementation)	nodeClientInstance.clientSocket.addEventListener("open",doAllOnConnection);
+						else																										nodeClientInstance.clientSocket.on("connect",doAllOnConnection);
+						
 					},
 					
 				
@@ -8524,7 +9040,7 @@ WebsocketImplementation={
 		
 		// BROWSER CLIENT
 		
-		/*private*/connectToServerFromBrowser:(serverURL, port, timeout)=>{
+		/*private*/connectToServerFromBrowser:(serverURL, port, isSecure, timeout)=>{
 			
 			// NEW : ws :
 			if(typeof(WebSocket)==="undefined"){
@@ -8532,23 +9048,49 @@ WebsocketImplementation={
 				lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
 				return null;
 			}
-				
-			const clientSocket=new WebSocket(serverURL+":"+port,["wss"]);
+			
+			// 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)=>{
+
+						// DBG
+						lognow("!!! SETTING UP RECEIVE for :",channelName);
 						
-						browserInstance.clientSocket.addEventListener("message", (event)=>{
+						const doOnMessage=(message)=>{
 							
-								let dataWrapped=JSON.parse(event.data);
-	
-	
+//							// 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
+
+								const dataWrapped=(WebsocketImplementation.useFlatStrings?JSON.parse(message):message);
+							
+								
 								// Channel information is stored in exchanged data :
-								if(dataWrapped.channelName!==channelName) return;
+								if(dataWrapped.channelName && dataWrapped.channelName!==channelName) return;
 	
 								let clientSocket=browserInstance.clientSocket;
 	
@@ -8557,9 +9099,14 @@ WebsocketImplementation={
 	
 								doOnIncomingMessage(dataWrapped.data, clientSocket);
 					    	
-					    });
+					    };
+					   
+					    
+					   if(!WebsocketImplementation.useSocketIOImplementation)	browserInstance.clientSocket.addEventListener("message", doOnMessage);
+						 else																										browserInstance.clientSocket.on(channelName, doOnMessage);
+
 						
-						return browserInstance;
+						 return browserInstance;
 					},
 					
 					
@@ -8571,8 +9118,10 @@ WebsocketImplementation={
 //					// DBG
 //					console.log("(BROWSER) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
 
-            
-						if(clientSocket.readyState!==WebSocket.OPEN)	return;
+						// 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;
@@ -8587,7 +9136,11 @@ WebsocketImplementation={
             
 						dataWrapped=JSON.stringify(dataWrapped);
 
-				   	clientSocket.send(dataWrapped);
+				   	
+		   				// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+		      	else																										clientSocket.emit(channelName,dataWrapped);
+
 						
 						return browserInstance;
 					},
@@ -8601,7 +9154,15 @@ WebsocketImplementation={
 					
 					
 					onConnectionToServer:(doOnConnection)=>{
-						browserInstance.clientSocket.addEventListener("open",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);
+						
+						
 					},
 					
 				
@@ -8732,7 +9293,7 @@ launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /
 	
 
 	// TRACE
-	console.log("INFO : SERVER : Generic Nodejs server launched and listening on port " + port + "!");
+	console.log("INFO : SERVER : Generic Nodejs server launched and listening on port:" + port + "!");
 
 
 	return server;
@@ -8743,7 +9304,7 @@ initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OP
 
 	// TRACE
 	console.log("Server launched.");
-	console.log("Usage :							node <server.js> [port] [ssl certificate path | unsecure ] [ssl key path]");
+	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> <clearText>");
 	// 			EXAMPLE : 							node orita-srv.js hash orita.global@saltkey 1234567890
 	console.log("Server launched.");
@@ -8753,30 +9314,46 @@ initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OP
 	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")	argCLPort=val;
-			 else				isHashAsked=true;	
+			if(val==="hash")		isHashAsked=true;
 		}else if(i==3){
-			if(!isHashAsked)	argCLCertPath=val;
-			else				persisterId=val;
+			if(!isHashAsked){
+				try{
+					const jsonConf=JSON.parse(val);	
+					argCLPort=jsonConf.port;
+					argCLCertPath=jsonConf.sslCertPath;
+					argCLKeyPath=jsonConf.sslKeyPath;
+					try{
+						serverConfig=nonull({},JSON.parse(jsonConf.serverConfig));
+					}catch(err1){
+						lognow("ERROR : Cannot parse JSON string «"+jsonConf.serverConfig+"».",err1);
+					}
+				}catch(err2){
+					lognow("ERROR : Cannot parse JSON string «"+val+"».",err2);
+					isHashAsked=true;
+				}
+			}	else						persisterId=val;
 		}else if(i==4){
-			if(!isHashAsked)	argCLKeyPath=val;
-			else				clearTextParam=val;
+			if(isHashAsked)		clearTextParam=val;
 		}
 	});
-	
 	isForceUnsecure=(argCLCertPath==="unsecure");
-		
-	let aotraNodeServer={};
+	
+	
+	
+	const aotraNodeServer={config:serverConfig};
 	aotraNodeServer.serverManager={ start:()=>{/*DEFAULT START FUNCTION, WILL BE OVERRIDEN LATER*/}};
 
 	if(isHashAsked){
@@ -8820,8 +9397,6 @@ initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OP
 	}
 
 	
-
-	
 	const DEFAULT_PORT=nonull(argCLPort,25000);
 	const DEFAULT_CERT_PATH=nonull(argCLCertPath,"cert.pem");
 	const DEFAULT_KEY_PATH=nonull(argCLKeyPath,"key.key");
@@ -8838,9 +9413,9 @@ initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OP
 
 	
 	// UNUSEFUL :
-//	aotraNodeServer.serverManager.microClientsSockets=[];
+//aotraNodeServer.serverManager.microClientsSockets=[];
 	// UNUSEFUL :
-//	aotraNodeServer.serverManager.mainClientsSockets=[];
+//aotraNodeServer.serverManager.mainClientsSockets=[];
 	aotraNodeServer.serverManager.start=function(){
 
 		// Eventual encryption options : 
@@ -8871,147 +9446,181 @@ initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OP
 	return aotraNodeServer;
 }
 
+// ========================= FUSRODA SERVER : =========================
 
-// -Client :
+//
+// 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;
+//}
 
-// TODO : Use everywhere it's applicable !
-initClient=function(isNode=true, doOnServerConnection=null, doOnError=null, url, /*OPTIONAL*/port=25000, /*OPTIONAL*/timeout=10000, /*OPTIONAL*/selfParam=null){
-	let aotraClient={};
 
-	
-	aotraClient.client={};
-	aotraClient.client.start=function(){
-	
+// ========================= 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");
 		
-		let socketToServer=WebsocketImplementation.getStatic(isNode).connectToServer(url, port, timeout);
-		if(!socketToServer){
+		this.itemsInfos={};
+		this.time=null;
+		this.started=false;
+	}
+	
+	addItem(id,item){
+		if(id==null){
 			// TRACE
-			lognow("ERROR : CLIENT : Could not get socketToServer, aborting client connection.");
-			return null;
+			lognow("ERROR : Cannot add item with no id.");
+			return;
 		}
-		
-		// When client is connected, we execute the callback :
-		// CAUTION : MUST BE CALLED ONLY ONCE !
-		socketToServer.onConnectionToServer(()=>{
-			if(doOnServerConnection){
-				if(selfParam)	doOnServerConnection.apply(selfParam,[socketToServer]);
-				else			doOnServerConnection(socketToServer);
-			}
-		});
-
-		// Errors handling :
-		if(doOnError){
-			
-//			// DBG
-//			lognow(">>> serverSocket.connected:"+serverSocket.connected);
-//			lognow(">>> serverSocket:",serverSocket);
-
-
-			const errorMethod=function(){
-				// TRACE
-				lognow("ERROR : CLIENT : Client encountered an error while trying to connect to server.");
-				
-				if(selfParam)	doOnError.apply(selfParam);
-				else			doOnError();
-			};
-			
-//			// DOES NOT SEEM TO WORK :
-//			socketToServer.on("connect_failed", errorMethod);
-//			// DOES NOT SEEM TO WORK :
-//			socketToServer.on("error", errorMethod);
-			
+		if(!item){
+			// TRACE
+			lognow("ERROR : Cannot add null item.");
+			return;
 		}
-
-		
-		aotraClient.client.socketToServer=socketToServer;
-		
-		return aotraClient;
-	};
-	
+		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(),
+		};
+	}
 	
-	return aotraClient;
-}
-
-
-
-
-// ===================================================================================================
-
-/*FUSRODA server stands from FSRD SERVER, for Fucking Simple Remote Desktop SERVER*/
-createFusrodaServer=function(certPathParam=null,keyPathParam=null,portParam=6001){
+	startSession(){
+		this.time==getNow();
+		this.started=true;
+	}
 	
-	// https://www.npmjs.com/package/screenshot-desktop
-	// https://github.com/octalmage/robotjs
-	// npm install --save screenshot-desktop robotjs
+	stopSession(){
+		this.started=false;
+	}
 	
-	const screenshot=require("screenshot-desktop");
-
-	const REFRESH_SCREENSHOTS_MILLIS=500;
-
+	isSessionActive(){
+		if(!this.sessionDurationSeconds)	return true;
+		if(!this.started)									return false;
+		return !hasDelayPassed(this.time, this.sessionDurationSeconds*1000);
+	}
 	
-	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) => {
+	isClientActive(clientId){
+		if(!clientsListManager.isSessionActive())	return false;
+		const clientPosition=this.getItemPosition(clientId);
+		const result=(clientPosition<=this.maxItemsNumber);
+		return result;
+	}
 	
-					const data={image:img};
-					serverParam.send("data_fusroda", 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=6001)=>{
-//		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
-//	};
-
-	return server;
-}
-
+	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;
+	}
 
-createFusrodaClient=function(doOnDataReception, urlParam=null,portParam=6001){
 	
-	const isNode=false;
-	const client=WebsocketImplementation.getStatic(isNode).connectToServer(urlParam, portParam);
-	client.onConnectionToServer((nodeClientInstance)=>{
-		
-			nodeClientInstance.send("protocol_fusroda");
+}
 
-			nodeClientInstance.receive("data_fusroda", doOnDataReception, "clients");
-		
-	});
-	
-	return client;
+function getListManager(config){
+	return new ListManager(config);
 }
 
 
@@ -9020,7 +9629,8 @@ createFusrodaClient=function(doOnDataReception, urlParam=null,portParam=6001){
 
 
 
-/*utils COMMONS library associated with aotra version : «1.0.0.000 (11/01/2022-00:18:33)»*/
+
+/*utils COMMONS library associated with aotra version : «1.0.0.000 (11/07/2022-00:48:13)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -10884,9 +11494,9 @@ window.LZWString={
 	
 	readBits : function(numBits, data){
 	var res=0;
-	var maxpower=Math.pow(2,numBits);
+	var maxPower=Math.pow(2,numBits);
 	var power=1;
-	while (power!=maxpower){
+	while (power!=maxPower){
 	 res |= this.readBit(data) * power;
 	 power <<= 1;
 	}
@@ -11230,6 +11840,31 @@ window.copy=function(array){
 	return result;
 }
 
+
+
+window.removeByIndex=function(array, elementIndex){
+	if(array instanceof Array){
+		if(empty(array))	return false;
+		if(elementIndex<0)	return false;
+		array.splice(elementIndex, 1);
+		return true;
+	} 
+	let hasDeleted=false;
+	// Case of regular objects that are like associative arrays :
+	let i=0;
+	for (key in array){
+		if(!array.hasOwnProperty(key)) continue;
+		if(i===elementIndex){
+			delete array[key];
+			hasDeleted=true;
+			break;
+		}
+		i++;
+	}
+	return hasDeleted;
+}
+
+
 window.remove=function(array, element){
 	if(array instanceof Array){
 		if(empty(array))	return false;
@@ -11335,15 +11970,41 @@ Math.minInArray=function(arrayOfValues){
 	return min;
 };
 
+
+
 // TODO : FIXME : Create a namespace MathUtils. and ArraysUtils. and sort out the corresponding static methods.
-Math.getRandomInArray=function(arrayOfValues){
-	if(empty(arrayOfValues))
-		return null;
-	var size=getArraySize(arrayOfValues);
+Math.getRandomsInArray=function(arrayOfValues, numberOfItemsToGet=1){
+	
+	if(numberOfItemsToGet<0 || empty(arrayOfValues))	return [];
+	const size=getArraySize(arrayOfValues);
+	// We skip a costly random calculation if we have only one element in array :
+	if(size===1)	return [valueAt(arrayOfValues,0)];
+	
+	const indexesPool=[];
+	for(let i=0;i<size;i++)		indexesPool.push(i);
+	
+	const results=[];	
+	for(let i=0;i<numberOfItemsToGet;i++){
+		if(empty(indexesPool))	break;
+		const chosenIndex=Math.getRandomInArray(indexesPool,true);
+		const item=valueAt(arrayOfValues,chosenIndex);
+		results.push(item);
+	}
+
+	return results;
+}
+
+// TODO : FIXME : Create a namespace MathUtils. and ArraysUtils. and sort out the corresponding static methods.
+Math.getRandomInArray=function(arrayOfValues,removeFromArray=false){
+	if(empty(arrayOfValues))	return null;
+	const size=getArraySize(arrayOfValues);
 	// We skip a costly random calculation if we have only one element in array :
 	if(size===1)	return valueAt(arrayOfValues,0);
-	var chosenIndex=Math.getRandomInt(size-1,0);
-	return valueAt(arrayOfValues,chosenIndex);
+	
+	const chosenIndex=Math.getRandomInt(size-1,0);
+	const result=valueAt(arrayOfValues, chosenIndex);
+	if(removeFromArray)		removeByIndex(arrayOfValues, chosenIndex);
+	return result;
 }
 
 // This function is for arrays, like Array or Objects used as associative arrays you want to test as holding elements :
@@ -11956,6 +12617,52 @@ Math.demiCurve=function(min, max, value, strategy="triangle", precision=2){
 	return Math.roundTo(cursorFactor,precision);
 }
 
+// Not the same as curve, where min and max are the minimum and maximum values taken by returned value : 
+Math.curveTriggered=function(minTriggerFactor, maxTriggerFactor, valueFactorParam, strategy="linear"){
+	const valueFactor=Math.coerceInRange(valueFactorParam,0,1);
+	let result=1;
+	if(valueFactor<minTriggerFactor){
+		// Ascending slope :
+		if(minTriggerFactor==0)	return 1;
+		result=valueFactor/minTriggerFactor;
+	}else{
+		if(maxTriggerFactor==0)	return 1;
+		if(maxTriggerFactor<valueFactor){
+		// Descending slope :
+			result=1-((valueFactor-maxTriggerFactor)/(1-maxTriggerFactor));
+		}else{
+			// Plateau :
+			return 1;
+		}
+	}
+	return result;
+}
+
+Math.slopeTriggered=function(minTriggerFactor, maxTriggerFactor, valueFactorParam, direction="ascending", strategy="linear"){
+	
+	const valueFactor=Math.coerceInRange(valueFactorParam,0,1);
+	
+	if(valueFactor<minTriggerFactor){
+		// Beginning plateau : 
+		if(direction=="ascending")	return 0;
+		else												return 1;
+	}else if(maxTriggerFactor<valueFactor){
+		// Ending plateau : 
+		if(direction=="ascending")	return 1;
+		else												return 0;
+	}
+	
+	// Intermediate slope :
+	const total=(maxTriggerFactor-minTriggerFactor);
+	if(total==0)	return ((direction=="ascending")?1:0);
+	
+	const factor=((valueFactor-minTriggerFactor)/total);
+	
+	return ((direction=="ascending")?factor:(1-factor));
+}
+
+
+
 Math.curve=function(min, max, value, strategy="triangle",
 		// It is actually where to place the «summit» of the curve, before returning to 0,
 		// the factor value where the values starts decreasing, after having increased all along, and then goes back to 0: