From 1407c8fdef01ecd0ffb8a8bd46e7113f119b9fde Mon Sep 17 00:00:00 2001
From: julieng <julien.gattelier@gmail.com>
Date: Sat, 2 Oct 2021 17:20:24 +0200
Subject: convert content to md

---
 files/fr/web/api/node/appendchild/index.md         | 116 +++---
 files/fr/web/api/node/baseuri/index.md             |  63 ++-
 files/fr/web/api/node/childnodes/index.md          | 127 +++---
 files/fr/web/api/node/clonenode/index.md           |  95 ++---
 .../web/api/node/comparedocumentposition/index.md  | 139 +++----
 files/fr/web/api/node/contains/index.md            |  64 ++-
 files/fr/web/api/node/firstchild/index.md          |  99 ++---
 files/fr/web/api/node/getrootnode/index.md         |  88 ++--
 files/fr/web/api/node/haschildnodes/index.md       |  90 ++---
 files/fr/web/api/node/index.md                     | 448 +++++++++------------
 files/fr/web/api/node/insertbefore/index.md        | 160 +++-----
 files/fr/web/api/node/isconnected/index.md         |  66 ++-
 files/fr/web/api/node/isdefaultnamespace/index.md  |  33 +-
 files/fr/web/api/node/isequalnode/index.md         |  86 ++--
 files/fr/web/api/node/issamenode/index.md          | 107 +++--
 files/fr/web/api/node/issupported/index.md         |  91 ++---
 files/fr/web/api/node/lastchild/index.md           |  64 +--
 files/fr/web/api/node/lookupnamespaceuri/index.md  |  14 +-
 files/fr/web/api/node/lookupprefix/index.md        |  12 +-
 files/fr/web/api/node/nextsibling/index.md         |  63 ++-
 files/fr/web/api/node/nodename/index.md            | 151 +++----
 files/fr/web/api/node/nodetype/index.md            | 235 +++++------
 files/fr/web/api/node/nodevalue/index.md           | 131 +++---
 files/fr/web/api/node/normalize/index.md           |  27 +-
 files/fr/web/api/node/ownerdocument/index.md       |  59 +--
 files/fr/web/api/node/parentelement/index.md       |  45 +--
 files/fr/web/api/node/parentnode/index.md          |  57 ++-
 files/fr/web/api/node/previoussibling/index.md     |  55 ++-
 files/fr/web/api/node/removechild/index.md         | 110 ++---
 files/fr/web/api/node/replacechild/index.md        |  82 ++--
 files/fr/web/api/node/textcontent/index.md         | 134 +++---
 31 files changed, 1247 insertions(+), 1864 deletions(-)

(limited to 'files/fr/web/api/node')

diff --git a/files/fr/web/api/node/appendchild/index.md b/files/fr/web/api/node/appendchild/index.md
index 800be4c3bb..c71ba507b3 100644
--- a/files/fr/web/api/node/appendchild/index.md
+++ b/files/fr/web/api/node/appendchild/index.md
@@ -10,90 +10,64 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/appendChild
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La méthode <code><strong>Node.appendChild()</strong></code> ajoute un nœud à la fin de la liste des enfants d'un nœud parent spécifié. Si l'enfant donné est une référence à un nœud existant dans le document, <code>appendChild()</code> le déplace  de sa position actuelle vers une nouvelle position (il n'est pas nécessaire de supprimer le noeud sur son noeud parent avant de l'ajouter à un autre).</p>
+La méthode **`Node.appendChild()`** ajoute un nœud à la fin de la liste des enfants d'un nœud parent spécifié. Si l'enfant donné est une référence à un nœud existant dans le document, `appendChild()` le déplace  de sa position actuelle vers une nouvelle position (il n'est pas nécessaire de supprimer le noeud sur son noeud parent avant de l'ajouter à un autre).
 
-<p>Cela signifie qu'un noeud ne peut pas être à deux points du document simultanément. Donc, si le nœud a déjà un parent, le nœud est d'abord retiré, puis ajouté à la nouvelle position. Le {{domxref("Node.cloneNode()")}} peut être utilisé pour réaliser une copie de noeud avant de l'ajouter à son nouveau parent. Notez que les copies faites avec <code>cloneNode</code> ne seront pas automatiquement synchronisées.</p>
+Cela signifie qu'un noeud ne peut pas être à deux points du document simultanément. Donc, si le nœud a déjà un parent, le nœud est d'abord retiré, puis ajouté à la nouvelle position. Le {{domxref("Node.cloneNode()")}} peut être utilisé pour réaliser une copie de noeud avant de l'ajouter à son nouveau parent. Notez que les copies faites avec `cloneNode` ne seront pas automatiquement synchronisées.
 
-<p>Si l'enfant donné est un {{domxref("DocumentFragment")}} , le contenu entier du {{domxref("DocumentFragment")}} est déplacé dans la liste d'enfants du noeud parent spécifié.</p>
+Si l'enfant donné est un {{domxref("DocumentFragment")}} , le contenu entier du {{domxref("DocumentFragment")}} est déplacé dans la liste d'enfants du noeud parent spécifié.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="eval">var <em>elementAjoute</em> = <em>element</em>.appendChild(<em>enfant</em>);
-</pre>
+    var elementAjoute = element.appendChild(enfant);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><strong>enfant</strong></dt>
- <dd>Le noeud à ajouter au noeud parent donné (généralement un élément).</dd>
-</dl>
+- **enfant**
+  - : Le noeud à ajouter au noeud parent donné (généralement un élément).
 
-<h3 id="Valeur_renvoyée">Valeur renvoyée</h3>
+### Valeur renvoyée
 
-<p>La valeur renvoyée est l'enfant ajouté sauf si l'enfant donné est un {{domxref ("DocumentFragment")}}, auquel cas le {{domxref ("DocumentFragment")}} vide est renvoyé.</p>
+La valeur renvoyée est l'enfant ajouté sauf si l'enfant donné est un {{domxref ("DocumentFragment")}}, auquel cas le {{domxref ("DocumentFragment")}} vide est renvoyé.
 
-<h2 id="Notes">Notes</h2>
+## Notes
 
-<p>Le chaînage peut ne pas fonctionner comme prévu en raison de <code>appendChild()</code> renvoyant l'élément enfant :</p>
+Le chaînage peut ne pas fonctionner comme prévu en raison de `appendChild()` renvoyant l'élément enfant :
 
-<pre class="brush: js">var aBlock = doc.createElement('block').appendChild(doc.createElement('b'));</pre>
+```js
+var aBlock = doc.createElement('block').appendChild(doc.createElement('b'));
+```
 
-<p>Définit <code>aBlock</code> pour <code>&lt;b&gt;&lt;/b&gt;</code> uniquement, ce que vous ne voulez probablement pas.</p>
+Définit `aBlock` pour `<b></b>` uniquement, ce que vous ne voulez probablement pas.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush:js">// Crée un nouvel élément paragraphe et l'ajoute à la fin du corps du document
+```js
+// Crée un nouvel élément paragraphe et l'ajoute à la fin du corps du document
 var p = document.createElement("p");
-document.body.appendChild(p);</pre>
-
-<h2 id="Spécification">Spécification</h2>
-
-<p> </p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-appendchild', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Pas de changement de {{SpecName("DOM3 Core")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-184E7107', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Pas de changement de {{SpecName("DOM2 Core")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-184E7107', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Pas de changement de {{SpecName("DOM1")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-184E7107', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.appendChild")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("Node.removeChild")}}</li>
- <li>{{domxref("Node.replaceChild")}}</li>
- <li>{{domxref("Node.insertBefore")}}</li>
- <li>{{domxref("Node.hasChildNodes")}}</li>
- <li>{{domxref("ParentNode.append()")}}</li>
-</ul>
+document.body.appendChild(p);
+```
+
+## Spécification
+
+
+
+| Spécification                                                                                            | Statut                           | Commentaire                                            |
+| -------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------------------------------------ |
+| {{SpecName('DOM WHATWG', '#dom-node-appendchild', 'Node.appendChild()')}}         | {{Spec2('DOM WHATWG')}} | Pas de changement de {{SpecName("DOM3 Core")}}. |
+| {{SpecName('DOM3 Core', 'core.html#ID-184E7107', 'Node.appendChild()')}}         | {{Spec2('DOM3 Core')}}     | Pas de changement de {{SpecName("DOM2 Core")}}. |
+| {{SpecName('DOM2 Core', 'core.html#ID-184E7107', 'Node.appendChild()')}}         | {{Spec2('DOM2 Core')}}     | Pas de changement de {{SpecName("DOM1")}}.     |
+| {{SpecName('DOM1', 'level-one-core.html#ID-184E7107', 'Node.appendChild()')}} | {{Spec2('DOM1')}}         | Définition initiale.                                   |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.appendChild")}}
+
+## Voir aussi
+
+- {{domxref("Node.removeChild")}}
+- {{domxref("Node.replaceChild")}}
+- {{domxref("Node.insertBefore")}}
+- {{domxref("Node.hasChildNodes")}}
+- {{domxref("ParentNode.append()")}}
diff --git a/files/fr/web/api/node/baseuri/index.md b/files/fr/web/api/node/baseuri/index.md
index 68cf5be1bc..cbecf41d24 100644
--- a/files/fr/web/api/node/baseuri/index.md
+++ b/files/fr/web/api/node/baseuri/index.md
@@ -12,60 +12,49 @@ tags:
   - XML
 translation_of: Web/API/Node/baseURI
 ---
-<div>
-<div>{{APIRef("DOM")}}</div>
-</div>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule <code><strong>Node.baseURI</strong></code> renvoie l'URL de base absolue d'un noeud.</p>
+La propriété en lecture seule **`Node.baseURI`** renvoie l'URL de base absolue d'un noeud.
 
-<p>L'URL de base est utilisée pour <a href="http://developers.whatwg.org/urls.html#resolving-urls">résoudre</a> les URL relatives quand le navigateur a besoin d'obtenir une URL absolue, par exemple lors du traitement de l'attribut <code>src</code>  en HTML ou XML <code><a href="/fr/docs/Glossaire/XLink">xlink</a>:href</code> d'un élément {{HTMLElement("img")}} HTML.</p>
+L'URL de base est utilisée pour [résoudre](http://developers.whatwg.org/urls.html#resolving-urls) les URL relatives quand le navigateur a besoin d'obtenir une URL absolue, par exemple lors du traitement de l'attribut `src`  en HTML ou XML `xlink:href` d'un élément {{HTMLElement("img")}} HTML.
 
-<p>En général, l'URL de base est simplement l'emplacement du document, mais elle peut être affectée par de nombreux facteurs, y compris l'élément {{HTMLElement("base")}} en HTML et l'attribut  <code><a href="/fr/docs/Introduction_%C3%A0_XML/xml:base">xml:base</a></code> en XML.</p>
+En général, l'URL de base est simplement l'emplacement du document, mais elle peut être affectée par de nombreux facteurs, y compris l'élément {{HTMLElement("base")}} en HTML et l'attribut  [`xml:base`](/fr/docs/Introduction_%C3%A0_XML/xml:base) en XML.
 
-<h2 id="Syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <em>baseURI</em> = <em>node</em>.baseURI;
-</pre>
+    var baseURI = node.baseURI;
 
-<ul>
- <li><code>baseURI</code> est une {{ domxref("DOMString") }} (<em>chaîne de caractères</em>) représentant l'URL de base du {{domxref("Node")}} spécifié. Elle peut être <code>null</code> s'il est impossible d'obtenir une URI absolue.</li>
- <li><code><em>node</em>.baseURI</code> est en lecture seule.</li>
- <li><code><em>node</em>.baseURI</code> peut changer avec le temps (voir ci-dessous).</li>
-</ul>
+- `baseURI` est une {{ domxref("DOMString") }} (_chaîne de caractères_) représentant l'URL de base du {{domxref("Node")}} spécifié. Elle peut être `null` s'il est impossible d'obtenir une URI absolue.
+- `node.baseURI` est en lecture seule.
+- `node.baseURI` peut changer avec le temps (voir ci-dessous).
 
-<h2 id="Details">Détails</h2>
+## Détails
 
-<h3 id="L'URL_de_base_d'un_document">L'URL de base d'un document</h3>
+### L'URL de base d'un document
 
-<p>L'URL de base d'un <em>document</em> est par défaut l'adresse du document (telle qu'affichée par le navigateur et disponible dans {{domxref("window.location")}}), mais peut changer par défaut :</p>
+L'URL de base d'un _document_ est par défaut l'adresse du document (telle qu'affichée par le navigateur et disponible dans {{domxref("window.location")}}), mais peut changer par défaut :
 
-<ul>
- <li>Si une balise HTML {{HTMLElement("base")}} est trouvée dans le document ;</li>
- <li>Lorsque celui-ci est un nouveau document créé dynamiquement.</li>
-</ul>
+- Si une balise HTML {{HTMLElement("base")}} est trouvée dans le document ;
+- Lorsque celui-ci est un nouveau document créé dynamiquement.
 
