convert content to md

27 files changed, 1123 insertions, 1501 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/regexp/@@match/index.md b/files/fr/web/javascript/reference/global_objects/regexp/@@match/index.md
index 9d3c824406..0126ab2d2f 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/@@match/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/@@match/index.md
@@ -11,54 +11,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/@@match
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/@@match
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>[@@match]()</code></strong> permet de récupérer les correspondances obtenues lorsqu'on teste une chaîne de caractères par rapport à une expression rationnelle (<em>regexp</em>).</p>
+La méthode **`[@@match]()`** permet de récupérer les correspondances obtenues lorsqu'on teste une chaîne de caractères par rapport à une expression rationnelle (_regexp_).
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-@@match.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-@@match.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>regexp</var>[Symbol.match](str)</pre>
+    regexp[Symbol.match](str)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>str</code></dt>
- <dd>La chaîne de caractères ({{jsxref("String")}}) sur laquelle on veut chercher des correspondances.</dd>
-</dl>
+- `str`
+  - : La chaîne de caractères ({{jsxref("String")}}) sur laquelle on veut chercher des correspondances.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau ({{jsxref("Array")}}) qui contient les résultats des correspondances et les groupes capturés grâce aux parenthèse. S'il n'y a aucune correspondance, ce sera {{jsxref("null")}}.</p>
+Un tableau ({{jsxref("Array")}}) qui contient les résultats des correspondances et les groupes capturés grâce aux parenthèse. S'il n'y a aucune correspondance, ce sera {{jsxref("null")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode est appelée de façon interne lorsqu'on utilise {{jsxref("String.prototype.match()")}}. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :</p>
+Cette méthode est appelée de façon interne lorsqu'on utilise {{jsxref("String.prototype.match()")}}. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :
 
-<pre class="brush: js">'abc'.match(/a/);
+```js
+'abc'.match(/a/);
 
-/a/[Symbol.match]('abc');</pre>
+/a/[Symbol.match]('abc');
+```
 
-<p>Cette méthode existe afin de permettre d'adapter le comportement de la recherche des correspondances pour les sous-classes de <code>RegExp</code>.</p>
+Cette méthode existe afin de permettre d'adapter le comportement de la recherche des correspondances pour les sous-classes de `RegExp`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Appel_direct">Appel direct</h3>
+### Appel direct
 
-<p>Cette méthode peut être utilisée comme {{jsxref("String.prototype.match()")}} mais avec un objet <code>this</code> différent et un ordre des paramètres également différent.</p>
+Cette méthode peut être utilisée comme {{jsxref("String.prototype.match()")}} mais avec un objet `this` différent et un ordre des paramètres également différent.
 
-<pre class="brush: js">var re = /[0-9]+/g;
+```js
+var re = /[0-9]+/g;
 var str = '2016-01-02';
 var résultat = re[Symbol.match](str);
 console.log(résultat);  // ["2016", "01", "02"]
-</pre>
+```
 
-<h3 id="Utilisation_de_match_avec_une_sous-classe">Utilisation de <code>@@match</code> avec une sous-classe</h3>
+### Utilisation de `@@match` avec une sous-classe
 
-<p>Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger la méthode <code>[@@match]()</code> afin de modifier le comportement.</p>
+Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger la méthode `[@@match]()` afin de modifier le comportement.
 
-<pre class="brush: js">class MaRegExp extends RegExp {
+```js
+class MaRegExp extends RegExp {
   [Symbol.match](str) {
     var résultat = RegExp.prototype[Symbol.match].call(this, str);
     if (!résultat) return null;
@@ -76,41 +78,24 @@ var résultat = str.match(re); // String.prototype.match appelle re[@@match].
 console.log(résultat.group(1)); // 2016
 console.log(résultat.group(2)); // 01
 console.log(résultat.group(3)); // 02
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype-@@match', 'RegExp.prototype[@@match]')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype-@@match', 'RegExp.prototype[@@match]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.@@match")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.match()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
- <li>{{jsxref("RegExp.prototype.test()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-regexp.prototype-@@match', 'RegExp.prototype[@@match]')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-regexp.prototype-@@match', 'RegExp.prototype[@@match]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.@@match")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.match()")}}
+- {{jsxref("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}
+- {{jsxref("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}
+- {{jsxref("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}
+- {{jsxref("RegExp.prototype.exec()")}}
+- {{jsxref("RegExp.prototype.test()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/@@matchall/index.md b/files/fr/web/javascript/reference/global_objects/regexp/@@matchall/index.md
index 303390a68c..b0e6a51185 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/@@matchall/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/@@matchall/index.md
@@ -10,56 +10,58 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/@@matchAll
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/@@matchAll
 ---
-<p>{{JSRef}}</p>
+{{JSRef}}
 
-<p>La méthode <strong><code>[@@matchAll]</code></strong> renvoie l'ensemble des correspondances d'une expression rationnelle sur une chaîne de caractères.</p>
+La méthode **`[@@matchAll]`** renvoie l'ensemble des correspondances d'une expression rationnelle sur une chaîne de caractères.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-@@matchall.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-@@matchall.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>regexp</var>[Symbol.matchAll](<var>str</var>)</pre>
+    regexp[Symbol.matchAll](str)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>str</code></dt>
- <dd>Une chaîne de caractères ({{jsxref("String")}}) dont on souhaite trouver les correspondances.</dd>
-</dl>
+- `str`
+  - : Une chaîne de caractères ({{jsxref("String")}}) dont on souhaite trouver les correspondances.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un <a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">itérateur</a>.</p>
+Un [itérateur](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs).
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode est appelée, en interne, par le moteur JavaScript, pendant l'exécution {{jsxref("String.prototype.matchAll()")}}. Les deux lignes qui suivent renverront donc le même résultat.</p>
+Cette méthode est appelée, en interne, par le moteur JavaScript, pendant l'exécution {{jsxref("String.prototype.matchAll()")}}. Les deux lignes qui suivent renverront donc le même résultat.
 
-<pre class="brush: js">'abc'.matchAll(/a/);
+```js
+'abc'.matchAll(/a/);
 
-/a/[Symbol.matchAll]('abc');</pre>
+/a/[Symbol.matchAll]('abc');
+```
 
-<p>Cette méthode existe afin de personnaliser le comportement des correspondances pour les sous-classes de <code>RegExp</code>.</p>
+Cette méthode existe afin de personnaliser le comportement des correspondances pour les sous-classes de `RegExp`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Appel_direct">Appel direct</h3>
+### Appel direct
 
-<p>Cette méthode peut être utilisée de façon semblable à {{jsxref("String.prototype.matchAll()")}} mais l'objet <code>this</code> et l'ordre des arguments seront différents.</p>
+Cette méthode peut être utilisée de façon semblable à {{jsxref("String.prototype.matchAll()")}} mais l'objet `this` et l'ordre des arguments seront différents.
 
-<pre class="brush: js">var re = /[0-9]+/g;
+```js
+var re = /[0-9]+/g;
 var str = '2016-01-02';
 var resultat = re[Symbol.matchAll](str);
 
-console.log(Array.from(resultat, x =&gt; x[0]));
+console.log(Array.from(resultat, x => x[0]));
 // ["2016", "01", "02"]
-</pre>
+```
 
-<h3 id="Utiliser_matchAll_dans_une_sous-classe">Utiliser <code>@@matchAll</code> dans une sous-classe</h3>
+### Utiliser `@@matchAll` dans une sous-classe
 
-<p>Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger la méthode <code>[@@matchAll]()</code> afin de modifier le comportement par défaut (par exemple pour renvoyer un tableau ({{jsxref("Array")}}) plutôt qu'un <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">itérateur</a>).</p>
+Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger la méthode `[@@matchAll]()` afin de modifier le comportement par défaut (par exemple pour renvoyer un tableau ({{jsxref("Array")}}) plutôt qu'un [itérateur](/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators)).
 
-<pre class="brush: js">class MaRegExp extends RegExp {
+```js
+class MaRegExp extends RegExp {
   [Symbol.matchAll](str) {
     var resultat = RegExp.prototype[Symbol.matchAll].call(this, str);
     if (!resultat) {
@@ -75,32 +77,19 @@ var str = '2016-01-02|2019-03-07';
 var resultat = str.matchAll(re);
 console.log(resultat[0]); // [ "2016-01-02", "2016", "01", "02" ]
 console.log(resultat[1]); // [ "2019-03-07", "2019", "03", "07" ]
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp-prototype-matchall', 'RegExp.prototype[@@matchAll]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.@@matchAll")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{JSxRef("String.prototype.matchAll()")}}</li>
- <li>{{JSxRef("Symbol.matchAll")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------ |
+| {{SpecName('ESDraft', '#sec-regexp-prototype-matchall', 'RegExp.prototype[@@matchAll]')}} | {{Spec2('ESDraft')}} |              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.@@matchAll")}}
+
+## Voir aussi
+
+- {{JSxRef("String.prototype.matchAll()")}}
+- {{JSxRef("Symbol.matchAll")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/@@replace/index.md b/files/fr/web/javascript/reference/global_objects/regexp/@@replace/index.md
index 699bb1ad11..f1ea9e66db 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/@@replace/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/@@replace/index.md
@@ -10,60 +10,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/@@replace
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/@@replace
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>[@@replace]()</code></strong> remplace toutes ou certaines correspondances d'un motif <code>this</code> dans une chaîne de caractère avec un outil de remplacement. La valeur renvoyée est la nouvelle chaîne ainsi créée. Cet outil de remplacement peut être une chaîne de caractère ou une fonction appelée pour chacune des correspondances.</p>
+La méthode **`[@@replace]()`** remplace toutes ou certaines correspondances d'un motif `this` dans une chaîne de caractère avec un outil de remplacement. La valeur renvoyée est la nouvelle chaîne ainsi créée. Cet outil de remplacement peut être une chaîne de caractère ou une fonction appelée pour chacune des correspondances.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-@@replace.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-@@replace.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>regexp</var>[Symbol.replace](str, <var>newSubStr</var>|<var>function</var>)</pre>
+    regexp[Symbol.replace](str, newSubStr|function)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>str</code></dt>
- <dd>Une chaîne de caractères ({{jsxref("String")}}) pour laquelle on souhaite effectuer des remplacement.</dd>
- <dt><code>newSubStr (replacement)</code></dt>
- <dd>La chaîne de caractères qui remplace les correspondances trouvées. On peut effectuer le remplacement sur un nombre donné de correspondances (cf. la section {{jsxref("String.prototype.replace", "Utiliser une chaîne de caractères comme paramètre", "#Utiliser_une_chaîne_de_caractère_comme_paramètre", 1)}} de la page {{jsxref("String.prototype.replace()")}}).</dd>
- <dt><code>function (replacement)</code></dt>
- <dd>Une fonction qui est appelée pour créer la sous-chaîne de remplacement. Les arguments fournis à cette fonction sont décrits dans la section {{jsxref("String.prototype.replace", "Utiliser une chaîne de caractères comme paramètre", "#Utiliser_une_chaîne_de_caractère_comme_paramètre", 1)}} de la page {{jsxref("String.prototype.replace()")}}.</dd>
-</dl>
+- `str`
+  - : Une chaîne de caractères ({{jsxref("String")}}) pour laquelle on souhaite effectuer des remplacement.
+- `newSubStr (replacement)`
+  - : La chaîne de caractères qui remplace les correspondances trouvées. On peut effectuer le remplacement sur un nombre donné de correspondances (cf. la section {{jsxref("String.prototype.replace", "Utiliser une chaîne de caractères comme paramètre", "#Utiliser_une_chaîne_de_caractère_comme_paramètre", 1)}} de la page {{jsxref("String.prototype.replace()")}}).
+- `function (replacement)`
+  - : Une fonction qui est appelée pour créer la sous-chaîne de remplacement. Les arguments fournis à cette fonction sont décrits dans la section {{jsxref("String.prototype.replace", "Utiliser une chaîne de caractères comme paramètre", "#Utiliser_une_chaîne_de_caractère_comme_paramètre", 1)}} de la page {{jsxref("String.prototype.replace()")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une nouvelle chaîne de caractères pour laquelle les correspondances (toutes ou une partie) ont été remplacées.</p>
+Une nouvelle chaîne de caractères pour laquelle les correspondances (toutes ou une partie) ont été remplacées.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode est appelée de façon interne par la méthode {{jsxref("String.prototype.replace()")}} lorsque l'arugment <code>pattern</code> argument est un objet {{jsxref("RegExp")}}. Les deux lignes de code qui suivent sont équivalentes et la seconde est la version interne de la première :</p>
+Cette méthode est appelée de façon interne par la méthode {{jsxref("String.prototype.replace()")}} lorsque l'arugment `pattern` argument est un objet {{jsxref("RegExp")}}. Les deux lignes de code qui suivent sont équivalentes et la seconde est la version interne de la première :
 
-<pre class="brush: js">'abc'.replace(/a/, 'A');
+```js
+'abc'.replace(/a/, 'A');
 
-/a/[Symbol.replace]('abc', 'A');</pre>
+/a/[Symbol.replace]('abc', 'A');
+```
 
-<p>Cette méthode existe afin de pouvoir personnaliser le comportement du remplacement pour les classes filles de <code>RegExp</code>.</p>
+Cette méthode existe afin de pouvoir personnaliser le comportement du remplacement pour les classes filles de `RegExp`.
 
-<p>Si l'argument décrivant le motif <strong>n'est pas</strong> un objet {{jsxref("RegExp")}}, {{jsxref("String.prototype.replace()")}} n'appellera pas cette méthode et ne créera pas d'objet {{jsxref("RegExp")}}.</p>
+Si l'argument décrivant le motif **n'est pas** un objet {{jsxref("RegExp")}}, {{jsxref("String.prototype.replace()")}} n'appellera pas cette méthode et ne créera pas d'objet {{jsxref("RegExp")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Appel_direct">Appel direct</h3>
+### Appel direct
 
-<p>Cette méthode peut être utilisée comme {{jsxref("String.prototype.replace()")}}, aux différences près que l'objet <code>this</code> est différent et que l'ordre des arguments change :</p>
+Cette méthode peut être utilisée comme {{jsxref("String.prototype.replace()")}}, aux différences près que l'objet `this` est différent et que l'ordre des arguments change :
 
-<pre class="brush: js">var re = /-/g;
+```js
+var re = /-/g;
 var str = '2016-01-01';
 var newstr = re[Symbol.replace](str, '.');
 console.log(newstr);  // 2016.01.01
-</pre>
+```
 
-<h3 id="Utiliser_replace_dans_une_sous-classe">Utiliser <code>@@replace</code> dans une sous-classe</h3>
+### Utiliser `@@replace` dans une sous-classe
 
-<p>Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger la méthode <code>[@@replace]()</code> pour modifier le comportement.</p>
+Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger la méthode `[@@replace]()` pour modifier le comportement.
 
-<pre class="brush: js">class MaRegExp extends RegExp {
+```js
+class MaRegExp extends RegExp {
   constructor(pattern, flags, count) {
     super(pattern, flags);
     this.count = count;
@@ -71,7 +73,7 @@ console.log(newstr);  // 2016.01.01
   [Symbol.replace](str, replacement) {
     // Applique @@replace |count| fois.
     var result = str;
-    for (var i = 0; i &lt; this.count; i++) {
+    for (var i = 0; i < this.count; i++) {
       result = RegExp.prototype[Symbol.replace].call(this, result, replacement);
     }
     return result;
@@ -81,41 +83,25 @@ console.log(newstr);  // 2016.01.01
 var re = new MaRegExp('\\d', '', 3);
 var str = '01234567';
 var newstr = str.replace(re, '#'); // String.prototype.replace appelle re[@@replace].
-console.log(newstr); // ###34567</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype-@@replace', 'RegExp.prototype[@@replace]')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype-@@replace', 'RegExp.prototype[@@replace]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.@@replace")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.replace()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
- <li>{{jsxref("RegExp.prototype.test()")}}</li>
-</ul>
+console.log(newstr); // ###34567
+```
+
+## Spécifications
+
+| Spécification                                                                                                            | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-regexp.prototype-@@replace', 'RegExp.prototype[@@replace]')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-regexp.prototype-@@replace', 'RegExp.prototype[@@replace]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.@@replace")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.replace()")}}
+- {{jsxref("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}
+- {{jsxref("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}
+- {{jsxref("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}
+- {{jsxref("RegExp.prototype.exec()")}}
+- {{jsxref("RegExp.prototype.test()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/@@search/index.md b/files/fr/web/javascript/reference/global_objects/regexp/@@search/index.md
index 0865f313ed..8b241fbe93 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/@@search/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/@@search/index.md
@@ -11,57 +11,57 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/@@search
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/@@search
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>[@@search]()</code></strong> recherche une correspondance entre une expression rationnelle décrite par <code>this</code> et une chaîne de caractères donnée.</p>
+La méthode **`[@@search]()`** recherche une correspondance entre une expression rationnelle décrite par `this` et une chaîne de caractères donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-@@search.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-@@search.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>regexp</var>[Symbol.search](str)</pre>
+    regexp[Symbol.search](str)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>str</code></dt>
- <dd>Une chaîne de caractères ({{jsxref("String")}}) sur laquelle on veut rechercher une correspondance.</dd>
-</dl>
+- `str`
+  - : Une chaîne de caractères ({{jsxref("String")}}) sur laquelle on veut rechercher une correspondance.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<dl>
- <dt><code>entier</code></dt>
- <dd>Si la recherche réussit, <code>[@@search]()</code> renvoie la position de la première correspondance de l'expression rationnelle au sein de la chaîne, sinon elle renvoie <code>-1</code>.</dd>
-</dl>
+- `entier`
+  - : Si la recherche réussit, `[@@search]()` renvoie la position de la première correspondance de l'expression rationnelle au sein de la chaîne, sinon elle renvoie `-1`.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode est appelée en interne lors de l'utilisation de {{jsxref("String.prototype.search()")}}. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :</p>
+Cette méthode est appelée en interne lors de l'utilisation de {{jsxref("String.prototype.search()")}}. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :
 
-<pre class="brush: js">'abc'.search(/a/);
+```js
+'abc'.search(/a/);
 
-/a/[Symbol.search]('abc');</pre>
+/a/[Symbol.search]('abc');
+```
 
-<p>Cette méthode existe afin de pouvoir adapter le comportement de la recherche pour les sous-classes de <code>RegExp</code>.</p>
+Cette méthode existe afin de pouvoir adapter le comportement de la recherche pour les sous-classes de `RegExp`.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Appel_direct">Appel direct</h3>
+### Appel direct
 
-<p>Cette méthode peut être utilisée comme {{jsxref("String.prototype.search()")}}, elle utilise simplement un objet <code>this</code> différent et un ordre de paramètres différent :</p>
+Cette méthode peut être utilisée comme {{jsxref("String.prototype.search()")}}, elle utilise simplement un objet `this` différent et un ordre de paramètres différent :
 
-<pre class="brush: js">var re = /-/g;
+```js
+var re = /-/g;
 var str = '2016-01-02';
 var résultat = re[Symbol.search](str);
 console.log(résultat);  // 4
-</pre>
+```
 
-<h3 id="Utiliser_search_avec_une_sous-classe">Utiliser <code>@@search</code> avec une sous-classe</h3>
+### Utiliser `@@search` avec une sous-classe
 
-<p>Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger <code>[@@search]()</code> afin de modifier le comportement obtenu :</p>
+Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger `[@@search]()` afin de modifier le comportement obtenu :
 
-<pre class="brush: js">class MaRegExp extends RegExp {
+```js
+class MaRegExp extends RegExp {
   constructor(str) {
     super(str)
     this.pattern = str;
@@ -75,41 +75,24 @@ var re = new MaRegExp('a+b');
 var str = 'ab a+b';
 var résultat = str.search(re); // String.prototype.search appelle re[@@search].
 console.log(résultat); // 3
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype-@@search', 'RegExp.prototype[@@search]')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype-@@search', 'RegExp.prototype[@@search]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.@@search")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.search()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
- <li>{{jsxref("RegExp.prototype.test()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-regexp.prototype-@@search', 'RegExp.prototype[@@search]')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-regexp.prototype-@@search', 'RegExp.prototype[@@search]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.@@search")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.search()")}}
+- {{jsxref("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}
+- {{jsxref("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}
+- {{jsxref("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}
+- {{jsxref("RegExp.prototype.exec()")}}
+- {{jsxref("RegExp.prototype.test()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/@@species/index.md b/files/fr/web/javascript/reference/global_objects/regexp/@@species/index.md
index 22f0fbb375..f073630ef9 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/@@species/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/@@species/index.md
@@ -11,64 +11,50 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/@@species
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/@@species
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété accesseur <code><strong>RegExp[@@species]</strong></code> renvoie le constructeur <code>RegExp</code>.</p>
+La propriété accesseur **`RegExp[@@species]`** renvoie le constructeur `RegExp`.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-getregexp-@@species.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-getregexp-@@species.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">RegExp[Symbol.species]
-</pre>
+    RegExp[Symbol.species]
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'accesseur <code>species</code> renvoie le constructeur par défaut pour les objets <code>RegExp</code>. Les constructeurs des sous-classes peuvent surcharger ce symbole afin de modifier l'affectation du constructeur.</p>
+L'accesseur `species` renvoie le constructeur par défaut pour les objets `RegExp`. Les constructeurs des sous-classes peuvent surcharger ce symbole afin de modifier l'affectation du constructeur.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La propriété <code>species</code> renvoie le constructeur par défaut, dans le cas des objets <code>RegExp</code>, c'est le constructeur <code>RegExp</code> :</p>
+La propriété `species` renvoie le constructeur par défaut, dans le cas des objets `RegExp`, c'est le constructeur `RegExp` :
 
-<pre class="brush: js">RegExp[Symbol.species]; // function RegExp()</pre>
+```js
+RegExp[Symbol.species]; // function RegExp()
+```
 
-<p>Pour les objets dérivés (par exemple, une classe <code>MaRegExp</code>), la valeur de <code>species</code> sera le constructeur <code>MaRegExp</code>. Il est possible de surcharger ce comportement afin de renvoyer le constructeur parent <code>RegExp</code> :</p>
+Pour les objets dérivés (par exemple, une classe `MaRegExp`), la valeur de `species` sera le constructeur `MaRegExp`. Il est possible de surcharger ce comportement afin de renvoyer le constructeur parent `RegExp` :
 
-<pre class="brush: js">class MaRegExp extends RegExp {
+```js
+class MaRegExp extends RegExp {
   // On surcharge species pour renvoyer
   // le constructeur parent RegExp
   static get [Symbol.species]() { return RegExp; }
-}</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-get-regexp-@@species', 'get RegExp [ @@species ]')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp-@@species', 'get RegExp [ @@species ]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.@@species")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp")}}</li>
- <li>{{jsxref("Symbol.species")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                                                | État                         | Commentaires         |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-get-regexp-@@species', 'get RegExp [ @@species ]')}}         | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-regexp-@@species', 'get RegExp [ @@species ]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.@@species")}}
+
+## Voir aussi
+
+- {{jsxref("RegExp")}}
+- {{jsxref("Symbol.species")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/@@split/index.md b/files/fr/web/javascript/reference/global_objects/regexp/@@split/index.md
index 99fcaf30d4..8b576affe5 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/@@split/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/@@split/index.md
@@ -11,63 +11,63 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/@@split
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/@@split
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>[@@split]()</code></strong> permet de découper une chaîne de caractères ({{jsxref("String")}}) en un tableau de sous-chaînes.</p>
+La méthode **`[@@split]()`** permet de découper une chaîne de caractères ({{jsxref("String")}}) en un tableau de sous-chaînes.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-@@split.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-@@split.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate"><var>regexp</var>[Symbol.split](str[, <var>limite</var>])</pre>
+    regexp[Symbol.split](str[, limite])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>str</code></dt>
- <dd>La chaîne de caractères qu'on souhaite découper.</dd>
- <dt><code>limite</code></dt>
- <dd>
- <p>Paramètre optionnel. Un entier indiquant le nombre maximal de sous-chaînes à trouver. La méthode <code>[@@split]()</code> découpe la chaîne pour chaque correspondance de l'expression rationnelle <code>this</code> jusqu'à ce que le nombre d'éléments obtenus atteigne cette limite ou que la chaîne n'ait plus de correspondances.</p>
- </dd>
-</dl>
+- `str`
+  - : La chaîne de caractères qu'on souhaite découper.
+- `limite`
+  - : Paramètre optionnel. Un entier indiquant le nombre maximal de sous-chaînes à trouver. La méthode `[@@split]()` découpe la chaîne pour chaque correspondance de l'expression rationnelle `this` jusqu'à ce que le nombre d'éléments obtenus atteigne cette limite ou que la chaîne n'ait plus de correspondances.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un tableau ({{jsxref("Array")}}) dont les éléments sont les sous-chaînes de caractères issues de la découpe.</p>
+Un tableau ({{jsxref("Array")}}) dont les éléments sont les sous-chaînes de caractères issues de la découpe.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Cette méthode est appelée de façon interne par la méthode {{jsxref("String.prototype.split()")}} lorsque l'argument <code>str</code> est un objet {{jsxref("RegExp")}}. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :</p>
+Cette méthode est appelée de façon interne par la méthode {{jsxref("String.prototype.split()")}} lorsque l'argument `str` est un objet {{jsxref("RegExp")}}. Ainsi, les deux exemples qui suivent sont équivalents et le second est la version interne du premier :
 
-<pre class="brush: js notranslate">'a-b-c'.split(/-/);
+```js
+'a-b-c'.split(/-/);
 
-/-/[Symbol.split]('a-b-c');</pre>
+/-/[Symbol.split]('a-b-c');
+```
 
-<p>Cette méthode existe afin de pouvoir adapter le fonctionnement de la découpe pour les sous-classes de <code>RegExp</code>.</p>
+Cette méthode existe afin de pouvoir adapter le fonctionnement de la découpe pour les sous-classes de `RegExp`.
 
-<p>Si le séparateur n'est pas un objet {{jsxref("RegExp")}}, la méthode {{jsxref("String.prototype.split()")}} n'appellera pas cette méthode et ne créera pas d'objet {{jsxref("RegExp")}}.</p>
+Si le séparateur n'est pas un objet {{jsxref("RegExp")}}, la méthode {{jsxref("String.prototype.split()")}} n'appellera pas cette méthode et ne créera pas d'objet {{jsxref("RegExp")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Appel_direct">Appel direct</h3>
+### Appel direct
 
-<p>Cette méthode peut être utilisée comme  {{jsxref("String.prototype.split()")}}, l'objet <code>this</code> est différent et l'ordre des arguments également.</p>
+Cette méthode peut être utilisée comme  {{jsxref("String.prototype.split()")}}, l'objet `this` est différent et l'ordre des arguments également.
 
-<pre class="brush: js notranslate">var re = /-/g;
+```js
+var re = /-/g;
 var str = '2016-01-02';
 var résultat = re[Symbol.split](str);
 console.log(résultat);  // ["2016", "01", "02"]
-</pre>
+```
 
-<h3 id="Utiliser_split_avec_une_sous-classe">Utiliser <code>@@split</code> avec une sous-classe</h3>
+### Utiliser `@@split` avec une sous-classe
 
-<p>Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger  <code>[@@split]()</code> afin de modifier le comportement de la découpe :</p>
+Les sous-classes de {{jsxref("RegExp")}} peuvent surcharger  `[@@split]()` afin de modifier le comportement de la découpe :
 
-<pre class="brush: js notranslate">class MaRegExp extends RegExp {
+```js
+class MaRegExp extends RegExp {
   [Symbol.split](str, limit) {
     var résultat = RegExp.prototype[Symbol.split].call(this, str, limit);
-    return résultat.map(x =&gt; "(" + x + ")");
+    return résultat.map(x => "(" + x + ")");
   }
 }
 
@@ -75,41 +75,24 @@ var re = new MaRegExp('-');
 var str = '2016-01-02';
 var résultat = str.split(re); // String.prototype.split appelle re[@@split].
 console.log(résultat); // ["(2016)", "(01)", "(02)"]
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype-@@split', 'RegExp.prototype[@@split]')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype-@@split', 'RegExp.prototype[@@split]')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.@@split")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.split()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}</li>
- <li>{{jsxref("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}</li>
- <li>{{jsxref("RegExp.prototype.exec()")}}</li>
- <li>{{jsxref("RegExp.prototype.test()")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES6', '#sec-regexp.prototype-@@split', 'RegExp.prototype[@@split]')}}     | {{Spec2('ES6')}}         | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-regexp.prototype-@@split', 'RegExp.prototype[@@split]')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.@@split")}}
+
+## Voir aussi
+
+- {{jsxref("String.prototype.split()")}}
+- {{jsxref("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}
+- {{jsxref("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}
+- {{jsxref("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}
+- {{jsxref("RegExp.prototype.exec()")}}
+- {{jsxref("RegExp.prototype.test()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/compile/index.md b/files/fr/web/javascript/reference/global_objects/regexp/compile/index.md
index d6002f1ba0..fa48e0f0c8 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/compile/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/compile/index.md
@@ -11,76 +11,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/compile
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/compile
 ---
-<div>{{JSRef}} {{deprecated_header}}</div>
+{{JSRef}} {{deprecated_header}}
 
-<p>La méthode dépréciée <code><strong>compile</strong></code><strong><code>()</code></strong> est utilisée afin de (re)compiler une expression rationnelle lors de l'exécution d'un script. Cette méthode effectue essentiellement les mêmes actions que le constructeur <code>RegExp</code>.</p>
+La méthode dépréciée **`compile`\*\***`()`\*\* est utilisée afin de (re)compiler une expression rationnelle lors de l'exécution d'un script. Cette méthode effectue essentiellement les mêmes actions que le constructeur `RegExp`.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><var>regexObj</var>.compile(<var>motif, flags</var>)</code></pre>
+    regexObj.compile(motif, flags)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>motif</code></dt>
- <dd>Le texte de l'expression rationnelle.</dd>
- <dt><code>flags</code></dt>
- <dd>
- <p>S'ils sont utilisés, les drapeaux (<em>flags</em>) peuvent être combinés avec les valeurs suivantes :</p>
+- `motif`
+  - : Le texte de l'expression rationnelle.
+- `flags`
 
- <dl>
-  <dt><code>g</code></dt>
-  <dd>correspondance globale</dd>
-  <dt><code>i</code></dt>
-  <dd>ignorer la casse</dd>
-  <dt><code>m</code></dt>
-  <dd>multiligne : on traite les caractères de début et de fin (^ et $) de façon à travailler sur plusieurs lignes (ils correspondent au début et à la fin de chaque ligne et non au début ou à la fin de la chaîne entière)</dd>
-  <dt><code>y</code></dt>
-  <dd>adhérence : ne recherche les correspondances qu'à partir de l'indice fourni par la propriété <code>lastIndex</code> de l'expression rationnelle dans la chaîne cible (la recherche n'est pas effectuée pour les indices suivants).</dd>
- </dl>
- </dd>
-</dl>
+  - : S'ils sont utilisés, les drapeaux (_flags_) peuvent être combinés avec les valeurs suivantes :
 
-<h2 id="Description">Description</h2>
+    - `g`
+      - : correspondance globale
+    - `i`
+      - : ignorer la casse
+    - `m`
+      - : multiligne : on traite les caractères de début et de fin (^ et $) de façon à travailler sur plusieurs lignes (ils correspondent au début et à la fin de chaque ligne et non au début ou à la fin de la chaîne entière)
+    - `y`
+      - : adhérence : ne recherche les correspondances qu'à partir de l'indice fourni par la propriété `lastIndex` de l'expression rationnelle dans la chaîne cible (la recherche n'est pas effectuée pour les indices suivants).
 
-<p>La méthode <code>compile</code> est dépréciée. Pour obtenir le même effet, on utilisera le constructeur <code>RegExp</code>.</p>
+## Description
 
-<h2 id="Exemples">Exemples</h2>
+La méthode `compile` est dépréciée. Pour obtenir le même effet, on utilisera le constructeur `RegExp`.
 
-<p>Dans l'exemple qui suit, on voit comment réinitialiser le motif et les drapeaux d'une expression rationnelle grâce à  la méthode <code>compile()</code>.</p>
+## Exemples
 
-<pre class="brush: js">var regexObj = new RegExp("toto", "gi");
+Dans l'exemple qui suit, on voit comment réinitialiser le motif et les drapeaux d'une expression rationnelle grâce à  la méthode `compile()`.
+
+```js
+var regexObj = new RegExp("toto", "gi");
 regexObj.compile("nouveau toto", "g");
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Définition initiale dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Définition initiale dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.compile")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                    | Statut                       | Commentaires                                                                                                                 |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}     | {{Spec2('ES6')}}         | Définition initiale dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+| {{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}} | {{Spec2('ESDraft')}} | Définition initiale dans l'annexe B (normative) pour les fonctionnalités ECMAScript additionnelles pour les navigateurs web. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.compile")}}
+
+## Voir aussi
+
+- {{jsxref("RegExp")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/dotall/index.md b/files/fr/web/javascript/reference/global_objects/regexp/dotall/index.md
index d3942bbb9a..1c8c351469 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/dotall/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/dotall/index.md
@@ -11,39 +11,35 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/dotAll
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/dotAll
 ---
-<p>{{JSRef}}{{Draft}}</p>
+{{JSRef}}{{Draft}}
 
-<p>La propriété <strong><code>dotAll</code></strong> indique si le marqueur "<code>s</code>" est utilisé pour l'expression rationnelle. <code>dotAll</code> est une propriété en lecture seule et qui renseigne à propos de l'expression rationnelle courante.</p>
+La propriété **`dotAll`** indique si le marqueur "`s`" est utilisé pour l'expression rationnelle. `dotAll` est une propriété en lecture seule et qui renseigne à propos de l'expression rationnelle courante.
 
-<p>{{JS_Property_Attributes(0, 0, 1)}}</p>
+{{JS_Property_Attributes(0, 0, 1)}}
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p><code>dotAll</code> est un booléen qui vaut <code>true</code> si le marqueur "<code>s</code>" a été utilisé pour l'expression et <code>false</code> sinon. Le marqueur "<code>s</code>" indique que le caractère spécial point ("<code>.</code>") doit également correspondre aux caractères de saut de ligne (et pour lesquels il ne correspondrait pas s'il n'était pas activé) :</p>
+`dotAll` est un booléen qui vaut `true` si le marqueur "`s`" a été utilisé pour l'expression et `false` sinon. Le marqueur "`s`" indique que le caractère spécial point ("`.`") doit également correspondre aux caractères de saut de ligne (et pour lesquels il ne correspondrait pas s'il n'était pas activé) :
 
-<ul>
- <li>U+000A LINE FEED (LF) ("<code>\n</code>")</li>
- <li>U+000D CARRIAGE RETURN (CR) ("<code>\r</code>")</li>
- <li>U+2028 LINE SEPARATOR</li>
- <li>U+2029 PARAGRAPH SEPARATOR</li>
-</ul>
+- U+000A LINE FEED (LF) ("`\n`")
+- U+000D CARRIAGE RETURN (CR) ("`\r`")
+- U+2028 LINE SEPARATOR
+- U+2029 PARAGRAPH SEPARATOR
 
-<p>Cela signifie ainsi que le point peut correspondre à n'importe quel caractère du plan multilingue de base Unicode (ou <em>Basic Multilingual Plane</em> (BMP)). Si on souhaite également cibler les caractères des plans astraux, il faudra utiliser le marqueur "<code>u</code>" (unicode). En utilisant les deux marqueurs simultanément, on peut alors cibler n'importe quel caractère Unicode.</p>
+Cela signifie ainsi que le point peut correspondre à n'importe quel caractère du plan multilingue de base Unicode (ou _Basic Multilingual Plane_ (BMP)). Si on souhaite également cibler les caractères des plans astraux, il faudra utiliser le marqueur "`u`" (unicode). En utilisant les deux marqueurs simultanément, on peut alors cibler n'importe quel caractère Unicode.
 
-<p>Cette propriété est uniquement accessible en lecture et ne peut pas être modifiée.</p>
+Cette propriété est uniquement accessible en lecture et ne peut pas être modifiée.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.dotAll")}}</p>
+{{Compat("javascript.builtins.RegExp.dotAll")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{JSxRef("RegExp.lastIndex")}}</li>
- <li>{{JSxRef("RegExp.prototype.global")}}</li>
- <li>{{JSxRef("RegExp.prototype.ignoreCase")}}</li>
- <li>{{JSxRef("RegExp.prototype.multiline")}}</li>
- <li>{{JSxRef("RegExp.prototype.source")}}</li>
- <li>{{JSxRef("RegExp.prototype.sticky")}}</li>
- <li>{{JSxRef("RegExp.prototype.unicode")}}</li>
-</ul>
+- {{JSxRef("RegExp.lastIndex")}}
+- {{JSxRef("RegExp.prototype.global")}}
+- {{JSxRef("RegExp.prototype.ignoreCase")}}
+- {{JSxRef("RegExp.prototype.multiline")}}
+- {{JSxRef("RegExp.prototype.source")}}
+- {{JSxRef("RegExp.prototype.sticky")}}
+- {{JSxRef("RegExp.prototype.unicode")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/exec/index.md b/files/fr/web/javascript/reference/global_objects/regexp/exec/index.md
index 3245c98358..be53ae8ddd 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/exec/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/exec/index.md
@@ -10,118 +10,136 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/exec
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>exec()</code></strong> exécute la recherche d'une correspondance sur une chaîne de caractères donnée. Elle renvoie un tableau contenant les résultats ou {{jsxref("null")}}.</p>
+La méthode **`exec()`** exécute la recherche d'une correspondance sur une chaîne de caractères donnée. Elle renvoie un tableau contenant les résultats ou {{jsxref("null")}}.
 
-<p>Si on souhaite uniquement savoir s'il y a une correspondance, on utilisera la méthode {{jsxref("RegExp.prototype.test()")}} ou la méthode {{jsxref("String.prototype.search()")}}.</p>
+Si on souhaite uniquement savoir s'il y a une correspondance, on utilisera la méthode {{jsxref("RegExp.prototype.test()")}} ou la méthode {{jsxref("String.prototype.search()")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-exec.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-exec.html")}}
 
+Les objets représentant des expressions rationnelles gardent un état en mémoire lorsqu'ils utilisent les marqueurs {{jsxref("RegExp.global", "global")}} ou {{jsxref("RegExp.sticky", "sticky")}} et ils gardent notamment en mémoire {{jsxref("RegExp.lastIndex", "lastIndex")}} à partir de la correspondance précédemment trouvée. Ainsi, `exec()` peut être utilisée afin de parcourir plusieurs correspondances dans un texte (avec des groupes capturants) (contrairement à {{jsxref("String.prototype.match()")}}).
 
+## Syntaxe
 
-<p>Les objets représentant des expressions rationnelles gardent un état en mémoire lorsqu'ils utilisent les marqueurs {{jsxref("RegExp.global", "global")}} ou {{jsxref("RegExp.sticky", "sticky")}} et ils gardent notamment en mémoire {{jsxref("RegExp.lastIndex", "lastIndex")}} à partir de la correspondance précédemment trouvée. Ainsi, <code>exec()</code> peut être utilisée afin de parcourir plusieurs correspondances dans un texte (avec des groupes capturants) (contrairement à {{jsxref("String.prototype.match()")}}).</p>
+    regexObj.exec(chaîne)
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox"><var>regexObj</var>.exec(<var>chaîne</var>)</pre>
+- `chaîne`
+  - : La chaîne de caractères dans laquelle on recherche la correspondance décrite par l'expression rationnelle.
 
-<h3 id="Paramètres">Paramètres</h3>
+### Valeur de retour
 
-<dl>
- <dt><code>chaîne</code></dt>
- <dd>La chaîne de caractères dans laquelle on recherche la correspondance décrite par l'expression rationnelle.</dd>
-</dl>
+S'il y a une correspondance, la méthode `exec()` renvoie un tableau (contenant des éléments et deux propriétés `index` et `values`, cf. ci-après) et met à jour les propriétés de l'objet représentant l'expression rationnelle (notamment {{jsxref("RegExp.lastIndex", "lastIndex")}}). Le tableau renvoyé contient le texte qui correspond dans le premier élément puis un élément pour chaque groupe capturé dans les parenthèses capturantes.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+S'il n'y a aucune correspondance, la méthode `exec()` renvoie {{jsxref("null")}} et la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} reçoit la valeur 0.
 
-<p>S'il y a une correspondance, la méthode <code>exec()</code> renvoie un tableau (contenant des éléments et deux propriétés <code>index</code> et <code>values</code>, cf. ci-après) et met à jour les propriétés de l'objet représentant l'expression rationnelle (notamment {{jsxref("RegExp.lastIndex", "lastIndex")}}). Le tableau renvoyé contient le texte qui correspond dans le premier élément puis un élément pour chaque groupe capturé dans les parenthèses capturantes.</p>
+## Description
 
-<p>S'il n'y a aucune correspondance, la méthode <code>exec()</code> renvoie {{jsxref("null")}} et la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} reçoit la valeur 0.</p>
+Si on a l'exemple suivant :
 
-<h2 id="Description">Description</h2>
-
-<p>Si on a l'exemple suivant :</p>
-
-<pre class="brush: js">// On a une correspondance si on a "quick brown" suivi par "jumps", on ignore les caractères entre
+```js
+// On a une correspondance si on a "quick brown" suivi par "jumps", on ignore les caractères entre
 // On garde en mémoire "brown" et "jumps"
 // On ignore la casse
 var re = /quick\s(brown).+?(jumps)/ig;
 var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog');
-</pre>
+```
 
-<p>Le tableau suivant montre l'état résultant suite à ce script :</p>
+Le tableau suivant montre l'état résultant suite à ce script :
 
 <table class="fullwidth-table">
- <tbody>
-  <tr>
-   <td class="header">Objet</td>
-   <td class="header">Propriété/Index</td>
-   <td class="header">Description</td>
-   <td class="header">Exemple</td>
-  </tr>
-  <tr>
-   <td rowspan="4"><code>result</code></td>
-   <td><code>[0]</code></td>
-   <td>La chaîne complète des caractères qui correspondent.</td>
-   <td><code>"Quick Brown Fox Jumps"</code></td>
-  </tr>
-  <tr>
-   <td><code>[1], ...[<em>n</em> ]</code></td>
-   <td>Les sous-chaînes correspondantes aux groupes capturants s'il y en a. Le nombre de groupes de parenthèses capturantes est illimité.</td>
-   <td><code>result[1] === "Brown"<br>
-    result[2] === "Jumps"</code></td>
-  </tr>
-  <tr>
-   <td><code>index</code></td>
-   <td>L'indice (compté à partir de 0) de la correspondance dans la chaîne.</td>
-   <td><code>4</code></td>
-  </tr>
-  <tr>
-   <td><code>input</code></td>
-   <td>La chaîne de caractères utilisée en entrée.</td>
-   <td><code>"The Quick Brown Fox Jumps Over The Lazy Dog"</code></td>
-  </tr>
-  <tr>
-   <td rowspan="5"><code>re</code></td>
-   <td><code>lastIndex</code></td>
-   <td>L'indice à partir duquel chercher la prochaine correspondance. Lorsque le drapeau "g" est absent, cette propriété sera 0.</td>
-   <td><code>25</code></td>
-  </tr>
-  <tr>
-   <td><code>ignoreCase</code></td>
-   <td>Indique si le drapeau "<code>i</code>" a été utilisé pour ignorer la casse.</td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>global</code></td>
-   <td>Indique si le drapeau "<code>g</code>" a été utilisé pour la correspondance globale.</td>
-   <td><code>true</code></td>
-  </tr>
-  <tr>
-   <td><code>multiline</code></td>
-   <td>Indique si le drapeau "<code>m</code>" a été utilisé pour chercher une correspondance sur plusieurs lignes.</td>
-   <td><code>false</code></td>
-  </tr>
-  <tr>
-   <td><code>source</code></td>
-   <td>Le texte du motif.</td>
-   <td><code>"quick\s(brown).+?(jumps)"</code></td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <td class="header">Objet</td>
+      <td class="header">Propriété/Index</td>
+      <td class="header">Description</td>
+      <td class="header">Exemple</td>
+    </tr>
+    <tr>
+      <td rowspan="4"><code>result</code></td>
+      <td><code>[0]</code></td>
+      <td>La chaîne complète des caractères qui correspondent.</td>
+      <td><code>"Quick Brown Fox Jumps"</code></td>
+    </tr>
+    <tr>
+      <td>
+        <code>[1], ...[<em>n</em> ]</code>
+      </td>
+      <td>
+        Les sous-chaînes correspondantes aux groupes capturants s'il y en a. Le
+        nombre de groupes de parenthèses capturantes est illimité.
+      </td>
+      <td>
+        <code>result[1] === "Brown"<br />result[2] === "Jumps"</code>
+      </td>
+    </tr>
+    <tr>
+      <td><code>index</code></td>
+      <td>
+        L'indice (compté à partir de 0) de la correspondance dans la chaîne.
+      </td>
+      <td><code>4</code></td>
+    </tr>
+    <tr>
+      <td><code>input</code></td>
+      <td>La chaîne de caractères utilisée en entrée.</td>
+      <td><code>"The Quick Brown Fox Jumps Over The Lazy Dog"</code></td>
+    </tr>
+    <tr>
+      <td rowspan="5"><code>re</code></td>
+      <td><code>lastIndex</code></td>
+      <td>
+        L'indice à partir duquel chercher la prochaine correspondance. Lorsque
+        le drapeau "g" est absent, cette propriété sera 0.
+      </td>
+      <td><code>25</code></td>
+    </tr>
+    <tr>
+      <td><code>ignoreCase</code></td>
+      <td>
+        Indique si le drapeau "<code>i</code>" a été utilisé pour ignorer la
+        casse.
+      </td>
+      <td><code>true</code></td>
+    </tr>
+    <tr>
+      <td><code>global</code></td>
+      <td>
+        Indique si le drapeau "<code>g</code>" a été utilisé pour la
+        correspondance globale.
+      </td>
+      <td><code>true</code></td>
+    </tr>
+    <tr>
+      <td><code>multiline</code></td>
+      <td>
+        Indique si le drapeau "<code>m</code>" a été utilisé pour chercher une
+        correspondance sur plusieurs lignes.
+      </td>
+      <td><code>false</code></td>
+    </tr>
+    <tr>
+      <td><code>source</code></td>
+      <td>Le texte du motif.</td>
+      <td><code>"quick\s(brown).+?(jumps)"</code></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Trouver_des_correspondances_successives">Trouver des correspondances successives</h3>
+### Trouver des correspondances successives
 
-<p>Si on utilise le drapeau "<code>g</code>" dans l'expression rationnelle, on peut utiliser la méthode <code>exec()</code> plusieurs fois afin de trouver les correspondances successives dans la chaîne. Lorsqu'on procède ainsi, la recherche reprend à la position indiquée par la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} ({{jsxref("RegExp.prototype.test()", "test()")}} fera également progresser la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}}).</p>
+Si on utilise le drapeau "`g`" dans l'expression rationnelle, on peut utiliser la méthode `exec()` plusieurs fois afin de trouver les correspondances successives dans la chaîne. Lorsqu'on procède ainsi, la recherche reprend à la position indiquée par la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} ({{jsxref("RegExp.prototype.test()", "test()")}} fera également progresser la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}}).
 
-<p>On notera que la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} ne sera pas réinitialisée lors de la recherche sur une autre chaîne de caractères, c'est la valeur existante de {{jsxref("RegExp.lastIndex", "lastIndex")}} qui sera utilisée.</p>
+On notera que la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} ne sera pas réinitialisée lors de la recherche sur une autre chaîne de caractères, c'est la valeur existante de {{jsxref("RegExp.lastIndex", "lastIndex")}} qui sera utilisée.
 
-<p>Par exemple, si on utilise le fragment de code suivant :</p>
+Par exemple, si on utilise le fragment de code suivant :
 
-<pre class="brush: js">var maRegex = /ab*/g;
+```js
+var maRegex = /ab*/g;
 var str = 'abbcdefabh';
 var monTableau;
 while ((monTableau = maRegex.exec(str)) !== null) {
@@ -129,71 +147,42 @@ while ((monTableau = maRegex.exec(str)) !== null) {
   msg += 'Prochaine correspondance à partir de ' + maRegex.lastIndex;
   console.log(msg);
 }
-</pre>
+```
 
-<p>Le script affichera alors :</p>
+Le script affichera alors :
 
-<pre>Trouvé abb. Prochaine correspondance à partir de 3
-Trouvé ab. Prochaine correspondance à partir de 9
-</pre>
+    Trouvé abb. Prochaine correspondance à partir de 3
+    Trouvé ab. Prochaine correspondance à partir de 9
 
-<div class="warning">
-<p><strong>Attention :</strong> Il ne faut pas placer un littéral d'expression rationnelle (ou le constructeur {{jsxref("RegExp")}}) au sein de la condition <code>while</code> car cela créerait un boucle infinie s'il y a une correspondance car la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} serait redéfinie à chaque itération. Il faut également s'assurer que le drapeau global est défini sinon on aura également une boucle.</p>
-</div>
+> **Attention :** Il ne faut pas placer un littéral d'expression rationnelle (ou le constructeur {{jsxref("RegExp")}}) au sein de la condition `while` car cela créerait un boucle infinie s'il y a une correspondance car la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} serait redéfinie à chaque itération. Il faut également s'assurer que le drapeau global est défini sinon on aura également une boucle.
 
-<h3 id="Utiliser_exec()_avec_des_littéraux">Utiliser <code>exec()</code> avec des littéraux</h3>
+### Utiliser `exec()` avec des littéraux
 
-<p>Il est aussi possible d'utiliser <code>exec()</code> sans créer d'objet {{jsxref("RegExp")}} explicite :</p>
+Il est aussi possible d'utiliser `exec()` sans créer d'objet {{jsxref("RegExp")}} explicite :
 
-<pre class="brush: js">var matches = /(coucou \S+)/.exec('Ceci est un coucou monde !');
+```js
+var matches = /(coucou \S+)/.exec('Ceci est un coucou monde !');
 console.log(matches[1]);
-</pre>
-
-<p>Cela affichera 'coucou monde !'.</p>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+```
+
+Cela affichera 'coucou monde !'.
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}} | {{Spec2('ESDraft')}} |                                                       |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.exec")}}</p>
+{{Compat("javascript.builtins.RegExp.exec")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>Le chapitre sur <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">les expressions rationnelles</a> du <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a></li>
- <li>{{jsxref("RegExp")}}</li>
- <li>{{jsxref("String.prototype.match()")}}</li>
- <li>{{jsxref("String.prototype.matchAll()")}}</li>
-</ul>
+- Le chapitre sur [les expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières) du [Guide JavaScript](/fr/docs/Web/JavaScript/Guide)
+- {{jsxref("RegExp")}}
+- {{jsxref("String.prototype.match()")}}
+- {{jsxref("String.prototype.matchAll()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/flags/index.md b/files/fr/web/javascript/reference/global_objects/regexp/flags/index.md
index f03a085b92..1bea14f02d 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/flags/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/flags/index.md
@@ -12,31 +12,29 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/flags
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/flags
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>flags</code></strong> renvoie une chaîne de caractères contenant les <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières#Effectuer_des_recherches_avanc.C3.A9es_en_utilisant_les_drapeaux_(flags)">drapeaux (<em>flags</em>)</a> de l'objet {{jsxref("RegExp")}} auquel elle appartient.</p>
+La propriété **`flags`** renvoie une chaîne de caractères contenant les [drapeaux (_flags_)](</fr/docs/Web/JavaScript/Guide/Expressions_régulières#Effectuer_des_recherches_avanc.C3.A9es_en_utilisant_les_drapeaux_(flags)>) de l'objet {{jsxref("RegExp")}} auquel elle appartient.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-flags.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-flags.html")}}{{js_property_attributes(0, 0, 1)}}
 
+## Description
 
+Les drapeaux de la propriété `flags` sont rangés par ordre alphabétique de gauche à droite.
 
-<div>{{js_property_attributes(0, 0, 1)}}</div>
+## Exemples
 
-<h2 id="Description">Description</h2>
+### Utiliser `flags`
 
-<p>Les drapeaux de la propriété <code>flags</code> sont rangés par ordre alphabétique de gauche à droite.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Utiliser_flags">Utiliser <code>flags</code></h3>
-
-<pre class="brush: js">/toto/ig.flags;   // "gi"
+```js
+/toto/ig.flags;   // "gi"
 /truc/myu.flags;  // "muy"
-</pre>
+```
 
-<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2>
+## Prothèse d'émulation (_polyfill_)
 
-<pre class="brush: js">if (RegExp.prototype.flags === undefined) {
+```js
+if (RegExp.prototype.flags === undefined) {
   Object.defineProperty(RegExp.prototype, 'flags', {
     configurable: true,
     get: function() {
@@ -44,36 +42,19 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/flags
     }
   });
 }
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-get-regexp.prototype.flags', 'RegExp.prototype.flags')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.flags', 'RegExp.prototype.flags')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                    | État                         | Commentaires         |
+| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-get-regexp.prototype.flags', 'RegExp.prototype.flags')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-regexp.prototype.flags', 'RegExp.prototype.flags')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.flags")}}</p>
+{{Compat("javascript.builtins.RegExp.flags")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("RegExp.prototype.source")}}</li>
-</ul>
+- {{jsxref("RegExp.prototype.source")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/global/index.md b/files/fr/web/javascript/reference/global_objects/regexp/global/index.md
index 7702ec1769..0b97b04853 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/global/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/global/index.md
@@ -10,25 +10,22 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/global
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/global
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>global</strong></code> indique si le marqueur (<em>flag</em>) "<code>g</code>" est utilisé pour l'expression rationnelle. <code>global</code> est une propriété accessible en lecture seule pour une expression rationnelle donnée.</p>
+La propriété **`global`** indique si le marqueur (_flag_) "`g`" est utilisé pour l'expression rationnelle. `global` est une propriété accessible en lecture seule pour une expression rationnelle donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-global.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-global.html")}}{{js_property_attributes(0,0,1)}}
 
+## Description
 
+La valeur de `global` est un booléen. Elle vaut `true` si le flag "`g`" a été utilisé, `false` sinon. Le _flag_ "`g`" indique que l'expression rationnelle recherchera toutes les correspondances possibles d'une chaîne de caractères. Lorsqu'une expression rationnelle utilise à la fois les marqueurs `global` et `sticky` (respectivement `"g"` et `"y"`), elle ignorera le marqueur `global`.
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+Cette propriété ne peut pas être modifiée directement.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La valeur de <code>global</code> est un booléen. Elle vaut <code>true</code> si le flag "<code>g</code>" a été utilisé, <code>false</code> sinon. Le <em>flag</em> "<code>g</code>" indique que l'expression rationnelle recherchera toutes les correspondances possibles d'une chaîne de caractères. Lorsqu'une expression rationnelle utilise à la fois les marqueurs <code>global</code> et <code>sticky</code> (respectivement <code>"g"</code> et <code>"y"</code>), elle ignorera le marqueur <code>global</code>.</p>
-
-<p>Cette propriété ne peut pas être modifiée directement.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush:js">var regex = new RegExp("toto", "g");
+```js
+var regex = new RegExp("toto", "g");
 
 console.log(regex.global); // true
 
@@ -40,50 +37,26 @@ console.log(str1);  // affichera "exemple" dans la console
 var regex1 = new RegExp('toto');
 var str2 = str.replace(regex1, '');
 
-console.log(str2);  // affichera "exempletoto" dans la console</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : <code>global</code> est une propriété d'une instance de {{jsxref("RegExp")}} et non une propriété de l'objet <code>RegExp</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10.7.2', 'RegExp.prototype.global')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-get-regexp.prototype.global', 'RegExp.prototype.global')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td><code>global</code> est désormais un accesseur lié au prototype plutôt qu'une propriété de données liée à l'instance.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.global', 'RegExp.prototype.global')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.global")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
- <li>{{jsxref("RegExp.prototype.lastIndex")}}</li>
- <li>{{jsxref("RegExp.prototype.multiline")}}</li>
- <li>{{jsxref("RegExp.prototype.source")}}</li>
- <li>{{jsxref("RegExp.prototype.sticky")}}</li>
-</ul>
+console.log(str2);  // affichera "exempletoto" dans la console
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | Statut                       | Commentaires                                                                                                                                                                                    |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                             | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : `global` est une propriété d'une instance de {{jsxref("RegExp")}} et non une propriété de l'objet `RegExp`. |
+| {{SpecName('ES5.1', '#sec-15.10.7.2', 'RegExp.prototype.global')}}                             | {{Spec2('ES5.1')}}     |                                                                                                                                                                                                 |
+| {{SpecName('ES6', '#sec-get-regexp.prototype.global', 'RegExp.prototype.global')}}         | {{Spec2('ES6')}}         | `global` est désormais un accesseur lié au prototype plutôt qu'une propriété de données liée à l'instance.                                                                                      |
+| {{SpecName('ESDraft', '#sec-get-regexp.prototype.global', 'RegExp.prototype.global')}} | {{Spec2('ESDraft')}} |                                                                                                                                                                                                 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.global")}}
+
+## Voir aussi
+
+- {{jsxref("RegExp.prototype.ignoreCase")}}
+- {{jsxref("RegExp.prototype.lastIndex")}}
+- {{jsxref("RegExp.prototype.multiline")}}
+- {{jsxref("RegExp.prototype.source")}}
+- {{jsxref("RegExp.prototype.sticky")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/ignorecase/index.md b/files/fr/web/javascript/reference/global_objects/regexp/ignorecase/index.md
index 22fecc736d..d893c5d57e 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/ignorecase/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/ignorecase/index.md
@@ -10,73 +10,43 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/ignoreCase
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>ignoreCase</strong></code> indique si le drapeau (<em>flag</em>) "<code>i</code>" est utilisé ou non pour cette expression rationnelle. <code>ignoreCase</code> est une propriété accessible en lecture seule d'une instance d'expression rationnelle donnée.</p>
+La propriété **`ignoreCase`** indique si le drapeau (_flag_) "`i`" est utilisé ou non pour cette expression rationnelle. `ignoreCase` est une propriété accessible en lecture seule d'une instance d'expression rationnelle donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-ignorecase.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-ignorecase.html")}}{{js_property_attributes(0,0,1)}}
 
+## Description
 
+La valeur de `ignoreCase` est un booléen. Elle vaut `true` si le flag "`i`" a été utilisé et `false` sinon. Le drapeau "`i`" indique si la recherche de correspondances doit être sensible à la casse ou non.
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+Cette propriété ne peut pas être modifiée directement.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La valeur de <code>ignoreCase</code> est un booléen. Elle vaut <code>true</code> si le flag "<code>i</code>" a été utilisé et <code>false</code> sinon. Le drapeau "<code>i</code>" indique si la recherche de correspondances doit être sensible à la casse ou non.</p>
-
-<p>Cette propriété ne peut pas être modifiée directement.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush:js">var regex = new RegExp("toto", "i");
+```js
+var regex = new RegExp("toto", "i");
 
 console.log(regex.ignoreCase); // true
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : <code>ignoreCase</code> est une propriété d'une instance de {{jsxref("RegExp")}} et pas une propriété de l'objet <code>RegExp</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10.7.3', 'RegExp.prototype.ignoreCase')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td><code>ignoreCase</code> est désormais une propriété du prototype sous forme d'accesseur plutôt qu'une propriété directe de l'instance.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+```
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
+| Spécification                                                                                                                | Statut                       | Commentaires                                                                                                                                                                                        |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : `ignoreCase` est une propriété d'une instance de {{jsxref("RegExp")}} et pas une propriété de l'objet `RegExp`. |
+| {{SpecName('ES5.1', '#sec-15.10.7.3', 'RegExp.prototype.ignoreCase')}}                                 | {{Spec2('ES5.1')}}     |                                                                                                                                                                                                     |
+| {{SpecName('ES6', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}     | {{Spec2('ES6')}}         | `ignoreCase` est désormais une propriété du prototype sous forme d'accesseur plutôt qu'une propriété directe de l'instance.                                                                         |
+| {{SpecName('ESDraft', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}} | {{Spec2('ESDraft')}} |                                                                                                                                                                                                     |
 
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.ignoreCase")}}</p>
+{{Compat("javascript.builtins.RegExp.ignoreCase")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("RegExp.prototype.global")}}</li>
- <li>{{jsxref("RegExp.prototype.lastIndex")}}</li>
- <li>{{jsxref("RegExp.prototype.multiline")}}</li>
- <li>{{jsxref("RegExp.prototype.source")}}</li>
- <li>{{jsxref("RegExp.prototype.sticky")}}</li>
-</ul>
+- {{jsxref("RegExp.prototype.global")}}
+- {{jsxref("RegExp.prototype.lastIndex")}}
+- {{jsxref("RegExp.prototype.multiline")}}
+- {{jsxref("RegExp.prototype.source")}}
+- {{jsxref("RegExp.prototype.sticky")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/index.md b/files/fr/web/javascript/reference/global_objects/regexp/index.md
index 720207ce42..85c0aeee92 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/index.md
@@ -10,136 +10,134 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Le constructeur <strong>RegExp</strong> crée un objet expression rationnelle pour la reconnaissance d'un modèle dans un texte.</p>
+Le constructeur **RegExp** crée un objet expression rationnelle pour la reconnaissance d'un modèle dans un texte.
 
-<p>Pour une introduction aux expressions rationnelles, lire le <a href="/fr/docs/Web/JavaScript/Guide/Expressions_r%C3%A9guli%C3%A8res">chapitre Expressions rationnelles dans le Guide JavaScript</a>.</p>
+Pour une introduction aux expressions rationnelles, lire le [chapitre Expressions rationnelles dans le Guide JavaScript](/fr/docs/Web/JavaScript/Guide/Expressions_r%C3%A9guli%C3%A8res).
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-constructor.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-constructor.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<p>Les notations littérales, par constructeur ou de base sont possibles :</p>
+Les notations littérales, par constructeur ou de base sont possibles :
 
-<pre class="syntaxbox">/<em>modèle</em>/<var>marqueurs</var>
-new RegExp(<var>modèle</var>[, <em>marqueurs</em>])
-RegExp(<var>modèle</var>[, <em>marqueurs</em>])
-</pre>
+    /modèle/marqueurs
+    new RegExp(modèle[, marqueurs])
+    RegExp(modèle[, marqueurs])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>modèle</code></dt>
- <dd>Le texte de l'expression rationnelle ou, à partir d'ES5, un autre objet ou littéral <code>RegExp</code> à copier. Ce motif peut inclure <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières#Types_de_caractères_spéciaux">certains caractères spéciaux</a> pour correspondre à un ensemble de valeurs plus large (qu'une simple chaîne littérale).</dd>
- <dt><code>marqueurs</code></dt>
- <dd>
- <p>Si cet argument est utilisé, il indique les marqueurs à utiliser pour l'expression rationnelle. Ces valeurs remplaceront celles de l'objet à copier si <code>modèle</code> est un objet <code>RegExp</code> (<code>lastIndex</code> sera réinitialisé à 0 à partir d'ECMAScript 2015 / ES6). Cet argument est une chaîne de caractères qui peut contenir une combinaison des valeurs suivantes:</p>
+- `modèle`
+  - : Le texte de l'expression rationnelle ou, à partir d'ES5, un autre objet ou littéral `RegExp` à copier. Ce motif peut inclure [certains caractères spéciaux](/fr/docs/Web/JavaScript/Guide/Expressions_régulières#Types_de_caractères_spéciaux) pour correspondre à un ensemble de valeurs plus large (qu'une simple chaîne littérale).
+- `marqueurs`
 
- <dl>
-  <dt><code>g</code></dt>
-  <dd>recherche globale ; retrouve toutes les correspondances plutôt que de s'arrêter après la première.</dd>
-  <dt><code>i</code></dt>
-  <dd>la casse est ignorée. Si le marqueur <code>u</code> est également activé, les caractères Unicode équivalents pour la casse correspondent.</dd>
-  <dt><code>m</code></dt>
-  <dd>multiligne : les caractères de début et de fin (^ et $) sont traités comme travaillant sur des lignes multiples (i.e, ils correspondent au début et à la fin de <em>chaque</em> ligne (délimitée par \n ou \r), pas seulement au début ou à la fin de la chaîne d'entrée complète).</dd>
-  <dt><code>u</code></dt>
-  <dd>unicode : traite le modèle comme une séquence de points de code Unicode (voir également <a href="/fr/docs/Web/API/DOMString/Binary">les chaînes binaires</a>).</dd>
-  <dt><code>y</code></dt>
-  <dd>adhérence : n'établit de correspondance qu'à partir de l'indice dans la chaîne cible indiqué par la propriété <code>lastIndex</code> de l'expression rationnelle (et ne cherche pas à établir de correspondance à partir d'indices au delà).</dd>
-  <dt><code>s</code></dt>
-  <dd>"dotAll" : permet d'indiquer que <code>.</code> peut correspondre à un saut de ligne.</dd>
- </dl>
- </dd>
-</dl>
+  - : Si cet argument est utilisé, il indique les marqueurs à utiliser pour l'expression rationnelle. Ces valeurs remplaceront celles de l'objet à copier si `modèle` est un objet `RegExp` (`lastIndex` sera réinitialisé à 0 à partir d'ECMAScript 2015 / ES6). Cet argument est une chaîne de caractères qui peut contenir une combinaison des valeurs suivantes:
 
-<h2 id="Description">Description</h2>
+    - `g`
+      - : recherche globale ; retrouve toutes les correspondances plutôt que de s'arrêter après la première.
+    - `i`
+      - : la casse est ignorée. Si le marqueur `u` est également activé, les caractères Unicode équivalents pour la casse correspondent.
+    - `m`
+      - : multiligne : les caractères de début et de fin (^ et $) sont traités comme travaillant sur des lignes multiples (i.e, ils correspondent au début et à la fin de _chaque_ ligne (délimitée par \n ou \r), pas seulement au début ou à la fin de la chaîne d'entrée complète).
+    - `u`
+      - : unicode : traite le modèle comme une séquence de points de code Unicode (voir également [les chaînes binaires](/fr/docs/Web/API/DOMString/Binary)).
+    - `y`
+      - : adhérence : n'établit de correspondance qu'à partir de l'indice dans la chaîne cible indiqué par la propriété `lastIndex` de l'expression rationnelle (et ne cherche pas à établir de correspondance à partir d'indices au delà).
+    - `s`
+      - : "dotAll" : permet d'indiquer que `.` peut correspondre à un saut de ligne.
 
-<p>Il existe deux façons de créer un objet <code>RegExp</code> : une notation littérale ou un constructeur. La notation littérale est délimitée par des barres obliques (<em>slashes</em>) tandis que le constructeur utilise des apostrophes. Ainsi, les expressions suivantes créent la même expression rationnelle :</p>
+## Description
 
-<pre class="brush: js">/ab+c/i;                   // notation littérale
+Il existe deux façons de créer un objet `RegExp` : une notation littérale ou un constructeur. La notation littérale est délimitée par des barres obliques (_slashes_) tandis que le constructeur utilise des apostrophes. Ainsi, les expressions suivantes créent la même expression rationnelle :
+
+```js
+/ab+c/i;                   // notation littérale
 new RegExp('ab+c', 'i');   // constructeur
 new RegExp(/ab+c/, 'i');   // notation littérale dans un constructeur
-</pre>
+```
 
-<p>La notation littérale effectue la compilation de l'expression rationnelle lorsque l'expression est évaluée. Utilisez la notation littérale lorsque l'expression rationnelle reste constante. Par exemple, si vous utilisez la notation littérale pour construire une expression rationnelle utilisée dans une boucle, l'expression rationnelle ne sera pas recompilée à chaque itération.</p>
+La notation littérale effectue la compilation de l'expression rationnelle lorsque l'expression est évaluée. Utilisez la notation littérale lorsque l'expression rationnelle reste constante. Par exemple, si vous utilisez la notation littérale pour construire une expression rationnelle utilisée dans une boucle, l'expression rationnelle ne sera pas recompilée à chaque itération.
 
-<p>Le constructeur de l'objet expression rationnelle, par exemple <code>new RegExp('ab+c')</code>, effectue la compilation de l'expression rationnelle au moment de l'exécution. Utilisez la fonction constructeur quand vous savez que le modèle d'une expression rationnelle sera variable, ou si vous ne connaissez pas le modèle et que vous l'obtiendrez d'une autre source, telle qu'une saisie utilisateur.</p>
+Le constructeur de l'objet expression rationnelle, par exemple `new RegExp('ab+c')`, effectue la compilation de l'expression rationnelle au moment de l'exécution. Utilisez la fonction constructeur quand vous savez que le modèle d'une expression rationnelle sera variable, ou si vous ne connaissez pas le modèle et que vous l'obtiendrez d'une autre source, telle qu'une saisie utilisateur.
 
-<p>À partir d'ECMAScript 6, <code>new RegExp(/ab+c/, 'i')</code> ne déclenche plus d'exception {{jsxref("TypeError")}} ("can't supply flags when constructing one RegExp from another") lorsque le premier argument est une RegExp et que le second argument <code>marqueurs</code> est présent. Une nouvelle <code>RegExp</code> sera créée à la place à partir des arguments.</p>
+À partir d'ECMAScript 6, `new RegExp(/ab+c/, 'i')` ne déclenche plus d'exception {{jsxref("TypeError")}} ("can't supply flags when constructing one RegExp from another") lorsque le premier argument est une RegExp et que le second argument `marqueurs` est présent. Une nouvelle `RegExp` sera créée à la place à partir des arguments.
 
-<p>Lorsqu'on utilise le constructeur, les règles normales d'échappement de chaîne (le fait de faire précéder d'un \ les caractères spéciaux à l'intérieur d'une chaîne) sont requises. Par exemple, les définitions suivantes sont équivalentes :</p>
+Lorsqu'on utilise le constructeur, les règles normales d'échappement de chaîne (le fait de faire précéder d'un \ les caractères spéciaux à l'intérieur d'une chaîne) sont requises. Par exemple, les définitions suivantes sont équivalentes :
 
-<pre class="brush: js">var re = /\w+/;
+```js
+var re = /\w+/;
 var re = new RegExp('\\w+');
-</pre>
+```
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("RegExp.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés à tous les objets qui sont des expressions rationnelles.</dd>
- <dt><code>RegExp.length</code></dt>
- <dd>La valeur de longueur pour le constructeur dont la valeur est 2.</dd>
- <dt>{{jsxref("RegExp.@@species", "get RegExp[@@species]")}}</dt>
- <dd>La fonction de construction utilisée pour créer les objets dérivés.</dd>
- <dt>{{jsxref("RegExp.lastIndex")}}</dt>
- <dd>L'indice à partir duquel rechercher la prochaine correspondance.</dd>
-</dl>
+- {{jsxref("RegExp.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés à tous les objets qui sont des expressions rationnelles.
+- `RegExp.length`
+  - : La valeur de longueur pour le constructeur dont la valeur est 2.
+- {{jsxref("RegExp.@@species", "get RegExp[@@species]")}}
+  - : La fonction de construction utilisée pour créer les objets dérivés.
+- {{jsxref("RegExp.lastIndex")}}
+  - : L'indice à partir duquel rechercher la prochaine correspondance.
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<p>L'objet global <code>RegExp</code> ne possède pas de méthode propre. En revanche, il hérite de certaines méthodes via sa chaîne de prototypes.</p>
+L'objet global `RegExp` ne possède pas de méthode propre. En revanche, il hérite de certaines méthodes via sa chaîne de prototypes.
 
-<h2 id="Le_prototype_de_RegExp_et_les_instances">Le prototype de <code>RegExp</code> et les instances</h2>
+## Le prototype de `RegExp` et les instances
 
-<h3 id="Propriétés_2">Propriétés</h3>
+### Propriétés
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/RegExp/prototype', 'Propriétés')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/RegExp/prototype', 'Propriétés')}}
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<div>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/RegExp/prototype', 'Méthodes')}}</div>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/RegExp/prototype', 'Méthodes')}}
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_une_expression_rationnelle_pour_modifier_un_format_de_données">Utiliser une expression rationnelle pour modifier un format de données</h3>
+### Utiliser une expression rationnelle pour modifier un format de données
 
-<p>Dans le script suivant, on utilise la méthode {{jsxref("String.prototype.replace()", "replace()")}} de {{jsxref("String")}} pour effectuer une correspondance sur le prénom et le nom pour les inverser. On utilise des parenthèses capturantes pour pouvoir utiliser les correspondances dans la construction du résultat (avec <code>$1</code> et <code>$2</code>).</p>
+Dans le script suivant, on utilise la méthode {{jsxref("String.prototype.replace()", "replace()")}} de {{jsxref("String")}} pour effectuer une correspondance sur le prénom et le nom pour les inverser. On utilise des parenthèses capturantes pour pouvoir utiliser les correspondances dans la construction du résultat (avec `$1` et `$2`).
 
-<pre class="brush: js">var re = /(\w+)\s(\w+)/;
+```js
+var re = /(\w+)\s(\w+)/;
 var chaîne = 'Alain Dupont';
 var nouvelleChaîne = chaîne.replace(re, '$2, $1');
 console.log(nouvelleChaîne);
-</pre>
+```
 
-<p>Cela affichera "Dupont, Alain".</p>
+Cela affichera "Dupont, Alain".
 
-<h3 id="Utiliser_une_expression_rationnelle_pour_découper_des_lignes_avec_différents_sauts_de_lignefins_de_ligne">Utiliser une expression rationnelle pour découper des lignes avec différents sauts de ligne/fins de ligne</h3>
+### Utiliser une expression rationnelle pour découper des lignes avec différents sauts de ligne/fins de ligne
 
-<p>La fin de ligne par défaut dépend de la plateforme (Unix, Windows, etc.). Cette méthode de découpage fournie permet de découper indépendamment de la plateforme utilisée.</p>
+La fin de ligne par défaut dépend de la plateforme (Unix, Windows, etc.). Cette méthode de découpage fournie permet de découper indépendamment de la plateforme utilisée.
 
-<pre class="brush: js">var texte = 'Un texte\net un autre\r\npuis ensuite\rla fin';
+```js
+var texte = 'Un texte\net un autre\r\npuis ensuite\rla fin';
 var lignes = texte.split(/\r\n|\r|\n/);
 console.log(lignes); // affiche [ 'Un texte', 'et un autre', 'puis ensuite', 'la fin' ]
-</pre>
+```
 
-<p>On voit ici que l'ordre des modèles dans l'expression rationnelle importe.</p>
+On voit ici que l'ordre des modèles dans l'expression rationnelle importe.
 
-<h3 id="Utiliser_une_expression_rationnelle_sur_plusieurs_lignes">Utiliser une expression rationnelle sur plusieurs lignes</h3>
+### Utiliser une expression rationnelle sur plusieurs lignes
 
-<pre class="brush: js">var s = 'Et voici\nune autre ligne !';
+```js
+var s = 'Et voici\nune autre ligne !';
 s.match(/voici.*ligne/);
 // Renvoie null
 s.match(/voici[^]*ligne/);
 // Renvoie ['voici\nune autre ligne']
-</pre>
+```
 
-<h3 id="Utiliser_une_expression_rationnelle_avec_le_marqueur_d'adhérence">Utiliser une expression rationnelle avec le marqueur d'adhérence</h3>
+### Utiliser une expression rationnelle avec le marqueur d'adhérence
 
-<p>Cet exemple illustre comment on peut utiliser ce marqueur qui recherche une correspondance après {{jsxref("RegExp.prototype.lastIndex")}}.</p>
+Cet exemple illustre comment on peut utiliser ce marqueur qui recherche une correspondance après {{jsxref("RegExp.prototype.lastIndex")}}.
 
-<pre class="brush: js">var str = '#toto#';
+```js
+var str = '#toto#';
 var regex = /toto/y;
 
 regex.lastIndex; // 0
@@ -148,13 +146,15 @@ regex.lastIndex = 1;
 regex.test(str); // true
 regex.lastIndex = 5;
 regex.test(str); // false (lastIndex est pris en compte avec ce marqueur)
-regex.lastIndex; // 0 (réinitialisation suite à l'échec)</pre>
+regex.lastIndex; // 0 (réinitialisation suite à l'échec)
+```
 
-<h3 id="Les_expressions_rationnelles_et_les_caractères_Unicode">Les expressions rationnelles et les caractères Unicode</h3>
+### Les expressions rationnelles et les caractères Unicode
 
-<p>Comme mentionné ci-avant, les classes <code>\w</code> ou <code>\W</code> ne correspondent qu'à des caractères ASCII "a" à "z", "A" à "Z", "0" à "9" et "_". Pour effectuer des correspondances sur d'autres caractères (comme par exemple les caractères cyrilliques), on utilisera <code>\uhhhh</code>, où "hhhh" représente la valeur Unicode exprimée en hexadécimal. Cet exemple illustre comment il est possible de séparer les caractères Unicode d'un mot.</p>
+Comme mentionné ci-avant, les classes `\w` ou `\W` ne correspondent qu'à des caractères ASCII "a" à "z", "A" à "Z", "0" à "9" et "\_". Pour effectuer des correspondances sur d'autres caractères (comme par exemple les caractères cyrilliques), on utilisera `\uhhhh`, où "hhhh" représente la valeur Unicode exprimée en hexadécimal. Cet exemple illustre comment il est possible de séparer les caractères Unicode d'un mot.
 
-<pre class="brush: js">var texte = 'Образец text на русском языке';
+```js
+var texte = 'Образец text на русском языке';
 var regex = /[\u0400-\u04FF]+/g;
 
 var corresp = regex.exec(texte);
@@ -166,59 +166,70 @@ console.log(corresp2[0]);     // affiche 'на' (n'affiche pas text
 console.log(regex.lastIndex); // affiche '15'
 
 // et ainsi de suite
-</pre>
+```
 
-<p>Voici une ressource tierce pour obtenir les différents intervalles Unicode des différents alphabets : <a href="https://kourge.net/projects/regexp-unicode-block">Regexp-unicode-block</a>.</p>
+Voici une ressource tierce pour obtenir les différents intervalles Unicode des différents alphabets : [Regexp-unicode-block](https://kourge.net/projects/regexp-unicode-block).
 
-<h3 id="Extraire_un_sous-domaine_d'une_URL">Extraire un sous-domaine d'une URL</h3>
+### Extraire un sous-domaine d'une URL
 
-<pre class="brush: js">var url = 'http://xxx.domaine.com';
+```js
+var url = 'http://xxx.domaine.com';
 console.log(/[^.]+/.exec(url)[0].substr(7)); // affiche 'xxx'
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10', 'RegExp')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>
-    <p>Le constructeur <code>RegExp</code> ne renvoie plus d'exception lorsqu'il est utilisé avec un objet <code>RegExp</code> et que le second argument est utilisé. Ajout du marqueur d'adhérence et du marqueur Unicode.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp-regular-expression-objects', 'RegExp')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <th scope="col">Spécification</th>
+      <th scope="col">État</th>
+      <th scope="col">Commentaires</th>
+    </tr>
+    <tr>
+      <td>{{SpecName('ES1')}}</td>
+      <td>{{Spec2('ES1')}}</td>
+      <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
+    </tr>
+    <tr>
+      <td>{{SpecName('ES5.1', '#sec-15.10', 'RegExp')}}</td>
+      <td>{{Spec2('ES5.1')}}</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}}
+      </td>
+      <td>{{Spec2('ES6')}}</td>
+      <td>
+        <p>
+          Le constructeur <code>RegExp</code> ne renvoie plus d'exception
+          lorsqu'il est utilisé avec un objet <code>RegExp</code> et que le
+          second argument est utilisé. Ajout du marqueur d'adhérence et du
+          marqueur Unicode.
+        </p>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        {{SpecName('ESDraft', '#sec-regexp-regular-expression-objects', 'RegExp')}}
+      </td>
+      <td>{{Spec2('ESDraft')}}</td>
+      <td></td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp")}}</p>
+{{Compat("javascript.builtins.RegExp")}}
 
-<h3 id="Notes_spécifiques_à_Firefox">Notes spécifiques à Firefox</h3>
+### Notes spécifiques à Firefox
 
-<p>À partir de Firefox 34, dans le cas où on utilise un groupe capturant avec des quantificateurs qui l'invalident, le texte correspondant au groupe est désormais <code>undefined</code> et non la chaîne vide :</p>
+À partir de Firefox 34, dans le cas où on utilise un groupe capturant avec des quantificateurs qui l'invalident, le texte correspondant au groupe est désormais `undefined` et non la chaîne vide :
 
-<pre class="brush: js">// Firefox 33 ou antérieur
+```js
+// Firefox 33 ou antérieur
 'x'.replace(/x(.)?/g, function(m, group) {
   console.log("'group:" + group + "'");
 }); // 'group:'
@@ -227,14 +238,12 @@ console.log(/[^.]+/.exec(url)[0].substr(7)); // affiche 'xxx'
 'x'.replace(/x(.)?/g, function(m, group) {
   console.log("'group:" + group + "'");
 }); // 'group:undefined'
-</pre>
+```
 
-<p>Pour des raisons de compatibilité web, <code>RegExp.$N</code> renverra une chaîne vide au lieu de <code>undefined</code> ({{bug(1053944)}}).</p>
+Pour des raisons de compatibilité web, `RegExp.$N` renverra une chaîne vide au lieu de `undefined` ({{bug(1053944)}}).
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">Le chapitre Expressions rationnelles</a> du <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a></li>
- <li>{{jsxref("String.prototype.match()")}}</li>
- <li>{{jsxref("String.prototype.replace()")}}</li>
-</ul>
+- [Le chapitre Expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières) du [Guide JavaScript](/fr/docs/Web/JavaScript/Guide)
+- {{jsxref("String.prototype.match()")}}
+- {{jsxref("String.prototype.replace()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/input/index.md b/files/fr/web/javascript/reference/global_objects/regexp/input/index.md
index 15935f9bd8..1d3de04192 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/input/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/input/index.md
@@ -10,49 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/input
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/input
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété non-standard <strong><code>input</code></strong> est une propriété statique de l'expression rationnelle qui contient la chaîne de caractères sur laquelle est effectuée la recherche de correspondances. <code>RegExp.$_</code> est un alias de cette propriété.</p>
+La propriété non-standard **`input`** est une propriété statique de l'expression rationnelle qui contient la chaîne de caractères sur laquelle est effectuée la recherche de correspondances. `RegExp.$_` est un alias de cette propriété.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>RegExp</var>.input
-RegExp.$_
-</pre>
+    RegExp.input
+    RegExp.$_
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>input</code> est statique. Ce n'est pas la propriété d'une instance d'expression rationnelle. Cette propriété doit toujours être utilisée avec la syntaxe <code>RegExp.input</code> ou <code>RegExp.$_.</code></p>
+La propriété `input` est statique. Ce n'est pas la propriété d'une instance d'expression rationnelle. Cette propriété doit toujours être utilisée avec la syntaxe `RegExp.input` ou `RegExp.$_.`
 
-<p>La valeur de la propriété <code><strong>input</strong></code> est modifiée à chaque fois que la chaîne sur laquelle on recherche est modifiée et qu'il y a une correspondance.</p>
+La valeur de la propriété **`input`** est modifiée à chaque fois que la chaîne sur laquelle on recherche est modifiée et qu'il y a une correspondance.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_input_et__">Utiliser <code>input</code> et <code>$_</code></h3>
+### Utiliser `input` et `$_`
 
-<pre class="brush: js">var re = /coucou/g;
+```js
+var re = /coucou/g;
 re.test("coucou toi !");
 RegExp.input;         // "coucou toi !"
 re.test("toto");      // nouveau test, pas de correspondance
 RegExp.$_;            // "coucou toi !"
 re.test("coucou monde !"); // nouveau test avec correspondance
 RegExp.$_;            // "coucou monde !"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.</p>
+Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.input")}}</p>
+{{Compat("javascript.builtins.RegExp.input")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li>
-</ul>
+- {{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}
+- {{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/lastindex/index.md b/files/fr/web/javascript/reference/global_objects/regexp/lastindex/index.md
index e5bc84ca24..4693bdfb7a 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/lastindex/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/lastindex/index.md
@@ -9,95 +9,66 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/lastIndex
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>lastIndex</strong></code> est un entier en lecture/écriture qui permet de définir l'indice (position) à partir duquel chercher la prochaine correspondance pour une instance d'expression rationnelle donnée.</p>
+La propriété **`lastIndex`** est un entier en lecture/écriture qui permet de définir l'indice (position) à partir duquel chercher la prochaine correspondance pour une instance d'expression rationnelle donnée.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-lastindex.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-lastindex.html")}}{{js_property_attributes(1,0,0)}}
 
+## Syntaxe
 
+    regExpObj.lastIndex
 
-<div>{{js_property_attributes(1,0,0)}}</div>
+## Description
 
-<h2 id="Syntaxe">Syntaxe</h2>
+Cette propriété n'est définie que si l'instance d'expression rationnelle utilise le marqueur (_flag_) `"g"` pour effectuer une recherche globale ou le marqueur `"y"` afin d'effectuer une recherche adhérente. Les règles suivantes s'appliquent :
 
-<pre class="syntaxbox"><var>regExpObj</var>.lastIndex
-</pre>
+- Si `lastIndex` est supérieur à la longueur de la chaîne de caractères, `regexp.test` et `regexp.exec` échoueront et `lastIndex` sera redéfini à 0.
+- Si `lastIndex` est égal à la longueur de la chaîne de caractères et si l'expression rationnelle correspond avec la chaîne vide, il y aura une correspondance à partir de `lastIndex`.
+- Si `lastIndex` est égal à la longueur de la chaîne de caractères et que l'expression rationnelle ne peut correspondre à la chaîne vide, on n'aura pas de correspondance et `lastIndex` sera réinitialisé à 0.
+- Sinon, `lastIndex` sera défini à la position suivant la correspondance la plus récente.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>Cette propriété n'est définie que si l'instance d'expression rationnelle utilise le marqueur (<em>flag</em>) <code>"g"</code> pour effectuer une recherche globale ou le marqueur <code>"y"</code> afin d'effectuer une recherche adhérente. Les règles suivantes s'appliquent :</p>
+Si on a la séquence d'instructions suivante :
 
-<ul>
- <li>Si <code>lastIndex</code> est supérieur à la longueur de la chaîne de caractères, <code>regexp.test</code> et <code>regexp.exec</code> échoueront et <code>lastIndex</code> sera redéfini à 0.</li>
- <li>Si <code>lastIndex</code> est égal à la longueur de la chaîne de caractères et si l'expression rationnelle correspond avec la chaîne vide, il y aura une correspondance à partir de <code>lastIndex</code>.</li>
- <li>Si <code>lastIndex</code> est égal à la longueur de la chaîne de caractères et que l'expression rationnelle ne peut correspondre à la chaîne vide, on n'aura pas de correspondance et <code>lastIndex</code> sera réinitialisé à 0.</li>
- <li>Sinon, <code>lastIndex</code> sera défini à la position suivant la correspondance la plus récente.</li>
-</ul>
+```js
+var re = /(hi)?/g;
+```
 
-<h2 id="Exemples">Exemples</h2>
+Correspond à la chaîne vide.
 
-<p>Si on a la séquence d'instructions suivante :</p>
-
-<pre class="brush: js">var re = /(hi)?/g;
-</pre>
+```js
+console.log(re.exec('hi'));
+console.log(re.lastIndex);
+```
 
-<p>Correspond à la chaîne vide.</p>
+Renvoie `["hi", "hi"]` avec `lastIndex` égal à 2.
 
-<pre class="brush: js">console.log(re.exec('hi'));
+```js
+console.log(re.exec('hi'));
 console.log(re.lastIndex);
-</pre>
+```
 
-<p>Renvoie <code>["hi", "hi"]</code> avec <code>lastIndex</code> égal à 2.</p>
+Renvoie `["", undefined]`, un tableau dont le premier élément est la chaîne vide car `lastIndex` valait 2 (et vaut toujours 2) et `"hi"` était de longueur 2.
 
-<pre class="brush: js">console.log(re.exec('hi'));
-console.log(re.lastIndex);
-</pre>
-
-<p>Renvoie <code>["", undefined]</code>, un tableau dont le premier élément est la chaîne vide car <code>lastIndex</code> valait 2 (et vaut toujours 2) et <code>"hi"</code> était de longueur 2.</p>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. JavaScript 1.5 : <code>lastIndex</code> est une propriété d'une instance de <code>RegExp</code> et n'est pas une propriété directe de <code>RegExp</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10.7.5', 'RegExp.lastIndex')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-properties-of-regexp-instances', 'RegExp.lastIndex')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-properties-of-regexp-instances', 'RegExp.lastIndex')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.lastIndex")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
- <li>{{jsxref("RegExp.prototype.global")}}</li>
- <li>{{jsxref("RegExp.prototype.multiline")}}</li>
- <li>{{jsxref("RegExp.prototype.source")}}</li>
- <li>{{jsxref("RegExp.prototype.sticky")}}</li>
-</ul>
+## Spécifications
+
+| Spécification                                                                                                | Statut                       | Commentaires                                                                                                                                   |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                     | {{Spec2('ES3')}}         | Définition initiale. JavaScript 1.5 : `lastIndex` est une propriété d'une instance de `RegExp` et n'est pas une propriété directe de `RegExp`. |
+| {{SpecName('ES5.1', '#sec-15.10.7.5', 'RegExp.lastIndex')}}                             | {{Spec2('ES5.1')}}     |                                                                                                                                                |
+| {{SpecName('ES6', '#sec-properties-of-regexp-instances', 'RegExp.lastIndex')}}     | {{Spec2('ES6')}}         |                                                                                                                                                |
+| {{SpecName('ESDraft', '#sec-properties-of-regexp-instances', 'RegExp.lastIndex')}} | {{Spec2('ESDraft')}} |                                                                                                                                                |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.lastIndex")}}
+
+## Voir aussi
+
+- {{jsxref("RegExp.prototype.ignoreCase")}}
+- {{jsxref("RegExp.prototype.global")}}
+- {{jsxref("RegExp.prototype.multiline")}}
+- {{jsxref("RegExp.prototype.source")}}
+- {{jsxref("RegExp.prototype.sticky")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/lastmatch/index.md b/files/fr/web/javascript/reference/global_objects/regexp/lastmatch/index.md
index 08e0e2ce91..82d41d04bb 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/lastmatch/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/lastmatch/index.md
@@ -10,48 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/lastMatch
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété non-standard <strong><code>lastMatch</code> </strong>est une propriété statique en lecture seule pour les expressions rationnelles qui contient les caractères de la dernière correspondance. <code>RegExp.$&amp;</code> est un alias pour cette propriété.</p>
+La propriété non-standard **`lastMatch` **est une propriété statique en lecture seule pour les expressions rationnelles qui contient les caractères de la dernière correspondance. `RegExp.$&` est un alias pour cette propriété.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>RegExp</var>.lastMatch
-RegExp['$&amp;']
-</pre>
+    RegExp.lastMatch
+    RegExp['$&']
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>lastMatch</code> est une propriété statique, ce n'est pas une propriété pour chaque objet qui représente une expression rationnelle. Cette propriété doit donc toujours être utilisée avec la syntaxe <code>RegExp.lastMatch</code> ou <code>RegExp['$&amp;'].</code></p>
+La propriété `lastMatch` est une propriété statique, ce n'est pas une propriété pour chaque objet qui représente une expression rationnelle. Cette propriété doit donc toujours être utilisée avec la syntaxe `RegExp.lastMatch` ou `RegExp['$&'].`
 
-<p>La valeur de la propriété <code>lastMatch</code> n'est accessible qu'en lecture seule et est modifiée à chaque fois qu'une correspondance est trouvée.</p>
+La valeur de la propriété `lastMatch` n'est accessible qu'en lecture seule et est modifiée à chaque fois qu'une correspondance est trouvée.
 
-<p>Il n'est pas possible d'utiliser l'alias avec la notation utilisant le point pour accéder à la propriété (<code>RegExp.$&amp;</code>) car le parseur attend une expression avec "&amp;" dans ce cas, ce qui provoque une exception {{jsxref("SyntaxError")}}. Pour utiliser l'alias, on prendra donc la notation <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets">utilisant les crochets</a>.</p>
+Il n'est pas possible d'utiliser l'alias avec la notation utilisant le point pour accéder à la propriété (`RegExp.$&`) car le parseur attend une expression avec "&" dans ce cas, ce qui provoque une exception {{jsxref("SyntaxError")}}. Pour utiliser l'alias, on prendra donc la notation [utilisant les crochets](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_lastMatch_et">Utiliser <code>lastMatch</code> et <code>$&amp;</code></h3>
+### Utiliser `lastMatch` et `$&`
 
-<pre class="brush: js">var re = /coucou/g;
+```js
+var re = /coucou/g;
 re.test("coucou toi!");
 RegExp.lastMatch; // "coucou"
-RegExp['$&amp;'];     // "coucou"
-</pre>
+RegExp['$&'];     // "coucou"
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.</p>
+Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.lastMatch")}}</p>
+{{Compat("javascript.builtins.RegExp.lastMatch")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li>
-</ul>
+- {{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}
+- {{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/lastparen/index.md b/files/fr/web/javascript/reference/global_objects/regexp/lastparen/index.md
index c2df70f393..ee1f864078 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/lastparen/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/lastparen/index.md
@@ -9,48 +9,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/lastParen
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/lastParen
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété <code><strong>lastParen</strong></code> est une propriété statique accessible en lecture seule qui contient la dernière correspondance enregistrée dans un groupe (entre parenthèse) si jamais elle existe. <code>RegExp.$+</code> est un alias pour cette propriété.</p>
+La propriété **`lastParen`** est une propriété statique accessible en lecture seule qui contient la dernière correspondance enregistrée dans un groupe (entre parenthèse) si jamais elle existe. `RegExp.$+` est un alias pour cette propriété.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>RegExp</var>.lastParen
-RegExp['$+']
-</pre>
+    RegExp.lastParen
+    RegExp['$+']
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>lastParen</code> est une propriété statique, ce n'est pas une propriété liée à chaque objet. Il faut donc toujours utiliser la syntaxe <code>RegExp.lastParen</code> ou <code>RegExp['$+'].</code></p>
+La propriété `lastParen` est une propriété statique, ce n'est pas une propriété liée à chaque objet. Il faut donc toujours utiliser la syntaxe `RegExp.lastParen` ou `RegExp['$+'].`
 
-<p>La valeur de la propriété <code>lastParen</code> n'est accessible qu'en lecture seule et est modifiée automatiquement à chaque fois qu'il y a une correspondance.</p>
+La valeur de la propriété `lastParen` n'est accessible qu'en lecture seule et est modifiée automatiquement à chaque fois qu'il y a une correspondance.
 
-<p>Cet alias ne peut pas être utilisé avec la notation utilisant le point pour l'accès aux propriétés (<code>RegExp.$+</code>). En effet, le parseur attend une expression avec "+", dans ce cas, une exception {{jsxref("SyntaxError")}} est levée. Pour utiliser cette notation raccourcie, on utilisera <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets">la notation avec les crochets</a>.</p>
+Cet alias ne peut pas être utilisé avec la notation utilisant le point pour l'accès aux propriétés (`RegExp.$+`). En effet, le parseur attend une expression avec "+", dans ce cas, une exception {{jsxref("SyntaxError")}} est levée. Pour utiliser cette notation raccourcie, on utilisera [la notation avec les crochets](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_lastParen_et">Utiliser <code>lastParen</code> et <code>$+</code></h3>
+### Utiliser `lastParen` et `$+`
 
-<pre class="brush: js">var re = /(coucou)/g;
+```js
+var re = /(coucou)/g;
 re.test("coucou toi !");
 RegExp.lastParen; // "coucou"
 RegExp['$+'];     // "coucou"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.</p>
+Cette propriété n'est pas standard. Elle ne fait partie d'aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.lastParen")}}</p>
+{{Compat("javascript.builtins.RegExp.lastParen")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li>
-</ul>
+- {{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}
+- {{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/leftcontext/index.md b/files/fr/web/javascript/reference/global_objects/regexp/leftcontext/index.md
index e5a3bda79d..34820f2311 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/leftcontext/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/leftcontext/index.md
@@ -10,46 +10,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/leftContext
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/leftContext
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété non-standard <code><strong>leftContext</strong></code> est une propriété statique accessible uniquement en lecture. Cette propriété liée aux expressions rationnelles contient la sous-chaîne qui précède la correspondance la plus récente. <code>RegExp.$`</code> est un alias pour cette propriété.</p>
+La propriété non-standard **`leftContext`** est une propriété statique accessible uniquement en lecture. Cette propriété liée aux expressions rationnelles contient la sous-chaîne qui précède la correspondance la plus récente. `` RegExp.$` `` est un alias pour cette propriété.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>RegExp</var>.leftContext
-RegExp['$`']
-</pre>
+    RegExp.leftContext
+    RegExp['$`']
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>leftContext</code> est une propriété statique, elle n'est donc pas distincte entre les différents objets représentants les expressions rationnelles. Il faut donc toujours utiliser la syntaxe <code>RegExp.leftContext</code> ou <code>RegExp['$`'].</code></p>
+La propriété `leftContext` est une propriété statique, elle n'est donc pas distincte entre les différents objets représentants les expressions rationnelles. Il faut donc toujours utiliser la syntaxe `RegExp.leftContext` ou `` RegExp['$`']. ``
 
-<p>La valeur de la propriété <code>leftContext</code> n'est accessible uniquement qu'en lecture. Elle est modifiée par le moteur à chaque fois qu'une nouvelle correspondance est trouvée.</p>
+La valeur de la propriété `leftContext` n'est accessible uniquement qu'en lecture. Elle est modifiée par le moteur à chaque fois qu'une nouvelle correspondance est trouvée.
 
-<p>L'alias ne peut pas être utilisé avec la notation utilisant le point (<code>RegExp.$`</code>). En effet, le parseur attend un gabarit de chaîne à la suite de l'accent grave. Si on utilise le point, on aura donc une exception {{jsxref("SyntaxError")}}. Pour cet alias, on utilisera <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets">la notation à base de crochets</a>.</p>
+L'alias ne peut pas être utilisé avec la notation utilisant le point (`` RegExp.$` ``). En effet, le parseur attend un gabarit de chaîne à la suite de l'accent grave. Si on utilise le point, on aura donc une exception {{jsxref("SyntaxError")}}. Pour cet alias, on utilisera [la notation à base de crochets](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var re = /monde/g;
+```js
+var re = /monde/g;
 re.test("coucou monde !");
 RegExp.leftContext; // "coucou "
 RegExp['$`'];       // "coucou "
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Cette propriété n'est pas standard et ne fait partie d'aucune spécification.</p>
+Cette propriété n'est pas standard et ne fait partie d'aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.leftContext")}}</p>
+{{Compat("javascript.builtins.RegExp.leftContext")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li>
-</ul>
+- {{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}
+- {{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/multiline/index.md b/files/fr/web/javascript/reference/global_objects/regexp/multiline/index.md
index 3c6d1df46a..72c86650cf 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/multiline/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/multiline/index.md
@@ -10,77 +10,47 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/multiline
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/multiline
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>multiline</strong></code> indique si le drapeau (<em>flag</em>) "<code>m</code>" a été utilisé ou non pour l'expression rationnelle. <code>multiline</code> est une propriété liée à l'instance, accessible en lecture seule.</p>
+La propriété **`multiline`** indique si le drapeau (_flag_) "`m`" a été utilisé ou non pour l'expression rationnelle. `multiline` est une propriété liée à l'instance, accessible en lecture seule.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-multiline.html", "taller")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-multiline.html", "taller")}}{{js_property_attributes(0,0,1)}}
 
+## Description
 
+La valeur de `multiline` est un booléen. Elle vaut `true` si le drapeau "`m`" a été utilisé et `false` sinon. Le flag "`m`" indique qu'une chaine de caractères qui s'étend sur plusieurs lignes doit être traitée comme une série de ligne. Ainsi, si "`m`" est utilisé, "`^`" et "`$`" ne correspondent plus au début et à la fin de la chaîne mais aux débuts et aux fins de chaque ligne de la chaîne.
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+Cette propriété ne peut pas être modifiée directement.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La valeur de <code>multiline</code> est un booléen. Elle vaut <code>true</code> si le drapeau "<code>m</code>" a été utilisé et <code>false</code> sinon. Le flag "<code>m</code>" indique qu'une chaine de caractères qui s'étend sur plusieurs lignes doit être traitée comme une série de ligne. Ainsi, si "<code>m</code>" est utilisé, "<code>^</code>" et "<code>$</code>" ne correspondent plus au début et à la fin de la chaîne mais aux débuts et aux fins de chaque ligne de la chaîne.</p>
+```js
+var regex = new RegExp("toto", "m");
 
-<p>Cette propriété ne peut pas être modifiée directement.</p>
+console.log(regex.multiline); // true
+```
 
-<h2 id="Exemples">Exemples</h2>
+## Spécifications
 
-<pre class="brush:js">var regex = new RegExp("toto", "m");
+| Spécification                                                                                                                | Statut                       | Commentaires                                                                                                                                                                           |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : `multiline` est une propriété liée à l'instance de {{jsxref("RegExp")}} et non à l'objet `RegExp`. |
+| {{SpecName('ES5.1', '#sec-15.10.7.4', 'RegExp.prototype.multiline')}}                                 | {{Spec2('ES5.1')}}     |                                                                                                                                                                                        |
+| {{SpecName('ES6', '#sec-get-regexp.prototype.multiline', 'RegExp.prototype.multiline')}}         | {{Spec2('ES6')}}         | `multiline` est désormais un propriété du prototype sous forme d'accesseur plutôt qu'une propriété directement liée à l'instance.                                                      |
+| {{SpecName('ESDraft', '#sec-get-regexp.prototype.multiline', 'RegExp.prototype.multiline')}} | {{Spec2('ESDraft')}} |                                                                                                                                                                                        |
 
-console.log(regex.multiline); // true
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : <code>multiline</code> est une propriété liée à l'instance de {{jsxref("RegExp")}} et non à l'objet <code>RegExp</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10.7.4', 'RegExp.prototype.multiline')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-get-regexp.prototype.multiline', 'RegExp.prototype.multiline')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td><code>multiline</code> est désormais un propriété du prototype sous forme d'accesseur plutôt qu'une propriété directement liée à l'instance.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.multiline', 'RegExp.prototype.multiline')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.multiline")}}</p>
-
-<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2>
-
-<ul>
- <li>Avant Firefox 48 , une propriété globale non-standard <code>RegExp.multiline</code> existait en plus de la propriété <code>RegExp.prototype.multiline</code>. Elle a été retirée dans les nouvelles versions du moteur (cf. {{bug(1219757)}}). On utilisera la propriété décrite sur cette page ou le <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières#Effectuer_des_recherches_avancées_en_utilisant_les_drapeaux_(flags)">marqueur <code>m</code></a> à la place.</li>
-</ul>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp.prototype.global")}}</li>
- <li>{{jsxref("RegExp.prototype.lastIndex")}}</li>
- <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
- <li>{{jsxref("RegExp.prototype.source")}}</li>
- <li>{{jsxref("RegExp.prototype.sticky")}}</li>
-</ul>
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.multiline")}}
+
+## Notes de compatibilité
+
+- Avant Firefox 48 , une propriété globale non-standard `RegExp.multiline` existait en plus de la propriété `RegExp.prototype.multiline`. Elle a été retirée dans les nouvelles versions du moteur (cf. {{bug(1219757)}}). On utilisera la propriété décrite sur cette page ou le [marqueur `m`](</fr/docs/Web/JavaScript/Guide/Expressions_régulières#Effectuer_des_recherches_avancées_en_utilisant_les_drapeaux_(flags)>) à la place.
+
+## Voir aussi
+
+- {{jsxref("RegExp.prototype.global")}}
+- {{jsxref("RegExp.prototype.lastIndex")}}
+- {{jsxref("RegExp.prototype.ignoreCase")}}
+- {{jsxref("RegExp.prototype.source")}}
+- {{jsxref("RegExp.prototype.sticky")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/n/index.md b/files/fr/web/javascript/reference/global_objects/regexp/n/index.md
index 639b98d059..737e7368e0 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/n/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/n/index.md
@@ -10,58 +10,56 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/n
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/n
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>Les propriétés non-standard <strong>$1, $2, $3, $4, $5, $6, $7, $8, $9</strong> sont des propriétés statiques accessibles en lecture qui contiennent les différents groupes capturés par une expression rationnelle.</p>
+Les propriétés non-standard **$1, $2, $3, $4, $5, $6, $7, $8, $9** sont des propriétés statiques accessibles en lecture qui contiennent les différents groupes capturés par une expression rationnelle.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>RegExp</var>.$1
-RegExp.$2
-RegExp.$3
-RegExp.$4
-RegExp.$5
-RegExp.$6
-RegExp.$7
-RegExp.$8
-RegExp.$9
-</pre>
+    RegExp.$1
+    RegExp.$2
+    RegExp.$3
+    RegExp.$4
+    RegExp.$5
+    RegExp.$6
+    RegExp.$7
+    RegExp.$8
+    RegExp.$9
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>Les propriétés $1, ..., $9 sont des propriétés statiques. Ce ne sont pas des propriétés rattachées à une expression rationnelle donnée. Pour cette raison, on utilisera toujours la syntaxe <code>RegExp.$1</code>, ..., <code>RegExp.$9</code>.</p>
+Les propriétés $1, ..., $9 sont des propriétés statiques. Ce ne sont pas des propriétés rattachées à une expression rationnelle donnée. Pour cette raison, on utilisera toujours la syntaxe `RegExp.$1`, ..., `RegExp.$9`.
 
-<p>Les valeurs de ces propriétés ne sont accessibles qu'en lecture et sont modifiées par le moteur à chaque fois qu'une nouvelle correspondance est trouvée.</p>
+Les valeurs de ces propriétés ne sont accessibles qu'en lecture et sont modifiées par le moteur à chaque fois qu'une nouvelle correspondance est trouvée.
 
-<p>Le nombre de groupe d'une expression rationnelle n'est pas limité. Cependant, l'objet <code>RegExp</code> ne contient que les neufs premiers groupes. Pour accéder à chacun des groupes liés à une expression rationnelle donnée, on pourra utiliser les indices du tableau relevant les correspondances.</p>
+Le nombre de groupe d'une expression rationnelle n'est pas limité. Cependant, l'objet `RegExp` ne contient que les neufs premiers groupes. Pour accéder à chacun des groupes liés à une expression rationnelle donnée, on pourra utiliser les indices du tableau relevant les correspondances.
 
-<p>Ces propriétés peuvent être utilisées pour le texte de remplacement de la méthode {{jsxref("String.replace")}}. Avec cette méthode, on ne préfixera pas les valeurs par <code>RegExp</code> (voir l'exemple ci-après), lorsque les parenthèses groupantes ne sont pas utilisées dans l'expression, <code>$n</code> sera interprété littérallement (avec <code>n</code> un entier positif).</p>
+Ces propriétés peuvent être utilisées pour le texte de remplacement de la méthode {{jsxref("String.replace")}}. Avec cette méthode, on ne préfixera pas les valeurs par `RegExp` (voir l'exemple ci-après), lorsque les parenthèses groupantes ne sont pas utilisées dans l'expression, `$n` sera interprété littérallement (avec `n` un entier positif).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans le script qui suit, on utilise {{jsxref("String.prototype.replace()", "replace()")}} d'une instance de {{jsxref("String")}} pour inverser le premier mot et le dernier et placer une virgule entre. Le script utilise <code>$1</code> et <code>$2</code> pour faire référence aux groupes de l'expression rationnelle :</p>
+Dans le script qui suit, on utilise {{jsxref("String.prototype.replace()", "replace()")}} d'une instance de {{jsxref("String")}} pour inverser le premier mot et le dernier et placer une virgule entre. Le script utilise `$1` et `$2` pour faire référence aux groupes de l'expression rationnelle :
 
-<pre class="brush: js">var re = /(\w+)\s(\w+)/;
+```js
+var re = /(\w+)\s(\w+)/;
 var str = 'Jean Biche';
 str.replace(re, '$2, $1'); // "Biche, Jean"
 RegExp.$1; // "Jean"
 RegExp.$2; // "Biche"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Ces propriétés ne sont pas standard, elles ne font partie d'aucune spécification.</p>
+Ces propriétés ne sont pas standard, elles ne font partie d'aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.n")}}</p>
+{{Compat("javascript.builtins.RegExp.n")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</li>
-</ul>
+- {{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/rightcontext/index.md b/files/fr/web/javascript/reference/global_objects/regexp/rightcontext/index.md
index 8d7aecc28e..157ce8bdab 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/rightcontext/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/rightcontext/index.md
@@ -11,46 +11,44 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/rightContext
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/rightContext
 ---
-<div>{{JSRef}} {{non-standard_header}}</div>
+{{JSRef}} {{non-standard_header}}
 
-<p>La propriété non-standard <strong><code>rightContext</code> </strong>est une propriété statique, accessible uniquement en lecture, qui contient la sous-chaîne suivant la correspondance la plus récente. <code>RegExp.$'</code> est un alias pour cette propriété.</p>
+La propriété non-standard **`rightContext` **est une propriété statique, accessible uniquement en lecture, qui contient la sous-chaîne suivant la correspondance la plus récente. `RegExp.$'` est un alias pour cette propriété.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>RegExp</var>.rightContext
-RegExp["$'"]
-</pre>
+    RegExp.rightContext
+    RegExp["$'"]
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La propriété <code>rightContext</code> est une propriété statique et n'est pas liée à une instance d'expression rationnelle. Pour cette raison, il faut toujours utiliser la syntaxe <code>RegExp.rightContext</code> ou <code>RegExp["$'"].</code></p>
+La propriété `rightContext` est une propriété statique et n'est pas liée à une instance d'expression rationnelle. Pour cette raison, il faut toujours utiliser la syntaxe `RegExp.rightContext` ou `RegExp["$'"].`
 
-<p>La valeur de la propriété <code>rightContext</code> n'est accessible qu'en lecture. Le moteur la modifie à chaque fois qu'une nouvelle correspondance est trouvée.</p>
+La valeur de la propriété `rightContext` n'est accessible qu'en lecture. Le moteur la modifie à chaque fois qu'une nouvelle correspondance est trouvée.
 
-<p>L'alias ne peut pas être utilisé avec la syntaxe utilisant le point (<code>RegExp.$'</code>). En effet, l'analyseur (<em>parser</em>) attend un début de chaîne du fait de la simple quote, ce qui provoquerait une exception {{jsxref("SyntaxError")}}. Il faut donc utiliser <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets">la notation à base de crochets</a>.</p>
+L'alias ne peut pas être utilisé avec la syntaxe utilisant le point (`RegExp.$'`). En effet, l'analyseur (_parser_) attend un début de chaîne du fait de la simple quote, ce qui provoquerait une exception {{jsxref("SyntaxError")}}. Il faut donc utiliser [la notation à base de crochets](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres#Notation_avec_crochets).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: js">var re = /coucou/g;
+```js
+var re = /coucou/g;
 re.test("coucou monde !");
 RegExp.rightContext; // " monde !"
 RegExp["$'"];       // " monde !"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<p>Cette propriété n'est pas standard, elle ne fait partie d'aucune spécification.</p>
+Cette propriété n'est pas standard, elle ne fait partie d'aucune spécification.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.rightContext")}}</p>
+{{Compat("javascript.builtins.RegExp.rightContext")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li>
- <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li>
-</ul>
+- {{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}
+- {{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/source/index.md b/files/fr/web/javascript/reference/global_objects/regexp/source/index.md
index 7b5437e8cc..86cf78ae27 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/source/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/source/index.md
@@ -10,72 +10,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/source
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/source
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>source</strong></code> renvoie une chaîne de caractères qui contient le texte du motif à rechercher (<em>pattern</em>), sans les barres obliques (<em>slashes</em>). C'est une propriété en lecture seule liée à l'instance. <strong><code>source</code></strong> ne contient aucun des options ou drapeaux (<em>flags</em>) (tels que "g", "i" ou "m") de l'expression rationnelle.</p>
+La propriété **`source`** renvoie une chaîne de caractères qui contient le texte du motif à rechercher (_pattern_), sans les barres obliques (_slashes_). C'est une propriété en lecture seule liée à l'instance. **`source`** ne contient aucun des options ou drapeaux (_flags_) (tels que "g", "i" ou "m") de l'expression rationnelle.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-source.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-source.html")}}{{js_property_attributes(0,0,1)}}
 
+## Exemples
 
+### Utiliser `source`
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+```js
+var regex = /totoMachin/ig;
 
-<h2 id="Exemples">Exemples</h2>
+console.log(regex.source); // "totoMachin"
+```
 
-<h3 id="Utiliser_source">Utiliser <code>source</code></h3>
+### Les expressions ratonnelles vides et l'échappement
 
-<pre class="brush:js">var regex = /totoMachin/ig;
+À partir d'ECMAScript 5, la propriété `source` ne renvoie plus une chaîne vide pour les expressions rationnelles vides. Elle renvoie la chaîne `"(?:)"`. De plus, les fins de lignes (telles que "\n") sont désormais échappées.
 
-console.log(regex.source); // "totoMachin"
-</pre>
+```js
+new RegExp().source; // "(?:)"
 
-<h3 id="Les_expressions_ratonnelles_vides_et_l'échappement">Les expressions ratonnelles vides et l'échappement</h3>
+new RegExp('\n').source === "\n";  // true avant ES5
+new RegExp('\n').source === "\\n"; // true à partir d'ES5
+```
 
-<p>À partir d'ECMAScript 5, la propriété <code>source</code> ne renvoie plus une chaîne vide pour les expressions rationnelles vides. Elle renvoie la chaîne <code>"(?:)"</code>. De plus, les fins de lignes (telles que "\n") sont désormais échappées.</p>
+## Spécifications
 
-<pre class="brush: js">new RegExp().source; // "(?:)"
+| Spécification                                                                                                        | État                         | Commentaires                                                                                                                                                                                          |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                             | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : `source` est une propriété de l'instance de {{jsxref("RegExp")}}, ce n'est pas une propriété de l'objet `RegExp`. |
+| {{SpecName('ES5.1', '#sec-15.10.7.1', 'RegExp.prototype.source')}}                             | {{Spec2('ES5.1')}}     | `source` renvoie désormais "(?:)" (et non "") pour les expressions vides. La définition du comportement pour les échappements a été ajoutée.                                                          |
+| {{SpecName('ES6', '#sec-get-regexp.prototype.source', 'RegExp.prototype.source')}}         | {{Spec2('ES6')}}         | `source` est désormais un accesseur lié au prototype plutôt qu'une propriété directement rattachée à l'instance.                                                                                      |
+| {{SpecName('ESDraft', '#sec-get-regexp.prototype.source', 'RegExp.prototype.source')}} | {{Spec2('ESDraft')}} |                                                                                                                                                                                                       |
 
-new RegExp('\n').source === "\n";  // true avant ES5
-new RegExp('\n').source === "\\n"; // true à partir d'ES5</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2. Avec JavaScript 1.5 : <code>source</code> est une propriété de l'instance de {{jsxref("RegExp")}}, ce n'est pas une propriété de l'objet <code>RegExp</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10.7.1', 'RegExp.prototype.source')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td><code>source</code> renvoie désormais "(?:)" (et non "") pour les expressions vides. La définition du comportement pour les échappements a été ajoutée.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-get-regexp.prototype.source', 'RegExp.prototype.source')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td><code>source</code> est désormais un accesseur lié au prototype plutôt qu'une propriété directement rattachée à l'instance.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.source', 'RegExp.prototype.source')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.source")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp.prototype.flags")}}</li>
-</ul>
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.source")}}
+
+## Voir aussi
+
+- {{jsxref("RegExp.prototype.flags")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/sticky/index.md b/files/fr/web/javascript/reference/global_objects/regexp/sticky/index.md
index ab261c0d51..eb5c5a2b52 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/sticky/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/sticky/index.md
@@ -12,27 +12,24 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/sticky
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/sticky
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>sticky</strong></code> (adhérante) permet de déterminer si la recherche s'effectue uniquement à partir de l'indice {{jsxref("RegExp.lastIndex", "lastIndex")}} lié à l'expression rationnelle ou non). <code>sticky</code> est une propriété accessible en lecture seule, rattachée à l'instance.</p>
+La propriété **`sticky`** (adhérante) permet de déterminer si la recherche s'effectue uniquement à partir de l'indice {{jsxref("RegExp.lastIndex", "lastIndex")}} lié à l'expression rationnelle ou non). `sticky` est une propriété accessible en lecture seule, rattachée à l'instance.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-sticky.html")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-sticky.html")}}{{js_property_attributes(0,0,1)}}
 
+## Description
 
+La propriété `sticky` est un booléen qui vaut `true` si le marqueur (_flag_) "`y`" a été utilisé, `false` sinon. Ce marqueur indique que les correspondances ne sont recherchées qu'à partir de l'indice {{jsxref("RegExp.lastIndex", "lastIndex")}} au niveau de la chaîne de caractères (les correspondances à partir des autres positions ne seront pas trouvées). Lorsqu'une expression rationnelle qui utilise le marqueur `sticky` **et** le marqueur `global` ignorera le marqueur `global`.
 
-<div>{{js_property_attributes(0,0,1)}}</div>
+La propriété `sticky` ne peut pas être modifiée directement. Elle est uniquement en lecture seule.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La propriété <code>sticky</code> est un booléen qui vaut <code>true</code> si le marqueur (<em>flag</em>) "<code>y</code>" a été utilisé, <code>false</code> sinon. Ce marqueur indique que les correspondances ne sont recherchées qu'à partir de l'indice {{jsxref("RegExp.lastIndex", "lastIndex")}} au niveau de la chaîne de caractères (les correspondances à partir des autres positions ne seront pas trouvées). Lorsqu'une expression rationnelle qui utilise le marqueur <code>sticky</code> <strong>et</strong> le marqueur <code>global</code> ignorera le marqueur <code>global</code>.</p>
+### Utiliser une expression rationnelle avec le _flag_ _sticky_
 
-<p>La propriété <code>sticky</code> ne peut pas être modifiée directement. Elle est uniquement en lecture seule.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Utiliser_une_expression_rationnelle_avec_le_flag_sticky">Utiliser une expression rationnelle avec le <em>flag</em> <em>sticky</em></h3>
-
-<pre class="brush: js">var str = '#toto#';
+```js
+var str = '#toto#';
 var regex = /toto/y;
 
 regex.lastIndex = 1;
@@ -40,13 +37,14 @@ regex.test(str); // true
 regex.lastIndex = 5;
 regex.test(str); // false (lastIndex est pris en compte avec sticky)
 regex.lastIndex; // 0 (on rénitialise après un échec)
-</pre>
+```
 
-<h3 id="Marqueur_d'adhérence_«_ancré_»">Marqueur d'adhérence « ancré »</h3>
+### Marqueur d'adhérence « ancré »
 
-<p>Pendant plusieurs versions, le moteur JavaScript de Firefox, SpiderMonkey, avait un bug qui entraînait des correspondances invalides lorsqu'étaient utilisés le marqueur d'adhérence et le symbole <code>^</code> dans l'expression rationnelle. Ce bug est apparu peu après Firefox 3.6. Afin d'éviter ce bug, la spécification ES2015 indique spécifiquement que, lorsque le marqueur <code>y</code> est utilisé avec un motif commençant par <code>^</code>, ce dernier doit correspondre au début de la chaine (ou, si <code>multiline</code> vaut <code>true</code>, au début de la ligne). Les exemples qui suivent illustrent le comportement correct :</p>
+Pendant plusieurs versions, le moteur JavaScript de Firefox, SpiderMonkey, avait un bug qui entraînait des correspondances invalides lorsqu'étaient utilisés le marqueur d'adhérence et le symbole `^` dans l'expression rationnelle. Ce bug est apparu peu après Firefox 3.6. Afin d'éviter ce bug, la spécification ES2015 indique spécifiquement que, lorsque le marqueur `y` est utilisé avec un motif commençant par `^`, ce dernier doit correspondre au début de la chaine (ou, si `multiline` vaut `true`, au début de la ligne). Les exemples qui suivent illustrent le comportement correct :
 
-<pre class="brush: js">var regex = /^foo/y;
+```js
+var regex = /^foo/y;
 regex.lastIndex = 2; // désactive la correspondance au début
 regex.test("..foo"); // false
 
@@ -55,40 +53,23 @@ regex2.lastIndex = 2;
 regex2.test("..foo"); // false
 regex2.lastIndex = 2;
 regex2.test(".\nfoo"); // true
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Etat</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.sticky")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("RegExp.prototype.global")}}</li>
- <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
- <li>{{jsxref("RegExp.prototype.lastIndex")}}</li>
- <li>{{jsxref("RegExp.prototype.multiline")}}</li>
- <li>{{jsxref("RegExp.prototype.source")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | Etat                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}     | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}} | {{Spec2('ESDraft')}} |                      |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.sticky")}}
+
+## Voir aussi
+
+- {{jsxref("RegExp.prototype.global")}}
+- {{jsxref("RegExp.prototype.ignoreCase")}}
+- {{jsxref("RegExp.prototype.lastIndex")}}
+- {{jsxref("RegExp.prototype.multiline")}}
+- {{jsxref("RegExp.prototype.source")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/test/index.md b/files/fr/web/javascript/reference/global_objects/regexp/test/index.md
index 039407032c..776fc120b3 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/test/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/test/index.md
@@ -10,45 +10,45 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/test
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>test()</strong></code> vérifie s'il y a une correspondance entre un texte et une expression rationnelle. Elle retourne <code>true</code> en cas de succès et <code>false</code> dans le cas contraire.</p>
+La méthode **`test()`** vérifie s'il y a une correspondance entre un texte et une expression rationnelle. Elle retourne `true` en cas de succès et `false` dans le cas contraire.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-test.html", "taller")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-test.html", "taller")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox notranslate"><var>regexObj</var>.test(<var>chaîne</var>)</pre>
+    regexObj.test(chaîne)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>chaîne</code></dt>
- <dd>La chaîne de caractères qu'on souhaite comparer à l'expression rationnelle.</dd>
-</dl>
+- `chaîne`
+  - : La chaîne de caractères qu'on souhaite comparer à l'expression rationnelle.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un booléen : <code>true</code> ou <code>false</code> selon qu'une correspondance a été trouvée entre la chaîne de caractères et la chaîne passée en argument.</p>
+Un booléen : `true` ou `false` selon qu'une correspondance a été trouvée entre la chaîne de caractères et la chaîne passée en argument.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>On utilisera <code>test()</code> dès qu'on souhaite savoir si une partie d'une chaîne de caractères correspond à une expression rationnelle (similaire à la méthode {{jsxref("String.prototype.search()")}}). Pour obtenir plus d'informations (mais une exécution moins rapide), on utilisera la méthode {{jsxref("RegExp.prototype.exec()", "exec()")}} (similaire à la méthode {{jsxref("String.prototype.match()")}}). Comme avec {{jsxref("RegExp.prototype.exec()", "exec()")}} (et même en combinant les deux), des appels successifs à <code>test()</code> sur une même instance d'une expression rationnelle permettent de rechercher après la dernière occurence. Cette méthode est différente de <code>search</code> car elle renvoie un booléen et non la position de la correspondance si elle est trouvée (ou <code>-1</code> sinon).</p>
+On utilisera `test()` dès qu'on souhaite savoir si une partie d'une chaîne de caractères correspond à une expression rationnelle (similaire à la méthode {{jsxref("String.prototype.search()")}}). Pour obtenir plus d'informations (mais une exécution moins rapide), on utilisera la méthode {{jsxref("RegExp.prototype.exec()", "exec()")}} (similaire à la méthode {{jsxref("String.prototype.match()")}}). Comme avec {{jsxref("RegExp.prototype.exec()", "exec()")}} (et même en combinant les deux), des appels successifs à `test()` sur une même instance d'une expression rationnelle permettent de rechercher après la dernière occurence. Cette méthode est différente de `search` car elle renvoie un booléen et non la position de la correspondance si elle est trouvée (ou `-1` sinon).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_test">Utiliser <code>test()</code></h3>
+### Utiliser `test()`
 
-<p>Voici un exemple simple qui illustre comment détecter si la chaîne <code>coucou</code> est contenue au début d'une chaîne :</p>
+Voici un exemple simple qui illustre comment détecter si la chaîne `coucou` est contenue au début d'une chaîne :
 
-<pre class="brush: js notranslate">const chaine = "coucou le monde !";
+```js
+const chaine = "coucou le monde !";
 const resultat = /^coucou/.test(chaine);
 console.log(resultat); // true
-</pre>
+```
 
-<p>L'exemple ci-dessous affiche un message qui dépend du succès du test :</p>
+L'exemple ci-dessous affiche un message qui dépend du succès du test :
 
-<pre class="brush: js notranslate">function testinput(regex, chaine){
+```js
+function testinput(regex, chaine){
     var midstring;
     if (regex.test(chaine)) {
         midstring = " contient ";
@@ -60,76 +60,51 @@ console.log(resultat); // true
 
 testinput(/^coucou/, "coucou le monde"); // coucou le monde contient coucou
 testinput(/^coucou/, "salut le monde") // salut le monde ne contient pas coucou
-</pre>
+```
 
-<h3 id="Utiliser_test_avec_le_marqueur_global_g">Utiliser <code>test()</code> avec le marqueur global (<code>/g</code>)</h3>
+### Utiliser `test()` avec le marqueur global (`/g`)
 
-<p>Si l'expression rationnelle utilise le marqueur global (<code>g</code>), la méthode <code>test()</code> avancera la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} associée à l'expression rationnelle. Ainsi, si on utilise <code>test()</code> ensuite, la recherche commencera à partir de la nouvelle valeur de <code>lastIndex</code> (de même {{jsxref("RegExp.prototype.exec()","exec()")}} fera également avancer la propriété <code>lastIndex</code>). On notera que la propriété <code>lastIndex</code> ne sera pas réinitialisée si la recherche est effectuée sur une autre chaîne de caractères.</p>
+Si l'expression rationnelle utilise le marqueur global (`g`), la méthode `test()` avancera la propriété {{jsxref("RegExp.lastIndex", "lastIndex")}} associée à l'expression rationnelle. Ainsi, si on utilise `test()` ensuite, la recherche commencera à partir de la nouvelle valeur de `lastIndex` (de même {{jsxref("RegExp.prototype.exec()","exec()")}} fera également avancer la propriété `lastIndex`). On notera que la propriété `lastIndex` ne sera pas réinitialisée si la recherche est effectuée sur une autre chaîne de caractères.
 
-<pre class="brush: js notranslate">var regex = /toto/g;
+```js
+var regex = /toto/g;
 
 // regex.lastIndex se situe à 0
 regex.test("toto"); // true
 
 // regex.lastIndex se situe désormais à 4
 regex.test("toto"); // false
-</pre>
+```
 
-<p>Avec le même mécanisme, on peut utiliser une boucle pour compter le nombre de mots contenus dans une chaîne de caractères</p>
+Avec le même mécanisme, on peut utiliser une boucle pour compter le nombre de mots contenus dans une chaîne de caractères
 
-<pre class="brush: js notranslate">function compterMots(texte) {
+```js
+function compterMots(texte) {
   for (var regex = /\w+/g, nbMots = 0; regex.test(texte); nbMots++);
   return nbMots;
 }
 
 console.log(compterMots("Ah que coucou Bob")); // 4
-</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.test', 'RegExp.test')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.test")}}</p>
-
-<h2 id="Notes_spécifiques_à_Firefox">Notes spécifiques à Firefox</h2>
-
-<p>Pour les versions antérieures à Firefox 8.0, l'implémentation de <code>test()</code> était erronée. Quand la méthode était appelée sans aucun paramètre, elle effectuait son test par rapport à la dernière entrée (la propriété <code>RegExp.input</code>) et non par rapport à la chaîne <code>"undefined"</code>. Ce comportement a été corrigé  ; désormais <code>/undefined/.test()</code> retourne bien <code>true</code> au lieu d'une erreur.</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>Le chapitre sur <a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">les expressions rationnelles</a> du <a href="/fr/docs/Web/JavaScript/Guide">guide JavaScript</a></li>
- <li>{{jsxref("RegExp")}}</li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                | État                         | Commentaires                                          |
+| -------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                     | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.2. |
+| {{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}}                     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-regexp.prototype.test', 'RegExp.test')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.test")}}
+
+## Notes spécifiques à Firefox
+
+Pour les versions antérieures à Firefox 8.0, l'implémentation de `test()` était erronée. Quand la méthode était appelée sans aucun paramètre, elle effectuait son test par rapport à la dernière entrée (la propriété `RegExp.input`) et non par rapport à la chaîne `"undefined"`. Ce comportement a été corrigé  ; désormais `/undefined/.test()` retourne bien `true` au lieu d'une erreur.
+
+## Voir aussi
+
+- Le chapitre sur [les expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières) du [guide JavaScript](/fr/docs/Web/JavaScript/Guide)
+- {{jsxref("RegExp")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/tosource/index.md b/files/fr/web/javascript/reference/global_objects/regexp/tosource/index.md
index ddd032b9f2..255db3a16a 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/tosource/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/tosource/index.md
@@ -11,46 +11,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toSource
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/toSource
 ---
-<div>{{JSRef}}{{non-standard_header}}</div>
+{{JSRef}}{{non-standard_header}}
 
-<p>La méthode <code><strong>toSource()</strong></code> permet de renvoyer une chaîne de caractères représentant le code source de l'objet.</p>
+La méthode **`toSource()`** permet de renvoyer une chaîne de caractères représentant le code source de l'objet.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>objetRegExp</var>.toSource()
-</pre>
+    objetRegExp.toSource()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant le code source de l'objet {{jsxref("RegExp")}}.</p>
+Une chaîne de caractères représentant le code source de l'objet {{jsxref("RegExp")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>La méthode <code>toSource</code> renvoie les valeurs suivantes :</p>
+La méthode `toSource` renvoie les valeurs suivantes :
 
-<ul>
- <li>Pour l'objet natif {{jsxref("RegExp")}}, <code>toSource()</code> renvoie la chaîne de caractères suivante, indiquant que le code source n'est pas disponible :
+- Pour l'objet natif {{jsxref("RegExp")}}, `toSource()` renvoie la chaîne de caractères suivante, indiquant que le code source n'est pas disponible :
 
-  <pre class="brush: js">function RegExp() {
-    [native code]
-}
-</pre>
- </li>
- <li>Pour les instances de {{jsxref("RegExp")}}, <code>toSource()</code> renvoie une chaîne de caractères indiquant le code source de l'objet.</li>
-</ul>
+  ```js
+    function RegExp() {
+        [native code]
+    }
+    ```
 
-<p>Cette méthode est généralement utilisée de façon interne au moteur JavaScript, elle n'est pas censée être utilisée dans du code JavaScript classique.</p>
+- Pour les instances de {{jsxref("RegExp")}}, `toSource()` renvoie une chaîne de caractères indiquant le code source de l'objet.
 
-<h2 id="Spécifications">Spécifications</h2>
+Cette méthode est généralement utilisée de façon interne au moteur JavaScript, elle n'est pas censée être utilisée dans du code JavaScript classique.
 
-<p>Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3.</p>
+## Spécifications
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+Cette méthode ne fait partie d'aucun standard. Elle a été implémentée avec JavaScript 1.3.
 
-<p>{{Compat("javascript.builtins.RegExp.toSource")}}</p>
+## Compatibilité des navigateurs
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+{{Compat("javascript.builtins.RegExp.toSource")}}
 
-<ul>
- <li>{{jsxref("Object.prototype.toSource()")}}</li>
-</ul>
+## Voir aussi
+
+- {{jsxref("Object.prototype.toSource()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/tostring/index.md b/files/fr/web/javascript/reference/global_objects/regexp/tostring/index.md
index d5f3e52afb..6b2a2e6413 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/tostring/index.md
@@ -10,84 +10,62 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>toString()</strong></code> renvoie une chaîne de caractères représentant l'expression rationnelle.</p>
+La méthode **`toString()`** renvoie une chaîne de caractères représentant l'expression rationnelle.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-tostring.html", "taller")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-tostring.html", "taller")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>regexObj</var>.toString();</pre>
+    regexObj.toString();
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant l'expression rationnelle appelante.</p>
+Une chaîne de caractères représentant l'expression rationnelle appelante.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("RegExp")}} surcharge la méthode <code>toString</code> de l'objet {{jsxref("Object")}}. Il n'hérite donc pas de {{jsxref("Object.prototype.toString()")}}. Pour les objets <code>RegExp</code>, la méthode <code>toString()</code> renvoie une représentation de l'expression rationnelle sous la forme d'une chaîne de caractères.</p>
+L'objet {{jsxref("RegExp")}} surcharge la méthode `toString` de l'objet {{jsxref("Object")}}. Il n'hérite donc pas de {{jsxref("Object.prototype.toString()")}}. Pour les objets `RegExp`, la méthode `toString()` renvoie une représentation de l'expression rationnelle sous la forme d'une chaîne de caractères.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toString()">Utiliser <code>toString()</code></h3>
+### Utiliser `toString()`
 
-<p>L'exemple qui suit affiche la chaîne correspondant à la valeur de l'objet {{jsxref("Global_Objects/RegExp", "RegExp")}} :</p>
+L'exemple qui suit affiche la chaîne correspondant à la valeur de l'objet {{jsxref("Global_Objects/RegExp", "RegExp")}} :
 
-<pre class="brush: js">var maRegExp = new RegExp("a+b+c");
+```js
+var maRegExp = new RegExp("a+b+c");
 console.log(maRegExp.toString());  // affiche "/a+b+c/"
 
 var toto = new RegExp("truc", "g");
 console.log(toto.toString());      // affiche "/truc/g"
-</pre>
+```
 
-<h3 id="Les_expressions_ratonnelles_vides_et_l'échappement">Les expressions ratonnelles vides et l'échappement</h3>
+### Les expressions ratonnelles vides et l'échappement
 
-<p>À partir d'ECMAScript 5, la méthode renvoie la chaîne <code>"(?:)"</code> pour les expressions vides. De plus, les fins de lignes (telles que "\n") sont désormais échappées.</p>
+À partir d'ECMAScript 5, la méthode renvoie la chaîne `"(?:)"` pour les expressions vides. De plus, les fins de lignes (telles que "\n") sont désormais échappées.
 
-<pre class="brush: js">new RegExp().toString(); // "(?:)"
+```js
+new RegExp().toString(); // "(?:)"
 
 new RegExp('\n').toString() === "/\n/";  // true avant ES5
-new RegExp('\n').toString() === "/\\n/"; // true à partir d'ES5</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5.2', 'RegExp.prototype.toString')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td><code>source</code> renvoie désormais "(?:)" (et non "") pour les expressions vides. La définition du comportement pour les échappements a été ajoutée.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.RegExp.toString")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Object.prototype.toString()")}}</li>
-</ul>
+new RegExp('\n').toString() === "/\\n/"; // true à partir d'ES5
+```
+
+## Spécifications
+
+| Spécification                                                                                                        | État                         | Commentaires                                                                                                                                 |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('ES3')}}                                                                                             | {{Spec2('ES3')}}         | Définition initiale. Implémentée avec JavaScript 1.1.                                                                                        |
+| {{SpecName('ES5.1', '#sec-15.9.5.2', 'RegExp.prototype.toString')}}                             | {{Spec2('ES5.1')}}     | `source` renvoie désormais "(?:)" (et non "") pour les expressions vides. La définition du comportement pour les échappements a été ajoutée. |
+| {{SpecName('ES6', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}}         | {{Spec2('ES6')}}         |                                                                                                                                              |
+| {{SpecName('ESDraft', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}} | {{Spec2('ESDraft')}} |                                                                                                                                              |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.RegExp.toString")}}
+
+## Voir aussi
+
+- {{jsxref("Object.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/regexp/unicode/index.md b/files/fr/web/javascript/reference/global_objects/regexp/unicode/index.md
index a15009ce4e..671fb82624 100644
--- a/files/fr/web/javascript/reference/global_objects/regexp/unicode/index.md
+++ b/files/fr/web/javascript/reference/global_objects/regexp/unicode/index.md
@@ -12,62 +12,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/unicode
 original_slug: Web/JavaScript/Reference/Objets_globaux/RegExp/unicode
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <strong><code>unicode</code></strong> indique si le drapeau "<code>u</code>" a été utilisé avec l'expression rationnelle. <code>unicode</code> est une propriété en lecture seule et liée à une instance d'expression rationnelle.</p>
+La propriété **`unicode`** indique si le drapeau "`u`" a été utilisé avec l'expression rationnelle. `unicode` est une propriété en lecture seule et liée à une instance d'expression rationnelle.
 
-<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-unicode.html", "taller")}}</div>
+{{EmbedInteractiveExample("pages/js/regexp-prototype-unicode.html", "taller")}}{{js_property_attributes(0, 0, 1)}}
 
+## Description
 
+La valeur d'`unicode` est un {{jsxref("Boolean")}} et vaut `true` si le drapeau "`u`" a été utilisé, sinon `false`. Le drapeau "`u`" permet d'activer les fonctionnalités liées à Unicode. En utilisant le drapeau "u" toute séquence d'échappement représentant un codet Unicode sera interprétée comme telle.
 
-<div>{{js_property_attributes(0, 0, 1)}}</div>
+Cette propriété ne peut pas être modifiée directement.
 
-<h2 id="Description">Description</h2>
+## Exemples
 
-<p>La valeur d'<code>unicode</code> est un {{jsxref("Boolean")}} et vaut <code>true</code> si le drapeau "<code>u</code>" a été utilisé, sinon <code>false</code>. Le drapeau "<code>u</code>" permet d'activer les fonctionnalités liées à Unicode. En utilisant le drapeau "u" toute séquence d'échappement représentant un codet Unicode sera interprétée comme telle.</p>
-
-<p>Cette propriété ne peut pas être modifiée directement.</p>
-
-<h2 id="Exemples">Exemples</h2>
-
-<pre class="brush: js">var regex = new RegExp('\u{61}', 'u');
+```js
+var regex = new RegExp('\u{61}', 'u');
 
 console.log(regex.unicode); // true
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">État</th>
-   <th scope="col">Commentaires</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-get-regexp.prototype.unicode', 'RegExp.prototype.unicode')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.unicode', 'RegExp.prototype.unicode')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                                        | État                         | Commentaires         |
+| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName('ES2015', '#sec-get-regexp.prototype.unicode', 'RegExp.prototype.unicode')}} | {{Spec2('ES2015')}}     | Définition initiale. |
+| {{SpecName('ESDraft', '#sec-get-regexp.prototype.unicode', 'RegExp.prototype.unicode')}} | {{Spec2('ESDraft')}} |                      |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.RegExp.unicode")}}</p>
+{{Compat("javascript.builtins.RegExp.unicode")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("RegExp.lastIndex")}}</li>
- <li>{{jsxref("RegExp.prototype.global")}}</li>
- <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
- <li>{{jsxref("RegExp.prototype.multiline")}}</li>
- <li>{{jsxref("RegExp.prototype.source")}}</li>
- <li>{{jsxref("RegExp.prototype.sticky")}}</li>
-</ul>
+- {{jsxref("RegExp.lastIndex")}}
+- {{jsxref("RegExp.prototype.global")}}
+- {{jsxref("RegExp.prototype.ignoreCase")}}
+- {{jsxref("RegExp.prototype.multiline")}}
+- {{jsxref("RegExp.prototype.source")}}
+- {{jsxref("RegExp.prototype.sticky")}}