Fix #4269 - Removes empty/special characters (#4270)

* Remove ufeff

* Remove u2064

* Remove u2062

* Replace u202f followed by : with  :

* Replace u202f next to « or » with   and « or »

* Replace u202f followed by ; with  ;

* Replace u202f followed by ! with  

* Replace u202f followed by ? with  ?

* Replace remaining u202f with classical space

* Replace u200b surrounded by space  with classical space

* Replace u200b surrounded by space  with classical space - again (repeated)

* Remove remaining u200b

* Remove u200a

* Replace u2009 with  

* Remove u00ad

* Replace u00a0 followed by : ! or ? with   and punctuation

* Replace u00a0 surrounded « or » with   and punctuation

* Replace u00a0 followed by whitespaces

* Replace u00a0 preceded by whitespaces

* Replace u00a0 followed by a newline with a newline

* Replace u00a0 followed by a newline with a newline - Take2

* Replace u00a0 followed by a ;   and punctuation

* Remove u00a0 followed by ,

* Remove u00a0 in indentation spaces with \n([ ]*)([\u00a0])([ ]*)

* Manual replacement of ([\u00a0])([ ]+)

* Replace remaining ([\u00a0]+) by a space

* cleaning empty elements

* remove ufe0f

* Remove u00a0 and u202f after merging against updated main

* remove double whitespace using (\w)(  )(\w)

4 files changed, 96 insertions, 96 deletions

diff --git a/files/fr/web/javascript/reference/classes/index.md b/files/fr/web/javascript/reference/classes/index.md
index 2808bc1d39..8fbdf65b9e 100644
--- a/files/fr/web/javascript/reference/classes/index.md
+++ b/files/fr/web/javascript/reference/classes/index.md
@@ -19,7 +19,7 @@ En réalité, les classes sont juste des [fonctions](/fr/docs/Web/JavaScript/Ref
 
 ### Les déclarations de classes
 
-Pour utiliser une déclaration de classe simple, on utilisera le mot-clé `class`, suivi par le nom de la classe que l'on déclare (ici « Rectangle »).
+Pour utiliser une déclaration de classe simple, on utilisera le mot-clé `class`, suivi par le nom de la classe que l'on déclare (ici « Rectangle »).
 
 ```js
 class Rectangle {
diff --git a/files/fr/web/javascript/reference/classes/private_class_fields/index.md b/files/fr/web/javascript/reference/classes/private_class_fields/index.md
index 45ad084074..7b6a0b1d73 100644
--- a/files/fr/web/javascript/reference/classes/private_class_fields/index.md
+++ b/files/fr/web/javascript/reference/classes/private_class_fields/index.md
@@ -35,12 +35,12 @@ La limitation des variables statiques ne pouvant être appelées que par des mé
 
 ```js
 class ClassWithPrivateStaticField {
-  static #PRIVATE_STATIC_FIELD
+  static #PRIVATE_STATIC_FIELD
 
-  static publicStaticMethod() {
-    ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42
-    return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD
-  }
+  static publicStaticMethod() {
+    ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42
+    return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD
+  }
 }
 
 console.assert(ClassWithPrivateStaticField.publicStaticMethod() === 42)
@@ -54,12 +54,12 @@ Ceci peut conduire à un comportement inattendu lors de l'utilisation de **`this
 
 ```js
 class BaseClassWithPrivateStaticField {
-  static #PRIVATE_STATIC_FIELD
+  static #PRIVATE_STATIC_FIELD
 
-  static basePublicStaticMethod() {
-    this.#PRIVATE_STATIC_FIELD = 42
-    return this.#PRIVATE_STATIC_FIELD
-  }
+  static basePublicStaticMethod() {
+    this.#PRIVATE_STATIC_FIELD = 42
+    return this.#PRIVATE_STATIC_FIELD
+  }
 }
 
 class SubClass extends BaseClassWithPrivateStaticField { }
@@ -75,18 +75,18 @@ console.assert(error instanceof TypeError)
 
 ### Champs d'instance privés
 
-Les champs d'instance privés sont déclarés avec des **noms** à **#** (prononcés "_noms à hash_", "_hash names_" en anglais), qui sont des identifieurs préfixés par `#`. Le `#` fait partie du nom lui-même. Il est utilisé tant pour la déclaration que pour l'accès.
+Les champs d'instance privés sont déclarés avec des **noms** à **#** (prononcés "_noms à hash_", "_hash names_" en anglais), qui sont des identifieurs préfixés par `#`. Le `#` fait partie du nom lui-même. Il est utilisé tant pour la déclaration que pour l'accès.
 
 L'encapsulation est forcée par le langage. C'est une erreur de syntaxe que de faire référence aux noms à `#` en dehors de leur portée.
 
 ```js
 class ClassWithPrivateField {
-  #privateField
+  #privateField
 
-  constructor() {
-    this.#privateField = 42
-    this.#randomField = 666 // Erreur de syntaxe
-  }
+  constructor() {
+    this.#privateField = 42
+    this.#randomField = 666 // Erreur de syntaxe
+  }
 }
 
 const instance = new ClassWithPrivateField()
@@ -103,17 +103,17 @@ Les méthodes statiques privées peuvent être des fonctions génératrices, asy
 
 ```js
 class ClassWithPrivateStaticMethod {
-    static #privateStaticMethod() {
-        return 42
-    }
+    static #privateStaticMethod() {
+        return 42
+    }
 
