convert content to md

5 files changed, 207 insertions, 289 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md
index 717a8d70e1..3d263884fe 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md
@@ -11,74 +11,54 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get
 original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/get
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>get()</strong></code>, rattachéee au prototype de  {{jsxref("WebAssembly.Table()")}}, permet de récupérer une référence à une fonction stockée dans le tableau WebAssembly grâce à sa position. dans le tableau.</p>
+La méthode **`get()`**, rattachéee au prototype de  {{jsxref("WebAssembly.Table()")}}, permet de récupérer une référence à une fonction stockée dans le tableau WebAssembly grâce à sa position. dans le tableau.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var funcRef = table.get(<em>index</em>);
-</pre>
+    var funcRef = table.get(index);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>index</code></dt>
- <dd>L'index de la référence de fonction qu'on souhaite récupérer.</dd>
-</dl>
+- `index`
+  - : L'index de la référence de fonction qu'on souhaite récupérer.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Une référence de fonction, c'est-à-dire <a href="/fr/docs/WebAssembly/Exported_functions">une fonction WebAssembly exportée</a> qui est une enveloppe JavaScript pour manipuler la fonction WebAssembly sous-jacente.</p>
+Une référence de fonction, c'est-à-dire [une fonction WebAssembly exportée](/fr/docs/WebAssembly/Exported_functions) qui est une enveloppe JavaScript pour manipuler la fonction WebAssembly sous-jacente.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Si <code>index</code> est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, la méthode lèvera une exception {{jsxref("RangeError")}}.</p>
+Si `index` est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, la méthode lèvera une exception {{jsxref("RangeError")}}.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans l'exemple suivant (cf. le fichier <code><a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table.html">table.html</a></code> sur GitHub ainsi que <a href="https://mdn.github.io/webassembly-examples/js-api-examples/table.html">le résultat obtenu</a>), on compile et on instancie le <em>bytecode</em> chargé, <code>table.wasm</code>, grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}. On récupère ensuite les références stockées dans le tableau d'export.</p>
+Dans l'exemple suivant (cf. le fichier [`table.html`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table.html) sur GitHub ainsi que [le résultat obtenu](https://mdn.github.io/webassembly-examples/js-api-examples/table.html)), on compile et on instancie le _bytecode_ chargé, `table.wasm`, grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}. On récupère ensuite les références stockées dans le tableau d'export.
 
-<pre class="brush: js">WebAssembly.instantiateStreaming(fetch('table.wasm'))
+```js
+WebAssembly.instantiateStreaming(fetch('table.wasm'))
 .then(function(obj) {
   var tbl = obj.instance.exports.tbl;
   console.log(tbl.get(0)());  // 13
   console.log(tbl.get(1)());  // 42
-});</pre>
+});
+```
 
-<p>On note ici qu'il est nécessaire d'avoir un deuxième opérateur d'appel après l'accesseur pour récupérer le valeur stockée dans la référence (autrement dit, on utilise <code>get(0)()</code> plutôt que <code>get(0)</code>). La valeur exportée est une fonction plutôt qu'une valeur simple.</p>
+On note ici qu'il est nécessaire d'avoir un deuxième opérateur d'appel après l'accesseur pour récupérer le valeur stockée dans la référence (autrement dit, on utilise `get(0)()` plutôt que `get(0)`). La valeur exportée est une fonction plutôt qu'une valeur simple.
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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('WebAssembly JS', '#webassemblytableprototypeget', 'get()')}}</td>
-   <td>{{Spec2('WebAssembly JS')}}</td>
-   <td>Brouillon de définition initial pour WebAssembly.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                    | État                                 | Commentaires                                      |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------------------------------------------- |
+| {{SpecName('WebAssembly JS', '#webassemblytableprototypeget', 'get()')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initial pour WebAssembly. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<div>
+{{Compat("javascript.builtins.WebAssembly.Table.get")}}
 
+## Voir aussi
 
-<p>{{Compat("javascript.builtins.WebAssembly.Table.get")}}</p>
-</div>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
-</ul>
+- [Le portail WebAssembly](/fr/docs/WebAssembly)
+- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md
index d5356522b6..9b8745086b 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md
@@ -11,70 +11,55 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow
 original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/grow
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>grow()</strong></code>, rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet d'augmenter la taille du tableau WebAssembly d'un nombre d'éléments donné.</p>
+La méthode **`grow()`**, rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet d'augmenter la taille du tableau WebAssembly d'un nombre d'éléments donné.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">table.grow(<em>nombre</em>);
-</pre>
+    table.grow(nombre);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>nombre</code></dt>
- <dd>Le nombre d'éléments qu'on souhaite ajouter au tableau.</dd>
-</dl>
+- `nombre`
+  - : Le nombre d'éléments qu'on souhaite ajouter au tableau.
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>La taille du tableau avant l'agrandissement.</p>
+La taille du tableau avant l'agrandissement.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<p>Si l'opération <code>grow()</code> échoue, pour quelque raison que ce soit, une exception {{jsxref("RangeError")}} sera levée.</p>
+Si l'opération `grow()` échoue, pour quelque raison que ce soit, une exception {{jsxref("RangeError")}} sera levée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans l'exemple qui suit, on crée une instance de <code>Table</code> pour représenter un tableau WebAssembly avec une taille initiale de 2 et une taille maximale de 10.</p>
+Dans l'exemple qui suit, on crée une instance de `Table` pour représenter un tableau WebAssembly avec une taille initiale de 2 et une taille maximale de 10.
 
-<pre class="brush: js">var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });</pre>
+```js
+var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });
+```
 
