remove retired locales (#699)

12 files changed, 0 insertions, 1472 deletions

diff --git a/files/it/web/api/node/appendchild/index.html b/files/it/web/api/node/appendchild/index.html
deleted file mode 100644
index acef4909a3..0000000000
--- a/files/it/web/api/node/appendchild/index.html
+++ /dev/null
@@ -1,99 +0,0 @@
----
-title: Node.appendChild()
-slug: Web/API/Node/appendChild
-tags:
-  - API
-  - DOM
-  - Node
-  - Referenza
-  - metodo
-translation_of: Web/API/Node/appendChild
----
-<div>{{APIRef("DOM")}}</div>
-
-<p>Il metodo <code><strong>Node.appendChild()</strong></code> aggiunge un nodo alla fine dell'elenco di figli di un nodo genitore specificato. Se il figlio dato è un riferimento a un nodo esistente nel documento, <code>appendChild()</code> lo sposta dalla sua posizione corrente alla nuova posizione (non è necessario rimuovere il nodo dal suo nodo padre prima di aggiungerlo ad un altro nodo).</p>
-
-<p>Ciò significa che un nodo non può essere in due punti del documento contemporaneamente. Quindi se il nodo ha già un genitore, il nodo viene prima rimosso, quindi aggiunto alla nuova posizione. Il metodo {{domxref("Node.cloneNode()")}} può essere usato per fare una copia del nodo prima di aggiungerlo sotto il nuovo genitore. Si noti che le copie eseguite con <code>cloneNode</code> non verranno automaticamente mantenute sincronizzate.</p>
-
-<p>Se il figlio dato è un {{domxref("DocumentFragment")}}, l'intero contenuto di {{domxref("DocumentFragment")}} viene spostato nell'elenco secondario del nodo genitore specificato.</p>
-
-<h2 id="Syntax" name="Syntax">Sintassi</h2>
-
-<pre class="syntaxbox"><em>element</em>.appendChild(<em>aChild</em>);</pre>
-
-<h3 id="Returns" name="Returns">Parametri</h3>
-
-<dl>
- <dt><strong>aChild</strong></dt>
- <dd>Il nodo da aggiungere al nodo genitore dato (comunemente un elemento).</dd>
-</dl>
-
-<h3 id="Returns" name="Returns">Valore di ritorno</h3>
-
-<p>Il valore restituito è il figlio aggiunto tranne quando il figlio dato è un {{domxref("DocumentFragment")}}, nel qual caso viene restituito il {{domxref("DocumentFragment")}}.</p>
-
-<h2 id="Notes" name="Notes">Appunti</h2>
-
-<p>Il concatenamento potrebbe non funzionare come previsto a causa di <code>appendChild()</code> che restituisce l'elemento figlio:</p>
-
-<pre class="brush: js">var aBlock = doc.createElement('block').appendChild(doc.createElement('b'));</pre>
-
-<p>Sets <code>aBlock</code> to <code>&lt;b&gt;&lt;/b&gt;</code> only, which is probably not what you want.</p>
-
-<h2 id="Example" name="Example">Esempio</h2>
-
-<pre class="brush:js">// Crea un nuovo elemento di paragrafo e aggiungilo alla fine del corpo del documento
-var p = document.createElement("p");
-document.body.appendChild(p);</pre>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-appendchild', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Nessun cambiamento da {{SpecName("DOM3 Core")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-184E7107', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Nessun cambiamento da {{SpecName("DOM2 Core")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-184E7107', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Nessun cambiamento da {{SpecName("DOM1")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-184E7107', 'Node.appendChild()')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Definizione inziale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-<div>
-
-
-<p>{{Compat("api.Node.appendChild")}}</p>
-</div>
-
-<h2 id="See_also" name="See_also">Vedi anche</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>
diff --git a/files/it/web/api/node/childnodes/index.html b/files/it/web/api/node/childnodes/index.html
deleted file mode 100644
index 1db83ea87c..0000000000
--- a/files/it/web/api/node/childnodes/index.html
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: Node.childNodes
-slug: Web/API/Node/childNodes
-translation_of: Web/API/Node/childNodes
-original_slug: Web/API/Element/childNodes
----
-<div>
-<div>{{APIRef("DOM")}}</div>
-</div>
-
-<p>La proprietà di sola lettura <code><strong>Node.childNodes</strong></code> restituisce una {{domxref("NodeList")}} dinamica di {{domxref("Node","nodi")}} figli dell'elemento dato in cui il primo nodo figlio viene assegnato all'indice 0.</p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox">var <var>nodeList</var> = <var>elementNodeReference</var>.childNodes;
-</pre>
-
-<h2 id="Esempi">Esempi</h2>
-
-<h3 id="Utilizzo_semplice">Utilizzo semplice</h3>
-
-<pre class="brush:js">// parg è un riferimento a un elemento &lt;p&gt;
-
-// Innanzitutto controlliamo che l'elemento abbia dei nodi figli
-if (parg.hasChildNodes()) {
-  var children = parg.childNodes;
-
-  for (var i = 0; i &lt; children.length; i++) {
-    // fare qualcosa con ogni bambino da children[i]
-    // NOTA: l'elenco è dinamico, l'aggiunta o la rimozione di bambini modificherà l'elenco
-  }
-}</pre>
-
-<h3 id="Rimuovi_tutti_i_bambini_da_un_nodo">Rimuovi tutti i bambini da un nodo</h3>
-
-<pre class="brush:js">// Questo è un modo per rimuovere tutti i bambini da una
-// finestra di nodo è un riferimento ad un oggetto
-
-while (box.firstChild) {
-    //L'elenco è DINAMICO, quindi indicizzerà nuovamente ogni chiamata
-    box.removeChild(box.firstChild);
-}</pre>
-
-<h2 id="Appunti">Appunti</h2>
-
-<p>Gli elementi nella raccolta di nodi sono oggetti e non stringhe. Per ottenere dati da oggetti nodo, usa le loro proprietà (ad esempio <code>elementNodeReference.childNodes[1].nodeName</code> per ottenere il nome, ecc.).</p>
-
-<p>L'oggetto <code>document</code> ha 2 figli: la dichiarazione Doctype e l'elemento root, in genere <code>documentElement</code>. (Nei documenti (X)HTML questo è l'elemento <code>HTML</code>.)</p>
-
-<p><code>childNodes</code> include tutti i nodi figli, inclusi nodi non-elemento come nodi di testo e commenti. Per ottenere una raccolta di soli elementi, usa {{domxref("ParentNode.children")}}.</p>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-childnodes', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-1451460987', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-1451460987', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-1451460987', 'Node.childNodes')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Definizione iniziale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.childNodes")}}</p>
-
-<h2 id="Vedi_anche">Vedi anche</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>
diff --git a/files/it/web/api/node/firstchild/index.html b/files/it/web/api/node/firstchild/index.html
deleted file mode 100644
index b99b694dbe..0000000000
--- a/files/it/web/api/node/firstchild/index.html
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: Node.firstChild
-slug: Web/API/Node/firstChild
-tags:
-  - API
-  - DOM
-  - Node
-  - Proprietà
-  - Referenza
-translation_of: Web/API/Node/firstChild
-original_slug: Web/API/Element/firstChild
----
-<div>{{APIRef("DOM")}}</div>
-
-<p><span class="seoSummary">La proprietà di sola lettura <code><strong>Node.firstChild</strong></code> restituisce il primo figlio del nodo nell'albero o <code>null</code> se il nodo non ha figli.</span> Se il nodo è un <code>Document</code>, restituisce il primo nodo nell'elenco dei suoi figli diretti.</p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox">var <var>childNode</var> = <var>node</var>.firstChild;
-</pre>
-
-<h2 id="Esempio">Esempio</h2>
-
-<p>Questo esempio dimostra l'uso di <code>firstChild</code> e il modo in cui i nodi degli spazi bianchi potrebbero interferire con l'utilizzo di questa proprietà.</p>
-
-<pre class="brush:html">&lt;p id="para-01"&gt;
-  &lt;span&gt;First span&lt;/span&gt;
-&lt;/p&gt;
-
-&lt;script&gt;
-  var p01 = document.getElementById('para-01');
-  console.log(p01.firstChild.nodeName);
-&lt;/script&gt;</pre>
-
-<p>In quanto sopra, la <a href="/en-US/docs/Web/API/Console">console</a> console mostrerà '#text' perché viene inserito un nodo di testo per mantenere lo spazio bianco tra la fine dei tag di apertura <code>&lt;p&gt;</code> e <code>&lt;span&gt;</code>. <strong>Qualsiasi</strong> <a href="/en-US/docs/Web/API/Document_Object_Model/Whitespace_in_the_DOM">spazio bianco</a> creerà un nodo <code>#text</code> da un singolo spazio a più spazi, ritorni, schede e così via.</p>
-
-<p>Un altro nodo <code>#text</code> viene inserito tra i tag di chiusura <code>&lt;/span&gt;</code> e <code>&lt;/p&gt;</code>.</p>
-
-<p>Se questo spazio viene rimosso dall'origine, i nodi #text non vengono inseriti e l'elemento span diventa il primo figlio del paragrafo.</p>
-
-<pre class="brush:html">&lt;p id="para-01"&gt;&lt;span&gt;First span&lt;/span&gt;&lt;/p&gt;
-
-&lt;script&gt;
-  var p01 = document.getElementById('para-01');
-  console.log(p01.firstChild.nodeName);
-&lt;/script&gt;
-</pre>
-
-<p>Ora l'avviso mostrerà 'SPAN'.</p>
-
-<p>Per evitare il problema con <code>node.firstChild</code> che restituisce i nodi <code>#text</code> o <code>#comment</code>, {{domxref("ParentNode.firstElementChild")}} può essere utilizzato per restituire solo il primo nodo elemento. Tuttavia, <code>node.firstElementChild</code> richiede uno shim per Internet Explorer 9 e versioni precedenti.</p>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commentp</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-firstchild', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-169727388', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-169727388', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-169727388', 'Node.firstChild')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Definizione iniziale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.firstChild")}}</p>
diff --git a/files/it/web/api/node/index.html b/files/it/web/api/node/index.html
deleted file mode 100644
index 7e0112e21c..0000000000
--- a/files/it/web/api/node/index.html
+++ /dev/null
@@ -1,368 +0,0 @@
----
-title: Node
-slug: Web/API/Node
-tags:
-  - API
-  - DOM
-  - DOM Reference
-  - Interface
-  - NeedsTranslation
-  - Node
-  - Reference
-  - TopicStub
-translation_of: Web/API/Node
----
-<div>{{APIRef("DOM")}}</div>
-
-<p><span class="seoSummary"><strong><code>Node</code></strong> is an interface from which a number of DOM API object types inherit. It allows those types to be treated similarly; for example, inheriting the same set of methods, or being tested in the same way.</span></p>
-
-<p>The following interfaces all inherit from <code>Node</code>’s methods and properties: {{domxref("Document")}}, {{domxref("Element")}}, {{domxref("Attr")}}, {{domxref("CharacterData")}} (which {{domxref("Text")}}, {{domxref("Comment")}}, and {{domxref("CDATASection")}} inherit), {{domxref("ProcessingInstruction")}}, {{domxref("DocumentFragment")}}, {{domxref("DocumentType")}}, {{domxref("Notation")}}, {{domxref("Entity")}}, {{domxref("EntityReference")}}</p>
-
-<p>These interfaces may return <code>null</code> in certain cases where the methods and properties are not relevant. They may throw an exception — for example when adding children to a node type for which no children can exist.</p>
-
-<p>{{InheritanceDiagram}}</p>
-
-<h2 id="Properties">Properties</h2>
-
-<p><em>Inherits properties from its parents {{domxref("EventTarget")}}</em>.<sup>[1]</sup></p>
-
-<dl>
- <dt>{{domxref("Node.baseURI")}} {{readonlyInline}}</dt>
- <dd>Returns a {{domxref("DOMString")}} representing the base URL. The concept of base URL changes from one language to another; in HTML, it corresponds to the protocol, the domain name and the directory structure, that is all until the last <code>'/'</code>.</dd>
- <dt>{{domxref("Node.baseURIObject")}} {{Non-standard_inline()}}</dt>
- <dd>(Not available to web content.) The read-only {{ Interface("nsIURI") }} object representing the base URI for the element.</dd>
- <dt>{{domxref("Node.childNodes")}} {{readonlyInline}}</dt>
- <dd>Returns a live {{domxref("NodeList")}} containing all the children of this node. {{domxref("NodeList")}} being live means that if the children of the <code>Node</code> change, the {{domxref("NodeList")}} object is automatically updated.</dd>
- <dt>{{domxref("Node.firstChild")}} {{readonlyInline}}</dt>
- <dd>Returns a {{domxref("Node")}} representing the first direct child node of the node, or <code>null</code> if the node has no child.</dd>
- <dt>{{domxref("Node.isConnected")}} {{readonlyInline}}</dt>
- <dd>Returns a boolean indicating whether or not the Node is connected (directly or indirectly) to the context object, e.g. the {{domxref("Document")}} object in the case of the normal DOM, or the {{domxref("ShadowRoot")}} in the case of a shadow DOM.</dd>
- <dt>{{domxref("Node.lastChild")}} {{readonlyInline}}</dt>
- <dd>Returns a {{domxref("Node")}} representing the last direct child node of the node, or <code>null</code> if the node has no child.</dd>
- <dt>{{domxref("Node.nextSibling")}} {{readonlyInline}}</dt>
- <dd>Returns a {{domxref("Node")}} representing the next node in the tree, or <code>null</code> if there isn't such node.</dd>
- <dt>{{domxref("Node.nodeName")}} {{readonlyInline}}</dt>
- <dd>Returns a {{domxref("DOMString")}} containing the name of the <code>Node</code>. The structure of the name will differ with the node type. E.g. An {{domxref("HTMLElement")}} will contain the name of the corresponding tag, like <code>'audio'</code> for an {{domxref("HTMLAudioElement")}}, a {{domxref("Text")}} node will have the <code>'#text'</code> string, or a {{domxref("Document")}} node will have the <code>'#document'</code> string.</dd>
- <dt>{{domxref("Node.nodePrincipal")}} {{Non-standard_inline()}}</dt>
- <dd>A {{ Interface("nsIPrincipal") }} representing the node principal.</dd>
- <dt>{{domxref("Node.nodeType")}}{{readonlyInline}}</dt>
- <dd>Returns an <code>unsigned short</code> representing the type of the node. Possible values are:
- <table class="standard-table">
-  <tbody>
-   <tr>
-    <th scope="col">Name</th>
-    <th scope="col">Value</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>
- </dd>
- <dt>{{domxref("Node.nodeValue")}}</dt>
- <dd>Returns / Sets the value of the current node</dd>
- <dt>{{domxref("Node.ownerDocument")}} {{readonlyInline}}</dt>
- <dd>Returns the {{domxref("Document")}} that this node belongs to. If the node is itself a document, returns <code>null</code>.</dd>
- <dt>{{domxref("Node.parentNode")}} {{readonlyInline}}</dt>
- <dd>Returns a {{domxref("Node")}} that is the parent of this node. If there is no such node, like if this node is the top of the tree or if doesn't participate in a tree, this property returns <code>null</code>.</dd>
- <dt>{{domxref("Node.parentElement")}} {{readonlyInline}}</dt>
- <dd>Returns an {{domxref("Element")}} that is the parent of this node. If the node has no parent, or if that parent is not an {{domxref("Element")}}, this property returns <code>null</code>.</dd>
- <dt>{{domxref("Node.previousSibling")}} {{readonlyInline}}</dt>
- <dd>Returns a {{domxref("Node")}} representing the previous node in the tree, or <code>null</code> if there isn't such node.</dd>
- <dt>{{domxref("Node.textContent")}}</dt>
- <dd>Returns / Sets the textual content of an element and all its descendants.</dd>
-</dl>
-
-<h3 id="Deprecated_properties">Deprecated properties</h3>
-
-<dl>
- <dt>{{domxref("Node.rootNode")}} {{readOnlyInline}} {{deprecated_inline}}</dt>
- <dd>Returns a {{domxref("Node")}} object representing the topmost node in the tree, or the current node if it's the topmost node in the tree. This has been replaced by {{domxref("Node.getRootNode()")}}.</dd>
-</dl>
-
-<h3 id="Obsolete_properties">Obsolete properties</h3>
-
-<dl>
- <dt>{{domxref("Node.localName")}} {{obsolete_inline}}{{readonlyInline}}</dt>
- <dd>Returns a {{domxref("DOMString")}} representing the local part of the qualified name of an element.
- <div class="note">
- <p><strong>Note:</strong> In Firefox 3.5 and earlier, the property upper-cases the local name for HTML elements (but not XHTML elements). In later versions, this does not happen, so the property is in lower case for both HTML and XHTML. {{gecko_minversion_inline("1.9.2")}}</p>
- </div>
- </dd>
- <dt>{{domxref("Node.namespaceURI")}} {{obsolete_inline}}{{readonlyInline}}</dt>
- <dd>The namespace URI of this node, or <code>null</code> if it is no namespace.
- <div class="note">
- <p><strong>Note:</strong> In Firefox 3.5 and earlier, HTML elements are in no namespace. In later versions, HTML elements are in the <code><a class="linkification-ext external" href="https://www.w3.org/1999/xhtml/">http://www.w3.org/1999/xhtml/</a></code> namespace in both HTML and XML trees. {{gecko_minversion_inline("1.9.2")}}</p>
- </div>
- </dd>
- <dt>{{domxref("Node.prefix")}} {{obsolete_inline}}{{readonlyInline}}</dt>
- <dd>Is a {{domxref("DOMString")}} representing the namespace prefix of the node, or <code>null</code> if no prefix is specified.</dd>
-</dl>
-
-<h2 id="Methods">Methods</h2>
-
-<p><em>Inherits methods from its parent, {{domxref("EventTarget")}}</em>.<sup>[1]</sup></p>
-
-<dl>
- <dt>{{domxref("Node.appendChild()")}}</dt>
- <dd>Adds the specified childNode argument as the last child to the current node.<br>
- If the argument referenced an existing node on the DOM tree, the node will be detached from its current position and attached at the new position.</dd>
- <dt>{{domxref("Node.cloneNode()")}}</dt>
- <dd>Clone a {{domxref("Node")}}, and optionally, all of its contents. By default, it clones the content of the node.</dd>
- <dt>{{domxref("Node.compareDocumentPosition()")}}</dt>
- <dd>Compares the position of the current node against another node in any other document.</dd>
- <dt>{{domxref("Node.contains()")}}</dt>
- <dd>Returns a {{jsxref("Boolean")}} value indicating whether a node is a descendant of a given node or not.</dd>
- <dt>{{domxref("Node.getRootNode()")}}</dt>
- <dd>Returns the context object's root which optionally includes the shadow root if it is available. </dd>
- <dt>{{domxref("Node.hasChildNodes()")}}</dt>
- <dd>Returns a {{jsxref("Boolean")}} indicating if the element has any child nodes, or not.</dd>
- <dt>{{domxref("Node.insertBefore()")}}</dt>
- <dd>Inserts a {{domxref("Node")}} before the reference node as a child of a specified parent node.</dd>
- <dt>{{domxref("Node.isDefaultNamespace()")}}</dt>
- <dd>Accepts a namespace URI as an argument and returns a {{jsxref("Boolean")}} with a value of <code>true</code> if the namespace is the default namespace on the given node or <code>false</code> if not.</dd>
- <dt>{{domxref("Node.isEqualNode()")}}</dt>
- <dd>Returns a {{jsxref("Boolean")}} which indicates whether or not two nodes are of the same type and all their defining data points match.</dd>
- <dt>{{domxref("Node.isSameNode()")}}</dt>
- <dd>Returns a {{jsxref("Boolean")}} value indicating whether or not the two nodes are the same (that is, they reference the same object).</dd>
- <dt>{{domxref("Node.lookupPrefix()")}}</dt>
- <dd>Returns a {{domxref("DOMString")}} containing the prefix for a given namespace URI, if present, and <code>null</code> if not. When multiple prefixes are possible, the result is implementation-dependent.</dd>
- <dt>{{domxref("Node.lookupNamespaceURI()")}}</dt>
- <dd>Accepts a prefix and returns the namespace URI associated with it on the given node if found (and <code>null</code> if not). Supplying <code>null</code> for the prefix will return the default namespace.</dd>
- <dt>{{domxref("Node.normalize()")}}</dt>
- <dd>Clean up all the text nodes under this element (merge adjacent, remove empty).</dd>
- <dt>{{domxref("Node.removeChild()")}}</dt>
- <dd>Removes a child node from the current element, which must be a child of the current node.</dd>
- <dt>{{domxref("Node.replaceChild()")}}</dt>
- <dd>Replaces one child {{domxref("Node")}} of the current one with the second one given in parameter.</dd>
-</dl>
-
-<h3 id="Obsolete_methods">Obsolete methods</h3>
-
-<dl>
- <dt>{{domxref("Node.getFeature()")}} {{obsolete_inline}}</dt>
- <dd> </dd>
- <dt>{{domxref("Node.getUserData()")}} {{obsolete_inline}}</dt>
- <dd>Allows a user to get some {{domxref("DOMUserData")}} from the node.</dd>
- <dt>{{domxref("Node.hasAttributes()")}} {{obsolete_inline}}</dt>
- <dd>Returns a {{jsxref("Boolean")}} indicating if the element has any attributes, or not.</dd>
- <dt>{{domxref("Node.isSupported()")}} {{obsolete_inline}}</dt>
- <dd>Returns a {{jsxref("Boolean")}} flag containing the result of a test whether the DOM implementation implements a specific feature and this feature is supported by the specific node.</dd>
- <dt>{{domxref("Node.setUserData()")}} {{obsolete_inline}}</dt>
- <dd>Allows a user to attach, or remove, {{domxref("DOMUserData")}} to the node.</dd>
-</dl>
-
-<h2 id="Examples">Examples</h2>
-
-<h3 id="Remove_all_children_nested_within_a_node">Remove all children nested within a node</h3>
-
-<pre class="brush: js">Element.prototype.removeAll = function () {
-  while (this.firstChild) { this.removeChild(this.firstChild); }
-  return this;
-};</pre>
-
-<h4 id="Sample_usage">Sample usage</h4>
-
-<pre class="brush: js">/* ... an alternative to document.body.innerHTML = "" ... */
-document.body.removeAll();</pre>
-
-<h3 id="Recurse_through_child_nodes">Recurse through child nodes</h3>
-
-<p>The following function calls a function recursively for each node contained by a root node (including the root itself):</p>
-
-<pre class="brush: js">function eachNode(rootNode, callback){
-	if(!callback){
-		var nodes = [];
-		eachNode(rootNode, function(node){
-			nodes.push(node);
-		});
-		return nodes;
-	}
-
-	if(false === callback(rootNode))
-		return false;
-
-	if(rootNode.hasChildNodes()){
-		var nodes = rootNode.childNodes;
-		for(var i = 0, l = nodes.length; i &lt; l; ++i)
-			if(false === eachNode(nodes[i], callback))
-				return;
-	}
-}</pre>
-
-<h4 id="Syntax">Syntax</h4>
-
-<pre class="syntaxbox">eachNode(rootNode, callback);</pre>
-
-<h4 id="Description">Description</h4>
-
-<p>Recursively calls a function for each descendant node of <code>rootNode</code> (including the root itself).</p>
-
-<p>If <code>callback</code> is omitted, the function returns an {{jsxref("Array")}} instead, which contains <code>rootNode</code> and all nodes contained therein.</p>
-
-<p>If <code>callback</code> is provided, and it returns {{jsxref("Boolean")}} <code>false</code> when called, the current recursion level is aborted, and the function resumes execution at the last parent's level. This can be used to abort loops once a node has been found (such as searching for a text node that contains a certain string).</p>
-
-<h4 id="Parameters">Parameters</h4>
-
-<dl>
- <dt><code>rootNode</code></dt>
- <dd>The <code>Node</code> object whose descendants will be recursed through.</dd>
- <dt><code>callback</code></dt>
- <dd>An optional callback <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function">function</a> that receives a <code>Node</code> as its only argument. If omitted, <code>eachNode</code> returns an {{jsxref("Array")}} of every node contained within <code>rootNode</code> (including the root itself).</dd>
-</dl>
-
-<h4 id="Sample_usage_2">Sample usage</h4>
-
-<p>The following example prints the <a href="/en-US/docs/Web/API/Node/textContent"><code>textContent</code></a> properties of each <code>&lt;span&gt;</code> tag in a <code>&lt;div&gt;</code> element named <code>"box"</code>:</p>
-
-<pre class="brush: html">&lt;div id="box"&gt;
-	&lt;span&gt;Foo&lt;/span&gt;
-	&lt;span&gt;Bar&lt;/span&gt;
-	&lt;span&gt;Baz&lt;/span&gt;
-&lt;/div&gt;</pre>
-
-<pre class="brush: js">var box = document.getElementById("box");
-eachNode(box, function(node){
-	if(null != node.textContent){
-		console.log(node.textContent);
-	}
-});</pre>
-
-<p>The following strings will be displayed in the user's console:</p>
-
-<pre class="brush: js">"\n\t", "Foo", "\n\t", "Bar", "\n\t", "Baz"</pre>
-
-<div class="note">
-<p><strong>Note:</strong> Whitespace forms part of a {{domxref("Text")}} node, meaning indentation and newlines form separate <code>Text</code> between the <code>Element</code> nodes.</p>
-</div>
-
-<h4 id="Realistic_usage">Realistic usage</h4>
-
-<p>The following demonstrates a real-world use of the <code>eachNode</code> function: searching for text on a web-page. We use a wrapper function named <code>grep</code> to do the searching:</p>
-
-<pre class="brush: js">function grep(parentNode, pattern){
-	var matches = [];
-	var endScan = false;
-
-	eachNode(parentNode, function(node){
-		if(endScan)
-			return false;
-
-		// Ignore anything which isn't a text node
-		if(node.nodeType !== Node.TEXT_NODE)
-			return;
-
-		if("string" === typeof pattern){
-			if(-1 !== node.textContent.indexOf(pattern))
-				matches.push(node);
-		}
-		else if(pattern.test(node.textContent)){
-			if(!pattern.global){
-				endScan = true;
-				matches = node;
-			}
-			else matches.push(node);
-		}
-	});
-
-	return matches;
-}</pre>
-
-<p>For example, to find {{domxref("Text")}} nodes that contain typos:</p>
-
-<pre class="brush: js">var typos = ["teh", "adn", "btu", "adress", "youre", "msitakes"];
-var pattern = new RegExp("\\b(" + typos.join("|") + ")\\b", "gi");
-var mistakes = grep(document.body, pattern);
-console.log(mistakes);
-</pre>
-
-<h2 id="Specifications">Specifications</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', '#interface-node', 'Node')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Removed the following properties: <code>attributes</code>, <code>namespaceURI</code>, <code>prefix</code>, and <code>localName</code>.<br>
-    Removed the following methods: <code>isSupported()</code>, <code>hasAttributes()</code>, <code>getFeature()</code>, <code>setUserData()</code>, and <code>getUserData()</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-1950641247', 'Node')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>The methods <code>insertBefore()</code>, <code>replaceChild()</code>, <code>removeChild()</code>, and <code>appendChild()</code> returns one more kind of error (<code>NOT_SUPPORTED_ERR</code>) if called on a {{domxref("Document")}}.<br>
-    The <code>normalize()</code> method has been modified so that {{domxref("Text")}} node can also be normalized if the proper {{domxref("DOMConfiguration")}} flag is set.<br>
-    Added the following methods: <code>compareDocumentPosition()</code>, <code>isSameNode()</code>, <code>lookupPrefix()</code>, <code>isDefaultNamespace()</code>, <code>lookupNamespaceURI()</code>, <code>isEqualNode()</code>, <code>getFeature()</code>, <code>setUserData()</code>, and <code>getUserData().</code><br>
-    Added the following properties: <code>baseURI</code> and <code>textContent</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-1950641247', 'Node')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>The <code>ownerDocument</code> property was slightly modified so that {{domxref("DocumentFragment")}} also returns <code>null</code>.<br>
-    Added the following properties: <code>namespaceURI</code>, <code>prefix</code>, and <code>localName</code>.<br>
-    Added the following methods: <code>normalize()</code>, <code>isSupported()</code> and <code>hasAttributes()</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-1950641247', 'Node')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Initial definition</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-
-
-<p>{{Compat("api.Node")}}</p>
diff --git a/files/it/web/api/node/lastchild/index.html b/files/it/web/api/node/lastchild/index.html
deleted file mode 100644
index 34804c5644..0000000000
--- a/files/it/web/api/node/lastchild/index.html
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: Node.lastChild
-slug: Web/API/Node/lastChild
-translation_of: Web/API/Node/lastChild
----
-<div>{{APIRef("DOM")}}</div>
-
-<p>La proprietà di sola lettura <code><strong>Node.lastChild</strong></code> restituisce l'ultimo figlio del nodo. Se il suo genitore è un elemento, allora il bambino è generalmente un nodo di elemento, un nodo di testo o un nodo di commento. Restituisce <code>null</code> se non ci sono elementi figli.</p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox">var <var>childNode</var> = <var>node</var>.lastChild;
-</pre>
-
-<h2 id="Esempio">Esempio</h2>
-
-<pre class="brush: js">var tr = document.getElementById("row1");
-var corner_td = tr.lastChild;
-</pre>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-lastchild', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-61AD09FB', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-61AD09FB', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-61AD09FB', 'Node.lastChild')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Definizione iniziale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.lastChild")}}</p>
diff --git a/files/it/web/api/node/nextsibling/index.html b/files/it/web/api/node/nextsibling/index.html
deleted file mode 100644
index f2355a6402..0000000000
--- a/files/it/web/api/node/nextsibling/index.html
+++ /dev/null
@@ -1,101 +0,0 @@
----
-title: Node.nextSibling
-slug: Web/API/Node/nextSibling
-translation_of: Web/API/Node/nextSibling
----
-<div>{{APIRef("DOM")}}</div>
-
-<p><span class="seoSummary">La proprietà di sola lettura <code><strong>Node.nextSibling</strong></code> restituisce il nodo immediatamente successivo a quello specificato nei {{domxref("Node.childNodes","childNodes")}}, del loro genitore o restituisce <code>null</code> se il nodo specificato è l'ultimo figlio nell'elemento genitore.</span></p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox"><var>nextNode</var> = <var>node</var>.nextSibling
-</pre>
-
-<h2 id="Appunti">Appunti</h2>
-
-<div>
-<p>I browser basati su Gecko inseriscono nodi di testo in un documento per rappresentare gli spazi bianchi nel codice sorgente. Pertanto, un nodo ottenuto, ad esempio, utilizzando <a href="/it/docs/Web/API/Node/firstChild" title="The Node.firstChild read-only property returns the node's first child in the tree, or null if the node has no children."><code>Node.firstChild</code></a> o <a href="/it/docs/Web/API/Node/previousSibling" title="The Node.previousSibling read-only property returns the node immediately preceding the specified one in its parent's childNodes list, or null if the specified node is the first in that list."><code>Node.previousSibling</code></a> può fare riferimento a un nodo di testo di spazi bianchi piuttosto che all'elemento effettivo che l'autore intendeva ottenere.</p>
-
-<p>Vedi <a href="/en-US/docs/Web/Guide/DOM/Whitespace_in_the_DOM">Whitespace in the DOM</a> e <a class="external" href="http://www.w3.org/DOM/faq.html#emptytext" rel="noopener">W3C DOM 3 FAQ: Why are some Text nodes empty?</a> per maggiori informazioni.</p>
-</div>
-
-<p>{{domxref("Element.nextElementSibling")}} può essere usato per ottenere l'elemento successivo saltando eventuali nodi di spazi vuoti, altro testo tra elementi o commenti.</p>
-
-<h2 id="Esempio">Esempio</h2>
-
-<pre class="brush:html">&lt;div id="div-1"&gt;Here is div-1&lt;/div&gt;
-&lt;div id="div-2"&gt;Here is div-2&lt;/div&gt;
-
-&lt;script&gt;
-var el = document.getElementById('div-1').nextSibling,
-    i = 1;
-
-console.group('Siblings of div-1:');
-
-while (el) {
-  console.log(i, '. ', el.nodeName);
-  el = el.nextSibling;
-  i++;
-}
-
-console.groupEnd();
-&lt;/script&gt;
-
-/**************************************************
-  The console displays the following:
-
-     Siblings of div-1
-
-      1. #text
-      2. DIV
-      3. #text
-      4. SCRIPT
-
-**************************************************/
-</pre>
-
-<p>Nell'esempio precedente, i nodi, <code>#text</code> sono inseriti nel DOM in cui si verifica lo spazio bianco tra i tag (ad esempio dopo il tag di chiusura di un elemento e prima del tag di apertura del successivo).</p>
-
-<p>La possibile inclusione di nodi di testo deve essere consentita quando si attraversa il DOM utilizzando <code>nextSibling</code>. Vedi le risorse <a href="#Appunti">nella sezione Appunti</a>.</p>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-nextsibling', 'Node.nextSibling')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-6AC54C2F', 'Node.nextSibling')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#attribute-nextSibling', 'Node.nextSibling')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Definizione iniziale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.nextSibling")}}</p>
-
-<h2 id="Vedi_anche">Vedi anche</h2>
-
-<ul>
- <li>{{domxref("Element.nextElementSibling")}}</li>
-</ul>
diff --git a/files/it/web/api/node/nodename/index.html b/files/it/web/api/node/nodename/index.html
deleted file mode 100644
index 2738910a45..0000000000
--- a/files/it/web/api/node/nodename/index.html
+++ /dev/null
@@ -1,117 +0,0 @@
----
-title: Node.nodeName
-slug: Web/API/Node/nodeName
-tags:
-  - API
-  - DOM
-  - Gecko
-  - NeedsSpecTable
-  - Node
-  - Property
-  - Read-only
-translation_of: Web/API/Node/nodeName
-original_slug: Web/API/Element/nodeName
----
-<div>{{APIRef("DOM")}}</div>
-
-<p>La proprietà di sola lettura <code><strong>nodeName</strong></code> restituisce il nome dell'attuale {{domxref("Node")}} come stringa.</p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox">var <em>str</em> = <em>node</em>.nodeName;
-</pre>
-
-<h3 id="Valore">Valore</h3>
-
-<p>Una {{domxref("DOMString")}}. I valori per i diversi tipi di nodi sono:</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Interfaccia</th>
-   <th>valore nodeName</th>
-  </tr>
-  <tr>
-   <td>{{domxref("Attr")}}</td>
-   <td>Il valore di {{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>Il valore di {{domxref("DocumentType.name")}}</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Element")}}</td>
-   <td>Il valore di {{domxref("Element.tagName")}}</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Entity")}}</td>
-   <td>Il nome dell'entità</td>
-  </tr>
-  <tr>
-   <td>{{domxref("EntityReference")}}</td>
-   <td>Il nome del riferimento all'entità</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Notation")}}</td>
-   <td>Il nome della notazione</td>
-  </tr>
-  <tr>
-   <td>{{domxref("ProcessingInstruction")}}</td>
-   <td>Il valore di {{domxref("ProcessingInstruction.target")}}</td>
-  </tr>
-  <tr>
-   <td>{{domxref("Text")}}</td>
-   <td><code>"#text"</code></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Esempio">Esempio</h2>
-
-<p>Dato il seguente markup:</p>
-
-<pre class="brush:html">&lt;div id="d1"&gt;hello world&lt;/div&gt;
-&lt;input type="text" id="t"&gt;
-</pre>
-
-<p>e il seguente script:</p>
-
-<pre class="brush:js">var div1 = document.getElementById("d1");
-var text_field = document.getElementById("t");
-
-text_field.value = div1.nodeName;
-</pre>
-
-<p>IIn XHTML (o in qualsiasi altro formato XML), il valore di <code>text_field</code> sarebbe letto <code>"div"</code>. Tuttavia, in HTML, il valore di <code>text_field</code> sarebbe letto <code>"DIV"</code>, poichè <code>nodeName</code> e <code>tagName</code> restituiscono in maiuscolo gli elementi HTML nei DOM contrassegnati come documenti HTML. Read more <a href="http://ejohn.org/blog/nodename-case-sensitivity/" title="http://ejohn.org/blog/nodename-case-sensitivity/">details on nodeName case sensitivity in different browsers</a>.</p>
-
-<p>Nota che la proprietà {{domxref("Element.tagName")}} potrebbe essere stata utilizzata, poiché <code>nodeName</code> ha lo stesso valore di <code>tagName</code> per un elemento. Tieni presente, tuttavia, che <code>nodeName</code> ritornerà <code>"#text"</code> per i nodi di testo mentre <code>tagName</code> restituirà <code>undefined</code>.</p>
-
-<h2 id="Specifiche">Specifiche</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></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à_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.nodeName")}}</p>
diff --git a/files/it/web/api/node/nodetype/index.html b/files/it/web/api/node/nodetype/index.html
deleted file mode 100644
index c484034dc7..0000000000
--- a/files/it/web/api/node/nodetype/index.html
+++ /dev/null
@@ -1,179 +0,0 @@
----
-title: Node.nodeType
-slug: Web/API/Node/nodeType
-tags:
-  - API
-  - DOM
-  - Proprietà
-  - Referenza
-translation_of: Web/API/Node/nodeType
-original_slug: Web/API/Element/nodeType
----
-<div>{{APIRef("DOM")}}</div>
-
-<p><span class="seoSummary">La proprietà di sola lettura <code><strong>Node.nodeType</strong></code> è un numero intero che identifica il nodo. Distingue tra diversi tipi di nodi tra loro, come {{domxref("Element", "elements")}}, {{domxref("Text", "text")}} and {{domxref("Comment", "comments")}}.</span></p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox">var <em><var>type</var></em> = <em>node</em>.nodeType;
-</pre>
-
-<p>Restituisce un numero intero che specifica il tipo del nodo. I valori possibili sono elencati in {{anch("Tipi di nodi costanti")}}.</p>
-
-<h2 id="Constanti">Constanti</h2>
-
-<h3 id="Tipi_di_nodi_costanti">Tipi di nodi costanti</h3>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Constante</th>
-   <th scope="col">Valore</th>
-   <th scope="col">Descrizione</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>Node.ELEMENT_NODE</code></td>
-   <td><code>1</code></td>
-   <td>Un nodo {{domxref("Element")}} come {{HTMLElement("p")}} o {{HTMLElement("div")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.TEXT_NODE</code></td>
-   <td><code>3</code></td>
-   <td>L'attuale {{domxref("Text")}} dentro un {{domxref("Element")}} o {{domxref("Attr")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.CDATA_SECTION_NODE</code></td>
-   <td><code>4</code></td>
-   <td>Una {{domxref("CDATASection")}}, ad esempio <code>&lt;!CDATA[[ … ]]&gt;</code>.</td>
-  </tr>
-  <tr>
-   <td><code>Node.PROCESSING_INSTRUCTION_NODE</code></td>
-   <td><code>7</code></td>
-   <td>Una {{domxref("ProcessingInstruction")}} di un documento XML, come <code>&lt;?xml-stylesheet … ?&gt;</code>.</td>
-  </tr>
-  <tr>
-   <td><code>Node.COMMENT_NODE</code></td>
-   <td><code>8</code></td>
-   <td>Un nodo {{domxref("Comment")}}, come <code>&lt;!-- … --&gt;</code>.</td>
-  </tr>
-  <tr>
-   <td><code>Node.DOCUMENT_NODE</code></td>
-   <td><code>9</code></td>
-   <td>Un nodo {{domxref("Document")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.DOCUMENT_TYPE_NODE</code></td>
-   <td><code>10</code></td>
-   <td>Un nodo {{domxref("DocumentType")}}, come <code>&lt;!DOCTYPE html&gt;</code>.</td>
-  </tr>
-  <tr>
-   <td><code>Node.DOCUMENT_FRAGMENT_NODE</code></td>
-   <td><code>11</code></td>
-   <td>Un nodo {{domxref("DocumentFragment")}}.</td>
-  </tr>
- </tbody>
-</table>
-
-<h3 id="Tipi_di_nodo_deprecati_deprecated_inline()">Tipi di nodo deprecati {{deprecated_inline()}}</h3>
-
-<div class="blockIndicator note">
-<p>Le seguenti costanti sono state deprecate e non dovrebbero essere più utilizzate.</p>
-</div>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td>Constante</td>
-   <td>Valore</td>
-   <td>Descrizione</td>
-  </tr>
-  <tr>
-   <td><code>Node.ATTRIBUTE_NODE</code></td>
-   <td>2</td>
-   <td>Un {{domxref("Attr", "Attribute")}} di un {{domxref("Element")}}. Gli attributi non implementano più l'interfaccia {{domxref("Node")}} dal {{SpecName("DOM4")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.ENTITY_REFERENCE_NODE</code></td>
-   <td>5</td>
-   <td>Un nodo di riferimento di entità XML, come <code>&amp;foo;</code>. Rimosso nel {{SpecName("DOM4")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.ENTITY_NODE</code></td>
-   <td>6</td>
-   <td>Un nodo XML <code>&lt;!ENTITY …&gt;</code>. Rimosso nel {{SpecName("DOM4")}}.</td>
-  </tr>
-  <tr>
-   <td><code>Node.NOTATION_NODE</code></td>
-   <td>12</td>
-   <td>Un nodo XML <code>&lt;!NOTATION …&gt;</code>. Rimosso nel {{SpecName("DOM4")}}.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Esempi">Esempi</h2>
-
-<h3 id="Diversi_tipi_di_nodi">Diversi tipi di nodi</h3>
-
-<pre class="brush: js">document.nodeType === Node.DOCUMENT_NODE; // true
-document.doctype.nodeType === Node.DOCUMENT_TYPE_NODE; // true
-
-document.createDocumentFragment().nodeType === Node.DOCUMENT_FRAGMENT_NODE; // true
-
-var p = document.createElement("p");
-p.textContent = "Once upon a time…";
-
-p.nodeType === Node.ELEMENT_NODE; // true
-p.firstChild.nodeType === Node.TEXT_NODE; // true
-</pre>
-
-<h3 id="Commenti">Commenti</h3>
-
-<p>Questo esempio controlla se il primo nodo all'interno dell'elemento del documento è un commento e visualizza un messaggio in caso contrario.</p>
-
-<pre class="brush: js">var node = document.documentElement.firstChild;
-if (node.nodeType !== Node.COMMENT_NODE) {
-  console.warn("Dovresti commentare il tuo codice!");
-}
-</pre>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-nodetype', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Deprecated <code>ATTRIBUTE_NODE</code>, <code>ENTITY_REFERENCE_NODE</code> and <code>NOTATION_NODE</code> types.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-1950641247', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Nessun cambiamento.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-111237558', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Nessun cambiamento.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#ID-111237558', 'Node.nodeType')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Definizione iniziale.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.nodeType")}}</p>
diff --git a/files/it/web/api/node/nodevalue/index.html b/files/it/web/api/node/nodevalue/index.html
deleted file mode 100644
index 6eef21baad..0000000000
--- a/files/it/web/api/node/nodevalue/index.html
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: element.nodeValue
-slug: Web/API/Node/nodeValue
-tags:
-  - DOM
-  - Gecko
-  - Reference_del_DOM_di_Gecko
-  - Tutte_le_categorie
-translation_of: Web/API/Node/nodeValue
-original_slug: Web/API/Element/nodeValue
----
-<p>{{ ApiRef() }}</p>
-<h3 id="Sommario" name="Sommario">Sommario</h3>
-<p>Restituisce il valore del nodo corrente.</p>
-<h3 id="Sintassi" name="Sintassi">Sintassi</h3>
-<pre class="eval"><em>valore</em> = document.nodeValue
-</pre>
-<p><code>valore</code> è una stringa contenente il valore del nodo corrente, se esiste.</p>
-<h3 id="Note" name="Note">Note</h3>
-<p>La proprietà <code>nodeValue</code> dell'intero documento, restituisce <code>null</code>. Per un nodo di tipo testo, commento o CDATA, <code>nodeValue</code> restituisce il contenuto del nodo. Per i nodi attributo, restituisce il valore dell'attributo.</p>
-<p>La tabella seguente mostra i valori restituiti per i vari tipi di elementi:</p>
-<table>
- <tbody>
-  <tr>
-   <td>Attr</td>
-   <td>il valore dell'attributo</td>
-  </tr>
-  <tr>
-   <td>CDATASection</td>
-   <td>il contenuto della sezione CDATA</td>
-  </tr>
-  <tr>
-   <td>Comment</td>
-   <td>il commento</td>
-  </tr>
-  <tr>
-   <td>Document</td>
-   <td>null</td>
-  </tr>
-  <tr>
-   <td>DocumentFragment</td>
-   <td>null</td>
-  </tr>
-  <tr>
-   <td>DocumentType</td>
-   <td>null</td>
-  </tr>
-  <tr>
-   <td>Element</td>
-   <td>null</td>
-  </tr>
-  <tr>
-   <td>NamedNodeMap</td>
-   <td>null</td>
-  </tr>
-  <tr>
-   <td>EntityReference</td>
-   <td>null</td>
-  </tr>
-  <tr>
-   <td>Notation</td>
-   <td>null</td>
-  </tr>
-  <tr>
-   <td>ProcessingInstruction</td>
-   <td>l'intero contenuto, escluso il target</td>
-  </tr>
-  <tr>
-   <td>Text</td>
-   <td>il contenuto del nodo testo</td>
-  </tr>
- </tbody>
-</table>
-<p>Quando <code>nodeValue</code> è impostato a <code>null</code>, reimpostarlo non ha alcun effetto.</p>
-<h3 id="Specifiche" name="Specifiche">Specifiche</h3>
-<p><a class="external" href="http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-F68D080">nodeValue </a></p>
diff --git a/files/it/web/api/node/parentnode/index.html b/files/it/web/api/node/parentnode/index.html
deleted file mode 100644
index 610cc3e5e4..0000000000
--- a/files/it/web/api/node/parentnode/index.html
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: Node.parentNode
-slug: Web/API/Node/parentNode
-tags:
-  - API
-  - DOM
-  - Gecko
-  - Proprietà
-translation_of: Web/API/Node/parentNode
-original_slug: Web/API/Element/parentNode
----
-<div>
-<div>{{APIRef("DOM")}}</div>
-</div>
-
-<p>La proprietà di sola lettura <code><strong>Node.parentNode</strong></code> restituisce il genitore del nodo specificato nell'albero DOM.</p>
-
-<h2 id="Syntax" name="Syntax">Sintassi</h2>
-
-<pre class="syntaxbox"><em>parentNode</em> = <em>node</em>.parentNode
-</pre>
-
-<p><code>parentNode</code> è il genitore del nodo corrente. Il genitore di un elemento è un nodo <code>Element</code>, un nodo <code>Document</code>, o un nodo <code>DocumentFragment</code>.</p>
-
-<h2 id="Example" name="Example">Esempio</h2>
-
-<pre class="brush:js">if (node.parentNode) {
-  // rimuovi un nodo dall'albero, a meno che
-  // non sia già nell'albero
-  node.parentNode.removeChild(node);
-}</pre>
-
-<h2 id="Notes" name="Notes">Note</h2>
-
-<p>I <a href="/it/docs/Web/API/Element/nodeType">nodi</a> <code>Document</code> e <code>DocumentFragment</code> non possono mai avere un genitore, quindi <code>parentNode</code> ritornerà sempre <code>null</code>.</p>
-
-<p>Restituisce anche <code>null</code> se il nodo è appena stato creato e non è ancora collegato all'albero.</p>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.parentNode")}}</p>
-
-<h2 id="Specification" name="Specification">Specifiche</h2>
-
-<ul>
- <li><a class="external" href="http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-1060184317">DOM Level 2 Core: Node.parentNode</a></li>
- <li><a class="external" href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-1060184317">DOM Level 3 Core: Node.parentNode</a></li>
-</ul>
-
-<h2 id="See_also" name="See_also">Vedi anche</h2>
-
-<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>
diff --git a/files/it/web/api/node/previoussibling/index.html b/files/it/web/api/node/previoussibling/index.html
deleted file mode 100644
index 735433da9e..0000000000
--- a/files/it/web/api/node/previoussibling/index.html
+++ /dev/null
@@ -1,81 +0,0 @@
----
-title: Node.previousSibling
-slug: Web/API/Node/previousSibling
-translation_of: Web/API/Node/previousSibling
----
-<div>
-<div>{{APIRef("DOM")}}</div>
-</div>
-
-<p>La proprietà di sola lettura <code><strong>Node.previousSibling</strong></code> restituisce il nodo immediatamente precedente a quello specificato nell'elenco {{domxref("Node.childNodes", "childNodes")}} del genitore, o <code>null</code> se il nodo specificato è il primo in tale elenco.</p>
-
-<h2 id="Syntax" name="Syntax">Sintassi</h2>
-
-<pre class="syntaxbox"><var>previousNode</var> = <em>node</em>.previousSibling;
-</pre>
-
-<h2 id="Example" name="Example">Esempio</h2>
-
-<pre class="brush: html">&lt;img id="b0"&gt;
-&lt;img id="b1"&gt;
-&lt;img id="b2"&gt;</pre>
-
-<pre class="brush:js">console.log(document.getElementById("b1").previousSibling); // &lt;img id="b0"&gt;
-console.log(document.getElementById("b2").previousSibling.id); // "b1"
-</pre>
-
-<h2 id="Notes" name="Notes">Appunti</h2>
-
-<div>
-<p>I browser basati su Gecko inseriscono nodi di testo in un documento per rappresentare gli spazi bianchi nel codice sorgente. Pertanto, un nodo ottenuto, ad esempio, utilizzando <a href="/it/docs/Web/API/Node/firstChild" title="The Node.firstChild read-only property returns the node's first child in the tree, or null if the node has no children."><code>Node.firstChild</code></a> o <a href="/it/docs/Web/API/Node/previousSibling" title="The Node.previousSibling read-only property returns the node immediately preceding the specified one in its parent's childNodes list, or null if the specified node is the first in that list."><code>Node.previousSibling</code></a> può fare riferimento a un nodo di testo di spazi bianchi piuttosto che all'elemento effettivo che l'autore intendeva ottenere.</p>
-
-<p>Vedi <a href="/en-US/docs/Web/Guide/DOM/Whitespace_in_the_DOM">Whitespace in the DOM</a> e <a class="external" href="http://www.w3.org/DOM/faq.html#emptytext" rel="noopener">W3C DOM 3 FAQ: Why are some Text nodes empty?</a> per maggiori informazioni.</p>
-</div>
-
-<p>Per navigare nella direzione opposta attraverso l'elenco dei nodi secondari usa <a href="/it/docs/Web/API/Node.nextSibling" title="DOM/Node.nextSibling">Node.nextSibling</a>.</p>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-node-previousSibling', 'Node.previousSibling')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM3 Core', 'core.html#ID-640FB3C8', 'Node.previousSibling')}}</td>
-   <td>{{Spec2('DOM3 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM2 Core', 'core.html#ID-640FB3C8', 'Node.previousSibling')}}</td>
-   <td>{{Spec2('DOM2 Core')}}</td>
-   <td>Nessun cambiamento</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM1', 'level-one-core.html#attribute-previousSibling', 'Node.previousSibling')}}</td>
-   <td>{{Spec2('DOM1')}}</td>
-   <td>Definizione iniziale</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.previousSibling")}}</p>
-
-<h2 id="Vedi_anche">Vedi anche</h2>
-
-<ul>
- <li>{{domxref("Node.nextSibling")}}</li>
-</ul>
diff --git a/files/it/web/api/node/textcontent/index.html b/files/it/web/api/node/textcontent/index.html
deleted file mode 100644
index bd2186323e..0000000000
--- a/files/it/web/api/node/textcontent/index.html
+++ /dev/null
@@ -1,139 +0,0 @@
----
-title: Node.textContent
-slug: Web/API/Node/textContent
-tags:
-  - API
-  - Command API
-  - DOM
-  - Proprietà
-  - Referenza
-translation_of: Web/API/Node/textContent
-original_slug: Web/API/Element/textContent
----
-<div>{{APIRef("DOM")}}</div>
-
-<p>La proprietà <code><strong>textContent</strong></code> dell'interfaccia {{domxref("Node")}} rappresenta il contenuto del testo di un nodo e dei suoi discendenti.</p>
-
-<div class="blockIndicator note">
-<p><strong>Note:</strong> <code>textContent</code> e {{domxref("HTMLElement.innerText")}} sono facilmente confusi, ma <a href="#Differenze_da_innerText">i due sono diversi in modi molto importanti</a>.</p>
-</div>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox">var <em>text</em> = <em>Node</em>.textContent;
-<em>Node</em>.textContent = <em>string</em>;
-</pre>
-
-<h3 id="Valore_di_ritorno">Valore di ritorno</h3>
-
-<p>Una stringa o <code>null</code>.</p>
-
-<h2 id="Descrizione">Descrizione</h2>
-
-<p>Quando ottieni questa proprietà:</p>
-
-<ul>
- <li>Se il nodo è <a href="/en-US/docs/DOM/document">document</a>, <a href="/en-US/docs/Glossary/Doctype">DOCTYPE</a>, o una <a href="/en-US/docs/Web/API/Notation">notation</a>, <code>textContent</code> ritorna <code>null</code>. (Per ottenere tutto il testo e i <a href="/en-US/docs/Web/API/CDATASection">dati CDATA</a> per l'intero documento, si potrebbe usare <code><a href="https://developer.mozilla.org/it/docs/Web/API/Document/documentElement">document.documentElement</a>.textContent</code>.)</li>
- <li>Se il nodo è una <a href="/en-US/docs/Web/API/CDATASection">sezione CDATA</a>, un commento, <a href="/en-US/docs/Web/API/ProcessingInstruction">istruzione di elaborazione</a>, o <a href="/en-US/docs/Web/API/Document/createTextNode">nodo di testo</a>, <code>textContent</code> restituisce il testo all'interno del nodo, cioè {{domxref("Node.nodeValue")}}.</li>
- <li>Per altri tipi di nodo, <code>textContent</code> restituisce la concatenazione del <code>textContent</code> di ogni nodo figlio, esclusi i commenti e le istruzioni di elaborazione. Questa è una stringa vuota se il nodo non ha figli.</li>
-</ul>
-
-<p>L'impostazione di <code>textContent</code> su un nodo rimuove tutti i figli del nodo e li sostituisce con un singolo nodo di testo con il valore di stringa specificato.</p>
-
-<h3 id="Differenze_da_innerText">Differenze da innerText</h3>
-
-<p>Non lasciarti confondere dalle differenze tra <code>Node.textContent</code> e {{domxref("HTMLElement.innerText")}}. Anche se i nomi sembrano simili, ci sono differenze importanti:</p>
-
-<ul>
- <li><code>textContent</code> ottiene il contenuto di tutti gli elementi, compresi gli elementi {{HTMLElement("script")}} e {{HTMLElement("style")}}. Al contrario, <code>innerText</code> mostra solo elementi "leggibili".</li>
- <li><code>textContent</code> restituisce ogni elemento nel nodo. Al contrario, <code>innerText</code> è consapevole dello stile e non restituirà il testo di elementi "nascosti". Inoltre, poiché <code>innerText</code> prende in considerazione gli stili CSS, la lettura del valore di <code>innerText</code> aziona un <a href="/it/docs/Glossary/Reflow">reflow</a> per garantire stili aggiornati. (I reflow possono essere computazionalmente costosi, e quindi dovrebbero essere evitati quando possibile.)</li>
- <li>A differenza di <code>textContent</code>, la modifica di <code>innerText</code> in Internet Explorer (versione 11 e inferiore) rimuove i nodi figlio dall'elemento e <em>distrugge in modo permanente</em> tutti i nodi di testo discendenti. È impossibile inserire nuovamente i nodi in qualsiasi altro elemento o nello stesso elemento.</li>
-</ul>
-
-<h3 id="Differenze_da_innerHTML">Differenze da innerHTML</h3>
-
-<p>{{domxref("Element.innerHTML")}} restituisce HTML, come indica il nome. A volte le persone usano <code>innerHTML</code> per recuperare o scrivere testo all'interno di un elemento, ma <code>textContent</code> ha prestazioni migliori perché il suo valore non viene analizzato come HTML. Inoltre, l'utilizzo di <code>textContent</code> può impedire <a href="/en-US/docs/Glossary/Cross-site_scripting">gli attacchi XSS</a>.</p>
-
-<h2 id="Esempi">Esempi</h2>
-
-<p>Dato questo codice HTML:</p>
-
-<pre class="brush: html">&lt;div id="divA"&gt;Questo è &lt;span&gt;un&lt;/span&gt; testo!&lt;/div&gt;</pre>
-
-<p>...puoi usare <code>textContent</code> per ottenere il contenuto del testo dell'elemento:</p>
-
-<pre class="brush: js">let text = document.getElementById('divA').textContent;
-// La variabile text è ora: "Questo è un testo!"</pre>
-
-<p>...o imposta il contenuto del testo dell'elemento:</p>
-
-<pre class="brush: js">document.getElementById('divA').textContent = 'Questo testo è diverso!';
-// L'HTML per divA è ora:
-// &lt;div id="divA"&gt;Questo testo è diverso!&lt;/div&gt;
-</pre>
-
-<h2 id="Polyfill_per_IE8">Polyfill per IE8</h2>
-
-<pre class="brush: js">// Source: Eli Grey @ https://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) {
-  (function() {
-    var innerText = Object.getOwnPropertyDescriptor(Element.prototype, "innerText");
-    Object.defineProperty(Element.prototype, "textContent",
-     // Passare innerText o innerText.get direttamente non funziona,
-     // è richiesta la funzione wrapper.
-     {
-       get: function() {
-         return innerText.get.call(this);
-       },
-       set: function(s) {
-         return innerText.set.call(this, s);
-       }
-     }
-   );
-  })();
-}
-</pre>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("api.Node.textContent")}}</p>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="spectable standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG','#dom-node-textcontent','Node.textContent')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Nessun cambiamento vs. 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>Introdotto</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Vedi_anche">Vedi anche</h2>
-
-<ul>
- <li>{{domxref("HTMLElement.innerText")}}</li>
- <li>{{domxref("Element.innerHTML")}}</li>
- <li><a href="http://perfectionkills.com/the-poor-misunderstood-innerText/">Maggiori informazioni sulle differenze tra <code>innerText</code> e <code>textContent</code></a> (blog post)</li>
-</ul>