-    static publicStaticMethod1() {
-        return ClassWithPrivateStaticMethod.#privateStaticMethod();
-    }
+    static publicStaticMethod1() {
+        return ClassWithPrivateStaticMethod.#privateStaticMethod();
+    }
 
-    static publicStaticMethod2() {
-        return this.#privateStaticMethod();
-    }
+    static publicStaticMethod2() {
+        return this.#privateStaticMethod();
+    }
 }
 
 console.assert(ClassWithPrivateStaticMethod.publicStaticMethod1() === 42);
@@ -124,15 +124,15 @@ Cela peut conduire à un comportement inattendu lors de l'utilisation de **`this
 
 ```js
 class Base {
-    static #privateStaticMethod() {
-        return 42;
-    }
-    static publicStaticMethod1() {
-        return Base.#privateStaticMethod();
-    }
-    static publicStaticMethod2() {
-        return this.#privateStaticMethod();
-    }
+    static #privateStaticMethod() {
+        return 42;
+    }
+    static publicStaticMethod1() {
+        return Base.#privateStaticMethod();
+    }
+    static publicStaticMethod2() {
+        return this.#privateStaticMethod();
+    }
 }
 
 class Derived extends Base {}
@@ -147,41 +147,41 @@ Les méthodes d'instance privées sont des méthodes disponibles dans les instan
 
 ```js
 class ClassWithPrivateMethod {
-  #privateMethod() {
-    return 'hello world'
-  }
+  #privateMethod() {
+    return 'hello world'
+  }
 
-  getPrivateMessage() {
-      return this.#privateMethod()
-  }
+  getPrivateMessage() {
+      return this.#privateMethod()
+  }
 }
 
 const instance = new ClassWithPrivateMethod()
 console.log(instance.getPrivateMessage())
-// expected output: "hello worl​d"
+// expected output: "hello world"
 ```
 
 Les méthodes d'instance privées peuvent être des fonctions génératrices, asynchones ou génératrices asynchrones. Des accesseurs (getters) et des mutateurs (setters) privés sont aussi posibles :
 
 ```js
 class ClassWithPrivateAccessor {
-  #message
-
-  get #decoratedMessage() {
-    return `✨${this.#message}✨`
-  }
-  set #decoratedMessage(msg) {
-    this.#message = msg
-  }
-
-  constructor() {
-    this.#decoratedMessage = 'hello world'
-    console.log(this.#decoratedMessage)
-  }
+  #message
+
+  get #decoratedMessage() {
+    return `✨${this.#message}✨`
+  }
+  set #decoratedMessage(msg) {
+    this.#message = msg
+  }
+
+  constructor() {
+    this.#decoratedMessage = 'hello world'
+    console.log(this.#decoratedMessage)
+  }
 }
 
 new ClassWithPrivateAccessor();
