convert content to md

6 files changed, 263 insertions, 326 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md b/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md
index 13023405cf..3465ce6c21 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/asintn/index.md
@@ -9,34 +9,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asIntN
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/asIntN
 ---
-<p>{{JSRef}}</p>
+{{JSRef}}
 
-<p>La méthode statique <strong><code>BigInt.asIntN()</code></strong> permet d'écréter un nombre <code>BigInt</code> pour obtenir un entier signé entre 2^(largeur-1) et 2^(largeur-1)-1.</p>
+La méthode statique **`BigInt.asIntN()`** permet d'écréter un nombre `BigInt` pour obtenir un entier signé entre 2^(largeur-1) et 2^(largeur-1)-1.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-asintn.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-asintn.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>resultat</var> = BigInt.asIntN(<var>largeur</var>, <var>bigint</var>);</pre>
+    var resultat = BigInt.asIntN(largeur, bigint);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>largeur</code></dt>
- <dd>La quantité de bits disponible pour stocker l'entier.</dd>
- <dt><code>bigint</code></dt>
- <dd>L'entier qu'on souhaite stocker sur le nombre de bits indiqués.</dd>
-</dl>
+- `largeur`
+  - : La quantité de bits disponible pour stocker l'entier.
+- `bigint`
+  - : L'entier qu'on souhaite stocker sur le nombre de bits indiqués.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur de <code>bigint</code> modulo 2^<code>largeur</code> comme entier signé.</p>
+La valeur de `bigint` modulo 2^`largeur` comme entier signé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La méthode <code>BigInt.asIntN()</code> peut être utile pour rester dans une arithmétique sur 64 bits :</p>
+La méthode `BigInt.asIntN()` peut être utile pour rester dans une arithmétique sur 64 bits :
 
-<pre class="brush: js">const max = 2n ** (64n - 1n) - 1n;
+```js
+const max = 2n ** (64n - 1n) - 1n;
 
 BigInt.asIntN(64, max);
 // ↪ 9223372036854775807n
@@ -44,30 +43,19 @@ BigInt.asIntN(64, max);
 BigInt.asIntN(64, max + 1n);
 // ↪ -9223372036854775807n
 // négatif car dépassement sur le nombre de bits
-</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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.asintn">BigInt proposal</a></td>
-   <td>Proposition de niveau 3.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                | État                     |
+| ---------------------------------------------------------------------------- | ------------------------ |
+| [BigInt proposal](https://tc39.github.io/proposal-bigint/#sec-bigint.asintn) | Proposition de niveau 3. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.asIntN")}}</p>
+{{Compat("javascript.builtins.BigInt.asIntN")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{JSxRef("BigInt")}}</li>
- <li>{{JSxRef("BigInt.asUintN()")}}</li>
-</ul>
+- {{JSxRef("BigInt")}}
+- {{JSxRef("BigInt.asUintN()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md b/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md
index 5331dbae11..096fc6af73 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/asuintn/index.md
@@ -10,64 +10,53 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/asUintN
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/asUintN
 ---
-<p>{{JSRef}}</p>
+{{JSRef}}
 
-<p>La méthode statique <strong><code>BigInt.asUintN()</code></strong> permet d'écréter un <code>BigInt</code> pour ramener sa valeur sur un entier non-signé entre 0 et 2^(largeur)-1.</p>
+La méthode statique **`BigInt.asUintN()`** permet d'écréter un `BigInt` pour ramener sa valeur sur un entier non-signé entre 0 et 2^(largeur)-1.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-asuintn.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-asuintn.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>résultat</var> = BigInt.asUintN(<var>largeur</var>, <var>bigint</var>);</pre>
+    var résultat = BigInt.asUintN(largeur, bigint);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>largeur</code></dt>
- <dd>Le nombre de bits disponible pour stocker l'entier.</dd>
- <dt><code>bigint</code></dt>
- <dd>L'entier qu'on souhaite stocker sur le nombre de bits indiqués.</dd>
-</dl>
+- `largeur`
+  - : Le nombre de bits disponible pour stocker l'entier.
+- `bigint`
+  - : L'entier qu'on souhaite stocker sur le nombre de bits indiqués.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La valeur de <code>bigint</code> modulo 2^<code>largeur</code> comme un entier non signé.</p>
+La valeur de `bigint` modulo 2^`largeur` comme un entier non signé.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>La méthode <code>BigInt.asUintN()</code> peut s'avérer utile pour rester dans une arithmétique exprimée sur 64 bits .</p>
+La méthode `BigInt.asUintN()` peut s'avérer utile pour rester dans une arithmétique exprimée sur 64 bits .
 
-<pre class="brush: js">const max = 2n ** 64n - 1n;
+```js
+const max = 2n ** 64n - 1n;
 
 BigInt.asUintN(64, max);
 // ↪ 18446744073709551615n
 
 BigInt.asUintN(64, max + 1n);
 // ↪ 0n