-<p>Voir la page <a href="http://developers.whatwg.org/urls.html#base-urls">Base URLs section of the HTML Living standard</a> (en) pour plus de détails.</p>
+Voir la page [Base URLs section of the HTML Living standard](http://developers.whatwg.org/urls.html#base-urls) (en) pour plus de détails.
 
-<p>Vous pouvez utiliser <code><em>{{domxref("document")}}</em>.baseURI</code> pour obtenir l'URL de base d'un document. Notez que l'obtention de l'URL de base d'un document peut renvoyer des URL différentes au fil du temps si la balise {{HTMLElement("base")}} ou l'emplacement du document change.</p>
+Vous pouvez utiliser `{{domxref("document")}}.baseURI` pour obtenir l'URL de base d'un document. Notez que l'obtention de l'URL de base d'un document peut renvoyer des URL différentes au fil du temps si la balise {{HTMLElement("base")}} ou l'emplacement du document change.
 
-<h3 id="L'URL_de_base_d'un_élément">L'URL de base d'un élément</h3>
+### L'URL de base d'un élément
 
-<p>L'URL de base d'un <em>element</em> en HTML est normalement équivalente à celle du document dans lequel se trouve le noeud.</p>
+L'URL de base d'un _element_ en HTML est normalement équivalente à celle du document dans lequel se trouve le noeud.
 
-<p>Si le document contient des attributs <code><a href="/fr/docs/Introduction_%C3%A0_XML/xml:base">xml:base</a></code> (ce que vous ne devriez pas faire dans les documents HTML), l'<code><em>element</em>.baseURI</code> prend en compte l'attribut <code>xml:base</code> des parents de l'élément  lors du calcul de l'URL de base. Voir <a href="/fr/docs/Introduction_%C3%A0_XML/xml:base">xml:base</a> pour plus de détails.</p>
+Si le document contient des attributs [`xml:base`](/fr/docs/Introduction_%C3%A0_XML/xml:base) (ce que vous ne devriez pas faire dans les documents HTML), l'`element.baseURI` prend en compte l'attribut `xml:base` des parents de l'élément  lors du calcul de l'URL de base. Voir [xml:base](/fr/docs/Introduction_%C3%A0_XML/xml:base) pour plus de détails.
 
-<p>Vous pouvez utiliser <code><em>{{domxref("element")}}</em>.baseURI</code> pour obtenir l'URL de base d'un élément.</p>
+Vous pouvez utiliser `{{domxref("element")}}.baseURI` pour obtenir l'URL de base d'un élément.
 
-<h2 id="Specification">Spécification</h2>
+## Spécification
 
-<ul>
- <li>{{spec("http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-baseURI","DOM Level 3 Core: baseURI","REC")}}</li>
-</ul>
+- {{spec("http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-baseURI","DOM Level 3 Core: baseURI","REC")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>l'élément {{HTMLElement("base")}} (HTML)</li>
- <li>l'attribut <code><a href="/fr/docs/Introduction_%C3%A0_XML/xml:base">xml:base</a></code> (documents XML).</li>
- <li>{{domxref("Node.baseURIObject")}} - une variante de cette API pour les add-ons Mozilla et le code interne. Renvoie l'URL de base en tant que {{interface("nsIURI")}}.</li>
-</ul>
+- l'élément {{HTMLElement("base")}} (HTML)
+- l'attribut [`xml:base`](/fr/docs/Introduction_%C3%A0_XML/xml:base) (documents XML).
+- {{domxref("Node.baseURIObject")}} - une variante de cette API pour les add-ons Mozilla et le code interne. Renvoie l'URL de base en tant que {{interface("nsIURI")}}.
diff --git a/files/fr/web/api/node/childnodes/index.md b/files/fr/web/api/node/childnodes/index.md
index b9f4630ffc..4482d18e89 100644
--- a/files/fr/web/api/node/childnodes/index.md
+++ b/files/fr/web/api/node/childnodes/index.md
@@ -9,95 +9,68 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/childNodes
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule  <code><strong>Node.childNodes</strong></code> renvoie une {{domxref("NodeList")}} (<em>liste de noeuds</em>) de {{domxref("Node","noeuds")}} enfants de l'élément donné avec le premier noeud enfant affecté à l'index 0.</p>
+La propriété en lecture seule  **`Node.childNodes`** renvoie une {{domxref("NodeList")}} (_liste de noeuds_) de {{domxref("Node","noeuds")}} enfants de l'élément donné avec le premier noeud enfant affecté à l'index 0.
 
-<h2 id="Syntaxe_et_valeurs">Syntaxe</h2>
+## Syntaxe
 
-<pre class="eval"><a href="/fr/Référence_de_JavaScript_1.5_Core/Instructions/var">var</a> <var>collNoeuds</var> = elementDeReference.<a href="/fr/DOM/element.childNodes">childNodes</a>;
-</pre>
+    var collNoeuds = elementDeReference.childNodes;
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<h3 id="Utilisation_simple">Utilisation simple</h3>
+### Utilisation simple
 
-<pre class="brush:js">// parg est une référence d'objet pour un élément &lt;p&gt;
+```js
+// parg est une référence d'objet pour un élément <p>
 
-// D'abord vérifier que l'élément a des noeuds enfants 
+// D'abord vérifier que l'élément a des noeuds enfants
 if (parg.hasChildNodes()) {
   var children = parg.childNodes;
 
-  for (var i = 0; i &lt; children.length; i++) {
+  for (var i = 0; i < children.length; i++) {
     // faire quelque chose avec chaque enfant[i]
     // NOTE: La liste est en ligne, l'ajout ou la suppression des enfants changera la liste
   }
-}</pre>
+}
+```
 
-<h3 id="Supprimer_tous_les_enfants_d'un_nom">Supprimer tous les enfants d'un nom</h3>
+### Supprimer tous les enfants d'un nom
 
-<pre>// Voici une manière de supprimer tous les enfants d'un nœud
-// (boite est une référence à un élément ayant des enfants)
-<a href="/fr/Référence_de_JavaScript_1.5_Core/Instructions/while">while</a>( boite.<a href="/fr/DOM/element.firstChild">firstChild</a>) {
-    // La liste n'est pas une copie, elle sera donc réindexée à chaque appel
-    boite.<a href="/fr/DOM/element.removeChild">removeChild</a>( boite.<a href="/fr/DOM/element.firstChild">firstChild</a>);
-}
-</pre>
-
-<h2 id="Notes">Notes</h2>
-
-<p>Les éléments de la collection de noeuds sont des objets et non des chaînes de caractères. Pour en obtenir les données, vous devez utiliser leurs propriétés (par exemple <code>elementNodeReference.childNodes[1].nodeName</code> pour obtenir son nom, etc.)</p>
-
-<p>L'objet <a href="/fr/DOM/document"><code>document</code></a> lui-même a deux enfants : la déclaration <a href="/fr/DOM/document.doctype">Doctype</a> et l'élément racine, généralement appelés  <code>documentElement</code> . (Dans les documents (X)HTML il s'agit d'éléments  <a href="/fr/HTML/Element/html"><code>HTML</code></a>).</p>
-
-<p><code>childNodes</code>  inclut tous les noeuds enfants, y compris les noeuds qui ne sont pas des éléments comme les noeuds texte et commentaire. Pour obtenir une collection des seuls éléments, utilisez {{domxref("ParentNode.children")}} à la place.</p>
-
-<p> </p>
-
-<h2 id="Spécification">Spécification</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-childnodes', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-1451460987', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-1451460987', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-1451460987', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.childNodes")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("Node.firstChild")}}</li>
- <li>{{domxref("Node.lastChild")}}</li>
- <li>{{domxref("Node.nextSibling")}}</li>
- <li>{{domxref("Node.previousSibling")}}</li>
- <li>{{domxref("ParentNode.children")}}</li>
-</ul>
+    // Voici une manière de supprimer tous les enfants d'un nœud
+    // (boite est une référence à un élément ayant des enfants)
+    while( boite.firstChild) {
+        // La liste n'est pas une copie, elle sera donc réindexée à chaque appel
+        boite.removeChild( boite.firstChild);
+    }
+
+## Notes
+
+Les éléments de la collection de noeuds sont des objets et non des chaînes de caractères. Pour en obtenir les données, vous devez utiliser leurs propriétés (par exemple `elementNodeReference.childNodes[1].nodeName` pour obtenir son nom, etc.)
+
+L'objet [`document`](/fr/DOM/document) lui-même a deux enfants : la déclaration [Doctype](/fr/DOM/document.doctype) et l'élément racine, généralement appelés  `documentElement` . (Dans les documents (X)HTML il s'agit d'éléments  [`HTML`](/fr/HTML/Element/html)).
+
+`childNodes`  inclut tous les noeuds enfants, y compris les noeuds qui ne sont pas des éléments comme les noeuds texte et commentaire. Pour obtenir une collection des seuls éléments, utilisez {{domxref("ParentNode.children")}} à la place.
+
+
+
+## Spécification
+
+| Spécification                                                                                        | Statut                           | Commentaire         |
+| ---------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------- |
+| {{SpecName('DOM WHATWG', '#dom-node-childnodes', 'Node.childNodes')}}         | {{Spec2('DOM WHATWG')}} | Pas de changement   |
+| {{SpecName('DOM3 Core', 'core.html#ID-1451460987', 'Node.childNodes')}}     | {{Spec2('DOM3 Core')}}     | Pas de changement   |
+| {{SpecName('DOM2 Core', 'core.html#ID-1451460987', 'Node.childNodes')}}     | {{Spec2('DOM2 Core')}}     | Pas de changement   |
+| {{SpecName('DOM1', 'level-one-core.html#ID-1451460987', 'Node.childNodes')}} | {{Spec2('DOM1')}}         | Définition initiale |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.childNodes")}}
+
+## Voir aussi
+
+- {{domxref("Node.firstChild")}}
+- {{domxref("Node.lastChild")}}
+- {{domxref("Node.nextSibling")}}
+- {{domxref("Node.previousSibling")}}
+- {{domxref("ParentNode.children")}}
diff --git a/files/fr/web/api/node/clonenode/index.md b/files/fr/web/api/node/clonenode/index.md
index fef79935dc..ca70a18cb3 100644
--- a/files/fr/web/api/node/clonenode/index.md
+++ b/files/fr/web/api/node/clonenode/index.md
@@ -9,84 +9,55 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/cloneNode
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La méthode <strong><code>Node.cloneNode()</code></strong> renvoie une copie du nœud sur lequel elle a été appelée.</p>
+La méthode **`Node.cloneNode()`** renvoie une copie du nœud sur lequel elle a été appelée.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <em><var>dupNode</var></em> = <em><var>node</var></em>.cloneNode([<em><var>deep]</var></em>);
-</pre>
+    var dupNode = node.cloneNode([deep]);
 
-<dl>
- <dt>node</dt>
- <dd>Le noeud à dupliquer.</dd>
- <dt>dupNode</dt>
- <dd>Le nouveau noeud qui sera un clone du <code>node</code>.</dd>
- <dt>deep <em>{{optional_inline}} (profondeur)</em></dt>
- <dd><code>true</code> (<em>vrai</em>) si les enfants du noeud doivent aussi être clonés ou <code>false</code> (<em>faux</em>) si seul le noeud spécifié doit l'être.</dd>
-</dl>
+- node
+  - : Le noeud à dupliquer.
+- dupNode
+  - : Le nouveau noeud qui sera un clone du `node`.
+- deep _{{optional_inline}} (profondeur)_
+  - : `true` (_vrai_) si les enfants du noeud doivent aussi être clonés ou `false` (_faux_) si seul le noeud spécifié doit l'être.
 
-<div class="note">
-<p><strong>Note :</strong> Dans la spécification DOM4 (telle qu'implémentée dans Gecko 13.0 {{geckoRelease(13)}}), <code>deep</code> est un argument facultatif. S'il est omis, la méthode agit comme si la valeur de  <code>deep</code> était <strong><code>true</code></strong> par défaut, elle utilise le clonage profond comme comportement par défaut. Pour créer un clone superficiel, <code>deep</code> doit être défini sur <code>false</code>.</p>
+> **Note :** Dans la spécification DOM4 (telle qu'implémentée dans Gecko 13.0 {{geckoRelease(13)}}), `deep` est un argument facultatif. S'il est omis, la méthode agit comme si la valeur de  `deep` était **`true`** par défaut, elle utilise le clonage profond comme comportement par défaut. Pour créer un clone superficiel, `deep` doit être défini sur `false`.
+>
+> Le comportement a été modifié dans la dernière spécification et, s'il est omis, la méthode doit agir comme si la valeur de `deep` était **`false`**. Bien que ce soit toujours facultatif, vous devriez toujours fournir l'argument `deep` pour la compatibilité amont et aval. Avec Gecko 28.0 {{geckoRelease(28)}}), la console a averti les développeurs de ne pas omettre l'argument. À partir de Gecko 29.0 {{geckoRelease(29)}}), un clone superficiel est défini par défaut au lieu d'un clone profond.
 
-<p>Le comportement a été modifié dans la dernière spécification et, s'il est omis, la méthode doit agir comme si la valeur de <code>deep</code> était <strong><code>false</code></strong>. Bien que ce soit toujours facultatif, vous devriez toujours fournir l'argument <code>deep</code> pour la compatibilité amont et aval. Avec Gecko 28.0 {{geckoRelease(28)}}), la console a averti les développeurs de ne pas omettre l'argument. À partir de Gecko 29.0 {{geckoRelease(29)}}), un clone superficiel est défini par défaut au lieu d'un clone profond.</p>
-</div>
+## Exemple
 
-<h2 id="Exemple">Exemple</h2>
+    p = document.getElementById("para1");
+    p_prime = p.cloneNode(true);
 
-<pre>p = document.getElementById("para1");
-p_prime = p.cloneNode(true);
-</pre>
+## Notes
 
-<h2 id="Notes">Notes</h2>
+Cloner un nœud copie tous ses attributs ainsi que leurs valeurs, y compris les auditeurs intrinsèques (en ligne). Il ne copie pas les auditeurs d'évènement ajoutés avec [`addEventListener()`](/en-US/docs/DOM/element.addEventListener) ou ceux assignés au propriétés d'éléments (par exemple `node.onclick = fn`). De plus, pour un élément {{HTMLElement("canvas")}} l'image peinte n'est pas copiée.
 
-<p>Cloner un nœud copie tous ses attributs ainsi que leurs valeurs, y compris les auditeurs intrinsèques (en ligne). Il ne copie pas les auditeurs d'évènement ajoutés avec <a href="/en-US/docs/DOM/element.addEventListener"><code>addEventListener()</code></a> ou ceux assignés au propriétés d'éléments (par exemple <code>node.onclick = fn</code>). De plus, pour un élément {{HTMLElement("canvas")}} l'image peinte n'est pas copiée.</p>
+Le nœud dupliqué renvoyé par `cloneNode` ne fera pas partie du document tant qu'il n'y est pas ajouté via la méthode {{domxref("Node.appendChild()")}} ou une méthode similaire. De même, il n'a pas de parent tant qu'il n'a pas été ajouté à un autre nœud.
 
-<p>Le nœud dupliqué renvoyé par <code>cloneNode</code> ne fera pas partie du document tant qu'il n'y est pas ajouté via la méthode  {{domxref("Node.appendChild()")}} ou une méthode similaire. De même, il n'a pas de parent tant qu'il n'a pas été ajouté à un autre nœud.</p>
+Si `deep` est défini à `false`, aucun des nœuds enfants n'est copié.
+*T*out texte contenu dans le nœud n'est pas copié non plus , car il fait partie d'un ou plusieurs nœuds {{domxref("Text")}} enfants.
 
-<p>Si <code>deep</code> est défini à <code>false</code>, aucun des nœuds enfants n'est copié.<br>
- <em>T</em>out texte contenu dans le nœud n'est pas copié non plus , car il fait partie d'un ou plusieurs nœuds {{domxref("Text")}}  enfants.</p>
+Si `deep` est évalué à `true`, le sous-arbre entier est copié également (y compris le texte qui peut être contenu dans des nœuds {{domxref("Text")}} enfants). Pour les nœuds vides (par exemple les éléments {{HTMLElement("img")}} et {{HTMLElement("input")}} ) le fait de mettre `deep` à `true` ou `false` n'a aucune incidence sur la copie, mais il est tout de même nécessaire de fournir une valeur.
 
-<p>Si <code>deep</code> est évalué à <code>true</code>, le sous-arbre entier est copié également (y compris le texte qui peut être contenu dans des nœuds  {{domxref("Text")}}  enfants). Pour les nœuds vides (par exemple les éléments  {{HTMLElement("img")}}  et  {{HTMLElement("input")}} ) le fait de mettre <code>deep</code> à <code>true</code> ou <code>false</code> n'a aucune incidence sur la copie, mais il est tout de même nécessaire de fournir une valeur.</p>
+> **Attention :** `cloneNode()` peut conduire à dupliquer des ID (_identifiant_) d'éléments dans un document.
 
-<div class="warning">
-<p><strong>Attention :</strong> <code>cloneNode()</code> peut conduire à dupliquer des ID (<em>identifiant</em>) d'éléments dans un document.</p>
-</div>
+Si le noeud d'origine a un identifiant et que le clone doit être placé dans le même document, l'identifiant du clone peut être modifié pour être unique. Les attributs du nom peuvent devoir être modifiés également, selon que les noms en double sont attendus.
 
-<p>Si le noeud d'origine a un identifiant et que le clone doit être placé dans le même document, l'identifiant du clone peut être modifié pour être unique. Les attributs du nom peuvent devoir être modifiés également, selon que les noms en double sont attendus.</p>
+Pour cloner un noeud à ajouter dans un document différent, utilisez  {{domxref("Document.importNode()")}} à la place.
 
-<p>Pour cloner un noeud à ajouter dans un document différent, utilisez  {{domxref("Document.importNode()")}} à la place.</p>
+### Spécification
 
-<h3 id="Sp.C3.A9cification">Spécification</h3>
+| Spécification                                                                                | Statut                           | Commentaire         |
+| -------------------------------------------------------------------------------------------- | -------------------------------- | ------------------- |
+| {{SpecName("DOM WHATWG", "#dom-node-clonenode", "Node.cloneNode()")}} | {{Spec2("DOM WHATWG")}} |                     |
+| {{SpecName("DOM3 Core", "core.html#ID-3A0ED0A4", "Node.cloneNode()")}} | {{Spec2("DOM3 Core")}}     |                     |
+| {{SpecName("DOM2 Core", "core.html#ID-3A0ED0A4", "Node.cloneNode()")}} | {{Spec2("DOM2 Core")}}     | Définition initiale |
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName("DOM WHATWG", "#dom-node-clonenode", "Node.cloneNode()")}}</td>
-   <td>{{Spec2("DOM WHATWG")}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName("DOM3 Core", "core.html#ID-3A0ED0A4", "Node.cloneNode()")}}</td>
-   <td>{{Spec2("DOM3 Core")}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName("DOM2 Core", "core.html#ID-3A0ED0A4", "Node.cloneNode()")}}</td>
-   <td>{{Spec2("DOM2 Core")}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
+## Compatibilité des navigateurs
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.cloneNode")}}</p>
+{{Compat("api.Node.cloneNode")}}
diff --git a/files/fr/web/api/node/comparedocumentposition/index.md b/files/fr/web/api/node/comparedocumentposition/index.md
index a40125b5c1..21bc78963d 100644
--- a/files/fr/web/api/node/comparedocumentposition/index.md
+++ b/files/fr/web/api/node/comparedocumentposition/index.md
@@ -10,99 +10,52 @@ tags:
   - Position
 translation_of: Web/API/Node/compareDocumentPosition
 ---
-<div>{{APIRef("DOM")}}</div>
-
-<p>La méthode <code><strong>Node.compareDocumentPosition()</strong></code>compare la position du noeud courant par rapport à un autre noeud dans tout autre document.</p>
-
-<p>La valeur retournée est un masque de bits avec les valeurs suivantes :</p>
-
-<table>
- <thead>
-  <tr>
-   <th scope="col">Nom</th>
-   <th scope="col">Valeur</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>DOCUMENT_POSITION_DISCONNECTED</code></td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_POSITION_PRECEDING</code></td>
-   <td>2</td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_POSITION_FOLLOWING</code></td>
-   <td>4</td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_POSITION_CONTAINS</code></td>
-   <td>8</td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_POSITION_CONTAINED_BY</code></td>
-   <td>16</td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC</code></td>
-   <td>32</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Syntax">Syntaxe</h2>
-
-<pre class="syntaxbox"><em>node</em>.compareDocumentPosition( <em>otherNode</em> )
-</pre>
-
-<h2 id="Example">Exemple</h2>
-
-<pre class="brush:js">var head = document.getElementsByTagName('head').item(0);
-
-if (head.compareDocumentPosition(document.body) &amp; Node.DOCUMENT_POSITION_FOLLOWING) {
+{{APIRef("DOM")}}
+
+La méthode **`Node.compareDocumentPosition()`**compare la position du noeud courant par rapport à un autre noeud dans tout autre document.
+
+La valeur retournée est un masque de bits avec les valeurs suivantes :
+
+| Nom                                         | Valeur |
+| ------------------------------------------- | ------ |
+| `DOCUMENT_POSITION_DISCONNECTED`            | 1      |
+| `DOCUMENT_POSITION_PRECEDING`               | 2      |
+| `DOCUMENT_POSITION_FOLLOWING`               | 4      |
+| `DOCUMENT_POSITION_CONTAINS`                | 8      |
+| `DOCUMENT_POSITION_CONTAINED_BY`            | 16     |
+| `DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC` | 32     |
+
+## Syntaxe
+
+    node.compareDocumentPosition( otherNode )
+
+## Exemple
+
+```js
+var head = document.getElementsByTagName('head').item(0);
+
+if (head.compareDocumentPosition(document.body) & Node.DOCUMENT_POSITION_FOLLOWING) {
   console.log("well-formed document");
 } else {
-  console.log("&lt;head&gt; is not before &lt;body&gt;");
+  console.log("<head> is not before <body>");
 }
-</pre>
-
-<div class="note">
-<p><strong>Note :</strong> Parce que le résultat renvoyé par<em> </em><code>compareDocumentPosition</code> est un masque de bits, des <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires">opérateurs binaires</a> doivent être utilisés pour des résultats significatifs.</p>
-</div>
-
-<div class="note">
-<p><strong>Note :</strong> La première instruction utilise l' <code>item(0)</code> de la méthode <a href="/en-US/docs/Web/API/NodeList/item">NodeList</a> , qui est l'équivalent de <code>getElementsByTagName('head')[0].</code></p>
-</div>
-
-<h2 id="Specification">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG','#dom-node-comparedocumentposition','Node.compareDocumentPosition()')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core','core.html#Node3-compareDocumentPosition','Node.compareDocumentPosition()')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.compareDocumentPosition")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><code><a href="/fr/docs/Web/API/Node/contains">Node.contains</a></code></li>
-</ul>
+```
+
+> **Note :** Parce que le résultat renvoyé par\* \*`compareDocumentPosition` est un masque de bits, des [opérateurs binaires](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires) doivent être utilisés pour des résultats significatifs.
+
+> **Note :** La première instruction utilise l' `item(0)` de la méthode [NodeList](/en-US/docs/Web/API/NodeList/item) , qui est l'équivalent de `getElementsByTagName('head')[0].`
+
+## Spécifications
+
+| Spécification                                                                                                                        | Statut                           | Commentaire         |
+| ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ------------------- |
+| {{SpecName('DOM WHATWG','#dom-node-comparedocumentposition','Node.compareDocumentPosition()')}}     | {{Spec2('DOM WHATWG')}} |                     |
+| {{SpecName('DOM3 Core','core.html#Node3-compareDocumentPosition','Node.compareDocumentPosition()')}} | {{Spec2('DOM3 Core')}}     | Définition initiale |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.compareDocumentPosition")}}
+
+## Voir aussi
+
+- [`Node.contains`](/fr/docs/Web/API/Node/contains)
diff --git a/files/fr/web/api/node/contains/index.md b/files/fr/web/api/node/contains/index.md
index e5906fbf28..ae386427c2 100644
--- a/files/fr/web/api/node/contains/index.md
+++ b/files/fr/web/api/node/contains/index.md
@@ -9,49 +9,33 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/contains
 ---
-<div>{{APIRef("DOM")}}</div>
+{{APIRef("DOM")}}La méthode **`Node.contains()`** renvoie une valeur {{jsxref("Boolean")}} (_booléenne_) indiquant si un nœud est un descendant d'un nœud donné, c'est-à-dire le nœud lui-même, l'un de ses enfants directs ({{domxref("Node.childNodes", "childNodes")}}), l'un des enfants directs des enfants, et ainsi de suite.
 
-<div>La méthode <strong><code>Node.contains()</code></strong> renvoie une valeur {{jsxref("Boolean")}} (<em>booléenne</em>) indiquant si un nœud est un descendant d'un nœud donné, c'est-à-dire le nœud lui-même, l'un de ses enfants directs ({{domxref("Node.childNodes", "childNodes")}}), l'un des enfants directs des enfants, et ainsi de suite.</div>
+## Syntaxe
 
-<h2 id="Syntaxe">Syntaxe</h2>
+    node.contains( otherNode )
 
-<pre class="syntaxbox">node.contains( otherNode )
-</pre>
+## Exemple
 
-<h2 id="Example">Exemple</h2>
+Cette fonction vérifie si un élément est dans le corps de la page. Comme `contains` est inclusif, déterminer si le corps est contenu en lui-même n'est pas le but de `isInPage,` donc ce cas renvoie `false`.
 
-<p>Cette fonction vérifie si un élément est dans le corps de la page. Comme <code>contains</code> est inclusif, déterminer si le corps est contenu en lui-même n'est pas le but de <code>isInPage,</code> donc ce cas renvoie <code>false</code>.</p>
-
-<pre class="brush:js">function isInPage(node) {
+```js
+function isInPage(node) {
   return (node === document.body) ? false : document.body.contains(node);
-}</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName("DOM WHATWG", "#dom-node-contains", "Node.contains()")}}</td>
-   <td>{{Spec2("DOM WHATWG")}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.contains")}}</p>
-
-<h2 id="See_also">Voir aussi</h2>
-
-<ul>
-  <li>{{domxref("Node.compareDocumentPosition")}}</li>
-  <li>{{domxref("Node.hasChildNodes")}}</li>
-</ul>
+}
+```
+
+## Spécifications
+
+| Spécification                                                                            | Statut                           | Commentaire         |
+| ---------------------------------------------------------------------------------------- | -------------------------------- | ------------------- |
+| {{SpecName("DOM WHATWG", "#dom-node-contains", "Node.contains()")}} | {{Spec2("DOM WHATWG")}} | Définition initiale |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.contains")}}
+
+## Voir aussi
+
+- {{domxref("Node.compareDocumentPosition")}}
+- {{domxref("Node.hasChildNodes")}}
diff --git a/files/fr/web/api/node/firstchild/index.md b/files/fr/web/api/node/firstchild/index.md
index 03550acf9f..02a1edd488 100644
--- a/files/fr/web/api/node/firstchild/index.md
+++ b/files/fr/web/api/node/firstchild/index.md
@@ -9,80 +9,57 @@ tags:
   - Propriété
 translation_of: Web/API/Node/firstChild
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule <strong><code>Node.firstChild</code> r</strong>envoie le premier nœud enfant de l'arbre ou <code>null</code> s'il n'en a pas. Si le noeud est un <code>Document</code> , il renvoie le premier noeud de la liste de ses enfants directs.</p>
+La propriété en lecture seule **`Node.firstChild` r**envoie le premier nœud enfant de l'arbre ou `null` s'il n'en a pas. Si le noeud est un `Document` , il renvoie le premier noeud de la liste de ses enfants directs.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>childNode</var> = <var>node</var>.firstChild;</pre>
+    var childNode = node.firstChild;
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<p>Cet exemple montre l'utilisation de <code>firstChild</code> et la manière dont les nœuds d'espaces peuvent interférer.</p>
+Cet exemple montre l'utilisation de `firstChild` et la manière dont les nœuds d'espaces peuvent interférer.
 
-<pre class="brush: html">&lt;p id="para-01"&gt;
-  &lt;span&gt;Premier span&lt;/span&gt;
-&lt;/p&gt;
+```html
+<p id="para-01">
+  <span>Premier span</span>
+</p>
 
-&lt;script type="text/javascript"&gt;
+<script type="text/javascript">
   var p01 = document.getElementById('para-01');
   alert(p01.firstChild.nodeName)
-&lt;/script&gt;
-</pre>
+</script>
+```
 
-<p>Dans le code ci-dessus, la <a href="/fr/docs/Web/API/Console">console</a> affichera « #text » car un nœud texte a été inséré pour préserver les blancs entre la fin des balises ouvrantes &lt;p&gt; et &lt;span&gt;. <strong>Tout</strong> <a href="/fr/docs/Gestion_des_espaces_dans_le_DOM">espace</a> provoquera l'insertion d'un nœud <code>#text</code> , qu'il s'agisse d'un simple espace ou de plusieurs, de retours à la ligne, tabulations, etc.</p>
+Dans le code ci-dessus, la [console](/fr/docs/Web/API/Console) affichera « #text » car un nœud texte a été inséré pour préserver les blancs entre la fin des balises ouvrantes \<p> et \<span>. **Tout** [espace](/fr/docs/Gestion_des_espaces_dans_le_DOM) provoquera l'insertion d'un nœud `#text` , qu'il s'agisse d'un simple espace ou de plusieurs, de retours à la ligne, tabulations, etc.
 
-<p>Un autre nœud <code>#text</code> est inséré entre les balises de fermeture &lt;/span&gt; et &lt;/p&gt;.</p>
+Un autre nœud `#text` est inséré entre les balises de fermeture \</span> et \</p>.
 
-<p>Si ces espaces sont retirés du code source, les nœuds <code>#text</code> n'apparaîtront plus et l'élément span deviendra le premier enfant du paragraphe.</p>
+Si ces espaces sont retirés du code source, les nœuds `#text` n'apparaîtront plus et l'élément span deviendra le premier enfant du paragraphe.
 
-<pre class="brush: html">&lt;p id="para-01"&gt;&lt;span&gt;Premier span&lt;/span&gt;&lt;/p&gt;
+```html
+<p id="para-01"><span>Premier span</span></p>
 
-&lt;script type="text/javascript"&gt;
+<script type="text/javascript">
   var p01 = document.getElementById('para-01');
   alert(p01.firstChild.nodeName)
-&lt;/script&gt;
-</pre>
-
-<p>À présent, l'alerte affichera « SPAN ».</p>
-
-<p>Pour éviter le problème avec <code>node.firstChild</code>  renvoyant des noeuds <code>#text</code> ou <code>#comment</code>,  {{domxref("ParentNode.firstElementChild")}}  peut être utilisé pour renvoyer seulement le premier noeud élément. Toutefois,  <code>node.firstElementChild</code> nécessite un "shim" pour Internet Explorer 9 et antérieurs.</p>
-
-<h2 id="Spécification">Spécification</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-firstchild', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-169727388', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-169727388', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-169727388', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.firstChild")}}</p>
\ No newline at end of file
+</script>
+```
+
+À présent, l'alerte affichera « SPAN ».
+
+Pour éviter le problème avec `node.firstChild`  renvoyant des noeuds `#text` ou `#comment`,  {{domxref("ParentNode.firstElementChild")}}  peut être utilisé pour renvoyer seulement le premier noeud élément. Toutefois,  `node.firstElementChild` nécessite un "shim" pour Internet Explorer 9 et antérieurs.
+
+## Spécification
+
+| Spécification                                                                                        | Statut                           | Commentaire         |
+| ---------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------- |
+| {{SpecName('DOM WHATWG', '#dom-node-firstchild', 'Node.firstChild')}}         | {{Spec2('DOM WHATWG')}} | Pas de changement   |
+| {{SpecName('DOM3 Core', 'core.html#ID-169727388', 'Node.firstChild')}}         | {{Spec2('DOM3 Core')}}     | Pas de changement   |
+| {{SpecName('DOM2 Core', 'core.html#ID-169727388', 'Node.firstChild')}}         | {{Spec2('DOM2 Core')}}     | Pas de changement   |
+| {{SpecName('DOM1', 'level-one-core.html#ID-169727388', 'Node.firstChild')}} | {{Spec2('DOM1')}}         | Définition initiale |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.firstChild")}}
diff --git a/files/fr/web/api/node/getrootnode/index.md b/files/fr/web/api/node/getrootnode/index.md
index 5a6297d55b..9170ad233a 100644
--- a/files/fr/web/api/node/getrootnode/index.md
+++ b/files/fr/web/api/node/getrootnode/index.md
@@ -9,43 +9,43 @@ tags:
   - Racine
 translation_of: Web/API/Node/getRootNode
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La méthode <strong><code>getRootNode()</code></strong> de l'interface {{domxref("Node")}} renvoie le contexte de la racine de l'objet, qui peut optionnellement inclure la racine "shadow" si elle est disponible.</p>
+La méthode **`getRootNode()`** de l'interface {{domxref("Node")}} renvoie le contexte de la racine de l'objet, qui peut optionnellement inclure la racine "shadow" si elle est disponible.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var root = node.getRootNode(options)</pre>
+    var root = node.getRootNode(options)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt>options {{optional_inline}}</dt>
- <dd>Un objet qui définit les options pour obtenir le noeud racine. Les options disponibles sont :
- <ul>
-  <li><code>composed</code> : un {{jsxref('Boolean')}} (<em>booléen</em>) qui indique si la racine shadow doit être retournée (<code>false</code> (<em>faux</em>) par défaut) ou un noeud racine au-delà de la racine shadow (<code>true</code>).</li>
- </ul>
- </dd>
-</dl>
+- options {{optional_inline}}
 
-<h3 id="Retourne">Retourne</h3>
+  - : Un objet qui définit les options pour obtenir le noeud racine. Les options disponibles sont :
 
-<p>Une interface {{domxref('Node')}}.</p>
+    - `composed` : un {{jsxref('Boolean')}} (_booléen_) qui indique si la racine shadow doit être retournée (`false` (_faux_) par défaut) ou un noeud racine au-delà de la racine shadow (`true`).
 
-<h2 id="Exemple">Exemple</h2>
+### Retourne
 
-<p>Le premier exemple retourne une référence au noeud HTML/document lorsqu'il est exécuté dans les navigateurs de support :</p>
+Une interface {{domxref('Node')}}.
 
-<pre class="brush: js">rootNode = node.getRootNode();</pre>
+## Exemple
 
-<p>Cet exemple plus complexe montre la différence entre retourner une racine normale et une racine qui inclut la racine shadow (voir le <a href="https://github.com/jserz/js_piece/blob/master/DOM/Node/getRootNode()/demo/getRootNode.html">code source complet</a>):</p>
+Le premier exemple retourne une référence au noeud HTML/document lorsqu'il est exécuté dans les navigateurs de support :
 
-<pre class="brush: html">&lt;!-- source: https://github.com/jserz/js_piece/blob/master/DOM/Node/getRootNode()/demo/getRootNode.html --&gt;
-&lt;div class="js-parent"&gt;
-    &lt;div class="js-child"&gt;&lt;/div&gt;
-&lt;/div&gt;
-&lt;div class="js-shadowHost"&gt;&lt;/div&gt;
-&lt;script&gt;
+```js
+rootNode = node.getRootNode();
+```
+
+Cet exemple plus complexe montre la différence entre retourner une racine normale et une racine qui inclut la racine shadow (voir le [code source complet](<https://github.com/jserz/js_piece/blob/master/DOM/Node/getRootNode()/demo/getRootNode.html>)):
+
+```html
+<!-- source: https://github.com/jserz/js_piece/blob/master/DOM/Node/getRootNode()/demo/getRootNode.html -->
+<div class="js-parent">
+    <div class="js-child"></div>
+</div>
+<div class="js-shadowHost"></div>
+<script>
     // work on Chrome 54+，Opera41+
 
     var parent = document.querySelector('.js-parent'),
@@ -57,33 +57,23 @@ translation_of: Web/API/Node/getRootNode
 
     // create a ShadowRoot
     var shadowRoot = shadowHost.attachShadow({mode:'open'});
-    shadowRoot.innerHTML = '&lt;style&gt;div{background:#2bb8aa;}&lt;/style&gt;'
-        + '&lt;div class="js-shadowChild"&gt;content&lt;/div&gt;';
+    shadowRoot.innerHTML = '<style>div{background:#2bb8aa;}</style>'
+        + '<div class="js-shadowChild">content</div>';
     var shadowChild = shadowRoot.querySelector('.js-shadowChild');
 
     // The default value of composed is false
     console.log(shadowChild.getRootNode() === shadowRoot); // true
     console.log(shadowChild.getRootNode({composed:false}) === shadowRoot); // true
     console.log(shadowChild.getRootNode({composed:true}).nodeName); // #document
-&lt;/script&gt;</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">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG','#dom-node-getrootnode','getRootNode()')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.getRootNode")}}</p>
\ No newline at end of file
+</script>
+```
+
+## Spécifications
+
+| Spécification                                                                            | Statut                           | Commentaire          |
+| ---------------------------------------------------------------------------------------- | -------------------------------- | -------------------- |
+| {{SpecName('DOM WHATWG','#dom-node-getrootnode','getRootNode()')}} | {{Spec2('DOM WHATWG')}} | Définition initiale. |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.getRootNode")}}
diff --git a/files/fr/web/api/node/haschildnodes/index.md b/files/fr/web/api/node/haschildnodes/index.md
index c14ad9836f..54fd502016 100644
--- a/files/fr/web/api/node/haschildnodes/index.md
+++ b/files/fr/web/api/node/haschildnodes/index.md
@@ -10,69 +10,57 @@ tags:
   - Reference
 translation_of: Web/API/Node/hasChildNodes
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La méthode <code><strong>Node.hasChildNodes()</strong></code> renvoie un {{jsxref("Boolean")}} indiquant si le {{domxref("Node","noeud")}} actuel possède des <a href="/fr/docs/Web/API/Node/childNodes">nœuds enfants</a> ou non.</p>
+La méthode **`Node.hasChildNodes()`** renvoie un {{jsxref("Boolean")}} indiquant si le {{domxref("Node","noeud")}} actuel possède des [nœuds enfants](/fr/docs/Web/API/Node/childNodes) ou non.
 
-<h2 id="Syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="brush: js"><var>bool</var> = <var>node</var>.hasChildNodes();</pre>
+```js
+bool = node.hasChildNodes();
+```
 
-<h3 id="Return_value">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Un {{jsxref("Boolean")}} qui est <code>true</code> si le nœud a des nœuds enfants, et <code>false</code> dans le cas contraire.</p>
+Un {{jsxref("Boolean")}} qui est `true` si le nœud a des nœuds enfants, et `false` dans le cas contraire.
 
-<h2 id="Example">Exemple</h2>
+## Exemple
 
-<pre class="brush:js">let foo = document.getElementById('foo');
+```js
+let foo = document.getElementById('foo');
 
 if (foo.hasChildNodes()) {
   // Faire quelque chose avec 'foo.childNodes'
-}</pre>
+}
+```
 
-<h2 id="Polyfill">Prothèse d'émulation</h2>
+## Prothèse d'émulation
 
-<pre class="brush:js">(function(prototype) {
+```js
+(function(prototype) {
   prototype.hasChildNodes = prototype.hasChildNodes || function() {
     return !!this.firstChild;
   }
-})(Node.prototype);</pre>
-
-<p>Il y a différentes façons de déterminer si le noeud a un noeud enfant :</p>
-
-<ul>
-  <li><code>node.hasChildNodes()</code></li>
-  <li><code>node.firstChild != null</code> (ou simplement <code>node.firstChild</code>)</li>
-  <li><code>node.childNodes &amp;&amp; node.childNodes.length</code> (ou <code>node.childNodes.length &gt; 0</code>)</li>
-</ul>
-
-<h2 id="Specifications">Spécification</h2>
-
-<table class="standard-table">
-  <thead>
-    <tr>
-      <th scope="col">Spécification</th>
-      <th scope="col">Statut</th>
-      <th scope="col">Commentaire</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>{{SpecName("DOM WHATWG", "#dom-node-haschildnodes", "Node: hasChildNodes")}}
-      </td>
-      <td>{{Spec2("DOM WHATWG")}}</td>
-      <td></td>
-    </tr>
-  </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.hasChildNodes")}}</p>
-
-<h2 id="See_also">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("Node.childNodes")}}</li>
- <li>{{domxref("Node.hasAttributes")}}</li>
-</ul>
+})(Node.prototype);
+```
+
+Il y a différentes façons de déterminer si le noeud a un noeud enfant :
+
+- `node.hasChildNodes()`
+- `node.firstChild != null` (ou simplement `node.firstChild`)
+- `node.childNodes && node.childNodes.length` (ou `node.childNodes.length > 0`)
+
+## Spécification
+
+| Spécification                                                                                        | Statut                           | Commentaire |
+| ---------------------------------------------------------------------------------------------------- | -------------------------------- | ----------- |
+| {{SpecName("DOM WHATWG", "#dom-node-haschildnodes", "Node: hasChildNodes")}} | {{Spec2("DOM WHATWG")}} |             |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.hasChildNodes")}}
+
+## Voir aussi
+
+- {{domxref("Node.childNodes")}}
+- {{domxref("Node.hasAttributes")}}
diff --git a/files/fr/web/api/node/index.md b/files/fr/web/api/node/index.md
index 4c7ddde36b..624d732fe0 100644
--- a/files/fr/web/api/node/index.md
+++ b/files/fr/web/api/node/index.md
@@ -13,294 +13,208 @@ tags:
   - hierarchy
 translation_of: Web/API/Node
 ---
-<p>{{ApiRef("DOM")}}</p>
-
-<p><code><strong>Node</strong></code> (<em>nœud)</em> est une classe abstraite de laquelle de nombreux objets de type DOM API héritent, leur permettant d'être traités de manière similaire et souvent interchangeable. Étant une classe abstraire, il n'existe pas d'objet qui soit directement un <code>Node</code>. Tous les objets implantant les fonctionnalités de <code>Node</code> sont des instances d'une de ses sous-classes, dont les plus notables sont {{domxref("Document")}}, {{domxref("Element")}} et {{domxref("DocumentFragment")}}.</p>
-
-<p>De pls, tous les types de nœuds du DOM sont représentés par une classe héritant des propriétés et méthodes de <code>Node</code> : {{domxref("CharacterData")}} (duquel {{domxref("Text")}}, {{domxref("Comment")}} et {{domxref("CDATASection")}} héritent), {{domxref("ProcessingInstruction")}}, , {{domxref("DocumentType")}}, {{domxref("Notation")}}, {{domxref("Entity")}} et {{domxref("EntityReference")}}.</p>
-
-<p>Les propriétés ou méthodes de ces interfaces peuvent retourner <code>null</code> lorsque leur existence n'est pas pertinente. Elles peuvent aussi générer une exception – par exemple lors de l'ajout d'un enfant à un type de nœud pour lequel aucun enfant ne peut exister.</p>
-
-<p>{{InheritanceDiagram}}</p>
-
-<h2 id="Propriétés">Propriétés</h2>
-
-<p><em>Hérite les propriétés de son parent {{domxref("EventTarget")}}</em>.</p>
-
-<dl>
- <dt>{{DOMxRef("Node.baseURI")}} {{readonlyInline}}</dt>
- <dd>Retourne une {{domxref("DOMString")}} (<em>chaine de caractères</em>) représentant l'URL de base du document contenant le <code>Node</code>. En HTML, il correspond au protocole, au nom de domaine et à la structure du répertoire, jusqu'au dernier <code>/</code>.</dd>
- <dt>{{DOMxRef("Node.baseURIObject")}} {{Non-standard_inline()}}</dt>
- <dd>(Non disponible pour le contenu Web). L'objet en lecture seule  {{Interface ("nsIURI")}} représentant l'URI de base pour l'élément.</dd>
- <dt>{{DOMxRef("Node.childNodes")}} {{readonlyInline}}</dt>
- <dd>Renvoie un {{domxref ("NodeList")}} contenant tous les enfants de ce nœud. {{domxref ("NodeList")}} signifie que si les enfants du <code>Node</code> changent, l'objet {{domxref ("NodeList")}} est automatiquement mis à jour.</dd>
- <dt>{{DOMxRef("Node.firstChild")}} {{readonlyInline}}</dt>
- <dd>Renvoie un {{domxref ("Node")}} représentant le premier nœud enfant direct de ce nœud ou <code>null</code> s'il n'a pas d'enfant.</dd>
- <dt>{{DOMxRef("Node.lastChild")}} {{readonlyInline}}</dt>
- <dd>Retourne un {{domxref("Node")}} représentant le dernier nœud enfant direct de ce nœud ou <code>null</code> s'il n'a pas d'enfant.</dd>
- <dt>{{DOMxRef("Node.nextSibling")}} {{readonlyInline}}</dt>
- <dd>Retourne un {{domxref("Node")}} représentant le nœud suivant dans l'arbre ou <code>null</code> s'il n'y en a pas.</dd>
- <dt>{{DOMxRef("Node.nodeName")}} {{readonlyInline}}</dt>
- <dd>Retourne une {{domxref("DOMString")}} (<em>chaîne de caractères</em>) contenant le nom du nœud. La structure du nom diffère du type de nœud. Par exemple, un {{domxref("HTMLElement")}} contiendra le nom de la balise correspondante, comme <code>'audio'</code>  pour un {{domxref("HTMLAudioElement")}}, un nœud {{domxref("Text")}} doit avoir la chaîne <code>'#text'</code> ou un  {{domxref("Document")}}  doit avoir la chaîne <code>'#document'.</code>.</dd>
- <dt>{{DOMxRef("Node.nodeType")}}{{readonlyInline}}</dt>
- <dd>Retourne un <code>unsigned short</code> (<em>non signé court</em>) représentant le type du nœud. Les valeurs possibles sont :</dd>
-</dl>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Nom</th>
-   <th scope="col">Valeur</th>
-  </tr>
-  <tr>
-   <td><code>ELEMENT_NODE</code></td>
-   <td><code>1</code></td>
-  </tr>
-  <tr>
-   <td><code>ATTRIBUTE_NODE</code> {{deprecated_inline()}}</td>
-   <td><code>2</code></td>
-  </tr>
-  <tr>
-   <td><code>TEXT_NODE</code></td>
-   <td><code>3</code></td>
-  </tr>
-  <tr>
-   <td><code>CDATA_SECTION_NODE</code> {{deprecated_inline()}}</td>
-   <td><code>4</code></td>
-  </tr>
-  <tr>
-   <td><code>ENTITY_REFERENCE_NODE</code> {{deprecated_inline()}}</td>
-   <td><code>5</code></td>
-  </tr>
-  <tr>
-   <td><code>ENTITY_NODE</code> {{deprecated_inline()}}</td>
-   <td><code>6</code></td>
-  </tr>
-  <tr>
-   <td><code>PROCESSING_INSTRUCTION_NODE</code></td>
-   <td><code>7</code></td>
-  </tr>
-  <tr>
-   <td><code>COMMENT_NODE</code></td>
-   <td><code>8</code></td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_NODE</code></td>
-   <td><code>9</code></td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_TYPE_NODE</code></td>
-   <td><code>10</code></td>
-  </tr>
-  <tr>
-   <td><code>DOCUMENT_FRAGMENT_NODE</code></td>
-   <td><code>11</code></td>
-  </tr>
-  <tr>
-   <td><code>NOTATION_NODE</code> {{deprecated_inline()}}</td>
-   <td><code>12</code></td>
-  </tr>
- </tbody>
-</table>
-
-<dl>
- <dt>{{DOMxRef("Node.nodeValue")}}</dt>
- <dd>Retourne / définit la valeur du nœud courant.</dd>
- <dt>{{DOMxRef("Node.ownerDocument")}}{{readonlyInline}}</dt>
- <dd>Retourne le {{domxref("Document")}}  auquel ce noeud appartient. Si aucun document ne lui est associé, il retourne <code>null</code> .</dd>
- <dt>{{DOMxRef("Node.parentNode")}}{{readonlyInline}}</dt>
- <dd>Retourne un {{domxref("Node")}} qui est le parent de ce nœud. S'il n'existe pas, parce qu'il est en haut de l'arbre ou parce qu'il ne participe pas à un arbre, cette propriété retourne <code>null</code> .</dd>
- <dt>{{DOMxRef("Node.parentElement")}}{{readonlyInline}}</dt>
- <dd>Retourne un {{domxref("Element")}} qui est le parent de ce nœud. Si le nœud n'a aucun parent ou si ce parent n'est pas un  {{domxref("Element")}} , cette propriété retourne <code>null</code>.</dd>
- <dt>{{DOMxRef("Node.previousSibling")}}{{readonlyInline}}</dt>
- <dd>Retourne un {{domxref("Node")}} représentant le nœud précédent dans l'arbre ou  <code>null</code> s'il n'y en a pas.</dd>
- <dt>{{DOMxRef("Node.textContent")}}</dt>
- <dd>Retourne / définit le contenu textuel d'un élément et de tous ses descendants.</dd>
-</dl>
-
-<dl>
-</dl>
-
-<h3 id="Propriétés_obsolètes">Propriétés obsolètes</h3>
-
-<dl>
- <dt>{{DOMxRef("Node.localName")}} {{obsolete_inline}}{{readonlyInline}}</dt>
- <dd>Retourne un {{domxref("DOMString")}}  représentant la partie locale du nom d'un élément.</dd>
-</dl>
-
-<div class="note">
-<p><strong>Note :</strong> Dans Firefox 3.5 et versions antérieures, la propriété saisit le nom local pour les éléments HTML (mais pas les éléments XHTML). Dans les versions ultérieures, cela ne se produit pas, donc la propriété est en minuscule pour HTML et XHTML. {{gecko_minversion_inline("1.9.2")}}</p>
-</div>
-
-<dl>
- <dt>{{DOMxRef("Node.namespaceURI")}} {{obsolete_inline}}{{readonlyInline}}</dt>
- <dd>L'URI du "Namespace" de ce nom, ou  <code>null</code> s'il n'y en a pas.</dd>
-</dl>
-
-<div class="note">
-<p><strong>Note :</strong> Dans Firefox 3.5 et versions antérieures, les éléments HTML ne contiennent aucun "namespace". Dans les versions ultérieures, les éléments HTML sont dans le "namespace" <code><a href="https://www.w3.org/1999/xhtml/">https://www.w3.org/1999/xhtml/</a></code>  pour HTML et XML.  {{gecko_minversion_inline("1.9.2")}}</p>
-</div>
-
-<dl>
- <dt>{{DOMxRef("Node.prefix")}} {{obsolete_inline}}{{readonlyInline}}</dt>
- <dd>Est une {{domxref("DOMString")}} représentant le préfixe de l'espace de nom du nœud ou <code>null</code>  si aucun préfixe n'est spécifié.</dd>
- <dt>{{DOMxRef("Node.nodePrincipal")}} {{Non-standard_inline}}{{Obsolete_Inline("gecko46")}}</dt>
- <dd>Un {{Interface("nsIPrincipal")}} représentant le nœud principal.</dd>
- <dt>{{DOMxRef("Node.rootNode")}} {{Obsolete_Inline}}{{ReadOnlyInline}}</dt>
- <dd>Retourne un objet {{DOMxRef("Node")}} représentant le noeud le plus haut dans l'arbre ou le noeud en cours s'il est le noeud le plus haut de l'arbre. Cette propriété a été remplacée par {{DOMxRef("Node.getRootNode()")}}.</dd>
-</dl>
-
-<h2 id="Méthodes">Méthodes</h2>
-
-<p><em>Hérite des méthodes de son parent {{domxref("EventTarget")}}</em>.</p>
-
-<dl>
- <dt>{{DOMxRef("Node.appendChild()", "Node.appendChild(<var>childNode</var>)")}}</dt>
- <dd>Ajoute l'argument <code>childNode</code> spécifié comme dernier enfant au noeud actuel.<br>
- Si l'argument fait référence à un noeud existant sur l'arborescence DOM, le nœud sera détaché de sa position actuelle et attaché à la nouvelle position.</dd>
- <dt>{{DOMxRef("Node.cloneNode()")}}</dt>
- <dd>Clône un {{domxref("Node")}} et, éventuellement, tout son contenu. Par défaut, il duplique le contenu de ce nœud.</dd>
- <dt>{{DOMxRef("Node.compareDocumentPosition()")}}</dt>
- <dd>Compare la position du nœud courant par rapport à un autre nœud dans tout autre document.</dd>
- <dt>{{DOMxRef("Node.contains()")}}</dt>
- <dd>Retourne une valeur {{jsxref("Boolean")}} (<em>booléen</em>) indiquant si un noeud est un descendant d'un noeud donné ou non.</dd>
- <dt>{{domxref("Node.getBoxQuads()")}} {{experimental_inline}}</dt>
- <dd>Retourne une liste des boites CSS des nœuds relatifs à un autre nœud.</dd>
- <dt>{{DOMxRef("Node.getRootNode()")}}</dt>
- <dd>Retourne la racine de l'objet contextuel qui comprend éventuellement la "Shadow root" si elle est disponible.</dd>
- <dt>{{DOMxRef("Node.hasChildNodes()")}}</dt>
- <dd>Retourne un {{jsxref("Boolean")}} (<em>booléen</em>) indiquant si l'élément a des noeuds enfants ou non.</dd>
- <dt>{{DOMxRef("Node.insertBefore()")}}</dt>
- <dd>Insère un {{domxref("Node")}} avant le nœud de référence en tant qu'enfant du noeud actuel.</dd>
- <dt>{{DOMxRef("Node.isDefaultNamespace()")}}</dt>
- <dd>Accepte une URI d'espace de nom comme argument et retourne une valeur {{jsxref("Boolean")}} avec <code>true</code> (<em>vrai</em>) si l'espace de nom est celui par défaut du noeud donné ou <code>false</code> (<em>faux</em>) sinon.</dd>
- <dt>{{DOMxRef("Node.isEqualNode()")}}</dt>
- <dd>Retourne une valeur {{jsxref("Boolean")}} (<em>booléenne</em>) qui indique si oui ou non deux noeuds sont du même type et si tous leurs points de données définis correspondent.</dd>
- <dt>{{DOMxRef("Node.isSameNode()")}}</dt>
- <dd>Retourne une valeur {{jsxref("Boolean")}} (<em>booléenne</em>) indiquant si les deux noeuds sont ou non identiques (c'est-à-dire qu'ils font référence au même objet).</dd>
- <dt>{{DOMxRef("Node.lookupPrefix()")}}</dt>
- <dd>Retourne une {{domxref("DOMString")}} (<em>chaîne de caractères</em>) contenant le préfixe d'une URI d'un espace de nom donné, s'il est présent, et <code>null</code> sinon.</dd>
- <dt>{{DOMxRef("Node.lookupNamespaceURI()")}}</dt>
- <dd>Accepte un préfixe et retourne l'URI de l'espace de noms qui lui est associé sur le nœud donné s'il le trouve, <code>null</code> sinon. Fournir <code>null</code> comme préfixe retournera l'espace de noms par défaut.</dd>
- <dt>{{DOMxRef("Node.normalize()")}}</dt>
- <dd>Nettoye tous les nœuds de texte en-dessous de cet élément (fusionne adjacent, supprime vide).</dd>
- <dt>{{DOMxRef("Node.removeChild()")}}</dt>
- <dd>Supprime un nœud enfant, depuis l'élément courant, qui doit être un enfant de ce nœud.</dd>
- <dt>{{DOMxRef("Node.replaceChild()")}}</dt>
- <dd>Remplace un {{domxref("Node")}} enfant du nœud courant par celui donné dans le paramètre.</dd>
-</dl>
-
-<h3 id="Méthodes_obsolètes">Méthodes obsolètes</h3>
-
-<dl>
- <dt>{{domxref("Node.getFeature()")}} {{obsolete_inline}}</dt>
- <dd>Permet à un utilisateur d'obtenir un objet {{DOMxRef("DOMUserData")}} à partir du nœud fourni.</dd>
- <dt>{{domxref("Node.getUserData()")}} {{obsolete_inline}}</dt>
- <dd>Permet à un utilisateur d'obtenir une {{domxref ("DOMUserData")}} (<em>donnée utilisateur</em>) à partir du nœud.</dd>
- <dt>{{domxref("Node.hasAttributes()")}} {{obsolete_inline}}</dt>
- <dd>Retourne un {{jsxref("Boolean")}} indiquant si l'élément possède des attributs ou non.</dd>
- <dt>{{domxref("Node.isSupported()")}} {{obsolete_inline}}</dt>
- <dd>Retourne une marque {{jsxref("Boolean")}} qui contient le résultat d'un test si l'implémentation DOM prend en compte une caractéristique spécifique et si cette fonctionnalité est prise en charge par le nœud spécifique.</dd>
- <dt>{{domxref("Node.setUserData()")}} {{obsolete_inline}}</dt>
- <dd>Permet à un utilisateur d'attacher ou d'enlever  {{domxref("DOMUserData")}} du nœud.</dd>
-</dl>
-
-<h2 id="Exemples">Exemples</h2>
-
-<h3 id="Parcourir_tous_les_nœuds_enfants">Parcourir tous les nœuds enfants</h3>
-
-<p>La fonction suivante parcourt de manière récursive tous les nœuds enfants d'un noeud et exécute une fonction de rappel sur eux (et sur le nœud parent lui-même).</p>
-
-<pre class="brush: js">function DOMComb (oParent, oCallback) {
+{{ApiRef("DOM")}}
+
+**`Node`** (_nœud)_ est une classe abstraite de laquelle de nombreux objets de type DOM API héritent, leur permettant d'être traités de manière similaire et souvent interchangeable. Étant une classe abstraire, il n'existe pas d'objet qui soit directement un `Node`. Tous les objets implantant les fonctionnalités de `Node` sont des instances d'une de ses sous-classes, dont les plus notables sont {{domxref("Document")}}, {{domxref("Element")}} et {{domxref("DocumentFragment")}}.
+
+De pls, tous les types de nœuds du DOM sont représentés par une classe héritant des propriétés et méthodes de `Node` : {{domxref("CharacterData")}} (duquel {{domxref("Text")}}, {{domxref("Comment")}} et {{domxref("CDATASection")}} héritent), {{domxref("ProcessingInstruction")}}, , {{domxref("DocumentType")}}, {{domxref("Notation")}}, {{domxref("Entity")}} et {{domxref("EntityReference")}}.
+
+Les propriétés ou méthodes de ces interfaces peuvent retourner `null` lorsque leur existence n'est pas pertinente. Elles peuvent aussi générer une exception – par exemple lors de l'ajout d'un enfant à un type de nœud pour lequel aucun enfant ne peut exister.
+
+{{InheritanceDiagram}}
+
+## Propriétés
+
+_Hérite les propriétés de son parent {{domxref("EventTarget")}}_.
+
+- {{DOMxRef("Node.baseURI")}} {{readonlyInline}}
+  - : Retourne une {{domxref("DOMString")}} (_chaine de caractères_) représentant l'URL de base du document contenant le `Node`. En HTML, il correspond au protocole, au nom de domaine et à la structure du répertoire, jusqu'au dernier `/`.
+- {{DOMxRef("Node.baseURIObject")}} {{Non-standard_inline()}}
+  - : (Non disponible pour le contenu Web). L'objet en lecture seule {{Interface ("nsIURI")}} représentant l'URI de base pour l'élément.
+- {{DOMxRef("Node.childNodes")}} {{readonlyInline}}
+  - : Renvoie un {{domxref ("NodeList")}} contenant tous les enfants de ce nœud. {{domxref ("NodeList")}} signifie que si les enfants du `Node` changent, l'objet {{domxref ("NodeList")}} est automatiquement mis à jour.
+- {{DOMxRef("Node.firstChild")}} {{readonlyInline}}
+  - : Renvoie un {{domxref ("Node")}} représentant le premier nœud enfant direct de ce nœud ou `null` s'il n'a pas d'enfant.
+- {{DOMxRef("Node.lastChild")}} {{readonlyInline}}
+  - : Retourne un {{domxref("Node")}} représentant le dernier nœud enfant direct de ce nœud ou `null` s'il n'a pas d'enfant.
+- {{DOMxRef("Node.nextSibling")}} {{readonlyInline}}
+  - : Retourne un {{domxref("Node")}} représentant le nœud suivant dans l'arbre ou `null` s'il n'y en a pas.
+- {{DOMxRef("Node.nodeName")}} {{readonlyInline}}
+  - : Retourne une {{domxref("DOMString")}} (_chaîne de caractères_) contenant le nom du nœud. La structure du nom diffère du type de nœud. Par exemple, un {{domxref("HTMLElement")}} contiendra le nom de la balise correspondante, comme `'audio'`  pour un {{domxref("HTMLAudioElement")}}, un nœud {{domxref("Text")}} doit avoir la chaîne `'#text'` ou un  {{domxref("Document")}}  doit avoir la chaîne `'#document'.`.
+- {{DOMxRef("Node.nodeType")}}{{readonlyInline}}
+  - : Retourne un `unsigned short` (_non signé court_) représentant le type du nœud. Les valeurs possibles sont :
+
+| Nom                                                      | Valeur |
+| -------------------------------------------------------- | ------ |
+| `ELEMENT_NODE`                                           | `1`    |
+| `ATTRIBUTE_NODE` {{deprecated_inline()}}        | `2`    |
+| `TEXT_NODE`                                              | `3`    |
+| `CDATA_SECTION_NODE` {{deprecated_inline()}}    | `4`    |
+| `ENTITY_REFERENCE_NODE` {{deprecated_inline()}} | `5`    |
+| `ENTITY_NODE` {{deprecated_inline()}}           | `6`    |
+| `PROCESSING_INSTRUCTION_NODE`                            | `7`    |
+| `COMMENT_NODE`                                           | `8`    |
+| `DOCUMENT_NODE`                                          | `9`    |
+| `DOCUMENT_TYPE_NODE`                                     | `10`   |
+| `DOCUMENT_FRAGMENT_NODE`                                 | `11`   |
+| `NOTATION_NODE` {{deprecated_inline()}}         | `12`   |
+
+- {{DOMxRef("Node.nodeValue")}}
+  - : Retourne / définit la valeur du nœud courant.
+- {{DOMxRef("Node.ownerDocument")}}{{readonlyInline}}
+  - : Retourne le {{domxref("Document")}}  auquel ce noeud appartient. Si aucun document ne lui est associé, il retourne `null` .
+- {{DOMxRef("Node.parentNode")}}{{readonlyInline}}
+  - : Retourne un {{domxref("Node")}} qui est le parent de ce nœud. S'il n'existe pas, parce qu'il est en haut de l'arbre ou parce qu'il ne participe pas à un arbre, cette propriété retourne `null` .
+- {{DOMxRef("Node.parentElement")}}{{readonlyInline}}
+  - : Retourne un {{domxref("Element")}} qui est le parent de ce nœud. Si le nœud n'a aucun parent ou si ce parent n'est pas un  {{domxref("Element")}} , cette propriété retourne `null`.
+- {{DOMxRef("Node.previousSibling")}}{{readonlyInline}}
+  - : Retourne un {{domxref("Node")}} représentant le nœud précédent dans l'arbre ou  `null` s'il n'y en a pas.
+- {{DOMxRef("Node.textContent")}}
+  - : Retourne / définit le contenu textuel d'un élément et de tous ses descendants.
+
+<!---->
+
+### Propriétés obsolètes
+
+- {{DOMxRef("Node.localName")}} {{obsolete_inline}}{{readonlyInline}}
+  - : Retourne un {{domxref("DOMString")}}  représentant la partie locale du nom d'un élément.
+
+> **Note :** Dans Firefox 3.5 et versions antérieures, la propriété saisit le nom local pour les éléments HTML (mais pas les éléments XHTML). Dans les versions ultérieures, cela ne se produit pas, donc la propriété est en minuscule pour HTML et XHTML. {{gecko_minversion_inline("1.9.2")}}
+
+- {{DOMxRef("Node.namespaceURI")}} {{obsolete_inline}}{{readonlyInline}}
+  - : L'URI du "Namespace" de ce nom, ou  `null` s'il n'y en a pas.
+
+> **Note :** Dans Firefox 3.5 et versions antérieures, les éléments HTML ne contiennent aucun "namespace". Dans les versions ultérieures, les éléments HTML sont dans le "namespace" [`https://www.w3.org/1999/xhtml/`](https://www.w3.org/1999/xhtml/)  pour HTML et XML.  {{gecko_minversion_inline("1.9.2")}}
+
+- {{DOMxRef("Node.prefix")}} {{obsolete_inline}}{{readonlyInline}}
+  - : Est une {{domxref("DOMString")}} représentant le préfixe de l'espace de nom du nœud ou `null`  si aucun préfixe n'est spécifié.
+- {{DOMxRef("Node.nodePrincipal")}} {{Non-standard_inline}}{{Obsolete_Inline("gecko46")}}
+  - : Un {{Interface("nsIPrincipal")}} représentant le nœud principal.
+- {{DOMxRef("Node.rootNode")}} {{Obsolete_Inline}}{{ReadOnlyInline}}
+  - : Retourne un objet {{DOMxRef("Node")}} représentant le noeud le plus haut dans l'arbre ou le noeud en cours s'il est le noeud le plus haut de l'arbre. Cette propriété a été remplacée par {{DOMxRef("Node.getRootNode()")}}.
+
+## Méthodes
+
+_Hérite des méthodes de son parent {{domxref("EventTarget")}}_.
+
+- {{DOMxRef("Node.appendChild()", "Node.appendChild(<var>childNode</var>)")}}
+  - : Ajoute l'argument `childNode` spécifié comme dernier enfant au noeud actuel.
+    Si l'argument fait référence à un noeud existant sur l'arborescence DOM, le nœud sera détaché de sa position actuelle et attaché à la nouvelle position.
+- {{DOMxRef("Node.cloneNode()")}}
+  - : Clône un {{domxref("Node")}} et, éventuellement, tout son contenu. Par défaut, il duplique le contenu de ce nœud.
+- {{DOMxRef("Node.compareDocumentPosition()")}}
+  - : Compare la position du nœud courant par rapport à un autre nœud dans tout autre document.
+- {{DOMxRef("Node.contains()")}}
+  - : Retourne une valeur {{jsxref("Boolean")}} (_booléen_) indiquant si un noeud est un descendant d'un noeud donné ou non.
+- {{domxref("Node.getBoxQuads()")}} {{experimental_inline}}
+  - : Retourne une liste des boites CSS des nœuds relatifs à un autre nœud.
+- {{DOMxRef("Node.getRootNode()")}}
+  - : Retourne la racine de l'objet contextuel qui comprend éventuellement la "Shadow root" si elle est disponible.
+- {{DOMxRef("Node.hasChildNodes()")}}
+  - : Retourne un {{jsxref("Boolean")}} (_booléen_) indiquant si l'élément a des noeuds enfants ou non.
+- {{DOMxRef("Node.insertBefore()")}}
+  - : Insère un {{domxref("Node")}} avant le nœud de référence en tant qu'enfant du noeud actuel.
+- {{DOMxRef("Node.isDefaultNamespace()")}}
+  - : Accepte une URI d'espace de nom comme argument et retourne une valeur {{jsxref("Boolean")}} avec `true` (_vrai_) si l'espace de nom est celui par défaut du noeud donné ou `false` (_faux_) sinon.
+- {{DOMxRef("Node.isEqualNode()")}}
+  - : Retourne une valeur {{jsxref("Boolean")}} (_booléenne_) qui indique si oui ou non deux noeuds sont du même type et si tous leurs points de données définis correspondent.
+- {{DOMxRef("Node.isSameNode()")}}
+  - : Retourne une valeur {{jsxref("Boolean")}} (_booléenne_) indiquant si les deux noeuds sont ou non identiques (c'est-à-dire qu'ils font référence au même objet).
+- {{DOMxRef("Node.lookupPrefix()")}}
+  - : Retourne une {{domxref("DOMString")}} (_chaîne de caractères_) contenant le préfixe d'une URI d'un espace de nom donné, s'il est présent, et `null` sinon.
+- {{DOMxRef("Node.lookupNamespaceURI()")}}
+  - : Accepte un préfixe et retourne l'URI de l'espace de noms qui lui est associé sur le nœud donné s'il le trouve, `null` sinon. Fournir `null` comme préfixe retournera l'espace de noms par défaut.
+- {{DOMxRef("Node.normalize()")}}
+  - : Nettoye tous les nœuds de texte en-dessous de cet élément (fusionne adjacent, supprime vide).
+- {{DOMxRef("Node.removeChild()")}}
+  - : Supprime un nœud enfant, depuis l'élément courant, qui doit être un enfant de ce nœud.
+- {{DOMxRef("Node.replaceChild()")}}
+  - : Remplace un {{domxref("Node")}} enfant du nœud courant par celui donné dans le paramètre.
+
+### Méthodes obsolètes
+
+- {{domxref("Node.getFeature()")}} {{obsolete_inline}}
+  - : Permet à un utilisateur d'obtenir un objet {{DOMxRef("DOMUserData")}} à partir du nœud fourni.
+- {{domxref("Node.getUserData()")}} {{obsolete_inline}}
+  - : Permet à un utilisateur d'obtenir une {{domxref ("DOMUserData")}} (_donnée utilisateur_) à partir du nœud.
+- {{domxref("Node.hasAttributes()")}} {{obsolete_inline}}
+  - : Retourne un {{jsxref("Boolean")}} indiquant si l'élément possède des attributs ou non.
+- {{domxref("Node.isSupported()")}} {{obsolete_inline}}
+  - : Retourne une marque {{jsxref("Boolean")}} qui contient le résultat d'un test si l'implémentation DOM prend en compte une caractéristique spécifique et si cette fonctionnalité est prise en charge par le nœud spécifique.
+- {{domxref("Node.setUserData()")}} {{obsolete_inline}}
+  - : Permet à un utilisateur d'attacher ou d'enlever  {{domxref("DOMUserData")}} du nœud.
+
+## Exemples
+
+### Parcourir tous les nœuds enfants
+
+La fonction suivante parcourt de manière récursive tous les nœuds enfants d'un noeud et exécute une fonction de rappel sur eux (et sur le nœud parent lui-même).
+
+```js
+function DOMComb (oParent, oCallback) {
   if (oParent.hasChildNodes()) {
     for (var oNode = oParent.firstChild; oNode; oNode = oNode.nextSibling) {
       DOMComb(oNode, oCallback);
     }
   }
   oCallback.call(oParent);
-}</pre>
+}
+```
 
-<h4 id="Syntaxe">Syntaxe</h4>
+#### Syntaxe
 
-<pre class="syntaxbox">DOMComb(parentNode, callbackFunction);</pre>
+    DOMComb(parentNode, callbackFunction);
 
-<h4 id="Description">Description</h4>
+#### Description
 
-<p>Suit le cycle récursif de tous les nœuds enfants d'un <code>parentNode</code> et le <code>parentNode</code> lui-même, et exécute la fonction <code>callbackFunction</code> (<em>rappel</em>) sur eux comme un objet <a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this"><code>this</code></a>.</p>
+Suit le cycle récursif de tous les nœuds enfants d'un `parentNode` et le `parentNode` lui-même, et exécute la fonction `callbackFunction` (_rappel_) sur eux comme un objet [`this`](/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/L_op%C3%A9rateur_this).
 
-<h4 id="Paramètres">Paramètres</h4>
+#### Paramètres
 
-<dl>
- <dt><code>parentNode</code></dt>
- <dd>Le nœud parent (<code><strong>Node</strong> <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object">Object</a></code>)</dd>
- <dt><code>callbackFunction</code></dt>
- <dd>La fonction de rappel (<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a>).</dd>
-</dl>
+- `parentNode`
+  - : Le nœud parent (`Node Object`)
+- `callbackFunction`
+  - : La fonction de rappel ([`Function`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function)).
 
-<h4 id="Exemples_dutilisation">Exemples d'utilisation</h4>
+#### Exemples d'utilisation
 
-<p>L'exemple suivant envoie à la <code>console.log</code> le contenu texte du corps :</p>
+L'exemple suivant envoie à la `console.log` le contenu texte du corps :
 
-<pre class="brush: js">function printContent () {
+```js
+function printContent () {
   if (this.nodeValue) { console.log(this.nodeValue); }
 }
 
 onload = function () {
   DOMComb(document.body, printContent);
-};</pre>
+};
+```
 
-<h3 id="Supprimer_tous_les_enfants_imbriqués_dans_un_nœud">Supprimer tous les enfants imbriqués dans un nœud</h3>
+### Supprimer tous les enfants imbriqués dans un nœud
 
-<pre class="brush: js">Element.prototype.removeAll = function () {
+```js
+Element.prototype.removeAll = function () {
   while (this.firstChild) { this.removeChild(this.firstChild); }
   return this;
-};</pre>
-
-<h4 id="Exemple_dutilisation">Exemple d'utilisation</h4>
-
-<pre class="brush: js">/* ... an alternative to document.body.innerHTML = "" ... */
-document.body.removeAll();</pre>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#interface-node', 'Node')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Supprime les propriétés suivantes : <code>attributes</code>, <code>namespaceURI</code>, <code>prefix</code>, et <code>localName</code>.<br>
-    Supprime les méthodes suivantes : <code>isSupported()</code>, <code>hasAttributes()</code>, <code>getFeature()</code>, <code>setUserData()</code>, et <code>getUserData()</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-1950641247', 'Node')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Les méthodes <code>insertBefore()</code>, <code>replaceChild()</code>, <code>removeChild()</code>, et<code>appendChild()</code> renvoient un autre type d'erreur (<code>NOT_SUPPORTED_ERR</code>) si elles sont appelées par {{domxref("Document")}}.<br>
-    La méthode <code>normalize()</code>  a été modifiée, ainsi ce mode {{domxref("Text")}} peut aussi être normalisé si la marque {{domxref("DOMConfiguration")}} est définie.<br>
-    Ajout des méthodes suivantes : <code>compareDocumentPosition()</code>, <code>isSameNode()</code>, <code>lookupPrefix()</code>, <code>isDefaultNamespace()</code>, <code>lookupNamespaceURI()</code>, <code>isEqualNode()</code>, <code>getFeature()</code>, <code>setUserData()</code>, et <code>getUserData().</code><br>
-    Ajout des propriétés suivantes : <code>baseURI</code> et <code>textContent</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-1950641247', 'Node')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>La propriété <code>ownerDocument</code>a été légèrement modifiée pour que  {{domxref("DocumentFragment")}} renvoie également <code>null</code>.<br>
-    Ajout des propriétés suivantes : <code>namespaceURI</code>, <code>prefix</code>, et <code>localName</code>.<br>
-    Ajout des méthodes suivantes : <code>normalize()</code>, <code>isSupported()</code> et <code>hasAttributes()</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-1950641247', 'Node')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node")}}</p>
\ No newline at end of file
+};
+```
+
+#### Exemple d'utilisation
+
+```js
+/* ... an alternative to document.body.innerHTML = "" ... */
+document.body.removeAll();
+```
+
+## Spécifications
+
+| Spécification                                                                            | Statut                           | Commentaire                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ---------------------------------------------------------------------------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| {{SpecName('DOM WHATWG', '#interface-node', 'Node')}}                 | {{Spec2('DOM WHATWG')}} | Supprime les propriétés suivantes : `attributes`, `namespaceURI`, `prefix`, et `localName`. Supprime les méthodes suivantes : `isSupported()`, `hasAttributes()`, `getFeature()`, `setUserData()`, et `getUserData()`.                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| {{SpecName('DOM3 Core', 'core.html#ID-1950641247', 'Node')}}         | {{Spec2('DOM3 Core')}}     | Les méthodes `insertBefore()`, `replaceChild()`, `removeChild()`, et`appendChild()` renvoient un autre type d'erreur (`NOT_SUPPORTED_ERR`) si elles sont appelées par {{domxref("Document")}}. La méthode `normalize()`  a été modifiée, ainsi ce mode {{domxref("Text")}} peut aussi être normalisé si la marque {{domxref("DOMConfiguration")}} est définie. Ajout des méthodes suivantes : `compareDocumentPosition()`, `isSameNode()`, `lookupPrefix()`, `isDefaultNamespace()`, `lookupNamespaceURI()`, `isEqualNode()`, `getFeature()`, `setUserData()`, et `getUserData().` Ajout des propriétés suivantes : `baseURI` et `textContent`. |
+| {{SpecName('DOM2 Core', 'core.html#ID-1950641247', 'Node')}}         | {{Spec2('DOM2 Core')}}     | La propriété `ownerDocument`a été légèrement modifiée pour que  {{domxref("DocumentFragment")}} renvoie également `null`. Ajout des propriétés suivantes : `namespaceURI`, `prefix`, et `localName`. Ajout des méthodes suivantes : `normalize()`, `isSupported()` et `hasAttributes()`.                                                                                                                                                                                                                                                                                                                                                                      |
+| {{SpecName('DOM1', 'level-one-core.html#ID-1950641247', 'Node')}} | {{Spec2('DOM1')}}         | Définition initiale                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node")}}
diff --git a/files/fr/web/api/node/insertbefore/index.md b/files/fr/web/api/node/insertbefore/index.md
index 289539552f..55abf106dd 100644
--- a/files/fr/web/api/node/insertbefore/index.md
+++ b/files/fr/web/api/node/insertbefore/index.md
@@ -10,47 +10,43 @@ tags:
   - Noeud
 translation_of: Web/API/Node/insertBefore
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La méthode <code><strong>Node.insertBefore()</strong></code> insère un nœud avant un <em>nœud de référence</em> en tant qu'enfant d'un <em>nœud parent</em> spécifié.</p>
+La méthode **`Node.insertBefore()`** insère un nœud avant un _nœud de référence_ en tant qu'enfant d'un _nœud parent_ spécifié.
 
-<p>Si le nœud donné existe déjà dans le document, <code>insertBefore()</code> le déplace de sa position actuelle vers la nouvelle position. (C'est-à-dire qu'il sera automatiquement retiré de son parent existant avant d'être ajouté au nouveau parent spécifié).</p>
+Si le nœud donné existe déjà dans le document, `insertBefore()` le déplace de sa position actuelle vers la nouvelle position. (C'est-à-dire qu'il sera automatiquement retiré de son parent existant avant d'être ajouté au nouveau parent spécifié).
 
-<p>Cela signifie qu'un nœud ne peut pas se trouver simultanément à deux endroits du document.</p>
+Cela signifie qu'un nœud ne peut pas se trouver simultanément à deux endroits du document.
 
-<h2 id="Syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>insertedNode</var> = <var>parentNode</var>.insertBefore(<var>newNode</var>, <var>referenceNode</var>);
-</pre>
+    var insertedNode = parentNode.insertBefore(newNode, referenceNode);
 
-<dl>
-  <dt><code><var>insertedNode</var></code></dt>
-  <dd>Le nœud en cours d'insertion (le même que <code><var>newNode</var></code>).</dd>
-  <dt><code><var>parentNode</var></code></dt>
-  <dd>Le parent du nœud nouvellement inséré.</dd>
-  <dt><code><var>newNode</var></code></dt>
-  <dd>Le nœud à insérer.</dd>
-  <dt><code><var>referenceNode</var></code></dt>
-  <dd>Le nœud avant lequel <code><var>newNode</var></code> est inséré. Si c'est <code>null</code>, alors <code><var>newNode</var></code> est inséré à la fin des nœuds enfants de <code><var>parentNode</var></code>.</dd>
-</dl>
+- `insertedNode`
+  - : Le nœud en cours d'insertion (le même que `newNode`).
+- `parentNode`
+  - : Le parent du nœud nouvellement inséré.
+- `newNode`
+  - : Le nœud à insérer.
+- `referenceNode`
+  - : Le nœud avant lequel `newNode` est inséré. Si c'est `null`, alors `newNode` est inséré à la fin des nœuds enfants de `parentNode`.
 
-<div class="notecard note">
-  <p><strong>Note :</strong> <em><code>referenceNode</code></em> <strong>n'est pas</strong> un paramètre facultatif -- vous devez explicitement transmettre un <code>Node</code> ou <code>null</code>. Ne pas le fournir ou transmettre des valeurs invalides provoque des <a href="https://code.google.com/p/chromium/issues/detail?id=419780">comportements différents</a> selon les différentes versions des navigateurs.</p>
-</div>
+> **Note :** _`referenceNode`_ **n'est pas** un paramètre facultatif -- vous devez explicitement transmettre un `Node` ou `null`. Ne pas le fournir ou transmettre des valeurs invalides provoque des [comportements différents](https://code.google.com/p/chromium/issues/detail?id=419780) selon les différentes versions des navigateurs.
 
-<h3 id="Return_value">Valeur de retour</h3>
+### Valeur de retour
 
-<p>Renvoie l'enfant ajouté (sauf si <code><var>newNode</var></code> est un {{domxref("DocumentFragment")}}, auquel cas le {{domxref("DocumentFragment")}} vide est renvoyé).</p>
+Renvoie l'enfant ajouté (sauf si `newNode` est un {{domxref("DocumentFragment")}}, auquel cas le {{domxref("DocumentFragment")}} vide est renvoyé).
 
-<h2 id="Examples">Exemples</h2>
+## Exemples
 
-<h3 id="Example_1">Exemple 1</h3>
+### Exemple 1
 
-<pre class="brush: html">&lt;div id="parentElement"&gt;
-  &lt;span id="childElement"&gt;foo bar&lt;/span&gt;
-&lt;/div&gt;
+```html
+<div id="parentElement">
+  <span id="childElement">foo bar</span>
+</div>
 
-&lt;script&gt;
+<script>
 // Crée le nouveau nœud à insérer
 let newNode = document.createElement("span")
 
@@ -71,17 +67,18 @@ parentDiv.insertBefore(newNode, sp2) // Transfert dynamique implicite vers le ty
 let sp2 = "undefined" // Noeud non existant de l'id "childElement".
 parentDiv.insertBefore(newNode, sp2) // Génère "Erreur de type : Argument non valide".
 // Fin du cas de test [ 3 ]
-&lt;/script&gt;
-</pre>
+</script>
+```
 
-<h3 id="Example_2">Exemple 2</h3>
+### Exemple 2
 
-<pre class="brush:html">&lt;div id="parentElement"&gt;
-  &lt;span id="childElement"&gt;foo bar&lt;/span&gt;
-&lt;/div&gt;
+```html
+<div id="parentElement">
+  <span id="childElement">foo bar</span>
+</div>
 
-&lt;script&gt;
-// Crée un nouvel élément simple de type &lt;span&gt;
+<script>
+// Crée un nouvel élément simple de type <span>
 let sp1 = document.createElement("span")
 
 // Obtient l'élément de référence
@@ -91,76 +88,49 @@ let parentDiv = sp2.parentNode
 
 // Insert le nouvel élément dans avant sp2
 parentDiv.insertBefore(sp1, sp2)
-&lt;/script&gt;
-</pre>
+</script>
+```
 
-<p>Il n'existe pas de méthode <code>insertAfter</code>. Il peut être émulé avec une combinaison des méthodes <code>insertBefore</code><a href="/fr/docs/Web/API/Node/insertBefore"> </a>et <code><a href="/fr/docs/Web/API/Node/nextSibling">nextSibling</a></code>.</p>
+Il n'existe pas de méthode `insertAfter`. Il peut être émulé avec une combinaison des méthodes `insertBefore`[ ](/fr/docs/Web/API/Node/insertBefore)et [`nextSibling`](/fr/docs/Web/API/Node/nextSibling).
 
-<p>Dans l'exemple ci-dessus, <code>sp1</code> pourrait être inséré après <code>sp2</code> en utilisant :</p>
+Dans l'exemple ci-dessus, `sp1` pourrait être inséré après `sp2` en utilisant :
 
-<pre class="brush:js">parentDiv.insertBefore(sp1, sp2.nextSibling);</pre>
+```js
+parentDiv.insertBefore(sp1, sp2.nextSibling);
+```
 
-<p>Si <code>sp2</code> n'a pas d'enfant suivant, c'est qu'il est le dernier enfant. Dans ce cas, <code>sp2.nextSibling</code> renverra <code>null</code> et <code>sp1</code> sera donc inséré à la fin de la liste des nœuds enfants (c'est-à-dire immédiatement après <code>sp2</code>).</p>
+Si `sp2` n'a pas d'enfant suivant, c'est qu'il est le dernier enfant. Dans ce cas, `sp2.nextSibling` renverra `null` et `sp1` sera donc inséré à la fin de la liste des nœuds enfants (c'est-à-dire immédiatement après `sp2`).
 
-<h3 id="Example_3">Exemple 3</h3>
+### Exemple 3
 
-<p>Insérer un élément avant le premier élément enfant en utilisant la propriété <a href="/fr/docs/Web/API/Node/firstChild">firstChild</a>.</p>
+Insérer un élément avant le premier élément enfant en utilisant la propriété [firstChild](/fr/docs/Web/API/Node/firstChild).
 
-<pre class="brush:js">// Obtient l'élément parent
+```js
+// Obtient l'élément parent
   let parentElement = document.getElementById('parentElement')
   // Obtient le premier enfant du parent
   let theFirstChild = parentElement.firstChild
-  
+
   // Crée un nouvel élément
   let newElement = document.createElement("div")
-  
+
   // Insert le nouvel élément avant le premier enfant
   parentElement.insertBefore(newElement, theFirstChild)
-  </pre>
-
-<p>Si l'élément n'a pas de premier enfant, alors <code>firstChild</code> est <code>null</code>. L'élément est toujours ajouté au parent après le dernier enfant. Comme l'élément parent n'avait pas de premier enfant, il n'avait pas non plus de dernier enfant. Par conséquent, le nouvel élément est le seul élément, après l'insertion.</p>
-
-<h2 id="Specifications">Spécifications</h2>
-
-<table class="standard-table">
-  <thead>
-    <tr>
-      <th scope="col">Specification</th>
-      <th scope="col">Status</th>
-      <th scope="col">Comment</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>{{SpecName('DOM WHATWG','#dom-node-insertbefore','Node.insertBefore')}}</td>
-      <td>{{Spec2('DOM WHATWG')}}</td>
-      <td>Fixes errors in the insertion algorithm</td>
-    </tr>
-    <tr>
-      <td>{{SpecName('DOM4','#dom-node-insertbefore','Node.insertBefore')}}</td>
-      <td>{{Spec2('DOM4')}}</td>
-      <td>Describes the algorithm in more detail</td>
-    </tr>
-    <tr>
-      <td>{{SpecName('DOM3 Core','core.html#ID-952280727','Node.insertBefore')}}</td>
-      <td>{{Spec2('DOM3 Core')}}</td>
-      <td>No notable changes</td>
-    </tr>
-    <tr>
-      <td>{{SpecName('DOM2 Core','core.html#ID-952280727','Node.insertBefore')}}</td>
-      <td>{{Spec2('DOM2 Core')}}</td>
-      <td>No notable changes</td>
-    </tr>
-    <tr>
-      <td>
-        {{SpecName('DOM1','level-one-core.html#method-insertBefore','Node.insertBefore')}}
-      </td>
-      <td>{{Spec2('DOM1')}}</td>
-      <td>Introduced</td>
-    </tr>
-  </tbody>
-</table>
-
-<h2 id="Browser_Compatibility">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.insertBefore")}}</p>
+
+```
+
+Si l'élément n'a pas de premier enfant, alors `firstChild` est `null`. L'élément est toujours ajouté au parent après le dernier enfant. Comme l'élément parent n'avait pas de premier enfant, il n'avait pas non plus de dernier enfant. Par conséquent, le nouvel élément est le seul élément, après l'insertion.
+
+## Spécifications
+
+| Specification                                                                                                | Status                           | Comment                                 |
+| ------------------------------------------------------------------------------------------------------------ | -------------------------------- | --------------------------------------- |
+| {{SpecName('DOM WHATWG','#dom-node-insertbefore','Node.insertBefore')}}             | {{Spec2('DOM WHATWG')}} | Fixes errors in the insertion algorithm |
+| {{SpecName('DOM4','#dom-node-insertbefore','Node.insertBefore')}}                     | {{Spec2('DOM4')}}         | Describes the algorithm in more detail  |
+| {{SpecName('DOM3 Core','core.html#ID-952280727','Node.insertBefore')}}                 | {{Spec2('DOM3 Core')}}     | No notable changes                      |
+| {{SpecName('DOM2 Core','core.html#ID-952280727','Node.insertBefore')}}                 | {{Spec2('DOM2 Core')}}     | No notable changes                      |
+| {{SpecName('DOM1','level-one-core.html#method-insertBefore','Node.insertBefore')}} | {{Spec2('DOM1')}}         | Introduced                              |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.insertBefore")}}
diff --git a/files/fr/web/api/node/isconnected/index.md b/files/fr/web/api/node/isconnected/index.md
index 730afa1beb..3ffaaa50de 100644
--- a/files/fr/web/api/node/isconnected/index.md
+++ b/files/fr/web/api/node/isconnected/index.md
@@ -8,38 +8,38 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/isConnected
 ---
-<p> </p>
+{{APIRef("DOM")}}
 
-<p>{{APIRef("DOM")}}</p>
+La propriété en lecture seule **`isConnected`** de l'interface {{domxref("Node")}} renvoie un booléen indiquant si le noeud est connecté (directement ou indirectement) à l'objet contexte, par exemple l'objet {{domxref("Document")}} dans le cas d'un DOM normal  ou l'objet {{domxref("ShadowRoot")}} dans le cas du DOM shadow.
 
-<p>La propriété en lecture seule <strong><code>isConnected</code></strong> de l'interface {{domxref("Node")}} renvoie un booléen indiquant si le noeud est connecté (directement ou indirectement) à l'objet contexte, par exemple l'objet {{domxref("Document")}} dans le cas d'un DOM normal  ou l'objet {{domxref("ShadowRoot")}} dans le cas du DOM shadow.</p>
+## Syntaxe
 
-<h2 id="Syntaxe">Syntaxe</h2>
+    var isItConnected = nodeObjectInstance.isConnected
 
-<pre class="syntaxbox">var isItConnected = nodeObjectInstance.isConnected</pre>
+### Renvoie la valeur
 
-<h3 id="Renvoie_la_valeur">Renvoie la valeur</h3>
+Un {{domxref("Boolean")}} (_booléen_) — `true` (_vrai_) si le noeud est connecté à son objet contextuel pertinent et `false` (_faux_) sinon.
 
-<p>Un {{domxref("Boolean")}} (<em>booléen</em>) — <code>true</code> (<em>vrai</em>) si le noeud est connecté à son objet contextuel pertinent et <code>false</code> (<em>faux</em>) sinon.</p>
+## Exemples
 
-<h2 id="Exemples">Exemples</h2>
+Un exemple DOM standard :
 
-<p>Un exemple DOM standard :</p>
-
-<pre class="brush: js">let test = document.createElement('p');
-console.log(test.isConnected); // renvoie false (<em>faux</em>)
+```js
+let test = document.createElement('p');
+console.log(test.isConnected); // renvoie false (faux)
 document.body.appendChild(test);
-console.log(test.isConnected); // renvoie true (<em>vrai</em>)
-</pre>
+console.log(test.isConnected); // renvoie true (vrai)
+```
 
-<p>Un exemple DOM shadow :</p>
+Un exemple DOM shadow :
 
-<pre class="brush: js">// Crée une racine shadow
+```js
+// Crée une racine shadow
 var shadow = this.attachShadow({mode: 'open'});
 
 // Crée du CSS à appliquer au dom shadow
 var style = document.createElement('style');
-console.log(style.isConnected); // renvoie false (<em>faux</em>)
+console.log(style.isConnected); // renvoie false (faux)
 
 style.textContent = '.wrapper {' +
                        'position: relative;' +
@@ -64,33 +64,17 @@ style.textContent = '.wrapper {' +
 // attache l'élément de style créé au dom shadow
 
 shadow.appendChild(style);
-console.log(style.isConnected); // renvoie true (<em>vrai</em>)</pre>
-
-<p> </p>
+console.log(style.isConnected); // renvoie true (vrai)
+```
 
-<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">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG','#dom-node-isconnected','isConnected')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
-<div>
-<div>
+| Spécification                                                                        | Statut                           | Commentaire          |
+| ------------------------------------------------------------------------------------ | -------------------------------- | -------------------- |
+| {{SpecName('DOM WHATWG','#dom-node-isconnected','isConnected')}} | {{Spec2('DOM WHATWG')}} | Définition initiale. |
 
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.Node.isConnected")}}</p>
-</div>
-</div>
+{{Compat("api.Node.isConnected")}}
diff --git a/files/fr/web/api/node/isdefaultnamespace/index.md b/files/fr/web/api/node/isdefaultnamespace/index.md
index 1ea4b789bf..4e1fe3058e 100644
--- a/files/fr/web/api/node/isdefaultnamespace/index.md
+++ b/files/fr/web/api/node/isdefaultnamespace/index.md
@@ -8,32 +8,27 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/isDefaultNamespace
 ---
-<div>
-<div>{{APIRef("DOM")}}</div>
-</div>
+{{APIRef("DOM")}}
 
-<p>La méthode <strong><code>Node.isDefaultNamespace()</code></strong> accepte un URI d'espace de nom comme argument et renvoie un {{jsxref("Boolean")}} (booléen) avec une valeur <code>true</code> (<em>vrai</em>) si l'espace de nom est celui par défaut du noeud donné ou <code>false</code> (<em>faux</em>) sinon.</p>
+La méthode **`Node.isDefaultNamespace()`** accepte un URI d'espace de nom comme argument et renvoie un {{jsxref("Boolean")}} (booléen) avec une valeur `true` (_vrai_) si l'espace de nom est celui par défaut du noeud donné ou `false` (_faux_) sinon.
 
-<h2 id="Syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>result</em> = <em>node</em>.isDefaultNamespace(<em>namespaceURI</em>)
-</pre>
+    result = node.isDefaultNamespace(namespaceURI)
 
-<ul>
- <li><code>result</code> détient la valeur de retour <code>true</code> (<em>vrai</em>) ou <code>false</code> (<em>faux</em>).</li>
- <li><code>namespaceURI</code> est une <code>string</code> (<em>chaîne de caractères</em>) représentant l'espace de nom par rapport auquel l'élément sera vérifié.</li>
-</ul>
+- `result` détient la valeur de retour `true` (_vrai_) ou `false` (_faux_).
+- `namespaceURI` est une `string` (_chaîne de caractères_) représentant l'espace de nom par rapport auquel l'élément sera vérifié.
 
-<h2 id="Example">Exemple</h2>
+## Exemple
 
-<pre class="brush:js">var XULNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+```js
+var XULNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
 var el = document.getElementsByTagNameNS(XULNS, 'textbox')[0];
 
-alert(el.isDefaultNamespace(XULNS)); // true</pre>
+alert(el.isDefaultNamespace(XULNS)); // true
+```
 
-<h2 id="Specification">Spécification</h2>
+## Spécification
 
-<ul>
- <li><a href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-isDefaultNamespace">DOM Level 3 Core: isDefaultNamespace</a></li>
- <li><a href="/en-US/docs/Code_snippets/IsDefaultNamespace">Code snippets: isDefaultNamespace</a></li>
-</ul>
+- [DOM Level 3 Core: isDefaultNamespace](http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-isDefaultNamespace)
+- [Code snippets: isDefaultNamespace](/en-US/docs/Code_snippets/IsDefaultNamespace)
diff --git a/files/fr/web/api/node/isequalnode/index.md b/files/fr/web/api/node/isequalnode/index.md
index 79bcb16b17..e86aa2118c 100644
--- a/files/fr/web/api/node/isequalnode/index.md
+++ b/files/fr/web/api/node/isequalnode/index.md
@@ -9,82 +9,68 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/isEqualNode
 ---
-<div>
-<div>{{APIRef("DOM")}}</div>
-</div>
+{{APIRef("DOM")}}
 
-<p>La méthode <code><strong>Node.isEqualNode()</strong></code> permet de tester l'égalité entre deux éléments du DOM. Deux noeuds sont équivalents s'ils ont le même type, les mêmes caractéristiques de définition (ID, nombre d'enfants et autres), des attributs qui correspondent etc. L'ensemble spécifique de points des données qui doit correspondre varie en fonction des types de nœuds.</p>
+La méthode **`Node.isEqualNode()`** permet de tester l'égalité entre deux éléments du DOM. Deux noeuds sont équivalents s'ils ont le même type, les mêmes caractéristiques de définition (ID, nombre d'enfants et autres), des attributs qui correspondent etc. L'ensemble spécifique de points des données qui doit correspondre varie en fonction des types de nœuds.
 
-<h2 id="Syntax">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>isEqualNode</var> = <var>node</var>.isEqualNode(<var>otherNode</var>);
-</pre>
+    var isEqualNode = node.isEqualNode(otherNode);
 
-<ul>
- <li><code>otherNode</code> : Le noeud à comparer.</li>
-</ul>
+- `otherNode` : Le noeud à comparer.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<p>Dans cet exemple, nous créons trois blocs {{HTMLElement("div")}}. Le premier et le troisième ont les mêmes contenus et attributs, alors que le second est différent. Alors, nous éxécutons du JavaScript pour comparer les noeuds en utilisant <code>isEqualNode()</code> et sortons les résultats.</p>
+Dans cet exemple, nous créons trois blocs {{HTMLElement("div")}}. Le premier et le troisième ont les mêmes contenus et attributs, alors que le second est différent. Alors, nous éxécutons du JavaScript pour comparer les noeuds en utilisant `isEqualNode()` et sortons les résultats.
 
-<h3 id="HTML">HTML</h3>
+### HTML
 
-<pre class="brush: html">&lt;div&gt;This is the first element.&lt;/div&gt;
-&lt;div&gt;This is the second element.&lt;/div&gt;
-&lt;div&gt;This is the first element.&lt;/div&gt;
+```html
+<div>This is the first element.</div>
+<div>This is the second element.</div>
+<div>This is the first element.</div>
 
-&lt;p id="output"&gt;&lt;/p&gt;</pre>
+<p id="output"></p>
+```
 
-<h3 id="Specification">CSS</h3>
+### CSS
 
-<pre class="brush: css">#output {
+```css
+#output {
   width: 440px;
   border: 2px solid black;
   border-radius: 5px;
   padding: 10px;
   margin-top: 20px;
   display: block;
-}</pre>
+}
+```
 
-<h3 id="JavaScript">JavaScript</h3>
+### JavaScript
 
-<pre class="brush: js">let output = document.getElementById("output");
+```js
+let output = document.getElementById("output");
 let divList  = document.getElementsByTagName("div");
 
-output.innerHTML += "div 0 equals div 0: " + divList[0].isEqualNode(divList[0]) + "&lt;br/&gt;";
-output.innerHTML += "div 0 equals div 1: " + divList[0].isEqualNode(divList[1]) + "&lt;br/&gt;";
-output.innerHTML += "div 0 equals div 2: " + divList[0].isEqualNode(divList[2]) + "&lt;br/&gt;";</pre>
+output.innerHTML += "div 0 equals div 0: " + divList[0].isEqualNode(divList[0]) + "<br/>";
+output.innerHTML += "div 0 equals div 1: " + divList[0].isEqualNode(divList[1]) + "<br/>";
+output.innerHTML += "div 0 equals div 2: " + divList[0].isEqualNode(divList[2]) + "<br/>";
+```
 
-<h3 id="Résultats">Résultats</h3>
+### Résultats
 
-<p>{{ EmbedLiveSample('Example', 480) }}</p>
+{{ EmbedLiveSample('Example', 480) }}
 
-<h2 id="Specification">Spécifications</h2>
+## Spécifications
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-isequalnode', 'Node.isEqualNode')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                    | Statut                           | Commentaire |
+| ------------------------------------------------------------------------------------------------ | -------------------------------- | ----------- |
+| {{SpecName('DOM WHATWG', '#dom-node-isequalnode', 'Node.isEqualNode')}} | {{Spec2('DOM WHATWG')}} |             |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.Node.isEqualNode")}}</p>
+{{Compat("api.Node.isEqualNode")}}
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("Node.isSameNode()")}}</li>
-</ul>
+- {{domxref("Node.isSameNode()")}}
diff --git a/files/fr/web/api/node/issamenode/index.md b/files/fr/web/api/node/issamenode/index.md
index cab5401b56..682d50b9e7 100644
--- a/files/fr/web/api/node/issamenode/index.md
+++ b/files/fr/web/api/node/issamenode/index.md
@@ -8,86 +8,69 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/isSameNode
 ---
-<div>{{APIRef("DOM")}}</div>
+{{APIRef("DOM")}}
 
-<p>La méthode <code><strong>Node.isSameNode()</strong></code> teste si deux noeuds sont identiques, c'est-à-dire, s'ils font référence au même objet.</p>
+La méthode **`Node.isSameNode()`** teste si deux noeuds sont identiques, c'est-à-dire, s'ils font référence au même objet.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <em>isSameNode</em> = <em>node</em>.isSameNode(<em>other</em>);
-</pre>
+    var isSameNode = node.isSameNode(other);
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<ul>
- <li><code>other</code> Le {{domxref("Node")}} à tester.</li>
-</ul>
+- `other` Le {{domxref("Node")}} à tester.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<p>Dans cet exemple, nous créons 3 blocs {{HTMLElement("div")}}. Le premier et le troisième ont les mêmes contenus et attributs, alors que le second est différent. Ensuite, nous exécutons du JavaScript pour comparer les nœuds en utilisant <code>isSameNode()</code> et sortons les résultats.</p>
+Dans cet exemple, nous créons 3 blocs {{HTMLElement("div")}}. Le premier et le troisième ont les mêmes contenus et attributs, alors que le second est différent. Ensuite, nous exécutons du JavaScript pour comparer les nœuds en utilisant `isSameNode()` et sortons les résultats.
 
-<h3 id="HTML">HTML</h3>
+### HTML
 
-<pre class="brush: html">&lt;div&gt;This is the first element.&lt;/div&gt;
-&lt;div&gt;This is the second element.&lt;/div&gt;
-&lt;div&gt;This is the first element.&lt;/div&gt;
+```html
+<div>This is the first element.</div>
+<div>This is the second element.</div>
+<div>This is the first element.</div>
 
-&lt;p id="output"&gt;&lt;/p&gt;</pre>
+<p id="output"></p>
+```
 
-<pre class="brush: css hidden">#output {
+```css hidden
+#output {
   width: 440px;
   border: 2px solid black;
   border-radius: 5px;
   padding: 10px;
   margin-top: 20px;
   display: block;
-}</pre>
+}
+```
 
-<h3 id="JavaScript">JavaScript</h3>
+### JavaScript
 
-<pre class="brush: js">let output = document.getElementById("output");
+```js
+let output = document.getElementById("output");
 let divList  = document.getElementsByTagName("div");
 
-output.innerHTML += "div 0 same as div 0: " + divList[0].isSameNode(divList[0]) + "&lt;br/&gt;";
-output.innerHTML += "div 0 same as div 1: " + divList[0].isSameNode(divList[1]) + "&lt;br/&gt;";
-output.innerHTML += "div 0 same as div 2: " + divList[0].isSameNode(divList[2]) + "&lt;br/&gt;";
-</pre>
-
-<h3 id="Résultats">Résultats</h3>
-
-<p>{{ EmbedLiveSample('Example', 480) }}</p>
-
-<h2 id="Spécifications">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#interface-node', 'Node')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Pas de changement (a été longtemps retiré).</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#Node3-isSameNode', 'Node.isSameNode()')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.isSameNode")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("Node.isEqualNode()")}}</li>
-</ul>
+output.innerHTML += "div 0 same as div 0: " + divList[0].isSameNode(divList[0]) + "<br/>";
+output.innerHTML += "div 0 same as div 1: " + divList[0].isSameNode(divList[1]) + "<br/>";
+output.innerHTML += "div 0 same as div 2: " + divList[0].isSameNode(divList[2]) + "<br/>";
+```
+
+### Résultats
+
+{{ EmbedLiveSample('Example', 480) }}
+
+## Spécifications
+
+| Spécification                                                                                        | Statut                           | Commentaire                                 |
+| ---------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------------------------- |
+| {{SpecName('DOM WHATWG', '#interface-node', 'Node')}}                             | {{Spec2('DOM WHATWG')}} | Pas de changement (a été longtemps retiré). |
+| {{SpecName('DOM3 Core', 'core.html#Node3-isSameNode', 'Node.isSameNode()')}} | {{Spec2('DOM3 Core')}}     | Définition initiale                         |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.isSameNode")}}
+
+## Voir aussi
+
+- {{domxref("Node.isEqualNode()")}}
diff --git a/files/fr/web/api/node/issupported/index.md b/files/fr/web/api/node/issupported/index.md
index 3c241d4656..d59dab5a7b 100644
--- a/files/fr/web/api/node/issupported/index.md
+++ b/files/fr/web/api/node/issupported/index.md
@@ -8,71 +8,48 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/isSupported
 ---
-<p>{{APIRef("DOM")}}{{obsolete_header}}</p>
+{{APIRef("DOM")}}{{obsolete_header}}
 
-<p>La méthode <code><strong>Node.isSupported()</strong></code> renvoie une marque  {{domxref("Boolean","booléenne")}} contenant le résultat du test par lequel est vérifié si une implémentation DOM prend en charge une fonctionnalité spécifique et si celle-ci est supportée par un noeud spécifique.</p>
+La méthode **`Node.isSupported()`** renvoie une marque  {{domxref("Boolean","booléenne")}} contenant le résultat du test par lequel est vérifié si une implémentation DOM prend en charge une fonctionnalité spécifique et si celle-ci est supportée par un noeud spécifique.
 
-<h3 id="Syntaxe">Syntaxe</h3>
+### Syntaxe
 
-<pre class="syntaxbox"><em>boolValue</em> = <em>element</em>.isSupported(<em>feature</em>, <em>version</em>)</pre>
+    boolValue = element.isSupported(feature, version)
 
-<h3 id="Paramètres">Paramètres</h3>
+### Paramètres
 
-<dl>
- <dt><code>feature</code></dt>
- <dd>est une  {{domxref("DOMString")}} (<em>chaîne de caractères</em>) contenant le nom de la fonctionnalité à tester. C'est le même nom qui peut être passé à la méthode <code>hasFeature</code> de <a href="/fr/docs/Web/API/Document/implementation">DOMImplementation</a>. Les valeurs possibles définies dans la spécification DOM core sont listées dans la section <a href="http://www.w3.org/TR/DOM-Level-2-Core/introduction.html#ID-Conformance">Conformance</a> de DOM Level 2.</dd>
- <dt><code>version</code></dt>
- <dd>est une  {{domxref("DOMString")}} (<em>chaîne de caractères</em>) contenant le numéro de version de la fonctionnalité à tester. En DOM Level 2, première version, il s'agit de la chaîne « <code>2.0</code> ». Si la version n'est pas spécifiée, la gestion de n'importe quelle version de la fonctionnalité suffira pour que soit renvoyée la valeur <code>true</code>.</dd>
-</dl>
+- `feature`
+  - : est une  {{domxref("DOMString")}} (_chaîne de caractères_) contenant le nom de la fonctionnalité à tester. C'est le même nom qui peut être passé à la méthode `hasFeature` de [DOMImplementation](/fr/docs/Web/API/Document/implementation). Les valeurs possibles définies dans la spécification DOM core sont listées dans la section [Conformance](http://www.w3.org/TR/DOM-Level-2-Core/introduction.html#ID-Conformance) de DOM Level 2.
+- `version`
+  - : est une  {{domxref("DOMString")}} (_chaîne de caractères_) contenant le numéro de version de la fonctionnalité à tester. En DOM Level 2, première version, il s'agit de la chaîne « `2.0` ». Si la version n'est pas spécifiée, la gestion de n'importe quelle version de la fonctionnalité suffira pour que soit renvoyée la valeur `true`.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush: html">&lt;div id="doc"&gt;
-&lt;/div&gt;
+```html
+<div id="doc">
+</div>
 
-&lt;script&gt;
+<script>
  // Obtenir un élément et vérifier pour voir s'il est pris en charge par les modules HTML DOM2.
  var main = document.getElementById('doc');
  var output = main.isSupported('HTML', '2.0');
-&lt;/script&gt;</pre>
-
-<h2 id="Sp.C3.A9cification">Spécifications</h2>
-
-<p> </p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#interface-node', 'Node')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Supprimée de la spécification</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#Level-2-Core-Node-supports', 'Node.isSupported()')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Pas de changement de {{SpecName('DOM2 Core')}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#Level-2-Core-Node-supports', 'Node.isSupported()')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.isSupported")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li>L'interface {{domxref("Node")}} à laquelle elle appartient.</li>
-</ul>
+</script>
+```
+
+## Spécifications
+
+
+
+| Spécification                                                                                                        | Statut                           | Commentaire                                            |
+| -------------------------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------------------------------------ |
+| {{SpecName('DOM WHATWG', '#interface-node', 'Node')}}                                             | {{Spec2('DOM WHATWG')}} | Supprimée de la spécification                          |
+| {{SpecName('DOM3 Core', 'core.html#Level-2-Core-Node-supports', 'Node.isSupported()')}} | {{Spec2('DOM3 Core')}}     | Pas de changement de {{SpecName('DOM2 Core')}}. |
+| {{SpecName('DOM2 Core', 'core.html#Level-2-Core-Node-supports', 'Node.isSupported()')}} | {{Spec2('DOM2 Core')}}     | Définition initiale.                                   |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.isSupported")}}
+
+## Voir aussi
+
+- L'interface {{domxref("Node")}} à laquelle elle appartient.
diff --git a/files/fr/web/api/node/lastchild/index.md b/files/fr/web/api/node/lastchild/index.md
index 37963f8473..a44709a33d 100644
--- a/files/fr/web/api/node/lastchild/index.md
+++ b/files/fr/web/api/node/lastchild/index.md
@@ -9,58 +9,34 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/lastChild
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule<strong> </strong><code><strong>Node.lastChild</strong></code> renvoie le dernier enfant du noeud. Si son parent est un élément, l'enfant est généralement un noeud élément, texte ou commentaire. Elle renvoie <code>null</code> s'il n'y a aucun enfant.</p>
+La propriété en lecture seule** \*\***`Node.lastChild`\*\* renvoie le dernier enfant du noeud. Si son parent est un élément, l'enfant est généralement un noeud élément, texte ou commentaire. Elle renvoie `null` s'il n'y a aucun enfant.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <var>childNode</var> = <var>node</var>.lastChild;
-</pre>
+    var childNode = node.lastChild;
 
-<p> </p>
 
-<h2 id="Exemple">Exemple</h2>
 
-<p> </p>
+## Exemple
 
-<pre class="brush: js">var tr = document.getElementById("row1");
-var corner_td = tr.lastChild;</pre>
 
-<h2 id="Spécification">Spécification</h2>
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-lastchild', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-61AD09FB', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-61AD09FB', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-61AD09FB', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Définition initiale</td>
-  </tr>
- </tbody>
-</table>
+```js
+var tr = document.getElementById("row1");
+var corner_td = tr.lastChild;
+```
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécification
 
-<p>{{Compat("api.Node.lastChild")}}</p>
\ No newline at end of file
+| Spécification                                                                                    | Statut                           | Commentaire         |
+| ------------------------------------------------------------------------------------------------ | -------------------------------- | ------------------- |
+| {{SpecName('DOM WHATWG', '#dom-node-lastchild', 'Node.lastChild')}}         | {{Spec2('DOM WHATWG')}} | Pas de changement   |
+| {{SpecName('DOM3 Core', 'core.html#ID-61AD09FB', 'Node.lastChild')}}     | {{Spec2('DOM3 Core')}}     | Pas de changement   |
+| {{SpecName('DOM2 Core', 'core.html#ID-61AD09FB', 'Node.lastChild')}}     | {{Spec2('DOM2 Core')}}     | Pas de changement   |
+| {{SpecName('DOM1', 'level-one-core.html#ID-61AD09FB', 'Node.lastChild')}} | {{Spec2('DOM1')}}         | Définition initiale |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.lastChild")}}
diff --git a/files/fr/web/api/node/lookupnamespaceuri/index.md b/files/fr/web/api/node/lookupnamespaceuri/index.md
index 1c88e6b8a2..d97ba7c2ea 100644
--- a/files/fr/web/api/node/lookupnamespaceuri/index.md
+++ b/files/fr/web/api/node/lookupnamespaceuri/index.md
@@ -8,16 +8,12 @@ tags:
   - Noeuds
 translation_of: Web/API/Node/lookupNamespaceURI
 ---
-<div>{{APIRef("DOM")}}</div>
+{{APIRef("DOM")}}
 
-<p>La méthode <code><strong>Node.lookupNamespaceURI()</strong></code> accepte un préfixe et renvoie l'URI de l'espace de nom associé avec lui sur le noeud donné s'il le trouve (et <code>null</code> sinon). La fourniture de <code>null</code> pour le préfixe renverra l'espace de nom par défaut.</p>
+La méthode **`Node.lookupNamespaceURI()`** accepte un préfixe et renvoie l'URI de l'espace de nom associé avec lui sur le noeud donné s'il le trouve (et `null` sinon). La fourniture de `null` pour le préfixe renverra l'espace de nom par défaut.
 
-<p>Du fait du <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=312019">bug 312019</a>, cette méthode ne fonctionne pas avec les espaces de noms attribués dynamiquement (c'est-à-dire ceux qui sont définis par <a href="/en/DOM/Node.prefix">Node.prefix</a>).</p>
+Du fait du [bug 312019](https://bugzilla.mozilla.org/show_bug.cgi?id=312019), cette méthode ne fonctionne pas avec les espaces de noms attribués dynamiquement (c'est-à-dire ceux qui sont définis par [Node.prefix](/en/DOM/Node.prefix)).
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespaceURI">http://www.w3.org/TR/DOM-Level-3-Cor...upNamespaceURI</a></li>
-</ul>
-
-<p> </p>
+- [http://www.w3.org/TR/DOM-Level-3-Cor...upNamespaceURI](http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespaceURI)
diff --git a/files/fr/web/api/node/lookupprefix/index.md b/files/fr/web/api/node/lookupprefix/index.md
index 17cc48c622..a7a28baee5 100644
--- a/files/fr/web/api/node/lookupprefix/index.md
+++ b/files/fr/web/api/node/lookupprefix/index.md
@@ -10,14 +10,12 @@ tags:
   - URI
 translation_of: Web/API/Node/lookupPrefix
 ---
-<div>{{APIRef("DOM")}}</div>
+{{APIRef("DOM")}}
 
-<p>La méthode <code><strong>Node.lookupPrefix()</strong></code> renvoie une {{domxref("DOMString")}} (<em>chaîne de caractères</em>) contenant le préfixe d'un URI d'un espace de nom donné, s'il est présent, et <code>null</code> sinon. Quand plusieurs préfixes sont possibles, le résultat dépend de l'implémentation.</p>
+La méthode **`Node.lookupPrefix()`** renvoie une {{domxref("DOMString")}} (_chaîne de caractères_) contenant le préfixe d'un URI d'un espace de nom donné, s'il est présent, et `null` sinon. Quand plusieurs préfixes sont possibles, le résultat dépend de l'implémentation.
 
-<p>En raison du <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=312019">bug 312019</a>, cette méthode ne fonctionne plus avec les espaces de nom définis dynamiquement, c'est-à-dire ceux qui sont fixés avec la propriété {{domxref("Node.prefix")}}.</p>
+En raison du [bug 312019](https://bugzilla.mozilla.org/show_bug.cgi?id=312019), cette méthode ne fonctionne plus avec les espaces de nom définis dynamiquement, c'est-à-dire ceux qui sont fixés avec la propriété {{domxref("Node.prefix")}}.
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li><a href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix">http://www.w3.org/TR/DOM-Level-3-Cor...amespacePrefix</a></li>
-</ul>
+- [http://www.w3.org/TR/DOM-Level-3-Cor...amespacePrefix](http://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix)
diff --git a/files/fr/web/api/node/nextsibling/index.md b/files/fr/web/api/node/nextsibling/index.md
index 2a971a3067..19e0ddb762 100644
--- a/files/fr/web/api/node/nextsibling/index.md
+++ b/files/fr/web/api/node/nextsibling/index.md
@@ -8,34 +8,34 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/nextSibling
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule  <code><strong>Node.nextSibling</strong></code> renvoie le nœud (<code>node</code>) suivant immédiatement le nœud spécifié dans la liste des enfants ( {{domxref("Node.childNodes","childNodes")}}) de son nœud parent, ou <code>null</code> si le nœud spécifié est le dernier dans cette liste.</p>
+La propriété en lecture seule  **`Node.nextSibling`** renvoie le nœud (`node`) suivant immédiatement le nœud spécifié dans la liste des enfants ( {{domxref("Node.childNodes","childNodes")}}) de son nœud parent, ou `null` si le nœud spécifié est le dernier dans cette liste.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>nextNode</var> = <var>node</var>.nextSibling
-</pre>
+    nextNode = node.nextSibling
 
-<h2 id="Notes">Notes</h2>
+## Notes
 
-<p></p><p>Les navigateurs basés sur Gecko insèrent des nœuds texte dans un document pour représenter des espaces
-    vides dans le balisage source. Par conséquent, un nœud obtenu par exemple via <a href="/fr/docs/Web/API/Node/firstChild"><code>Node.firstChild</code></a> ou
-    <a href="/fr/docs/Web/API/Node/previousSibling" title='{{APIRef("DOM")}}'><code>Node.previousSibling</code></a> peut faire référence à un nœud texte contenant des espaces plutôt qu'au véritable élément
-    que l'auteur comptait obtenir.</p>
+Les navigateurs basés sur Gecko insèrent des nœuds texte dans un document pour représenter des espaces
+vides dans le balisage source. Par conséquent, un nœud obtenu par exemple via [`Node.firstChild`](/fr/docs/Web/API/Node/firstChild) ou
+[`Node.previousSibling`](/fr/docs/Web/API/Node/previousSibling "{{APIRef("DOM")}}") peut faire référence à un nœud texte contenant des espaces plutôt qu'au véritable élément
+que l'auteur comptait obtenir.
 
-    <p>Consultez <a href="/fr/docs/Gestion_des_espaces_dans_le_DOM">Gestion des espaces dans le DOM</a>
-    et <a href="http://www.w3.org/DOM/faq.html#emptytext" rel="noopener"><i>Why are some Text nodes empty?</i>
-    dans la FAQ DOM 3 du W3C</a> pour plus d'informations.</p><p></p>
+Consultez [Gestion des espaces dans le DOM](/fr/docs/Gestion_des_espaces_dans_le_DOM)
+et [_Why are some Text nodes empty?_
+dans la FAQ DOM 3 du W3C](http://www.w3.org/DOM/faq.html#emptytext) pour plus d'informations.
 
-<p>{{domxref("Element.nextElementSibling")}} peut être utilisé pour obtenir l'élément suivant en ignorant les noeuds d'espace.</p>
+{{domxref("Element.nextElementSibling")}} peut être utilisé pour obtenir l'élément suivant en ignorant les noeuds d'espace.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush:html">&lt;div id="div-01"&gt;Here is div-01&lt;/div&gt;
-&lt;div id="div-02"&gt;Here is div-02&lt;/div&gt;
+```html
+<div id="div-01">Here is div-01</div>
+<div id="div-02">Here is div-02</div>
 
-&lt;script type="text/javascript"&gt;
+<script type="text/javascript">
 var el = document.getElementById('div-01').nextSibling,
     i = 1;
 
@@ -47,7 +47,7 @@ while (el) {
   i++;
 }
 
-&lt;/script&gt;
+</script>
 
 /**************************************************
   Ce qui suit est écrit sur la console pendant le chargement:
@@ -59,25 +59,22 @@ while (el) {
       3. #text
       4. SCRIPT
 
-**************************************************/</pre>
+**************************************************/
+```
 
-<p>Dans cet exemple, on peut voir que des nœuds <code>#text</code> sont insérés dans le DOM là où des espaces se trouvent dans le code source entre les balises (c'est-à-dire après la balise de fermeture d'un élément et avant la balise d'ouverture du suivant). Aucun espace n'est créé entre les éléments insérés par l'instruction <code>document.write</code> .</p>
+Dans cet exemple, on peut voir que des nœuds `#text` sont insérés dans le DOM là où des espaces se trouvent dans le code source entre les balises (c'est-à-dire après la balise de fermeture d'un élément et avant la balise d'ouverture du suivant). Aucun espace n'est créé entre les éléments insérés par l'instruction `document.write` .
 
-<p>L'inclusion possible de nœuds textes dans le DOM doit être prise en compte pour le parcours du DOM à l'aide de <code>nextSibling</code>. Consultez les ressources dans la section Notes .</p>
+L'inclusion possible de nœuds textes dans le DOM doit être prise en compte pour le parcours du DOM à l'aide de `nextSibling`. Consultez les ressources dans la section Notes .
 
-<h2 id="Sp.C3.A9cification">Spécification</h2>
+## Spécification
 
-<ul>
- <li><a href="http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#attribute-nextSibling">DOM Level 1 Core: nextSibling</a> <small>— <a href="http://xmlfr.org/w3c/TR/REC-DOM-Level-1/level-one-core.html#attribute-nextSibling">traduction</a> (non normative)</small></li>
- <li><a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-6AC54C2F">DOM Level 2 Core: nextSibling</a> <small>— <a href="http://www.yoyodesign.org/doc/w3c/dom2/core/core.html#ID-6AC54C2F">traduction</a> (non normative)</small></li>
-</ul>
+- [DOM Level 1 Core: nextSibling](http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#attribute-nextSibling) — [traduction](http://xmlfr.org/w3c/TR/REC-DOM-Level-1/level-one-core.html#attribute-nextSibling) (non normative)
+- [DOM Level 2 Core: nextSibling](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-6AC54C2F) — [traduction](http://www.yoyodesign.org/doc/w3c/dom2/core/core.html#ID-6AC54C2F) (non normative)
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
+{{Compat("api.Node.nextSibling")}}
 
+## Voir aussi
 
-<p>{{Compat("api.Node.nextSibling")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<p>{{domxref("Element.nextElementSibling")}}</p>
+{{domxref("Element.nextElementSibling")}}
diff --git a/files/fr/web/api/node/nodename/index.md b/files/fr/web/api/node/nodename/index.md
index 11c471fff1..ef15c51fc1 100644
--- a/files/fr/web/api/node/nodename/index.md
+++ b/files/fr/web/api/node/nodename/index.md
@@ -9,103 +9,54 @@ tags:
   - Propriété
 translation_of: Web/API/Node/nodeName
 ---
-<p>{{APIRef("DOM")}}</p>
-
-<p>La propriété en lecture seule <code><strong>Node.nodeName</strong></code> renvoie le nom du nœud courant dans une chaîne.</p>
-
-<p>Les valeurs retournées pour les différents types de noeuds sont :</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Interface</th>
-   <th>Valeur nodeName</th>
-  </tr>
-  <tr>
-   <td>{{domxref("Attr")}}</td>
-   <td>La valeur de {{domxref("Attr.name")}}</td>
-  </tr>
-  <tr>
-   <td>{{domxref("CDATASection")}}</td>
-   <td><code>"#cdata-section"</code></td>
-  </tr>
-  <tr>
-   <td>{{domxref("Comment")}}</td>
-   <td><code>"#comment"</code></td>
-  </tr>
-  <tr>
-   <td>{{domxref("Document")}}</td>
-   <td><code>"#document"</code></td>
-  </tr>
-  <tr>
-   <td>{{domxref("DocumentFragment")}}</td>
-   <td><code>"#document-fragment"</code></td>
-  </tr>
-  <tr>
-   <td>{{domxref("DocumentType")}}</td>
-   <td>La valeur de {{domxref("DocumentType.name")}}</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Element")}}</td>
-   <td>La valeur de {{domxref("Element.tagName")}}</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Entity")}}</td>
-   <td>Le nom de l'entité</td>
-  </tr>
-  <tr>
-   <td>{{domxref("EntityReference")}}</td>
-   <td>Le nom de la référence d'entité</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Notation")}}</td>
-   <td>Le nom de notation</td>
-  </tr>
-  <tr>
-   <td>{{domxref("ProcessingInstruction")}}</td>
-   <td>La valeur de {{domxref("ProcessingInstruction.target")}}</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Text")}}</td>
-   <td><code>"#text"</code></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox">var <em>str</em> = <em>node</em>.nodeName;
-</pre>
-
-<h2 id="Exemple">Exemple</h2>
-
-<p>Avec le balisage suivant :</p>
-
-<pre>&lt;div id="d1"&gt;hello world&lt;/div&gt;
-&lt;input type="text" id="t"/&gt;
-</pre>
-
-<p>et le script suivant :</p>
-
-<pre>var div1 = document.getElementById("d1");
-var text_field = document.getElementById("t");
-text_field.value = div1.nodeName;
-</pre>
-
-<p>En XHTML (ou tout autre format XML), la valeur de <code>text_field</code> sera « div ». Cependant, en HTML, la valeur de <code>text_field</code> sera « DIV », parce que <code>nodeName</code> et <code>tagName</code> renvoient en casse majuscule sur les éléments HTML dans les DOM marqués comme des documents HTML. En lire plus <a href="http://ejohn.org/blog/nodename-case-sensitivity/">détails sur la sensibilité à la casse de nodeName dans différents navigateurs</a> (en).</p>
-
-<p>Notez que la propriété <code><a href="fr/DOM/element.tagName">tagName</a></code> aurait pu être uilisée à la place, puisque <code>nodeName</code> a la même valeur que <code>tagName</code> pour un élément. Souvenez vous cependant que <code>nodeName</code> renverra <code>#text</code> pour les nœuds texte tandis que <code>tagName</code> renverra <code>undefined</code>.</p>
-
-<h2 id="Sp.C3.A9cification">Spécification</h2>
-
-<ul>
- <li><a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-F68D095">DOM Level 2 Core: Node.nodeName</a> <small>— <a href="http://www.yoyodesign.org/doc/w3c/dom2-core/core.html#ID-F68D095">traduction</a> (non normative)</small></li>
- <li><a href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-F68D095">DOM Level 3 Core: Node.nodeName</a></li>
- <li><a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/dom.html#apis-in-html-documents">HTML 5: APIs in HTML documents</a></li>
-</ul>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-
-
-<p>{{Compat("api.Node.nodeName")}}</p>
+{{APIRef("DOM")}}
+
+La propriété en lecture seule **`Node.nodeName`** renvoie le nom du nœud courant dans une chaîne.
+
+Les valeurs retournées pour les différents types de noeuds sont :
+
+| Interface                                        | Valeur nodeName                                                       |
+| ------------------------------------------------ | --------------------------------------------------------------------- |
+| {{domxref("Attr")}}                         | La valeur de {{domxref("Attr.name")}}                         |
+| {{domxref("CDATASection")}}             | `"#cdata-section"`                                                    |
+| {{domxref("Comment")}}                     | `"#comment"`                                                          |
+| {{domxref("Document")}}                 | `"#document"`                                                         |
+| {{domxref("DocumentFragment")}}         | `"#document-fragment"`                                                |
+| {{domxref("DocumentType")}}             | La valeur de {{domxref("DocumentType.name")}}             |
+| {{domxref("Element")}}                     | La valeur de {{domxref("Element.tagName")}}                 |
+| {{domxref("Entity")}}                     | Le nom de l'entité                                                    |
+| {{domxref("EntityReference")}}         | Le nom de la référence d'entité                                       |
+| {{domxref("Notation")}}                 | Le nom de notation                                                    |
+| {{domxref("ProcessingInstruction")}} | La valeur de {{domxref("ProcessingInstruction.target")}} |
+| {{domxref("Text")}}                         | `"#text"`                                                             |
+
+## Syntaxe
+
+    var str = node.nodeName;
+
+## Exemple
+
+Avec le balisage suivant :
+
+    <div id="d1">hello world</div>
+    <input type="text" id="t"/>
+
+et le script suivant :
+
+    var div1 = document.getElementById("d1");
+    var text_field = document.getElementById("t");
+    text_field.value = div1.nodeName;
+
+En XHTML (ou tout autre format XML), la valeur de `text_field` sera « div ». Cependant, en HTML, la valeur de `text_field` sera « DIV », parce que `nodeName` et `tagName` renvoient en casse majuscule sur les éléments HTML dans les DOM marqués comme des documents HTML. En lire plus [détails sur la sensibilité à la casse de nodeName dans différents navigateurs](http://ejohn.org/blog/nodename-case-sensitivity/) (en).
+
+Notez que la propriété [`tagName`](fr/DOM/element.tagName) aurait pu être uilisée à la place, puisque `nodeName` a la même valeur que `tagName` pour un élément. Souvenez vous cependant que `nodeName` renverra `#text` pour les nœuds texte tandis que `tagName` renverra `undefined`.
+
+## Spécification
+
+- [DOM Level 2 Core: Node.nodeName](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-F68D095) — [traduction](http://www.yoyodesign.org/doc/w3c/dom2-core/core.html#ID-F68D095) (non normative)
+- [DOM Level 3 Core: Node.nodeName](http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-F68D095)
+- [HTML 5: APIs in HTML documents](http://www.whatwg.org/specs/web-apps/current-work/multipage/dom.html#apis-in-html-documents)
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.nodeName")}}
diff --git a/files/fr/web/api/node/nodetype/index.md b/files/fr/web/api/node/nodetype/index.md
index 2f6cd30d79..082ae1bd03 100644
--- a/files/fr/web/api/node/nodetype/index.md
+++ b/files/fr/web/api/node/nodetype/index.md
@@ -9,172 +9,125 @@ tags:
   - Types
 translation_of: Web/API/Node/nodeType
 ---
-<div>{{APIRef("DOM")}}</div>
+{{APIRef("DOM")}}La propriété en lecture seule **`Node.nodeType`** représente le type du noeud.
 
-<div>La propriété en lecture seule <code><strong>Node.nodeType</strong></code> représente le type du noeud.</div>
+## Description
 
-<h2 id="Description">Description</h2>
+La propriété **`nodeType`** peut être utilisée pour distinguer les uns des autres les différents genres de noeuds tels que {{domxref("Element")}}, {{domxref("Text")}} et {{domxref("Comment")}} .
 
-<p>La propriété <strong><code>nodeType</code></strong> peut être utilisée pour distinguer les uns des autres les différents genres de noeuds tels que {{domxref("Element")}}, {{domxref("Text")}} et {{domxref("Comment")}} .</p>
+## Syntaxe
 
-<h2 id="Syntaxe">Syntaxe</h2>
+    Type = node .nodeType
 
-<pre class="syntaxbox"><var>Type</var> = <var>node</var> .nodeType
-</pre>
+Renvoie un entier (_integer_) qui spécifie le type du noeud ; les valeurs possibles sont listées dans {{anch("Constantes")}}.
 
-<p>Renvoie un entier (<em>integer</em>) qui spécifie le type du noeud ; les valeurs possibles sont listées dans  {{anch("Constantes")}}.</p>
+## Constantes
 
-<h2>Constantes</h2>
+### Constantes de type nœud
 
-<h3 id="Exemple">Constantes de type nœud</h3>
+| Constante                          | Valeur | Description                                                                                                              |
+| ---------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------ |
+| `Node.ELEMENT_NODE`                | `1`    | Un noeud {{domxref("Element")}}  tel que {{HTMLElement("p")}} ou {{HTMLElement("div")}}`.`           |
+| `Node.TEXT_NODE`                   | `3`    | Le {{domxref("Text")}} actuel de l'{{domxref("Element")}} ou {{domxref("Attr")}}.                        |
+| `Node.PROCESSING_INSTRUCTION_NODE` | `7`    | Une {{domxref("ProcessingInstruction")}} d'un document XML tel que la déclaration `<?xml-stylesheet ... ?>`. |
+| `Node.COMMENT_NODE`                | `8`    | Un noeud {{domxref("Comment")}}.                                                                                   |
+| `Node.DOCUMENT_NODE`               | `9`    | Un noeud {{domxref("Document")}}.                                                                               |
+| `Node.DOCUMENT_TYPE_NODE`          | `10`   | Un noeud {{domxref("DocumentType")}} c'est-à-dire `<!DOCTYPE html>` pour des documents HTML5.                   |
+| `Node.DOCUMENT_FRAGMENT_NODE`      | `11`   | Un noeud {{domxref("DocumentFragment")}}.                                                                       |
 
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Constante</th>
-   <th scope="col">Valeur</th>
-   <th scope="col">Description</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>Node.ELEMENT_NODE</code></td>
-   <td><code>1</code></td>
-   <td>Un noeud {{domxref("Element")}}  tel que {{HTMLElement("p")}} ou {{HTMLElement("div")}}<code>.</code></td>
-  </tr>
-  <tr>
-   <td><code>Node.TEXT_NODE</code></td>
-   <td><code>3</code></td>
-   <td>Le {{domxref("Text")}} actuel de l'{{domxref("Element")}} ou {{domxref("Attr")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.PROCESSING_INSTRUCTION_NODE</code></td>
-   <td><code>7</code></td>
-   <td>Une {{domxref("ProcessingInstruction")}} d'un document XML tel que la déclaration <code>&lt;?xml-stylesheet ... ?&gt;</code>.</td>
-  </tr>
-  <tr>
-   <td><code>Node.COMMENT_NODE</code></td>
-   <td><code>8</code></td>
-   <td>Un noeud {{domxref("Comment")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.DOCUMENT_NODE</code></td>
-   <td><code>9</code></td>
-   <td>Un noeud {{domxref("Document")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.DOCUMENT_TYPE_NODE</code></td>
-   <td><code>10</code></td>
-   <td>Un noeud {{domxref("DocumentType")}} c'est-à-dire <code>&lt;!DOCTYPE html&gt;</code> pour des documents HTML5.</td>
-  </tr>
-  <tr>
-   <td><code>Node.DOCUMENT_FRAGMENT_NODE</code></td>
-   <td><code>11</code></td>
-   <td>Un noeud {{domxref("DocumentFragment")}}.</td>
-  </tr>
- </tbody>
-</table>
+### Constantes de type noeud dépréciées {{deprecated_inline()}}
 
-<h3 id="Constantes_de_type_noeud_dépréciées_deprecated_inline()">Constantes de type noeud dépréciées {{deprecated_inline()}}</h3>
-
-<p>Les constantes suivantes ont été dépréciées et ne doivent plus être utilisées.</p>
+Les constantes suivantes ont été dépréciées et ne doivent plus être utilisées.
 
 <table class="standard-table">
- <tbody>
-  <tr>
-   <td>Constante</td>
-   <td>Valeur</td>
-   <td>Description</td>
-  </tr>
-  <tr>
-   <td><code>Node.ATTRIBUTE_NODE</code></td>
-   <td>2</td>
-   <td>Un {{domxref("Attr", "Attribut")}} d'un {{domxref("Element")}}. Les attributs d'élément n'implémentent plus l'interface {{domxref("Node")}} dans la spécification {{SpecName("DOM4")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.CDATA_SECTION_NODE</code></td>
-   <td><code>4</code></td>
-   <td>Une {{domxref("CDATASection")}}. Supprimée dans la spécification {{SpecName("DOM4")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.ENTITY_REFERENCE_NODE</code></td>
-   <td>5</td>
-   <td>Un noeud référence d'entité XML. Supprimé dans la spécification {{SpecName("DOM4")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.ENTITY_NODE</code></td>
-   <td>6</td>
-   <td>Un noeud <code>&lt;!ENTITY ...&gt;</code> XML. Supprimé dans la spécificatioin {{SpecName("DOM4")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.NOTATION_NODE</code></td>
-   <td>12</td>
-   <td>Un noeud <code>&lt;!NOTATION ...&gt;</code> XML. Supprimé dans la spécification {{SpecName("DOM4")}}.</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <td>Constante</td>
+      <td>Valeur</td>
+      <td>Description</td>
+    </tr>
+    <tr>
+      <td><code>Node.ATTRIBUTE_NODE</code></td>
+      <td>2</td>
+      <td>
+        Un {{domxref("Attr", "Attribut")}} d'un
+        {{domxref("Element")}}. Les attributs d'élément n'implémentent
+        plus l'interface {{domxref("Node")}} dans la spécification
+        {{SpecName("DOM4")}}.
+      </td>
+    </tr>
+    <tr>
+      <td><code>Node.CDATA_SECTION_NODE</code></td>
+      <td><code>4</code></td>
+      <td>
+        Une {{domxref("CDATASection")}}. Supprimée dans la
+        spécification {{SpecName("DOM4")}}.
+      </td>
+    </tr>
+    <tr>
+      <td><code>Node.ENTITY_REFERENCE_NODE</code></td>
+      <td>5</td>
+      <td>
+        Un noeud référence d'entité XML. Supprimé dans la spécification
+        {{SpecName("DOM4")}}.
+      </td>
+    </tr>
+    <tr>
+      <td><code>Node.ENTITY_NODE</code></td>
+      <td>6</td>
+      <td>
+        Un noeud <code>&#x3C;!ENTITY ...></code> XML. Supprimé dans la
+        spécificatioin {{SpecName("DOM4")}}.
+      </td>
+    </tr>
+    <tr>
+      <td><code>Node.NOTATION_NODE</code></td>
+      <td>12</td>
+      <td>
+        Un noeud <code>&#x3C;!NOTATION ...></code> XML. Supprimé dans la
+        spécification {{SpecName("DOM4")}}.
+      </td>
+    </tr>
+  </tbody>
 </table>
 
-<h2 id="Exemple">Exemples</h2>
+## Exemples
 
-<h3 id="Différents_types_de_noeuds">Différents types de noeuds</h3>
+### Différents types de noeuds
 
-<pre class="brush: js">document.nodeType === Node.DOCUMENT_NODE; // true (<em>vrai</em>)
-document.doctype.nodeType === Node.DOCUMENT_TYPE_NODE; // true  (<em>vrai</em>)
+```js
+document.nodeType === Node.DOCUMENT_NODE; // true (vrai)
+document.doctype.nodeType === Node.DOCUMENT_TYPE_NODE; // true  (vrai)
 
 var fragment = document.createDocumentFragment();
-fragment.nodeType === Node.DOCUMENT_FRAGMENT_NODE; // true  (<em>vrai</em>)
+fragment.nodeType === Node.DOCUMENT_FRAGMENT_NODE; // true  (vrai)
 
-<code>var p = document.createElement("p");
-p.textContent = "Once upon a time...";</code>
+var p = document.createElement("p");
+p.textContent = "Once upon a time...";
 
-p.nodeType === Node.ELEMENT_NODE; // true  (<em>vrai</em>)
-p.firstChild.nodeType === Node.TEXT_NODE; // true  (<em>vrai</em>)
-</pre>
+p.nodeType === Node.ELEMENT_NODE; // true  (vrai)
+p.firstChild.nodeType === Node.TEXT_NODE; // true  (vrai)
+```
 
-<h3 id="Commentaires">Commentaires</h3>
+### Commentaires
 
-<p>Cet exemple vérifie si le premier noeud dans l'élément du document est un noeud commentaire et si ce n'est pas le cas, affiche un message.</p>
+Cet exemple vérifie si le premier noeud dans l'élément du document est un noeud commentaire et si ce n'est pas le cas, affiche un message.
 
-<pre class="brush: js">var node = document.documentElement.firstChild;
+```js
+var node = document.documentElement.firstChild;
 if (node.nodeType != Node.COMMENT_NODE)
-  console.log("You should comment your code well!");</pre>
-
-<h2 id="Sp.C3.A9cification">Spécifications</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-nodetype', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Sont dépréciés les types <code>ATTRIBUTE_NODE, CDATA_SECTION_NODE, ENTITY_REFERENCE_NODE et NOTATION_NODE</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-1950641247', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Pas de changement.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-111237558', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Pas de changement.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-111237558', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
+  console.log("You should comment your code well!");
+```
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Spécifications
 
+| Spécification                                                                                    | Statut                           | Commentaire                                                                                            |
+| ------------------------------------------------------------------------------------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| {{SpecName('DOM WHATWG', '#dom-node-nodetype', 'Node.nodeType')}}         | {{Spec2('DOM WHATWG')}} | Sont dépréciés les types `ATTRIBUTE_NODE, CDATA_SECTION_NODE, ENTITY_REFERENCE_NODE et NOTATION_NODE`. |
+| {{SpecName('DOM3 Core', 'core.html#ID-1950641247', 'Node.nodeType')}}     | {{Spec2('DOM3 Core')}}     | Pas de changement.                                                                                     |
+| {{SpecName('DOM2 Core', 'core.html#ID-111237558', 'Node.nodeType')}}     | {{Spec2('DOM2 Core')}}     | Pas de changement.                                                                                     |
+| {{SpecName('DOM1', 'level-one-core.html#ID-111237558', 'Node.nodeType')}} | {{Spec2('DOM1')}}         | Définition initiale.                                                                                   |
 
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.Node.nodeType")}}</p>
+{{Compat("api.Node.nodeType")}}
diff --git a/files/fr/web/api/node/nodevalue/index.md b/files/fr/web/api/node/nodevalue/index.md
index 9f3fa1f3b3..294ed8619a 100644
--- a/files/fr/web/api/node/nodevalue/index.md
+++ b/files/fr/web/api/node/nodevalue/index.md
@@ -8,86 +8,81 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/nodeValue
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété <code><strong>Node.nodeValue</strong></code> renvoie ou définit la valeur du nœud courant.</p>
+La propriété **`Node.nodeValue`** renvoie ou définit la valeur du nœud courant.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>value</var> = <var>node</var>.nodeValue;
-</pre>
+    value = node.nodeValue;
 
-<p><code>value</code> (<em>valeur</em>) est une chaîne contenant la valeur du nœud courant, s'il y en a une.</p>
+`value` (_valeur_) est une chaîne contenant la valeur du nœud courant, s'il y en a une.
 
-<h2 id="Notes">Notes</h2>
+## Notes
 
-<p>Pour le document lui-même, <code>nodeValue</code> renvoie <code>null</code>. Pour des nœuds texte, de commentaires et CDATA, <code>nodeValue</code> renvoie le contenu du nœud. Pour les nœuds d'attributs, il s'agira de la valeur de l'attribut.</p>
+Pour le document lui-même, `nodeValue` renvoie `null`. Pour des nœuds texte, de commentaires et CDATA, `nodeValue` renvoie le contenu du nœud. Pour les nœuds d'attributs, il s'agira de la valeur de l'attribut.
 
-<p>Le tableau suivant montre les valeurs de retour pour différents types de nœuds :</p>
+Le tableau suivant montre les valeurs de retour pour différents types de nœuds :
 
 <table>
- <tbody>
-  <tr>
-   <td>Attr</td>
-   <td>valeur de l'attribut</td>
-  </tr>
-  <tr>
-   <td>CDATASection</td>
-   <td>contenu de la section CDATA</td>
-  </tr>
-  <tr>
-   <td>Comment</td>
-   <td>contenu du commentaire</td>
-  </tr>
-  <tr>
-   <td>Document</td>
-   <td><code>null</code></td>
-  </tr>
-  <tr>
-   <td>DocumentFragment</td>
-   <td><code>null</code></td>
-  </tr>
-  <tr>
-   <td>DocumentType</td>
-   <td><code>null</code></td>
-  </tr>
-  <tr>
-   <td>Element</td>
-   <td><code>null</code></td>
-  </tr>
-  <tr>
-   <td>NamedNodeMap</td>
-   <td><code>null</code></td>
-  </tr>
-  <tr>
-   <td>EntityReference</td>
-   <td><code>null</code></td>
-  </tr>
-  <tr>
-   <td>Notation</td>
-   <td><code>null</code></td>
-  </tr>
-  <tr>
-   <td>ProcessingInstruction</td>
-   <td>tout le contenu à l'exception de la cible</td>
-  </tr>
-  <tr>
-   <td>Text</td>
-   <td>contenu du nœud texte</td>
-  </tr>
- </tbody>
+  <tbody>
+    <tr>
+      <td>Attr</td>
+      <td>valeur de l'attribut</td>
+    </tr>
+    <tr>
+      <td>CDATASection</td>
+      <td>contenu de la section CDATA</td>
+    </tr>
+    <tr>
+      <td>Comment</td>
+      <td>contenu du commentaire</td>
+    </tr>
+    <tr>
+      <td>Document</td>
+      <td><code>null</code></td>
+    </tr>
+    <tr>
+      <td>DocumentFragment</td>
+      <td><code>null</code></td>
+    </tr>
+    <tr>
+      <td>DocumentType</td>
+      <td><code>null</code></td>
+    </tr>
+    <tr>
+      <td>Element</td>
+      <td><code>null</code></td>
+    </tr>
+    <tr>
+      <td>NamedNodeMap</td>
+      <td><code>null</code></td>
+    </tr>
+    <tr>
+      <td>EntityReference</td>
+      <td><code>null</code></td>
+    </tr>
+    <tr>
+      <td>Notation</td>
+      <td><code>null</code></td>
+    </tr>
+    <tr>
+      <td>ProcessingInstruction</td>
+      <td>tout le contenu à l'exception de la cible</td>
+    </tr>
+    <tr>
+      <td>Text</td>
+      <td>contenu du nœud texte</td>
+    </tr>
+  </tbody>
 </table>
 
-<p>Lorsque <code>nodeValue</code> est défini comme étant <code>null</code>, l'assignation n'a aucun effet.</p>
+Lorsque `nodeValue` est défini comme étant `null`, l'assignation n'a aucun effet.
 
-<h2 id="Sp.C3.A9cification">Spécification</h2>
+## Spécification
 
-<ul>
- <li><a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-F68D080">DOM Level 2 Core: Node.nodeValue</a>  <small>— <a href="http://www.yoyodesign.org/doc/w3c/dom2-core/core.html#ID-F68D080">traduction</a> (non normative)</small></li>
-</ul>
+- [DOM Level 2 Core: Node.nodeValue](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-F68D080) — [traduction](http://www.yoyodesign.org/doc/w3c/dom2-core/core.html#ID-F68D080) (non normative)
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-
-
-<p>{{Compat("api.Node.nodeValue")}}</p>
+{{Compat("api.Node.nodeValue")}}
diff --git a/files/fr/web/api/node/normalize/index.md b/files/fr/web/api/node/normalize/index.md
index c1a299fb15..4864a1278a 100644
--- a/files/fr/web/api/node/normalize/index.md
+++ b/files/fr/web/api/node/normalize/index.md
@@ -3,20 +3,20 @@ title: element.normalize
 slug: Web/API/Node/normalize
 translation_of: Web/API/Node/normalize
 ---
-<p>{{ ApiRef("DOM") }}</p>
+{{ ApiRef("DOM") }}
 
-<h2 id="R.C3.A9sum.C3.A9">Résumé</h2>
+## Résumé
 
-<p>Place le nœud spécifié et tout son sous-arbre dans une forme « normale ». Dans un sous-arbre normalisé, aucun nœud texte n'est vide et il n'y a pas de nœuds texte adjacents.</p>
+Place le nœud spécifié et tout son sous-arbre dans une forme « normale ». Dans un sous-arbre normalisé, aucun nœud texte n'est vide et il n'y a pas de nœuds texte adjacents.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="eval"><em>élément</em>.normalize();
-</pre>
+    élément.normalize();
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush:js">var conteneur = document.createElement("div");
+```js
+var conteneur = document.createElement("div");
 conteneur.appendChild( document.createTextNode("Partie 1 ") );
 conteneu.appendChild( document.createTextNode("Partie 2 ") );
 
@@ -27,12 +27,11 @@ conteneu.appendChild( document.createTextNode("Partie 2 ") );
 conteneur.normalize();
 
 // À présent, conteneur.childNodes.length === 1
-// conteneur.childNodes[0].textContent === "Partie 1 Partie 2 "</pre>
+// conteneur.childNodes[0].textContent === "Partie 1 Partie 2 "
+```
 
-<h2 id="Notes">Notes</h2>
+## Notes
 
-<h2 id="Sp.C3.A9cification">Spécification</h2>
+## Spécification
 
-<ul>
- <li><a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-normalize">DOM Level 2 Core: Node.normalize (en)</a> <small>— <a href="http://www.yoyodesign.org/doc/w3c/dom2-core/core.html#ID-normalize">traduction en français</a> (non normative)</small></li>
-</ul>
\ No newline at end of file
+- [DOM Level 2 Core: Node.normalize (en)](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-normalize) — [traduction en français](http://www.yoyodesign.org/doc/w3c/dom2-core/core.html#ID-normalize) (non normative)
diff --git a/files/fr/web/api/node/ownerdocument/index.md b/files/fr/web/api/node/ownerdocument/index.md
index 35b5eb6859..83c9698497 100644
--- a/files/fr/web/api/node/ownerdocument/index.md
+++ b/files/fr/web/api/node/ownerdocument/index.md
@@ -9,58 +9,37 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/ownerDocument
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule <code><strong>Node.ownerDocument</strong></code> renvoie l'objet document de niveau supérieur pour ce nœud.</p>
+La propriété en lecture seule **`Node.ownerDocument`** renvoie l'objet document de niveau supérieur pour ce nœud.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="eval"><em>document</em> = element.ownerDocument;
-</pre>
+    document = element.ownerDocument;
 
-<ul>
- <li><code>document</code> est l'objet <a href="/fr/docs/Web/API/document"><code>document</code></a> parent de l'élément courant.</li>
-</ul>
+- `document` est l'objet [`document`](/fr/docs/Web/API/document) parent de l'élément courant.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush: html">// étant donné un nœud "p", obtient le premier enfant HTML
+```html
+// étant donné un nœud "p", obtient le premier enfant HTML
 // de l'objet document
 var d = p.ownerDocument;
 var html = d.documentElement;
-</pre>
+```
 
-<h2 id="Notes">Notes</h2>
+## Notes
 
-<p>L'objet <code>document</code> renvoyé par cette propriété est l'objet principal avec lequel tous les nœuds enfants du document HTML réel sont créés. Si cette propriété est utilisée sur un nœud qui est lui-même un document, le résultat est <code>null</code>.</p>
+L'objet `document` renvoyé par cette propriété est l'objet principal avec lequel tous les nœuds enfants du document HTML réel sont créés. Si cette propriété est utilisée sur un nœud qui est lui-même un document, le résultat est `null`.
 
-<h3 id="Sp.C3.A9cification">Spécifications</h3>
+### Spécifications
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Spécification</th>
-   <th>Statut</th>
-   <th>Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName("DOM4", "#dom-node-ownerdocument", "Node.ownerDocument")}}</td>
-   <td>{{Spec2("DOM4")}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName("DOM3 Core", "core.html#node-ownerDoc", "Node.ownerDocument")}}</td>
-   <td>{{Spec2("DOM3 Core")}}</td>
-   <td>Pas de changement</td>
-  </tr>
-  <tr>
-   <td>{{SpecName("DOM2 Core", "core.html#node-ownerDoc", "Node.ownerDocument")}}</td>
-   <td>{{Spec2("DOM2 Core")}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
+| Spécification                                                                                        | Statut                       | Commentaire          |
+| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- |
+| {{SpecName("DOM4", "#dom-node-ownerdocument", "Node.ownerDocument")}}         | {{Spec2("DOM4")}}     |                      |
+| {{SpecName("DOM3 Core", "core.html#node-ownerDoc", "Node.ownerDocument")}} | {{Spec2("DOM3 Core")}} | Pas de changement    |
+| {{SpecName("DOM2 Core", "core.html#node-ownerDoc", "Node.ownerDocument")}} | {{Spec2("DOM2 Core")}} | Définition initiale. |
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.Node.ownerDocument")}}</p>
\ No newline at end of file
+{{Compat("api.Node.ownerDocument")}}
diff --git a/files/fr/web/api/node/parentelement/index.md b/files/fr/web/api/node/parentelement/index.md
index 673cb3b8b2..66d50067d3 100644
--- a/files/fr/web/api/node/parentelement/index.md
+++ b/files/fr/web/api/node/parentelement/index.md
@@ -9,45 +9,32 @@ tags:
   - parent
 translation_of: Web/API/Node/parentElement
 ---
-<div>
-<div>
-<div>{{APIRef("DOM")}}</div>
-</div>
+{{APIRef("DOM")}}La propriété en lecture seule **`Node.parentElement`** renvoie le parent du noeud DOM ({{domxref("Element")}}) ou **`null`** si ce dernier n'a pas de parent ou si le parent n'est pas un {{domxref("Element")}} du DOM.
 
-<div>La propriété en lecture seule <code><strong>Node.parentElement</strong></code> renvoie le parent du noeud DOM ({{domxref("Element")}}) ou <code><strong>null</strong></code> si ce dernier n'a pas de parent ou si le parent n'est pas un {{domxref("Element")}} du DOM.</div>
-</div>
+## Syntaxe
 
-<h2 id="Syntax">Syntaxe</h2>
+    parentElement = node.parentElement
 
-<pre class="syntaxbox"><em>parentElement</em> = <em>node</em>.parentElement
-</pre>
+**`parentElement`** référence l'élément parent d'un nœud (**`node`**). C'est toujours un objet {{domxref("Element")}} du DOM ou `null`.
 
-<p><code><strong>parentElement</strong></code> référence l'élément parent d'un nœud (<code><strong>node</strong></code>). C'est toujours un objet {{domxref("Element")}}  du DOM ou <code>null</code>.</p>
+## Exemple
 
-<h2 id="Example">Exemple</h2>
-
-<pre class="brush:js">if (node.parentElement) {
+```js
+if (node.parentElement) {
     node.parentElement.style.color = "red";
-}</pre>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-<p>Sur quelques navigateurs, la propriété <code>parentElement</code> est seulement définie sur les noeuds qui sont eux-mêmes des {{domxref("Element")}}. En particulier, elle n'est pas définie sur les noeuds texte.</p>
+}
+```
 
-<div>
+## Compatibilité des navigateurs
 
+Sur quelques navigateurs, la propriété `parentElement` est seulement définie sur les noeuds qui sont eux-mêmes des {{domxref("Element")}}. En particulier, elle n'est pas définie sur les noeuds texte.
 
-<p>{{Compat("api.Node.parentElement")}}</p>
-</div>
+{{Compat("api.Node.parentElement")}}
 
-<h2 id="Spécifications">Spécifications</h2>
+## Spécifications
 
-<ul>
- <li>{{spec("http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#parent-element", "DOM Level 4: Node.parentElement", "WD")}}</li>
-</ul>
+- {{spec("http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#parent-element", "DOM Level 4: Node.parentElement", "WD")}}
 
-<h2 id="See_also">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("Node.parentNode")}}</li>
-</ul>
+- {{domxref("Node.parentNode")}}
diff --git a/files/fr/web/api/node/parentnode/index.md b/files/fr/web/api/node/parentnode/index.md
index 5d2088cbf6..1412167bca 100644
--- a/files/fr/web/api/node/parentnode/index.md
+++ b/files/fr/web/api/node/parentnode/index.md
@@ -9,50 +9,47 @@ tags:
   - parent
 translation_of: Web/API/Node/parentNode
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule <strong>parentNode</strong> renvoie le parent du nœud spécifié dans l'arborescence de DOM .</p>
+La propriété en lecture seule **parentNode** renvoie le parent du nœud spécifié dans l'arborescence de DOM .
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>parentNode</em> = <em>node</em>.parentNode</pre>
+    parentNode = node.parentNode
 
-<p><code>parentNode</code> est l'élément parent du nœud courant. Le parent d'un élément est un nœud <code>Element</code> , un nœud <code>Document</code> ou un nœud <code>DocumentFragment</code> .</p>
+`parentNode` est l'élément parent du nœud courant. Le parent d'un élément est un nœud `Element` , un nœud `Document` ou un nœud `DocumentFragment` .
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush:js">if (node.parentNode) {
-  // supprime un noeud  de l'arbre, 
+```js
+if (node.parentNode) {
+  // supprime un noeud  de l'arbre,
   // sauf s'il a déjà été supprimé
   node.parentNode.removeChild(node);
-}</pre>
+}
+```
 
-<h2 id="Notes">Notes</h2>
+## Notes
 
-<p>Les <a href="/en-US/docs/DOM/Node.nodeType">noeuds </a><code>Document</code> et <code>DocumentFragment</code> ne peuvent jamais avoir de parent, alors  <code>parentNode</code>  retournera toujours <code>null</code> .</p>
+Les [noeuds ](/en-US/docs/DOM/Node.nodeType)`Document` et `DocumentFragment` ne peuvent jamais avoir de parent, alors  `parentNode`  retournera toujours `null` .
 
-<p> Il renvoie également <code>null</code> si le nœud vient d'être créé et n'est pas encore attaché à l'arbre.</p>
+Il renvoie également `null` si le nœud vient d'être créé et n'est pas encore attaché à l'arbre.
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
-<p>{{Compat("api.Node.parentNode")}}</p>
+{{Compat("api.Node.parentNode")}}
 
-<h2 id="Spécification">Spécification</h2>
-</div>
+## Spécification
 
-<ul>
- <li><a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-1060184317">DOM Level 2 Core: Node.parentNode</a></li>
- <li><a href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-1060184317">DOM Level 3 Core: Node.parentNode</a></li>
-</ul>
+- [DOM Level 2 Core: Node.parentNode](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-1060184317)
+- [DOM Level 3 Core: Node.parentNode](http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-1060184317)
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{Domxref("Node.firstChild")}}</li>
- <li>{{Domxref("Node.lastChild")}}</li>
- <li>{{Domxref("Node.childNodes")}}</li>
- <li>{{Domxref("Node.nextSibling")}}</li>
- <li>{{Domxref("Node.parentElement")}}</li>
- <li>{{Domxref("Node.previousSibling")}}</li>
- <li>{{Domxref("Node.removeChild")}}</li>
-</ul>
\ No newline at end of file
+- {{Domxref("Node.firstChild")}}
+- {{Domxref("Node.lastChild")}}
+- {{Domxref("Node.childNodes")}}
+- {{Domxref("Node.nextSibling")}}
+- {{Domxref("Node.parentElement")}}
+- {{Domxref("Node.previousSibling")}}
+- {{Domxref("Node.removeChild")}}
diff --git a/files/fr/web/api/node/previoussibling/index.md b/files/fr/web/api/node/previoussibling/index.md
index 31e02f5c7a..4b1e499e59 100644
--- a/files/fr/web/api/node/previoussibling/index.md
+++ b/files/fr/web/api/node/previoussibling/index.md
@@ -8,49 +8,46 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/previousSibling
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété en lecture seule  <code><strong>Node.previousSibling</strong></code> renvoie le nœud (<code>node</code>) précédant immédiatement le nœud courant dans la liste {{domxref("Node.childNodes", "childNodes")}} de son parent, ou <code>null</code> s'il s'agit du premier nœud de la liste.</p>
+La propriété en lecture seule  **`Node.previousSibling`** renvoie le nœud (`node`) précédant immédiatement le nœud courant dans la liste {{domxref("Node.childNodes", "childNodes")}} de son parent, ou `null` s'il s'agit du premier nœud de la liste.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><var>previousNode</var> = <em>node</em>.previousSibling;
-</pre>
+    previousNode = node.previousSibling;
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="brush:js">// &lt;a&gt;&lt;b1 id="b1"/&gt;&lt;b2 id="b2"/&gt;&lt;/a&gt;
+```js
+// <a><b1 id="b1"/><b2 id="b2"/></a>
 
 alert(document.getElementById("b1").previousSibling); // null
-alert(document.getElementById("b2").previousSibling.id); // "b1"</pre>
+alert(document.getElementById("b2").previousSibling.id); // "b1"
+```
 
-<h2 id="Notes">Notes</h2>
+## Notes
 
-<p></p><p>Les navigateurs basés sur Gecko insèrent des nœuds texte dans un document pour représenter des espaces
-    vides dans le balisage source. Par conséquent, un nœud obtenu par exemple via <a href="/fr/docs/Web/API/Node/firstChild"><code>Node.firstChild</code></a> ou
-    <a href="/fr/docs/Web/API/Node/previousSibling" title='{{APIRef("DOM")}}'><code>Node.previousSibling</code></a> peut faire référence à un nœud texte contenant des espaces plutôt qu'au véritable élément
-    que l'auteur comptait obtenir.</p>
+Les navigateurs basés sur Gecko insèrent des nœuds texte dans un document pour représenter des espaces
+vides dans le balisage source. Par conséquent, un nœud obtenu par exemple via [`Node.firstChild`](/fr/docs/Web/API/Node/firstChild) ou
+[`Node.previousSibling`](/fr/docs/Web/API/Node/previousSibling "{{APIRef("DOM")}}") peut faire référence à un nœud texte contenant des espaces plutôt qu'au véritable élément
+que l'auteur comptait obtenir.
 
-    <p>Consultez <a href="/fr/docs/Gestion_des_espaces_dans_le_DOM">Gestion des espaces dans le DOM</a>
-    et <a href="http://www.w3.org/DOM/faq.html#emptytext" rel="noopener"><i>Why are some Text nodes empty?</i>
-    dans la FAQ DOM 3 du W3C</a> pour plus d'informations.</p><p></p>
+Consultez [Gestion des espaces dans le DOM](/fr/docs/Gestion_des_espaces_dans_le_DOM)
+et [_Why are some Text nodes empty?_
+dans la FAQ DOM 3 du W3C](http://www.w3.org/DOM/faq.html#emptytext) pour plus d'informations.
 
-<p>L'opération inverse <code><a href="/fr/docs/Web/API/Node/nextSibling">Node.nextSibling</a></code> permet de rechercher l'élément suivant.</p>
+L'opération inverse [`Node.nextSibling`](/fr/docs/Web/API/Node/nextSibling) permet de rechercher l'élément suivant.
 
-<h2 id="Sp.C3.A9cification">Spécifications</h2>
+## Spécifications
 
-<ul>
- <li><a href="http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#attribute-previousSibling">DOM Level 1 Core: previousSibling</a> <small>— <a href="http://xmlfr.org/w3c/TR/REC-DOM-Level-1/level-one-core.html#attribute-previousSibling">traduction</a> (non normative)</small></li>
- <li><a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-640FB3C8">DOM Level 2 Core: previousSibling</a> <small>— <a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-640FB3C8">traduction</a> (non normative)</small></li>
- <li><a href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-640FB3C8">DOM Level 3 Core: previousSibling</a></li>
-</ul>
+- [DOM Level 1 Core: previousSibling](http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#attribute-previousSibling) — [traduction](http://xmlfr.org/w3c/TR/REC-DOM-Level-1/level-one-core.html#attribute-previousSibling) (non normative)
+- [DOM Level 2 Core: previousSibling](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-640FB3C8) — [traduction](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-640FB3C8) (non normative)
+- [DOM Level 3 Core: previousSibling](http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-640FB3C8)
 
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+## Compatibilité des navigateurs
 
+{{Compat("api.Node.previousSibling")}}
 
+## Voir aussi
 
-<p>{{Compat("api.Node.previousSibling")}}</p>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<p>{{domxref("Node.nextSibling")}}</p>
+{{domxref("Node.nextSibling")}}
diff --git a/files/fr/web/api/node/removechild/index.md b/files/fr/web/api/node/removechild/index.md
index 051a65c4e6..727ad635d9 100644
--- a/files/fr/web/api/node/removechild/index.md
+++ b/files/fr/web/api/node/removechild/index.md
@@ -10,57 +10,53 @@ tags:
   - Suppression
 translation_of: Web/API/Node/removeChild
 ---
-<p>{{ ApiRef("DOM") }}</p>
+{{ ApiRef("DOM") }}
 
-<p>La méthode <code><strong>Node.removeChild()</strong></code> retire un nœud enfant de l'arbre DOM et retourne le nœud retiré.</p>
+La méthode **`Node.removeChild()`** retire un nœud enfant de l'arbre DOM et retourne le nœud retiré.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>var oldChild</em> = <em>node</em>.removeChild(<em>child</em>);
-<strong>OR</strong>
-<em>node</em>.removeChild(<em>child</em>);
-</pre>
+    var oldChild = node.removeChild(child);
+    OR
+    node.removeChild(child);
 
-<ul>
- <li><code>child</code> est le nœud enfant à retirer du DOM.</li>
- <li><code>node </code>est le nœud parent de <code>child</code>.</li>
- <li><code>oldchild</code> conserve une référence au nœud enfant retiré. <code>oldchild</code> === <code>child</code>.</li>
-</ul>
+- `child` est le nœud enfant à retirer du DOM.
+- `node `est le nœud parent de `child`.
+- `oldchild` conserve une référence au nœud enfant retiré. `oldchild` === `child`.
 
-<p>Le nœud enfant retiré existe toujours en mémoire, mais ne fait plus partie du DOM. Avec la première syntaxe, il est possible de réutiliser ultérieurement dans le code le nœud retiré, à l'aide de la référence à l'objet <code>ancienEnfant</code><em>. </em></p>
+Le nœud enfant retiré existe toujours en mémoire, mais ne fait plus partie du DOM. Avec la première syntaxe, il est possible de réutiliser ultérieurement dans le code le nœud retiré, à l'aide de la référence à l'objet `ancienEnfant`_._
 
-<p>Avec la seconde forme montrée en exemple, aucune référence à l'objet <code>ancienEnfant</code> n'est conservée ; ainsi, en supposant que votre code n'a conservé nulle part ailleurs cette référence à ce nœud, il devient immédiatement inutilisable et irrécupérable, et sera en général <a href="/fr/docs/Web/JavaScript/Gestion_de_la_m%C3%A9moire">automatiquement supprimé</a> de la mémoire après un court moment.</p>
+Avec la seconde forme montrée en exemple, aucune référence à l'objet `ancienEnfant` n'est conservée ; ainsi, en supposant que votre code n'a conservé nulle part ailleurs cette référence à ce nœud, il devient immédiatement inutilisable et irrécupérable, et sera en général [automatiquement supprimé](/fr/docs/Web/JavaScript/Gestion_de_la_m%C3%A9moire) de la mémoire après un court moment.
 
-<p>Si  <code>child</code> n'est pas un enfant du noeud  <code>element</code>, la méthode provoque une exception. Une exception sera aussi lancée dans la cas où le nœud <code>enfant </code>est bien un enfant du nœud <code>element </code>au moment de l'appel à la méthode, mais qu'il a été retiré par un gestionnaire d'événement invoqué dans la cadre d'une tentative de suppression du nœud <code>element </code>(comme <em>blur</em>).</p>
+Si  `child` n'est pas un enfant du noeud  `element`, la méthode provoque une exception. Une exception sera aussi lancée dans la cas où le nœud `enfant `est bien un enfant du nœud `element `au moment de l'appel à la méthode, mais qu'il a été retiré par un gestionnaire d'événement invoqué dans la cadre d'une tentative de suppression du nœud `element `(comme *blur*).
 
-<p>La méthode peut lever une exception de deux façons :</p>
+La méthode peut lever une exception de deux façons :
 
-<ol>
- <li>Si <code>enfant</code> était bien un enfant de element et qu'il existe donc dans le DOM, mais qu'il a déjà été retiré, la méthode provoque l'exception suivante :<code>​​</code><br>
-  <code>Uncaught NotFoundError: Failed to execute 'removeChild' on 'element': The node to be removed is not a child of this node</code>.</li>
- <li>si l'<code>enfant</code> n'existe pas dans le DOM de la page, la méthode provoque l'exception suivante :<br>
-  <code>Uncaught TypeError: Failed to execute 'removeChild' on 'element': parameter 1 is not of type 'Node'.</code></li>
-</ol>
+1.  Si `enfant` était bien un enfant de element et qu'il existe donc dans le DOM, mais qu'il a déjà été retiré, la méthode provoque l'exception suivante :`​​`
+    `Uncaught NotFoundError: Failed to execute 'removeChild' on 'element': The node to be removed is not a child of this node`.
+2.  si l'`enfant` n'existe pas dans le DOM de la page, la méthode provoque l'exception suivante :
+    `Uncaught TypeError: Failed to execute 'removeChild' on 'element': parameter 1 is not of type 'Node'.`
 
-<h2 id="Exemples">Exemples</h2>
+## Exemples
 
-<pre class="brush: html">&lt;!--Sample HTML code--&gt;
-&lt;div id="top" align="center"&gt; &lt;/div&gt;
+```html
+<!--Sample HTML code-->
+<div id="top" align="center"> </div>
 
-&lt;script type="text/javascript"&gt;
+<script type="text/javascript">
       var top = document.getElementById("top");
       var nested = document.getElementById("nested");
 
       var garbage = top.removeChild(nested);    //Cas test 2: la méthode lance l'exception (2)
 
-&lt;/script&gt;
+</script>
 
-&lt;!--Sample HTML code--&gt;
-&lt;div id="top" align="center"&gt;
- &lt;div id="nested"&gt;&lt;/div&gt;
-&lt;/div&gt;
+<!--Sample HTML code-->
+<div id="top" align="center">
+ <div id="nested"></div>
+</div>
 
-&lt;script type="text/javascript"&gt;
+<script type="text/javascript">
       var top = document.getElementById("top");
       var nested = document.getElementById("nested");
 
@@ -69,44 +65,48 @@ translation_of: Web/API/Node/removeChild
       // ......
       garbage = top.removeChild(nested);   // Cas test 1 : la méthode dans le second appel ici, lance l'exception (1)
 
-&lt;/script&gt;</pre>
+</script>
+```
 
-<pre class="brush: html">&lt;!--Sample HTML code--&gt;
+```html
+<!--Sample HTML code-->
 
-&lt;div id="top" align="center"&gt;
-  &lt;div id="nested"&gt;&lt;/div&gt;
-&lt;/div&gt;</pre>
+<div id="top" align="center">
+  <div id="nested"></div>
+</div>
+```
 
-<pre class="brush:js">// Supprime un élément spécifié quand son noeud parent est connu
+```js
+// Supprime un élément spécifié quand son noeud parent est connu
 var d = document.getElementById("top");
 var d_nested = document.getElementById("nested");
-var throwawayNode = d.removeChild(d_nested);</pre>
+var throwawayNode = d.removeChild(d_nested);
+```
 
-<pre class="brush:js">// Supprime un élément spécifié sans avoir à spécifier son noeud parent
+```js
+// Supprime un élément spécifié sans avoir à spécifier son noeud parent
 var node = document.getElementById("nested");
 if (node.parentNode) {
   node.parentNode.removeChild(node);
-}</pre>
+}
+```
 
-<pre class="brush:js">
+```js
 // Supprime tous les enfant d'un élément
 var element = document.getElementById("top");
 while (element.firstChild) {
   element.removeChild(element.firstChild);
-}</pre>
+}
+```
 
-<h2 id="Sp.C3.A9cification">Spécifications</h2>
+## Spécifications
 
-<ul>
- <li><a href="http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#method-removeChild">DOM Level 1 Core: removeChild</a> — <a href="http://xmlfr.org/w3c/TR/REC-DOM-Level-1/level-one-core.html#method-removeChild">traduction en français</a> (non normative)</li>
- <li><a href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-1734834066">DOM Level 2 Core: removeChild</a> — <a href="http://www.yoyodesign.org/doc/w3c/dom2/core/core.html#ID-1734834066">traduction en français</a> (non normative)</li>
- <li><a href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-1734834066">DOM Level 3 Core: removeChild</a></li>
-</ul>
+- [DOM Level 1 Core: removeChild](http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#method-removeChild) — [traduction en français](http://xmlfr.org/w3c/TR/REC-DOM-Level-1/level-one-core.html#method-removeChild) (non normative)
+- [DOM Level 2 Core: removeChild](http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-1734834066) — [traduction en français](http://www.yoyodesign.org/doc/w3c/dom2/core/core.html#ID-1734834066) (non normative)
+- [DOM Level 3 Core: removeChild](http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-1734834066)
 
-<h2 id="Voir_aussi">Voir aussi</h2>
+## Voir aussi
 
-<ul>
- <li>{{domxref("Node.replaceChild")}}</li>
- <li>{{domxref("Node.parentNode")}}</li>
- <li>{{domxref("ChildNode.remove")}}</li>
-</ul>
+- {{domxref("Node.replaceChild")}}
+- {{domxref("Node.parentNode")}}
+- {{domxref("ChildNode.remove")}}
diff --git a/files/fr/web/api/node/replacechild/index.md b/files/fr/web/api/node/replacechild/index.md
index 3cdf5aa950..492baac6d1 100644
--- a/files/fr/web/api/node/replacechild/index.md
+++ b/files/fr/web/api/node/replacechild/index.md
@@ -10,27 +10,25 @@ tags:
   - Remplacement
 translation_of: Web/API/Node/replaceChild
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La méthode <strong><code>Node.replaceChild()</code></strong> remplace un nœud enfant du noeud spécifié par un autre nœud.</p>
+La méthode **`Node.replaceChild()`** remplace un nœud enfant du noeud spécifié par un autre nœud.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox"><em>replacedNode</em> = <em>parentNode</em>.replaceChild(<em>newChild</em>, <em>oldChild</em>);
-</pre>
+    replacedNode = parentNode.replaceChild(newChild, oldChild);
 
-<ul>
- <li><code>newChild</code> est le nouveau nœud qui remplacera <code>oldChild</code>. S'il existe déjà dans le DOM, il sera d'abord enlevé.</li>
- <li><code>oldChild</code> est le nœud existant à remplacer.</li>
- <li><code>replaceNode</code> est le nœud remplacé. C'est le même nœud que <code>oldChild</code>.</li>
-</ul>
+- `newChild` est le nouveau nœud qui remplacera `oldChild`. S'il existe déjà dans le DOM, il sera d'abord enlevé.
+- `oldChild` est le nœud existant à remplacer.
+- `replaceNode` est le nœud remplacé. C'est le même nœud que `oldChild`.
 
-<h2 id="Example">Exemple</h2>
+## Exemple
 
-<pre class="brush:js">// Étant donné que :
-// &lt;div&gt;
-//   &lt;span id="childSpan"&gt;foo bar&lt;/span&gt;
-// &lt;/div&gt;
+```js
+// Étant donné que :
+// <div>
+//   <span id="childSpan">foo bar</span>
+// </div>
 
 // Crée un nœud d'élément vide
 // sans ID, sans attributs et sans contenu
@@ -53,38 +51,22 @@ var parentDiv = sp2.parentNode;
 parentDiv.replaceChild(sp1, sp2);
 
 // Résultat :
-// &lt;div&gt;
-//   &lt;span id="newSpan"&gt;nouvel élément span de remplacement.&lt;/span&gt;
-// &lt;/div&gt;
-</pre>
-
-<h2 id="Specifications">Spécifications</h2>
-
-<table class="standard-table">
-	<thead>
-		<tr>
-			<th scope="col">Spécification</th>
-			<th scope="col">Statut</th>
-			<th scope="col">Commentaire</th>
-		</tr>
-	</thead>
-	<tbody>
-		<tr>
-			<td>{{SpecName("DOM WHATWG", "#dom-node-replacechild", "Node: replaceChild")}}
-			</td>
-			<td>{{Spec2("DOM WHATWG")}}</td>
-			<td></td>
-		</tr>
-	</tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilité des navigateurs</h2>
-
-<p>{{Compat("api.Node.replaceChild")}}</p>
-
-<h2 id="See_also">Voir aussi</h2>
-
-<ul>
- <li>{{domxref("Node.removeChild")}}</li>
- <li>{{domxref("ChildNode.replaceWith")}}</li>
-</ul>
+// <div>
+//   <span id="newSpan">nouvel élément span de remplacement.</span>
+// </div>
+```
+
+## Spécifications
+
+| Spécification                                                                                        | Statut                           | Commentaire |
+| ---------------------------------------------------------------------------------------------------- | -------------------------------- | ----------- |
+| {{SpecName("DOM WHATWG", "#dom-node-replacechild", "Node: replaceChild")}} | {{Spec2("DOM WHATWG")}} |             |
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.replaceChild")}}
+
+## Voir aussi
+
+- {{domxref("Node.removeChild")}}
+- {{domxref("ChildNode.replaceWith")}}
diff --git a/files/fr/web/api/node/textcontent/index.md b/files/fr/web/api/node/textcontent/index.md
index 63e892d5b6..0b195eaa7a 100644
--- a/files/fr/web/api/node/textcontent/index.md
+++ b/files/fr/web/api/node/textcontent/index.md
@@ -8,61 +8,56 @@ tags:
   - Propriétés
 translation_of: Web/API/Node/textContent
 ---
-<p>{{APIRef("DOM")}}</p>
+{{APIRef("DOM")}}
 
-<p>La propriété <code><strong>Node.textContent</strong></code>  représente le contenu textuel d'un nœud et de ses descendants.</p>
+La propriété **`Node.textContent`**  représente le contenu textuel d'un nœud et de ses descendants.
 
-<h2 id="Syntaxe">Syntaxe</h2>
+## Syntaxe
 
-<pre class="syntaxbox">var <em>text</em> = element.textContent;
-element.textContent = "ceci est un simple exemple de texte";
-</pre>
+    var text = element.textContent;
+    element.textContent = "ceci est un simple exemple de texte";
 
-<h2 id="Notes">Description</h2>
+## Description
 
-<ul>
- <li><code>textContent</code> renvoie <code>null</code> si l'élément est un <a href="/fr/docs/Web/API/document">document</a>, un type de document (doctype) ou une notation. Pour saisir toutes les données textuelles et CDATA pour l'ensemble du document, on peut utiliser <code> <a href="/fr/docs/Web/API/document/documentElement">document.documentElement</a>.textContent</code> .</li>
- <li>Si le nœud est une section CDATA, un commentaire, une instruction de traitement ou un nœud texte, <code>textContent</code> renvoie le texte à l'intérieur du nœud (la valeur <a href="/fr/docs/Web/API/Node/nodeValue">nodeValue</a>).</li>
- <li>Pour les autres types de nœuds, <code>textContent</code> renvoie la concaténation des valeurs de propriété <code>textContent</code> de chaque nœud enfant, à l'exception des commentaires et nœuds d'instructions de traitement. Si le nœud n'a pas d'enfants, il s'agira d'une chaîne vide.</li>
- <li>En définissant cette propriété sur un nœud, on enlève tous ses enfants et ceux-ci sont remplacés par un seul nœud texte avec la valeur donnée.</li>
-</ul>
+- `textContent` renvoie `null` si l'élément est un [document](/fr/docs/Web/API/document), un type de document (doctype) ou une notation. Pour saisir toutes les données textuelles et CDATA pour l'ensemble du document, on peut utiliser `document.documentElement.textContent` .
+- Si le nœud est une section CDATA, un commentaire, une instruction de traitement ou un nœud texte, `textContent` renvoie le texte à l'intérieur du nœud (la valeur [nodeValue](/fr/docs/Web/API/Node/nodeValue)).
+- Pour les autres types de nœuds, `textContent` renvoie la concaténation des valeurs de propriété `textContent` de chaque nœud enfant, à l'exception des commentaires et nœuds d'instructions de traitement. Si le nœud n'a pas d'enfants, il s'agira d'une chaîne vide.
+- En définissant cette propriété sur un nœud, on enlève tous ses enfants et ceux-ci sont remplacés par un seul nœud texte avec la valeur donnée.
 
-<h3 id="Différences_avec_innerText">Différences avec <code>innerText</code></h3>
+### Différences avec `innerText`
 
-<p>Internet Explorer a introduit une propriété {{domxref("node.innerText")}}. L'intention est similaire mais comporte les différences suivantes :</p>
+Internet Explorer a introduit une propriété {{domxref("node.innerText")}}. L'intention est similaire mais comporte les différences suivantes :
 
-<ul>
- <li><code>textContent</code> récupère le contenu de tous les éléments, y compris {{HTMLElement("script")}} et {{HTMLElement("style")}}, ce qui n'est pas le cas de <code>innerText</code>.</li>
- <li><code>innerText</code> prend en compte le style de l'élément et ne retournera rien pour les éléments cachés. Aussi, il déclenchera un reflow à l'inverse de <code>textContent</code>.</li>
- <li>Comme <code>innerText</code> reconnaît le style CSS, il déclenchera une refusion (<em>reflow</em>), alors que <code>textContent</code> ne le fera pas.</li>
- <li>Contrairement à <code>textContent</code>, la modification <code>innerText</code> dans Internet Explorer (jusqu'à la version 11 incluse), non seulement supprime les nœuds enfants de l'élément, mais détruit aussi définitivement tout nœud de texte descendant (il est donc impossible d'insérer à nouveau des nœuds dans un autre élément ou dans le même élément) .</li>
-</ul>
+- `textContent` récupère le contenu de tous les éléments, y compris {{HTMLElement("script")}} et {{HTMLElement("style")}}, ce qui n'est pas le cas de `innerText`.
+- `innerText` prend en compte le style de l'élément et ne retournera rien pour les éléments cachés. Aussi, il déclenchera un reflow à l'inverse de `textContent`.
+- Comme `innerText` reconnaît le style CSS, il déclenchera une refusion (_reflow_), alors que `textContent` ne le fera pas.
+- Contrairement à `textContent`, la modification `innerText` dans Internet Explorer (jusqu'à la version 11 incluse), non seulement supprime les nœuds enfants de l'élément, mais détruit aussi définitivement tout nœud de texte descendant (il est donc impossible d'insérer à nouveau des nœuds dans un autre élément ou dans le même élément) .
 
-<h3 id="Différences_avec_innerHTML">Différences avec <code>innerHTML</code></h3>
+### Différences avec `innerHTML`
 
-<p>{{domxref("Element.innerHTML")}} renvoie le HTML comme son nom l'indique. Souvent, pour récupérer ou écrire du texte dans un élément, les utilisateurs utilisent <code>innerHTML</code>. Cependant, <code>textContent</code> a souvent de meilleures performances car le texte n'est pas analysé en HTML. De plus, l'utilisation de <code>textContent</code> peut empêcher les attaques XSS.</p>
+{{domxref("Element.innerHTML")}} renvoie le HTML comme son nom l'indique. Souvent, pour récupérer ou écrire du texte dans un élément, les utilisateurs utilisent `innerHTML`. Cependant, `textContent` a souvent de meilleures performances car le texte n'est pas analysé en HTML. De plus, l'utilisation de `textContent` peut empêcher les attaques XSS.
 
-<h2 id="Exemple">Exemple</h2>
+## Exemple
 
-<pre class="eval">// Étant donné le fragment de HTML suivant :
-//   &lt;div id="divA"&gt;Ceci est un &lt;span&gt;exemple de&lt;/span&gt; texte&lt;/div&gt;
+    // Étant donné le fragment de HTML suivant :
+    //   <div id="divA">Ceci est un <span>exemple de</span> texte</div>
 
-// On obtient le contenu textuel :
-var text = document.getElementById("divA").textContent;
-// |text| vaut "Ceci est un exemple de texte".
+    // On obtient le contenu textuel :
+    var text = document.getElementById("divA").textContent;
+    // |text| vaut "Ceci est un exemple de texte".
 
-// On définit le contenu textuel :
-document.getElementById("divA").textContent = "Ceci est un exemple de texte";
-// Le HTML pour divA est à présent &lt;div id="divA"&gt;Ceci est un exemple de texte&lt;/div&gt;
-</pre>
+    // On définit le contenu textuel :
+    document.getElementById("divA").textContent = "Ceci est un exemple de texte";
+    // Le HTML pour divA est à présent <div id="divA">Ceci est un exemple de texte</div>
 
-<h2 id="Polyfill_pour_IE8">Polyfill pour IE8</h2>
+## Polyfill pour IE8
 
-<pre class="brush: js">// Source: Eli Grey @ http://eligrey.com/blog/post/textcontent-in-ie8
+```js
+// Source: Eli Grey @ http://eligrey.com/blog/post/textcontent-in-ie8
 if (Object.defineProperty
-  &amp;&amp; Object.getOwnPropertyDescriptor
-  &amp;&amp; Object.getOwnPropertyDescriptor(Element.prototype, "textContent")
-  &amp;&amp; !Object.getOwnPropertyDescriptor(Element.prototype, "textContent").get) {
+  && Object.getOwnPropertyDescriptor
+  && Object.getOwnPropertyDescriptor(Element.prototype, "textContent")
+  && !Object.getOwnPropertyDescriptor(Element.prototype, "textContent").get) {
   (function() {
     var innerText = Object.getOwnPropertyDescriptor(Element.prototype, "innerText");
     Object.defineProperty(Element.prototype, "textContent",
@@ -78,48 +73,21 @@ if (Object.defineProperty
      }
    );
   })();
-}</pre>
-
-<ul>
-</ul>
-
-<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
-
-
-
-<p>{{Compat("api.Node.textContent")}}</p>
-
-<h2 id="Sp.C3.A9cification">Spécifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Spécification</th>
-   <th scope="col">Statut</th>
-   <th scope="col">Commentaire</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG','#dom-node-textcontent','Node.textContent')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Pas de changement de DOM4</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM4','#dom-node-textcontent','Node.textContent')}}</td>
-   <td>{{Spec2('DOM4')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core','core.html#Node3-textContent','Node.textContent')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Définition initiale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Voir_aussi">Voir aussi</h2>
-
-<ul>
- <li><a href="http://perfectionkills.com/the-poor-misunderstood-innerText/">Plus sur les différences entre <code>innerText</code> et <code>textContent</code></a> (blog post en)</li>
-</ul>
-
-<p> </p>
+}
+```
+
+## Compatibilité des navigateurs
+
+{{Compat("api.Node.textContent")}}
+
+## Spécifications
+
+| Spécification                                                                                        | Statut                           | Commentaire               |
+| ---------------------------------------------------------------------------------------------------- | -------------------------------- | ------------------------- |
+| {{SpecName('DOM WHATWG','#dom-node-textcontent','Node.textContent')}}         | {{Spec2('DOM WHATWG')}} | Pas de changement de DOM4 |
+| {{SpecName('DOM4','#dom-node-textcontent','Node.textContent')}}                 | {{Spec2('DOM4')}}         |                           |
+| {{SpecName('DOM3 Core','core.html#Node3-textContent','Node.textContent')}} | {{Spec2('DOM3 Core')}}     | Définition initiale.      |
+
+## Voir aussi
+
+- [Plus sur les différences entre `innerText` et `textContent`](http://perfectionkills.com/the-poor-misunderstood-innerText/) (blog post en)
-- 
cgit v1.2.3-54-g00ecf