-// expected output: "✨hello worl​d✨"
+// expected output: "✨hello world✨"
 ```
 
 ## Spécifications
diff --git a/files/fr/web/javascript/reference/classes/public_class_fields/index.md b/files/fr/web/javascript/reference/classes/public_class_fields/index.md
index 8630e5e473..9cf3f20d20 100644
--- a/files/fr/web/javascript/reference/classes/public_class_fields/index.md
+++ b/files/fr/web/javascript/reference/classes/public_class_fields/index.md
@@ -14,14 +14,14 @@ original_slug: Web/JavaScript/Reference/Classes/Class_fields
 >
 > Les déclarations de champs, tant publics que privés, sont [une fonctionnalité expérimentale (étape 3)](https://github.com/tc39/proposal-class-fields) proposée au [TC39](https://tc39.github.io/beta/), le comité des standards JavaScript.
 >
-> La prise en charge dans les navigateurs est limitée, mais cette fonctionnalité peut être utilisée à travers une étape de contruction avec des systèmes tels que [Babel](https://babeljs.io/). Voir [l'information de compatibilité](/fr/docs/Web/JavaScript/Reference/Classes/Class_fields$edit#Browser_compatibility) ci-dessous.
+> La prise en charge dans les navigateurs est limitée, mais cette fonctionnalité peut être utilisée à travers une étape de contruction avec des systèmes tels que [Babel](https://babeljs.io/). Voir [l'information de compatibilité](/fr/docs/Web/JavaScript/Reference/Classes/Class_fields$edit#Browser_compatibility) ci-dessous.
 
 Les champs publics, tant statiques que d'instance, sont des propriétés qui peuvent être écrites, et qui sont énumérables et configurables. En tant que telles, à la différence de leurs contreparties privées, elles participent à l'héritage du prototype.
 
 ## Syntaxe
 
     class ClasseAvecChampDInstance {
-      champDInstance = 'champ d\'instance'
+      champDInstance = 'champ d\'instance'
     }
 
     class ClasseAvecChampStatique {
@@ -29,9 +29,9 @@ Les champs publics, tant statiques que d'instance, sont des propriétés qui peu
     }
 
     class ClasseAvecMethodeDInstancePublique {
-      methodePublique() {
-        return 'hello world'
-      }
+      methodePublique() {
+        return 'hello world'
+      }
     }
 
 ## Exemples
@@ -44,18 +44,18 @@ Les champs statiques publics sont déclarés en utilisant le mot-clé `static`.
 
 ```js
 class ClasseAvecChampStatique {
-  static champStatique = 'champ statique'
+  static champStatique = 'champ statique'
 }
 
 console.log(ClasseAvecChampStatique.champStatique)
-// affichage attendu : "champ statique"​
+// affichage attendu : "champ statique"
 ```
 
 Les champs sans initialiseur sont initialisés à `undefined`.
 
 ```js
 class ClasseAvecChampStatique {
-  static champStatique
+  static champStatique
 }
 
 console.assert(ClasseAvecChampStatique.hasOwnProperty('champStatique'))
@@ -67,11 +67,11 @@ Les champs statiques publics ne sont pas réinitialisés dans les sous-classes,
 
 ```js
 class ClasseAvecChampStatique {
-  static champStatiqueDeBase = 'champ de base'
+  static champStatiqueDeBase = 'champ de base'
 }
 
 class SousClasseAvecChampStatique extends ClasseAvecChampStatique {
-  static sousChampStatique = 'champ de la sous-classe'
+  static sousChampStatique = 'champ de la sous-classe'
 }
 
 console.log(SousClasseAvecChampStatique.sousChampStatique)
@@ -85,14 +85,14 @@ Lors de l'initialisation des champs, `this` fait référence au constructeur de
 
 ```js
 class ClasseAvecChampStatique {
-  static champStatiqueDeBase = 'champ statique de base'
-  static autreChampStatiqueDeBase = this.champStatiqueDeBase
+  static champStatiqueDeBase = 'champ statique de base'
+  static autreChampStatiqueDeBase = this.champStatiqueDeBase
 
-  static methodeStatiqueDeBase() { return 'affichage de la méthode statique de base' }
+  static methodeStatiqueDeBase() { return 'affichage de la méthode statique de base' }
 }
 
 class SousClasseAvecChampStatique extends ClasseAvecChampStatique {
-  static sousChampStatique = super.methodeStatiqueDeBase()
+  static sousChampStatique = super.methodeStatiqueDeBase()
 }
 
 console.log(ClasseAvecChampStatique.autreChampStatiqueDeBase)
@@ -122,7 +122,7 @@ Les champs sans initialiseur sont initialisés à `undefined`.
 
 ```js
 class ClasseAvecChampDInstance {
-  champdDInstance
+  champdDInstance
 }
 
 const instance = new ClasseAvecChampDInstance()
@@ -137,7 +137,7 @@ console.log(instance.champDInstance);
 const PREFIXE = 'prefixe';
 
 class ClasseAvecNomDeChampCalcule {
-    [`${PREFIXE}Champ`] = 'champ préfixé'
+    [`${PREFIXE}Champ`] = 'champ préfixé'
 }
 
 const instance = new ClasseAvecNomDeChampCalcule()
@@ -149,13 +149,13 @@ Lors de l'initialisation des champs, `this` fait référence à l'instance en co
 
 ```js
 class ClasseAvecChampDInstance {
-  champDInstanceDeBase = 'champ de base'
-  autreChampDInstanceDeBase = this.champDInstanceDeBase
-  methodeDInstanceDeBase() { return 'affichage de la méthode de base' }
+  champDInstanceDeBase = 'champ de base'
+  autreChampDInstanceDeBase = this.champDInstanceDeBase
+  methodeDInstanceDeBase() { return 'affichage de la méthode de base' }
 }
 
 class SousClasseAvecChampDInstance extends ClasseAvecChampDInstance {
-  sousChampDInstance = super.methodeDInstanceDeBase()
+  sousChampDInstance = super.methodeDInstanceDeBase()
 }
 
 const base = new ClasseAvecChampDInstance()