-// zéro en raison du dépassement</pre>
+// zéro en raison du dépassement
+```
 
-<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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.asuintn">Proposition pour BigInt</a></td>
-   <td>Proposition de niveau 3</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                         | État                    |
+| ------------------------------------------------------------------------------------- | ----------------------- |
+| [Proposition pour BigInt](https://tc39.github.io/proposal-bigint/#sec-bigint.asuintn) | Proposition de niveau 3 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.asUintN")}}</p>
+{{Compat("javascript.builtins.BigInt.asUintN")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{JSxRef("BigInt")}}</li>
- <li>{{JSxRef("BigInt.asIntN()")}}</li>
-</ul>
+- {{JSxRef("BigInt")}}
+- {{JSxRef("BigInt.asIntN()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/index.md b/files/fr/web/javascript/reference/global_objects/bigint/index.md
index 6e842994cc..4cb7b392cf 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/index.md
@@ -9,39 +9,33 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p><strong><code>BigInt</code></strong> est un objet natif qui permet de représenter des nombres entiers supérieurs à 2^53 (la plus grande valeur entière qui puisse être représentée par le type primitif {{jsxref("Number")}}). <code>BigInt</code> peut être utilisé afin de représenter de grands entiers de n'importe quelle taille.</p>
+**`BigInt`** est un objet natif qui permet de représenter des nombres entiers supérieurs à 2^53 (la plus grande valeur entière qui puisse être représentée par le type primitif {{jsxref("Number")}}). `BigInt` peut être utilisé afin de représenter de grands entiers de n'importe quelle taille.
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> BigInt est actuellement une <strong>proposition de niveau 3</strong> pour la <a href="#Spécifications">spécification</a> ECMAScript.</p>
+> **Note :** BigInt est actuellement une **proposition de niveau 3** pour la [spécification](#Spécifications) ECMAScript.
+>
+> Lorsque cette proposition atteindra le niveau 4 (soit la spécification finale), BigInt sera le deuxième type natif disponible en JavaScript pour représenter des valeurs numériques.
+>
+> **`BigInt`** sera ainsi le prochain type primitif ajouté à JavaScript depuis {{JSxRef("Symbol")}} avec ES2015
 
-<p>Lorsque cette proposition atteindra le niveau 4 (soit la spécification finale), BigInt sera le deuxième type natif disponible en JavaScript pour représenter des valeurs numériques.</p>
+## Syntaxe
 
-<p><strong><code>BigInt</code></strong> sera ainsi le prochain type primitif ajouté à JavaScript depuis {{JSxRef("Symbol")}} avec ES2015</p>
-</div>
+    BigInt(valeur);
 
-<h2 id="Syntaxe">Syntaxe</h2>
+### Paramètres
 
-<pre class="syntaxbox">BigInt(valeur);
-</pre>
+- `valeur`
+  - : La valeur numérique de l'objet qu'on souhaite créer. Cet argument peut être une chaîne de caractères ou un entier.
 
-<h3 id="Paramètres">Paramètres</h3>
+> **Note :** `BigInt()` n'est pas censé être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.
 
-<dl>
- <dt><code>valeur</code></dt>
- <dd>La valeur numérique de l'objet qu'on souhaite créer. Cet argument peut être une chaîne de caractères ou un entier.</dd>
-</dl>
+## Description
 
-<div class="blockIndicator note">
-<p><strong>Note :</strong> <code>BigInt()</code> n'est pas censé être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new", "new")}}.</p>
-</div>
+Un objet `BigInt` est créé en ajoutant un `n` à la fin d'un littéral d'entier — `10n` par exemple — ou en appelant la fonction `BigInt()`.
 
-<h2 id="Description">Description</h2>
-
-<p>Un objet <code>BigInt</code> est créé en ajoutant un <code>n</code> à la fin d'un littéral d'entier — <code>10n</code> par exemple — ou en appelant la fonction <code>BigInt()</code>.</p>
-
-<pre class="brush: js">const plusGrandEntier = 9007199254740991n;
+```js
+const plusGrandEntier = 9007199254740991n;
 
 const grandNombre = BigInt(9007199254740991);
 // ↪ 9007199254740991n
@@ -53,32 +47,36 @@ const grandeNombreHexa = BigInt("0x1fffffffffffff");
 // ↪ 9007199254740991n
 
 const grandeNombreBinaire = BigInt("0b11111111111111111111111111111111111111111111111111111");