-<p>On étend ensuite le tableau d'une unité en utilisant la méthode <code>grow()</code> :</p>
+On étend ensuite le tableau d'une unité en utilisant la méthode `grow()` :
 
-<pre class="brush: js">console.log(table.length);   // "2"
+```js
+console.log(table.length);   // "2"
 console.log(table.grow(1));  // "2"
 console.log(table.length);   // "3"
-</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('WebAssembly JS', '#webassemblytableprototypegrow', 'grow()')}}</td>
-   <td>{{Spec2('WebAssembly JS')}}</td>
-   <td>Brouillon de définition initiale pour WebAssembly.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.WebAssembly.Table.grow")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
-</ul>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | État                                 | Commentaires                                       |
+| ---------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- |
+| {{SpecName('WebAssembly JS', '#webassemblytableprototypegrow', 'grow()')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initiale pour WebAssembly. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.WebAssembly.Table.grow")}}
+
+## Voir aussi
+
+- [Le portail WebAssembly](/fr/docs/WebAssembly)
+- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md
index 27df06ebb6..6e2380a974 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md
@@ -11,124 +11,104 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table
 original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>Le constructeur <code><strong>WebAssembly.Table()</strong></code> permet de créer un nouvel objet <code>Table</code>.</p>
+Le constructeur **`WebAssembly.Table()`** permet de créer un nouvel objet `Table`.
 
-<p>Cet objet est une enveloppe JavaScript qui représente un tableau WebAssembly et qui contient des références à des fonctions. Un tableau créé en JavaScript ou dans du code WebAssembly sera accessible et modifiable depuis du code JavaScript et depuis du code WebAssembly.</p>
+Cet objet est une enveloppe JavaScript qui représente un tableau WebAssembly et qui contient des références à des fonctions. Un tableau créé en JavaScript ou dans du code WebAssembly sera accessible et modifiable depuis du code JavaScript et depuis du code WebAssembly.
 
-<div class="note">
-<p><strong>Note :</strong> Actuellement, les tableaux WebAssembly peuvent uniquement stocker des références à des fonctions. Cette fonctionnalité sera vraisemblablement étendue par la suite.</p>
-</div>
+> **Note :** Actuellement, les tableaux WebAssembly peuvent uniquement stocker des références à des fonctions. Cette fonctionnalité sera vraisemblablement étendue par la suite.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var monTableau = new WebAssembly.Table(descripteurTableau);</pre>
+    var monTableau = new WebAssembly.Table(descripteurTableau);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>descripteurTableau</code></dt>
- <dd>Un objet composé des propriétés qui suivent :
- <dl>
-  <dt><code>element</code></dt>
-  <dd>Une chaîne de caractères qui représente le type de référence enregistrée dans le tableau. Actuellement, la seule valeur possible est <code>"anyfunc"</code> (pour indiquer des fonctions).</dd>
-  <dt><code>initial</code></dt>
-  <dd>La longueur initiale du tableau WebAssembly. Cela correspond au nombre d'éléments contenus dans le tableau.</dd>
-  <dt><code>maximum {{optional_inline}}</code></dt>
-  <dd>La taille maximale que pourra avoir tableau WebAssembly s'il est étendu.</dd>
- </dl>
- </dd>
-</dl>
+- `descripteurTableau`
 
-<h3 id="Exceptions">Exceptions</h3>
+  - : Un objet composé des propriétés qui suivent :
 
-<ul>
- <li>Si <code>tableDescriptor</code> n'est pas un objet, une exception {{jsxref("TypeError")}} sera levée.</li>
- <li>Si <code>maximum</code> est défini et est inférieur à <code>initial</code>, une exception {{jsxref("RangeError")}} sera levée.</li>
-</ul>
+    - `element`
+      - : Une chaîne de caractères qui représente le type de référence enregistrée dans le tableau. Actuellement, la seule valeur possible est `"anyfunc"` (pour indiquer des fonctions).
+    - `initial`
+      - : La longueur initiale du tableau WebAssembly. Cela correspond au nombre d'éléments contenus dans le tableau.
+    - `maximum {{optional_inline}}`
+      - : La taille maximale que pourra avoir tableau WebAssembly s'il est étendu.
 
-<h2 id="Instances_de_Table">Instances de <code>Table</code></h2>
+### Exceptions
 
-<p>Toutes les instances <code>Table</code> héritent des propriétés <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/prototype">du prototype du constructeur</a> <code>Table()</code>. Ce dernier peut être utilisé afin de modifier l'ensemble des instances <code>Table</code>.</p>
+- Si `tableDescriptor` n'est pas un objet, une exception {{jsxref("TypeError")}} sera levée.
+- Si `maximum` est défini et est inférieur à `initial`, une exception {{jsxref("RangeError")}} sera levée.
 
-<h3 id="Propriétés">Propriétés</h3>
+## Instances de `Table`
 
-<dl>
- <dt><code>Table.prototype.constructor</code></dt>
- <dd>Renvoie la fonction qui a créé l'instance. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Table()")}}.</dd>
- <dt>{{jsxref("WebAssembly/Table/length","Table.prototype.length")}}</dt>
- <dd>Renvoie la longueur du tableau, c'est-à-dire le nombre de références qui sont enregistrées dans le tableau.</dd>
-</dl>
+Toutes les instances `Table` héritent des propriétés [du prototype du constructeur](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/prototype) `Table()`. Ce dernier peut être utilisé afin de modifier l'ensemble des instances `Table`.
 
-<h3 id="Méthodes">Méthodes</h3>
+### Propriétés
 
-<dl>
- <dt>{{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}</dt>
- <dd>Une fonction d'accès qui permet d'obtenir l'élément du tableau situé à une position donnée.</dd>
- <dt>{{jsxref("WebAssembly/Table/grow","Table.prototype.grow()")}}</dt>
- <dd>Cette méthode permet d'augmenter la taille du tableau <code>Tabl</code><code>e</code> d'un incrément donné.</dd>
- <dt>{{jsxref("WebAssembly/Table/set","Table.prototype.set()")}}</dt>
- <dd>Cette méthode permet de modifier un élément du tableau situé à une position donnée.</dd>
-</dl>
+- `Table.prototype.constructor`
+  - : Renvoie la fonction qui a créé l'instance. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Table()")}}.
+- {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}
+  - : Renvoie la longueur du tableau, c'est-à-dire le nombre de références qui sont enregistrées dans le tableau.
 
-<h2 id="Exemples">Exemples</h2>
+### Méthodes
 
-<p>Dans l'exemple qui suit (tiré du fichier <a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html">table2.html</a> et qui dispose <a href="https://mdn.github.io/webassembly-examples/js-api-examples/table2.html">d'une démonstration</a>), on crée une nouvelle instance d'un tableau WebAssembly avec une taille initiale permettant de stocker 2 références. Ensuite, on imprime la longueur du tableau et le contenu des deux éléments (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get", "Table.prototype.get()")}} afin de montrer que la longueur vaut 2 et que le tableau ne contient encore aucune référence de fonction (pour les deux positions, on a la valeur {{jsxref("null")}}).</p>
+- {{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}
+  - : Une fonction d'accès qui permet d'obtenir l'élément du tableau situé à une position donnée.
+- {{jsxref("WebAssembly/Table/grow","Table.prototype.grow()")}}
+  - : Cette méthode permet d'augmenter la taille du tableau ` Tabl``e ` d'un incrément donné.
+- {{jsxref("WebAssembly/Table/set","Table.prototype.set()")}}
+  - : Cette méthode permet de modifier un élément du tableau situé à une position donnée.
 
-<pre class="brush: js">var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
+## Exemples
+
+Dans l'exemple qui suit (tiré du fichier [table2.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html) et qui dispose [d'une démonstration](https://mdn.github.io/webassembly-examples/js-api-examples/table2.html)), on crée une nouvelle instance d'un tableau WebAssembly avec une taille initiale permettant de stocker 2 références. Ensuite, on imprime la longueur du tableau et le contenu des deux éléments (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get", "Table.prototype.get()")}} afin de montrer que la longueur vaut 2 et que le tableau ne contient encore aucune référence de fonction (pour les deux positions, on a la valeur {{jsxref("null")}}).
+
+```js
+var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
 console.log(tbl.length);
 console.log(tbl.get(0));