@@ -200,7 +200,7 @@ class ClasseAvecMethodeDInstancePublique {
 
 const instance = new ClasseAvecMethodeDInstancePublique()
 console.log(instance.methodePublique())
-// affichage attendu : "hello worl​d"
+// affichage attendu : "hello world"
 ```
 
 Les méthodes d'instance publiques sont ajoutées au prototype au moment de l'évaluation de la classe en utilisant {{jsxref("Global_Objects/Object/defineProperty", "Object.defineProperty()")}}. Elles peuvent être écrites, ne sont pas énumérables et sont configurables.
@@ -219,39 +219,39 @@ A l'intérieur des méthodes d'instance, `this` fait référence à l'instance e
 
 ```js
 class ClasseDeBase {
-  msg = 'hello world'
-  methodePubliqueDeBase() {
-    return this.msg
-  }
+  msg = 'hello world'
+  methodePubliqueDeBase() {
+    return this.msg
+  }
 }
 
 class SousClasse extends ClasseDeBase {
-  sousMethodePublique() {
-    return super.methodePubliqueDeBase()
-  }
+  sousMethodePublique() {
+    return super.methodePubliqueDeBase()
+  }
 }
 
 const instance = new SousClasse()
 console.log(instance.sousMethodePublique())
-// affichage attendu : "hello worl​d"
+// affichage attendu : "hello world"
 ```
 
 Les accesseurs et les mutateurs sont des méthodes spéciales qui sont liées à une propriété de classe, et sont appelées lorsqu'on accède à cette propriété ou qu'on la définit. Utilisez la syntaxe [get](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/get) et [set](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript/Reference/Functions/set) pour déclarer un accesseur ou un mutateur publique d'une instance.
 
 ```js
 class ClasseAvecGetSet {
-  #msg = 'hello world'
-  get msg() {
-    return this.#msg
-  }
-  set msg(x) {
-    this.#msg = `hello ${x}`
-  }
+  #msg = 'hello world'
+  get msg() {
+    return this.#msg
+  }
+  set msg(x) {
+    this.#msg = `hello ${x}`
+  }
 }
 
 const instance = new ClasseAvecGetSet();
 console.log(instance.msg);
-// affichage attendu : "hello worl​d"
+// affichage attendu : "hello world"
 
 instance.msg = 'gâteau';
 console.log(instance.msg);
diff --git a/files/fr/web/javascript/reference/classes/static/index.md b/files/fr/web/javascript/reference/classes/static/index.md
index f08b2b5a94..7637ced784 100644
--- a/files/fr/web/javascript/reference/classes/static/index.md
+++ b/files/fr/web/javascript/reference/classes/static/index.md
@@ -77,7 +77,7 @@ StaticMethodCall.anotherStaticMethod();
 
 ### Depuis les constructeurs de classes et les autres méthodes
 
-Les méthodes statiques ne sont pas directement accessibles via le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this). Il faut les appeler avec le nom de la classe qui préfixe le nom de la méthode statique `NomDeClasse.MéthodeStatique()` (comme pour les autres appels en dehors de la classe) ou avec la propriété `constructor`  : `this.constructor.MéthodeStatique()`.
+Les méthodes statiques ne sont pas directement accessibles via le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this). Il faut les appeler avec le nom de la classe qui préfixe le nom de la méthode statique `NomDeClasse.MéthodeStatique()` (comme pour les autres appels en dehors de la classe) ou avec la propriété `constructor`  : `this.constructor.MéthodeStatique()`.
 
 ```js
 class StaticMethodCall{
@@ -89,7 +89,7 @@ class StaticMethodCall{
     // 'appel de la méthode statique'
   }
 
-  static  staticMethod(){
+  static staticMethod(){
     return 'appel de la méthode statique.';
   }
 }
@@ -100,7 +100,7 @@ class StaticMethodCall{
 | Spécification                                                                                | État                         | Commentaires         |
 | -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
 | {{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ES2015')}}     | Définition initiale. |
-| {{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ESDraft')}} |                      |
+| {{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}} | {{Spec2('ESDraft')}} |                      |
 
 ## Compatibilité des navigateurs