-// ↪ 9007199254740991n</pre>
-
-<p>Les objets <code>BigInt</code> sont semblables aux objets {{jsxref("Number")}} selon certains aspects mais avec quelques différences clés. Les objets <code>BigInt</code> ne peuvent pas êre utilisés avec l'objet {{jsxref("Math")}} et ne peuvent pas être manipulés avec des opérations qui impliquent des objets {{jsxref("Number")}}.</p>
+// ↪ 9007199254740991n
+```
 
-<div class="warning">
-<p><strong>Attention :</strong> Il est nécessaire de convertir des valeurs {{jsxref("Number")}} ou <code>BigInt</code> dans les opérations qui les combinent.</p>
+Les objets `BigInt` sont semblables aux objets {{jsxref("Number")}} selon certains aspects mais avec quelques différences clés. Les objets `BigInt` ne peuvent pas êre utilisés avec l'objet {{jsxref("Math")}} et ne peuvent pas être manipulés avec des opérations qui impliquent des objets {{jsxref("Number")}}.
 
-<p>Attention lors de ces conversions car la précision d'une valeur <code>BigInt</code> peut être perdue lorsque ce dernier est converti en {{jsxref("Number")}}.</p>
-</div>
+> **Attention :** Il est nécessaire de convertir des valeurs {{jsxref("Number")}} ou `BigInt` dans les opérations qui les combinent.
+>
+> Attention lors de ces conversions car la précision d'une valeur `BigInt` peut être perdue lorsque ce dernier est converti en {{jsxref("Number")}}.
 
-<h3 id="Type">Type</h3>
+### Type
 
-<p>Lorsqu'on utilise <code>typeof</code> sur une valeur <code>BigInt</code>, cet opérateur renverra <code>"bigint"</code> :</p>
+Lorsqu'on utilise `typeof` sur une valeur `BigInt`, cet opérateur renverra `"bigint"` :
 
-<pre class="brush: js">typeof 1n === "bigint"; // true
-typeof BigInt("1") === "bigint"; // true</pre>
+```js
+typeof 1n === "bigint"; // true
+typeof BigInt("1") === "bigint"; // true
+```
 
-<p>Lorsqu'on « enveloppe » la valeur dans un objet, on aura alors un type <code>"object"</code> (comme pour les autres valeurs primitives lorsqu'on les enveloppe dans le constructeur objet) :</p>
+Lorsqu'on « enveloppe » la valeur dans un objet, on aura alors un type `"object"` (comme pour les autres valeurs primitives lorsqu'on les enveloppe dans le constructeur objet) :
 
-<pre class="brush: js">typeof Object(1n) === "object"; // true</pre>
+```js
+typeof Object(1n) === "object"; // true
+```
 
-<h3 id="Opérateurs">Opérateurs</h3>
+### Opérateurs
 
-<p>On peut utiliser les opérateurs suivants avec les objets <code>BigInt</code> : <code>+</code>, `<code>*</code>`, `<code>-</code>`, `<code>**</code>`, `<code>%</code>` , <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires">les opérateurs binaires</a> (à l'exception de <code>&gt;&gt;&gt;</code> / décalage à droite avec des zéros) car les grands entiers sont signés. Le <code>+</code> unaire n'est pas non plus pris en charge (afin de <a href="https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs">ne pas casser asm.js</a>).</p>
+On peut utiliser les opérateurs suivants avec les objets `BigInt` : `+`, \``*`\`, \``-`\`, \``**`\`, \``%`\` , [les opérateurs binaires](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires) (à l'exception de `>>>` / décalage à droite avec des zéros) car les grands entiers sont signés. Le `+` unaire n'est pas non plus pris en charge (afin de [ne pas casser asm.js](https://github.com/tc39/proposal-bigint/blob/master/ADVANCED.md#dont-break-asmjs)).
 
-<pre class="brush: js">const nombreSain = BigInt(Number.MAX_SAFE_INTEGER);
+```js
+const nombreSain = BigInt(Number.MAX_SAFE_INTEGER);
 // ↪ 9007199254740991
 
 const maxPlusUn = nombreSain + 1n;
@@ -101,66 +99,75 @@ const bigN = 2n ** 54n;
 
 bigN * -1n
 // ↪ –18014398509481984n