-console.log(tbl.get(1));</pre>
+console.log(tbl.get(1));
+```
 
-<p>Ensuite, on crée un objet d'import qui contient une référence au tableau :</p>
+Ensuite, on crée un objet d'import qui contient une référence au tableau :
 
-<pre class="brush: js">var importObj = {
+```js
+var importObj = {
   js: {
     tbl:tbl
   }
-};</pre>
+};
+```
 
-<p>Enfin, on charge et on instancie un module WebAssembly (table2.wasm) grâce à la fonction {{jsxref("WebAssembly.instantiateStreaming()")}}. Le module <code>table2.wasm</code> a ajouté deux références de fonctions (cf. <a href="https://github.com/mdn/webassembly-examples/blob/0991effbbf2e2cce38a7dbadebd2f3495e3f4e07/js-api-examples/table2.wat">sa représentation textuelle</a>). Chacune de ces fonctions fournit une valeur simple :</p>
+Enfin, on charge et on instancie un module WebAssembly (table2.wasm) grâce à la fonction {{jsxref("WebAssembly.instantiateStreaming()")}}. Le module `table2.wasm` a ajouté deux références de fonctions (cf. [sa représentation textuelle](https://github.com/mdn/webassembly-examples/blob/0991effbbf2e2cce38a7dbadebd2f3495e3f4e07/js-api-examples/table2.wat)). Chacune de ces fonctions fournit une valeur simple :
 
-<pre class="brush: js">WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
+```js
+WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
 .then(function(obj) {
   console.log(tbl.length);   // "2"
   console.log(tbl.get(0)()); // "42"
   console.log(tbl.get(1)()); // "83"
-});</pre>
-
-<p>On voit ici qu'il faut d'abord récupérer la fonction puis effectuer une invocation pour obtenir la valeur correspondante à partir de l'accesseur (autrement dit, on écrit <code>get(0)()</code> plutôt que <code>get(0)</code> pour obtenir le résultat de la fonction) .</p>
-
-<p>Dans cet exemple, on voit comment créer et manipuler le tableau depuis du code JavaScript mais ce même tableau est également accessible depuis l'instance WebAssembly.</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('WebAssembly JS', '#webassemblytable-objects', 'Table')}}</td>
-   <td>{{Spec2('WebAssembly JS')}}</td>
-   <td>Brouillon de définition initial pour WebAssembly.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.WebAssembly.Table")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
-</ul>
+});
+```
+
+On voit ici qu'il faut d'abord récupérer la fonction puis effectuer une invocation pour obtenir la valeur correspondante à partir de l'accesseur (autrement dit, on écrit `get(0)()` plutôt que `get(0)` pour obtenir le résultat de la fonction) .
+
+Dans cet exemple, on voit comment créer et manipuler le tableau depuis du code JavaScript mais ce même tableau est également accessible depuis l'instance WebAssembly.
+
+## Spécifications
+
+| Spécification                                                                                | État                                 | Commentaires                                      |
+| -------------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------- |
+| {{SpecName('WebAssembly JS', '#webassemblytable-objects', 'Table')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initial pour WebAssembly. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.WebAssembly.Table")}}
+
+## Voir aussi
+
+- [Le portail WebAssembly](/fr/docs/WebAssembly)
+- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md
index 878447d1e1..6812a496a5 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md
@@ -11,55 +11,42 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length
 original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/length
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La propriété <code><strong>length</strong></code>, rattachée au prototype de l'objet {{jsxref("WebAssembly.Table")}}, renvoie la longueur du tableau WebAssembly, c'est-à-dire le nombre d'éléments qui y sont stockées.</p>
+La propriété **`length`**, rattachée au prototype de l'objet {{jsxref("WebAssembly.Table")}}, renvoie la longueur du tableau WebAssembly, c'est-à-dire le nombre d'éléments qui y sont stockées.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">table.length;
-</pre>
+    table.length;
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Avec l'instruction qui suit, on crée un tableau WebAssembly avec une taille initiale de 2 éléments et avec une taille maximale de 10.</p>
+Avec l'instruction qui suit, on crée un tableau WebAssembly avec une taille initiale de 2 éléments et avec une taille maximale de 10.
 
-<pre class="brush: js">var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });</pre>
+```js
+var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });
+```
 
-<p>On peut ensuite étendre le tableau d'un élément :</p>
+On peut ensuite étendre le tableau d'un élément :
 
-<pre class="brush: js">console.log(table.length);   // "2"
+```js
+console.log(table.length);   // "2"
 console.log(table.grow(1));  // "2"
 console.log(table.length);   // "3"