-</pre>
+```
 
-<p>L'opérateur <code>/</code> fonctionne de façon analogue aux nombres classiques. Toutefois, les objets <code>BigInt</code> permettent uniquement de représenter des entiers et non des nombres décimaux. Aussi, la division ne produira pas de partie décimale pour les <code>BigInt</code>.</p>
+L'opérateur `/` fonctionne de façon analogue aux nombres classiques. Toutefois, les objets `BigInt` permettent uniquement de représenter des entiers et non des nombres décimaux. Aussi, la division ne produira pas de partie décimale pour les `BigInt`.
 
-<pre class="brush: js">const attendu = 4n / 2n;
+```js
+const attendu = 4n / 2n;
 // ↪ 2n
 
 const tronque = 5n / 2n;
 // ↪ 2n et pas 2.5n
+```
 
-</pre>
+### Comparaisons
 
-<h3 id="Comparaisons">Comparaisons</h3>
+Un objet `BigInt` n'est pas strictement égal à {{jsxref( "Number")}} mais peut l'être au sens de l'égalité faible.
 
-<p>Un objet <code>BigInt</code> n'est pas strictement égal à {{jsxref( "Number")}} mais peut l'être au sens de l'égalité faible.</p>
-
-<pre class="brush: js">0n === 0
+```js
+0n === 0
 // ↪ false
 
 0n == 0
-// ↪ true</pre>
+// ↪ true
+```
 
-<p>On peut toutefois comparer des objets {{jsxref("Number")}} et <code>BigInt</code> :</p>
+On peut toutefois comparer des objets {{jsxref("Number")}} et `BigInt` :
 
-<pre class="brush: js">1n &lt; 2
+```js
+1n < 2
 // ↪ true
 
-2n &gt; 1
+2n > 1
 // ↪ true
 
-2 &gt; 2
+2 > 2
 // ↪ false
 
-2n &gt; 2
+2n > 2
 // ↪ false
 
-2n &gt;= 2
-// ↪ true</pre>
+2n >= 2
+// ↪ true
+```
 
-<p>On peut également mélanger ces valeurs au sein de tableaux :</p>
+On peut également mélanger ces valeurs au sein de tableaux :
 
-<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
+```js
+const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
 // ↪  [4n, 6, -12n, 10, 4, 0, 0n]
 
 mixed.sort();
-// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]</pre>
+// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]
+```
 
-<p>On notera que les comparaisons entre les valeurs <code>BigInt</code> et les mêmes valeurs, passées dans le constructeur <code>Object()</code> ne seront pas équivalentes au sens strict :</p>
+On notera que les comparaisons entre les valeurs `BigInt` et les mêmes valeurs, passées dans le constructeur `Object()` ne seront pas équivalentes au sens strict :
 
-<pre class="brush: js">0n === Object(0n); // false
+```js
+0n === Object(0n); // false
 Object(0n) === Object(0n); // false
 
 const o = Object(0n);
-o === o; // true</pre>
+o === o; // true
+```
 
-<h3 id="Opérations_conditionnelles">Opérations conditionnelles</h3>
+### Opérations conditionnelles
 
-<p>Un objet <code>BigInt</code> se comporte comme un objet {{jsxref("Number")}} lorsqu'il est utilisé dans un contexte booléen : comme argument pour le constructeur {{jsxref("Boolean")}}, comme opérandes pour les opérateurs logiques <code>||</code>, `<code>&amp;&amp;</code>` et <code>!</code> ou avec les instructions conditonnelles telles que <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if</a></code>.</p>
+Un objet `BigInt` se comporte comme un objet {{jsxref("Number")}} lorsqu'il est utilisé dans un contexte booléen : comme argument pour le constructeur {{jsxref("Boolean")}}, comme opérandes pour les opérateurs logiques `||`, \``&&`\` et `!` ou avec les instructions conditonnelles telles que [`if`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else).
 
-<pre class="brush: js">if (0n) {
+```js
+if (0n) {
   console.log('Nous voici dans le if !');
 } else {
   console.log('Et nous voilà dans le else !');
@@ -171,7 +178,7 @@ o === o; // true</pre>
 0n || 12n
 // ↪ 12n
 
-0n &amp;&amp; 12n
+0n && 12n
 // ↪ 0n
 
 Boolean(0n)
@@ -185,48 +192,45 @@ Boolean(12n)
 
 !0n
 // ↪ true
-</pre>
+```
 
-<h2 id="Méthodes">Méthodes</h2>
+## Méthodes
 
-<dl>
- <dt><strong><code>BigInt.asIntN()</code></strong></dt>
- <dd>Écrète un objet <code>BigInt</code> pour obtenir un entier signé entre -2^(largeur-1) et 2^(largeur-1)-1</dd>
- <dt><code>BigInt.asUintN()</code></dt>
- <dd>Écrète un objet <code>BigInt</code> pour obtenir un entier non-signé entre 0 et 2^(largeur)-1</dd>
-</dl>
+- **`BigInt.asIntN()`**
+  - : Écrète un objet `BigInt` pour obtenir un entier signé entre -2^(largeur-1) et 2^(largeur-1)-1
+- `BigInt.asUintN()`
+  - : Écrète un objet `BigInt` pour obtenir un entier non-signé entre 0 et 2^(largeur)-1
 
-<h2 id="Propriétés">Propriétés</h2>
+## Propriétés
 
-<dl>
- <dt>{{jsxref("BigInt.prototype")}}</dt>
- <dd>Cette propriété permet d'ajouter des propriétés aux objets <code>BigInt</code>.</dd>
-</dl>
+- {{jsxref("BigInt.prototype")}}
+  - : Cette propriété permet d'ajouter des propriétés aux objets `BigInt`.
 
-<h2 id="Instances_de_BigInt">Instances de <code>BigInt</code></h2>
+## Instances de `BigInt`
 
-<p>L'ensemble des instances de <code>BigInt</code> héritent de <code>BigInt.prototype</code>. Le prototype du constructeur <code>BigInt</code> peut être modifié afin de modifier l'ensemble des instances de <code>BigInt</code>.</p>
+L'ensemble des instances de `BigInt` héritent de `BigInt.prototype`. Le prototype du constructeur `BigInt` peut être modifié afin de modifier l'ensemble des instances de `BigInt`.
 
-<h3 id="Méthodes_2">Méthodes</h3>
+### Méthodes
 
-<p>{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/BigInt/prototype', 'Méthodes')}}</p>
+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/BigInt/prototype', 'Méthodes')}}
 
-<h2 id="Recommandations">Recommandations</h2>
+## Recommandations
 
-<h3 id="Coercition_en_Number">Coercition en <code>Number</code></h3>
+### Coercition en `Number`
 
-<p>Lorsqu'on convertit une valeur <code>BigInt</code> en {{jsxref("Objets_globaux/Number","Number")}}, on perd en précision. Si on effectue des allers-retours entre ces deux types, on ne conservera pas la même valeur. Aussi, il est recommandé d'utiliser uniquement <code>BigInt</code> lorsque les valeurs qu'on manipule seront supérieures à 2^53 et qu'il ne sera pas nécessaire de passer d'un type à l'autre.</p>
+Lorsqu'on convertit une valeur `BigInt` en {{jsxref("Objets_globaux/Number","Number")}}, on perd en précision. Si on effectue des allers-retours entre ces deux types, on ne conservera pas la même valeur. Aussi, il est recommandé d'utiliser uniquement `BigInt` lorsque les valeurs qu'on manipule seront supérieures à 2^53 et qu'il ne sera pas nécessaire de passer d'un type à l'autre.
 
-<h3 id="Cryptographie">Cryptographie</h3>
+### Cryptographie
 
-<p>Les opérations prises en charge pour les valeurs <code>BigInt</code> ne s'effectuent pas à temps constant. Aussi, <code>BigInt</code> ne serait être utilisé à <a href="https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html">des fins cryptographiques</a>.</p>
+Les opérations prises en charge pour les valeurs `BigInt` ne s'effectuent pas à temps constant. Aussi, `BigInt` ne serait être utilisé à [des fins cryptographiques](https://www.chosenplaintext.ca/articles/beginners-guide-constant-time-cryptography.html).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Calculer_des_nombres_premiers">Calculer des nombres premiers</h3>
+### Calculer des nombres premiers
 
-<pre class="brush: js">function isPrime(p) {
-  for (let i = 2n; i * i &lt;= p; i++) {
+```js
+function isPrime(p) {
+  for (let i = 2n; i * i <= p; i++) {
     if (p % i === 0n) return false;
   }
   return true;
@@ -237,7 +241,7 @@ function nthPrime(nth) {
   let maybePrime = 2n;
   let prime = 0n;
 
-  while (nth &gt;= 0n) {
+  while (nth >= 0n) {
     if (isPrime(maybePrime)) {
       nth -= 1n;
       prime = maybePrime;
@@ -249,31 +253,19 @@ function nthPrime(nth) {
 }
 
 nthPrime(20n)
-// ↪ 73n</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>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code><a href="https://tc39.es/proposal-bigint/#sec-bigint-objects">BigInt</a></code></td>
-   <td>Brouillon de niveau 3</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.BigInt")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{jsxref("Number")}}</li>
-</ul>
+// ↪ 73n
+```
+
+## Spécifications
+
+| Spécification                                                   | État                  |
+| --------------------------------------------------------------- | --------------------- |
+| [`BigInt`](https://tc39.es/proposal-bigint/#sec-bigint-objects) | Brouillon de niveau 3 |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.BigInt")}}
+
+## Voir aussi
+
+- {{jsxref("Number")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md
index 05c8d2860a..ba569b8723 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/tolocalestring/index.md
@@ -12,46 +12,46 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toLocaleString
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/toLocaleString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>toLocaleString()</code></strong> renvoie une chaîne de caractères représentant le grand entier pour la ou les locale(s) indiquée(s).</p>
+La méthode **`toLocaleString()`** renvoie une chaîne de caractères représentant le grand entier pour la ou les locale(s) indiquée(s).
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-tolocalestring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-tolocalestring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><em>bigIntObj</em>.toLocaleString(</code><code>[locales [, options]])</code></pre>
+    bigIntObj.toLocaleString([locales [, options]])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>locales</code> {{optional_inline}}</dt>
- <dd>Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument <code>locales</code>. Pour plus de détails quant à la forme et l'interprétation de l'argument <code>locales</code>, on consultera la page {{jsxref("Intl")}}.</dd>
- <dt><code>options</code> {{optional_inline}}</dt>
- <dd>Un objet qui contient des propriétés de configuration. Pour les nombres, consulter {{jsxref("Number.prototype.toLocaleString()")}}, pour les dates, consulter {{jsxref("Date.prototype.toLocaleString()")}}.</dd>
-</dl>
+- `locales` {{optional_inline}}
+  - : Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument `locales`. Pour plus de détails quant à la forme et l'interprétation de l'argument `locales`, on consultera la page {{jsxref("Intl")}}.
+- `options` {{optional_inline}}
+  - : Un objet qui contient des propriétés de configuration. Pour les nombres, consulter {{jsxref("Number.prototype.toLocaleString()")}}, pour les dates, consulter {{jsxref("Date.prototype.toLocaleString()")}}.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères qui représente le grand entier selon la ou les locales et les options indiquées.</p>
+Une chaîne de caractères qui représente le grand entier selon la ou les locales et les options indiquées.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toLocaleString()">Utiliser <code>toLocaleString()</code></h3>
+### Utiliser `toLocaleString()`
 
-<p>Voici un exemple d'utilisation simple, sans indiquer de locale ni d'options.</p>
+Voici un exemple d'utilisation simple, sans indiquer de locale ni d'options.
 
-<pre class="brush: js">var bigint = 3500n;
+```js
+var bigint = 3500n;
 
 bigint.toLocaleString();
 // Affichera "3500" en français
-</pre>
+```
 
-<h3 id="Utiliser_locales">Utiliser <code>locales</code></h3>
+### Utiliser `locales`
 
-<p>Cet exemple illustre certaines variations pour la représentation d'une même valeur en fonction des différentes locales. En fonction de la langue utilisée par l'utilisateur et par votre interface, vous pourrez utiliser <code>locales</code> pour indiquer la locale ciblée :</p>
+Cet exemple illustre certaines variations pour la représentation d'une même valeur en fonction des différentes locales. En fonction de la langue utilisée par l'utilisateur et par votre interface, vous pourrez utiliser `locales` pour indiquer la locale ciblée :
 
-<pre class="brush: js">var bigint = 123456789123456789n;
+```js
+var bigint = 123456789123456789n;
 
 // En allemand, on utilise les points pour séparer
 // les milliers
@@ -59,7 +59,7 @@ console.log(bigint.toLocaleString('de-DE'));
 // → 123.456.789.123.456.789
 
 // La plupart des pays arabes utilise
-// des chiffres <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">hindoux-arabes</a>
+// des chiffres hindoux-arabes
 console.log(bigint.toLocaleString('ar-EG'));
 // → ١٢٣٬٤٥٦٬٧٨٩٬١٢٣٬٤٥٦٬٧٨٩
 
@@ -78,13 +78,14 @@ console.log(bigint.toLocaleString('zh-Hans-CN-u-nu-hanidec'));
 // locale qui sera utilisée en recours (ici l'indonésien)
 console.log(bigint.toLocaleString(['ban', 'id']));
 // → 123.456.789.123.456.789
-</pre>
+```
 
-<h3 id="Utiliser_options">Utiliser <code>options</code></h3>
+### Utiliser `options`
 
-<p>Ici, on personnalise le résultat fourni par <code>toLocaleString()</code> grâce à l'argument <code>options</code> :</p>
+Ici, on personnalise le résultat fourni par `toLocaleString()` grâce à l'argument `options` :
 
-<pre class="brush: js">var bigint = 123456789123456789n;
+```js
+var bigint = 123456789123456789n;
 
 // On utilise un format avec une devise
 console.log(bigint.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
@@ -97,33 +98,22 @@ console.log(bigint.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY'
 // On limite l'écriture aux trois premiers chiffres significatifs
 console.log(bigint.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
 // → 1,23,00,00,00,00,00,00,000
-</pre>
+```
 
-<h2 id="Performance">Performance</h2>
+## Performance
 
-<p>Lorsqu'on souhaite mettre en forme une grande quantité de nombres, mieux vaudra créer un objet {{jsxref("NumberFormat")}} et utiliser la fonction fournie par sa propriété {{jsxref("NumberFormat.format")}}.</p>
+Lorsqu'on souhaite mettre en forme une grande quantité de nombres, mieux vaudra créer un objet {{jsxref("NumberFormat")}} et utiliser la fonction fournie par sa propriété {{jsxref("NumberFormat.format")}}.
 
-<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>
-  </tr>
-  <tr>
-   <td><code><a href="https://tc39.es/ecma402/#sup-bigint.prototype.tolocalestring">BigInt</a></code></td>
-   <td>Proposition de niveau 3.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                            | État                     |
+| ------------------------------------------------------------------------ | ------------------------ |
+| [`BigInt`](https://tc39.es/ecma402/#sup-bigint.prototype.tolocalestring) | Proposition de niveau 3. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.toLocaleString")}}</p>
+{{Compat("javascript.builtins.BigInt.toLocaleString")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("BigInt.toString()")}}</li>
-</ul>
+- {{jsxref("BigInt.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md b/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md
index 4fbc9eab99..b1fdcdbef7 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/tostring/index.md
@@ -10,85 +10,73 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/toString
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/toString
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>The <strong><code>toString()</code></strong> method returns a string representing the specified {{jsxref("BigInt")}} object. The trailing "n" is not part of the string.</p>
+The **`toString()`** method returns a string representing the specified {{jsxref("BigInt")}} object. The trailing "n" is not part of the string.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-tostring.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><code><var>bigIntObj</var>.toString([<var>base</var>])</code></pre>
+    bigIntObj.toString([base])
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>base</code>{{optional_inline}}</dt>
- <dd>Ce paramètre optionnel est compris entre 2 et 36 et indique la base à utiliser pour représenter les valeurs numériques.</dd>
-</dl>
+- `base`{{optional_inline}}
+  - : Ce paramètre optionnel est compris entre 2 et 36 et indique la base à utiliser pour représenter les valeurs numériques.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une chaîne de caractères représentant l'objet {{jsxref("BigInt")}} courant.</p>
+Une chaîne de caractères représentant l'objet {{jsxref("BigInt")}} courant.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Si la base fournie comme argument <code>toString()</code> est inférieure à 2 ou supérieure à 36, cela déclenchera une exception {{jsxref("RangeError")}}.</dd>
-</dl>
+- {{jsxref("RangeError")}}
+  - : Si la base fournie comme argument `toString()` est inférieure à 2 ou supérieure à 36, cela déclenchera une exception {{jsxref("RangeError")}}.
 
-<h2 id="Description">Description</h2>
+## Description
 
-<p>L'objet {{jsxref("BigInt")}} surcharge la méthode <code>toString()</code> de {{jsxref("Object")}}. Il n'hérite pas ou n'utilise pas {{jsxref("Object.prototype.toString()")}}. Pour les objets {{jsxref( "BigInt")}}, la méthode <code>toString()</code> renvoie une représentation textuelle de l'objet dans la base indiquée.</p>
+L'objet {{jsxref("BigInt")}} surcharge la méthode `toString()` de {{jsxref("Object")}}. Il n'hérite pas ou n'utilise pas {{jsxref("Object.prototype.toString()")}}. Pour les objets {{jsxref( "BigInt")}}, la méthode `toString()` renvoie une représentation textuelle de l'objet dans la base indiquée.
 
-<p>La méthode <code>toString()</code> analyse le premier argument qui lui est passé et tente de renvoyer une représentation textuelle dans cette base. Pour les bases supérieures à 10, ce seront les lettres de l'alphabet pour indiquer les chiffres supérieurs à 9. Pour les nombres hexadécimaux (base 16), les lettres <code>a</code> à <code>f</code> sont utilisées par exemple.</p>
+La méthode `toString()` analyse le premier argument qui lui est passé et tente de renvoyer une représentation textuelle dans cette base. Pour les bases supérieures à 10, ce seront les lettres de l'alphabet pour indiquer les chiffres supérieurs à 9. Pour les nombres hexadécimaux (base 16), les lettres `a` à `f` sont utilisées par exemple.
 
-<p>Si l'argument <code>base</code> n'est pas indiquée, ce sera la base 10 qui sera considérée par défaut.</p>
+Si l'argument `base` n'est pas indiquée, ce sera la base 10 qui sera considérée par défaut.
 
-<p>Si <code>bigIntObj</code> est négatif, le signe est conservé, y compris lorsque la base est 2 (dans ce cas, la chaîne renvoyée sera la représentation binaire précédée par un signe <code>-</code> et <strong>non</strong> le complément à deux de <code>bigIntObj</code>).</p>
+Si `bigIntObj` est négatif, le signe est conservé, y compris lorsque la base est 2 (dans ce cas, la chaîne renvoyée sera la représentation binaire précédée par un signe `-` et **non** le complément à deux de `bigIntObj`).
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_toString()">Utiliser <code>toString()</code></h3>
+### Utiliser `toString()`
 
-<pre class="brush: js">17n.toString();      // '17'
+```js
+17n.toString();      // '17'
 66n.toString(2);     // '1000010'
 254n.toString(16);   // 'fe'
 -10n.toString(2);    // -1010'
 -0xffn.toString(2);  // '-11111111'
-</pre>
+```
 
-<h3 id="Gestion_du_zéro_négatif_en_BigInt">Gestion du zéro négatif en <code>BigInt</code></h3>
+### Gestion du zéro négatif en `BigInt`
 
-<p>Il n'existe pas de zéro négatif pour <code>BigInt</code> car les entiers ne gèrent pas de concept de zéro négatif. <code>-0.0</code> est un concept relatif à la représentation flottante IEEE et n'est présent que pour le type {{jsxref("Number")}}.</p>
+Il n'existe pas de zéro négatif pour `BigInt` car les entiers ne gèrent pas de concept de zéro négatif. `-0.0` est un concept relatif à la représentation flottante IEEE et n'est présent que pour le type {{jsxref("Number")}}.
 
-<pre class="brush: js">(-0n).toString();      // '0'
-BigInt(-0).toString(); // '0'</pre>
+```js
+(-0n).toString();      // '0'
+BigInt(-0).toString(); // '0'
+```
 
-<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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.tostring">Proposition pour <code>BigInt</code></a></td>
-   <td>Proposition de niveau 3</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                      | État                    |
+| -------------------------------------------------------------------------------------------------- | ----------------------- |
+| [Proposition pour `BigInt`](https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.tostring) | Proposition de niveau 3 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.toString")}}</p>
+{{Compat("javascript.builtins.BigInt.toString")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("BigInt.prototype.toLocaleString()")}}</li>
- <li>{{jsxref("BigInt.prototype.valueOf()")}}</li>
- <li>{{jsxref("Number.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("BigInt.prototype.toLocaleString()")}}
+- {{jsxref("BigInt.prototype.valueOf()")}}
+- {{jsxref("Number.prototype.toString()")}}
diff --git a/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md b/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md
index 92a6e74350..fae0cd160f 100644
--- a/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md
+++ b/files/fr/web/javascript/reference/global_objects/bigint/valueof/index.md
@@ -11,49 +11,39 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/valueOf
 original_slug: Web/JavaScript/Reference/Objets_globaux/BigInt/valueOf
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <strong><code>valueOf()</code></strong> renvoie la valeur primitive encapsulée dans un objet {{jsxref("BigInt")}}.</p>
+La méthode **`valueOf()`** renvoie la valeur primitive encapsulée dans un objet {{jsxref("BigInt")}}.
 
-<div>{{EmbedInteractiveExample("pages/js/bigint-valueof.html")}}</div>
+{{EmbedInteractiveExample("pages/js/bigint-valueof.html")}}
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>bigIntObj</var>.valueOf()</pre>
+    bigIntObj.valueOf()
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un grand entier (<em>big int</em>) représentant la valeur primitive de l'objet {{jsxref("BigInt")}} courant.</p>
+Un grand entier (_big int_) représentant la valeur primitive de l'objet {{jsxref("BigInt")}} courant.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utiliser_valueOf()">Utiliser <code>valueOf()</code></h3>
+### Utiliser `valueOf()`
 
-<pre class="brush: js">typeof Object(1n); // object
+```js
+typeof Object(1n); // object
 typeof Object(1n).valueOf(); // bigint
-</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>
-  </tr>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.valueof">Proposition pour <code>BigInt</code></a></td>
-   <td>Proposition de niveau 3</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                     | État                    |
+| ------------------------------------------------------------------------------------------------- | ----------------------- |
+| [Proposition pour `BigInt`](https://tc39.github.io/proposal-bigint/#sec-bigint.prototype.valueof) | Proposition de niveau 3 |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.BigInt.valueOf")}}</p>
+{{Compat("javascript.builtins.BigInt.valueOf")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{jsxref("BigInt.prototype.toString()")}}</li>
-</ul>
+- {{jsxref("BigInt.prototype.toString()")}}