-</pre>
+```
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<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('WebAssembly JS', '#webassemblytableprototypelength', 'length')}}</td>
-   <td>{{Spec2('WebAssembly JS')}}</td>
-   <td>Brouillon de définition initiale pour WebAssembly.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                        | État                                 | Commentaires                                       |
+| ---------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- |
+| {{SpecName('WebAssembly JS', '#webassemblytableprototypelength', 'length')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initiale pour WebAssembly. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("javascript.builtins.WebAssembly.Table.length")}}</p>
+{{Compat("javascript.builtins.WebAssembly.Table.length")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
-</ul>
+- [Le portail WebAssembly](/fr/docs/WebAssembly)
+- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md
index 5413168f5e..4b1ca9f3f1 100644
--- a/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md
@@ -11,92 +11,78 @@ tags:
 translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set
 original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/set
 ---
-<div>{{JSRef}}</div>
+{{JSRef}}
 
-<p>La méthode <code><strong>set()</strong></code>, rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet de modifier une référence de fonction stockée dans un tableau WebAssembly.</p>
+La méthode **`set()`**, rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet de modifier une référence de fonction stockée dans un tableau WebAssembly.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">table.set(<em>index</em>, <em>valeur</em>);
-</pre>
+    table.set(index, valeur);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>index</code></dt>
- <dd>L'index de la référence de la fonction qu'on souhaite modifier.</dd>
- <dt><code>valeur</code></dt>
- <dd>La valeur par laquelle on souhaite remplacer la référence. Cette valeur doit être <a href="/fr/docs/WebAssembly/Exported_functions">une fonction exportée WebAssembly</a> (c'est-à-dire une enveloppe JavaScript représentant une fonction WebAssembly sous-jacente).</dd>
-</dl>
+- `index`
+  - : L'index de la référence de la fonction qu'on souhaite modifier.
+- `valeur`
+  - : La valeur par laquelle on souhaite remplacer la référence. Cette valeur doit être [une fonction exportée WebAssembly](/fr/docs/WebAssembly/Exported_functions) (c'est-à-dire une enveloppe JavaScript représentant une fonction WebAssembly sous-jacente).
 
-<h3 id="Valeur_de_retour">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Aucune.</p>
+Aucune.
 
-<h3 id="Exceptions">Exceptions</h3>
+### Exceptions
 
-<ul>
- <li>Si <code>index</code> est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, une exception {{jsxref("RangeError")}} sera levée.</li>
- <li>Si <code>valeur</code> n'est pas une fonction WebAssembly exportée ou la valeur {{jsxref("null")}}, une exception {{jsxref("TypeError")}} sera levée.</li>
-</ul>
+- Si `index` est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, une exception {{jsxref("RangeError")}} sera levée.
+- Si `valeur` n'est pas une fonction WebAssembly exportée ou la valeur {{jsxref("null")}}, une exception {{jsxref("TypeError")}} sera levée.
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<p>Dans l'exemple qui suit (basé sur le <a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html">code source de <code>table2.html</code></a> et qui dispose <a href="https://mdn.github.io/webassembly-examples/js-api-examples/table2.html">d'une démonstration</a>), on crée ue nouvelle instance d'un tableau WebAssembly (<code>Table</code>) qui permet initialement de stocker 2 référence. On imprime alors la longueur du tableau dans la console ainsi que le contenu pour les deux premiers index (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}) afin de montrer qu la longueur vaut 2 et qu'initialement, les deux éléments du tableau ne contiennent aucune référence (ils ont tous les deux la valeur {{jsxref("null")}}).</p>
+Dans l'exemple qui suit (basé sur le [code source de `table2.html`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html) et qui dispose [d'une démonstration](https://mdn.github.io/webassembly-examples/js-api-examples/table2.html)), on crée ue nouvelle instance d'un tableau WebAssembly (`Table`) qui permet initialement de stocker 2 référence. On imprime alors la longueur du tableau dans la console ainsi que le contenu pour les deux premiers index (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}) afin de montrer qu la longueur vaut 2 et qu'initialement, les deux éléments du tableau ne contiennent aucune référence (ils ont tous les deux la valeur {{jsxref("null")}}).
 
-<pre class="brush: js">var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
+```js
+var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
 console.log(tbl.length);
 console.log(tbl.get(0));
-console.log(tbl.get(1));</pre>
+console.log(tbl.get(1));
+```
 
-<p>On crée ensuite un objet d'import qui contient une référence au tableau :</p>
+On crée ensuite un objet d'import qui contient une référence au tableau :
 
-<pre class="brush: js">var importObj = {
+```js
+var importObj = {
   js: {
     tbl:tbl
   }
-};</pre>
+};
+```
 
-<p>Enfin, on charge et on instancie le module WebAssembly (<code>table2.wasm</code>) grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}, on logge la longueur du tableau et on appelle les deux fonctions référencées qui sont désormais dans le tableau (le module <code>table2.wasm</code> (cf. <a href="https://github.com/mdn/webassembly-examples/blob/master/text-format-examples/table2.was">la représentation textuelle</a>) ajoute deux références de fonctions au tableau et chacune affiche une valeur simple) :</p>
+Enfin, on charge et on instancie le module WebAssembly (`table2.wasm`) grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}, on logge la longueur du tableau et on appelle les deux fonctions référencées qui sont désormais dans le tableau (le module `table2.wasm` (cf. [la représentation textuelle](https://github.com/mdn/webassembly-examples/blob/master/text-format-examples/table2.was)) ajoute deux références de fonctions au tableau et chacune affiche une valeur simple) :
 
-<pre class="brush: js">WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
+```js
+WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
 .then(function(obj) {
   console.log(tbl.length);
   console.log(tbl.get(0)());
   console.log(tbl.get(1)());
-});</pre>
-
-<p>On voit ici qu'il faut appeler la fonction après avoir appeler l'opérateur sur l'accesseur (autrement dit, on écrit <code>get(0)()</code> plutôt que <code>get(0)</code>) .</p>
-
-<p>Dans cet exemple, on montre comment créer et manipuler un tableau en JavaScript mais ce tableau est également accessible et manipulable depuis l'instance WebAssembly.</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('WebAssembly JS', '#webassemblytableprototypeset', 'set()')}}</td>
-   <td>{{Spec2('WebAssembly JS')}}</td>
-   <td>Brouillon de définition initiale pour WebAssembly.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("javascript.builtins.WebAssembly.Table.set")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
- <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
-</ul>
+});
+```
+
+On voit ici qu'il faut appeler la fonction après avoir appeler l'opérateur sur l'accesseur (autrement dit, on écrit `get(0)()` plutôt que `get(0)`) .
+
+Dans cet exemple, on montre comment créer et manipuler un tableau en JavaScript mais ce tableau est également accessible et manipulable depuis l'instance WebAssembly.
+
+## Spécifications
+
+| Spécification                                                                                    | État                                 | Commentaires                                       |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ | -------------------------------------------------- |
+| {{SpecName('WebAssembly JS', '#webassemblytableprototypeset', 'set()')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initiale pour WebAssembly. |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.WebAssembly.Table.set")}}
+
+## Voir aussi
+
+- [Le portail WebAssembly](/fr/docs/WebAssembly)
+- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)