delete conflicting/orphaned in pt-BR (#1421)

* delete conflicting/orphaned in pt-BR * chore: remove empty line * deleted last orphaned redirects * remove deleted orphans Co-authored-by: Josiel Rocha <1158643+josielrocha@users.noreply.github.com> Co-authored-by: Josiel Rocha <josiel.rocha@gmail.com>
author: Peter Bengtsson <mail@peterbe.com> 2021-07-11 09:25:19 -0400
committer: GitHub <noreply@github.com> 2021-07-11 10:25:19 -0300
commit: 7053a316d36dc8193eb102d0cba46f4970a05637 (patch)
tree: 65e1b5586cb94cfb16300f496c7287d03a7aa251 /files/pt-br/orphaned/web
parent: 0cce4493c05cd8f7becf8e1de289259bef488986 (diff)
download: translated-content-7053a316d36dc8193eb102d0cba46f4970a05637.tar.gz
translated-content-7053a316d36dc8193eb102d0cba46f4970a05637.tar.bz2
translated-content-7053a316d36dc8193eb102d0cba46f4970a05637.zip
52 files changed, 0 insertions, 6628 deletions
diff --git a/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html b/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html
deleted file mode 100644
index 40fc26b856..0000000000
--- a/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Problemas com JAWS no Firefox
-slug: orphaned/Web/Accessibility/JAWS_Issues_with_Firefox
-tags:
-  - Acessibilidade
-  - Obsolento
-translation_of: Web/Accessibility/JAWS_Issues_with_Firefox
-original_slug: Web/Acessibilidade/Problemas_com_JAWS_no_Firefox
----
-<h2 id="Known_JAWS_Firefox_Issues" name="Known_JAWS_Firefox_Issues">Problemas JAWS Firefox conhecidos</h2>
-
-<p>Esse artigo não é mais relevante. Por favor, veja o <a class="external" href="http://support.mozilla.com/en-US/kb/Firefox+3+with+Screen+Readers+FAQ" title="http://support.mozilla.com/en-US/kb/Firefox+3+with+Screen+Readers+FAQ">FAQ</a> no site de suporte Mozilla.</p>
diff --git a/files/pt-br/orphaned/web/api/abstractworker/index.html b/files/pt-br/orphaned/web/api/abstractworker/index.html
deleted file mode 100644
index 2b5355f865..0000000000
--- a/files/pt-br/orphaned/web/api/abstractworker/index.html
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: AbstractWorker
-slug: orphaned/Web/API/AbstractWorker
-translation_of: Web/API/AbstractWorker
-original_slug: Web/API/AbstractWorker
----
-<p>{{ APIRef("Web Workers API") }}</p>
-
-<h2 id="Resumo">Resumo</h2>
-
-<p>A interface <strong><code>AbstractWorker</code></strong> abstrai propriedades e métodos comuns para todo o tipo de Workers, sendo {{domxref("Worker")}} ou {{domxref("SharedWorker")}}.</p>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<p><em>A interface <code>AbstractWorker</code></em><em> não herda qualquer propriedade..</em></p>
-
-<dl>
- <dt>{{domxref("AbstractWorker.onerror")}}</dt>
- <dd>É um {{ domxref("EventListener") }} que é chamado sempre que um {{domxref("ErrorEvent")}} do tipo <code>error</code> borbulha através do Worker.</dd>
-</dl>
-
-<h2 id="Métodos">Métodos</h2>
-
-<p><em>A interface <code>AbstractWorker</code></em><em> não implementa ou herda qualquer método.</em></p>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('HTML WHATWG', "#the-abstractworker-abstract-interface", "AbstractWorker")}}</td>
-   <td>{{Spec2('HTML WHATWG')}}</td>
-   <td>Sem mudanças para {{SpecName("Web Workers")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('Web Workers', "#the-abstractworker-abstract-interface", "AbstractWorker")}}</td>
-   <td>{{Spec2('HTML5 W3C')}}</td>
-   <td>Definição Inicial</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Recurso</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari (WebKit)</th>
-  </tr>
-  <tr>
-   <td>Suporte Básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Recurso</th>
-   <th>Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Phone</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte Básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>O {{domxref("Worker")}} e {{domxref("SharedWorker")}} herdá-lo.</li>
-</ul>
-
-<p> </p>
diff --git a/files/pt-br/orphaned/web/api/abstractworker/onerror/index.html b/files/pt-br/orphaned/web/api/abstractworker/onerror/index.html
deleted file mode 100644
index 9ad74fd3fe..0000000000
--- a/files/pt-br/orphaned/web/api/abstractworker/onerror/index.html
+++ /dev/null
@@ -1,105 +0,0 @@
----
-title: AbstractWorker.onerror
-slug: orphaned/Web/API/AbstractWorker/onerror
-translation_of: Web/API/AbstractWorker/onerror
-original_slug: Web/API/AbstractWorker/onerror
----
-<p>{{ APIRef("Web Workers API") }}</p>
-
-<h2 id="Resumo">Resumo</h2>
-
-<p>A propriedade <code><strong>AbstractWorker</strong></code><strong><code>.onerror</code></strong> da interface {{domxref("AbstractWorker")}} representa um {{event("Event_handlers", "event handler")}}, que é uma função a ser chamada quando o evento {{event("error")}} ocorre através de um balão de notificação {{domxref("Worker")}}.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">myWorker.onerror = function() { ... };</pre>
-
-<h2 id="Exemplo">Exemplo</h2>
-
-<p>O seguinte trecho de código mostra criação de um objeto <a href="https://developer.mozilla.org/en-US/docs/Web/API/Worker" title="The Worker interface represents a background task that can be easily created and can send messages back to its creator. Creating a worker is as simple as calling the Worker() constructor and specifying a script to be run in the worker thread."><code>Worker</code></a> usando o construtor de <a href="https://developer.mozilla.org/en-US/docs/Web/API/Worker.Worker" title="The Worker() constructor creates a Worker that executes the script at the specified URL. This script must obey the same-origin policy."><code>Worker()</code></a> e criando um manipulador <code>onerror</code> no objeto resultante:</p>
-
-<pre class="brush: js">var myWorker = new Worker("worker.js");
-
-myWorker.onerror = function() {
-  console.log('Há um erro com o seu worker!');
-}</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('HTML WHATWG', "#handler-abstractworker-onerror", "AbstractWorker.onerror")}}</td>
-   <td>{{Spec2('HTML WHATWG')}}</td>
-   <td>Nenhuma mudança em {{SpecName("Web Workers")}}.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('Web Workers', "#handler-abstractworker-onerror", "AbstractWorker.onerror")}}</td>
-   <td>{{Spec2('Web Workers')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_Navegadores">Compatibilidade dos Navegadores</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Características</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari (WebKit)</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatChrome(4)}}</td>
-   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
-   <td>10</td>
-   <td>10.6</td>
-   <td>4</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Características</th>
-   <th>Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>Firefox OS (Gecko)</th>
-   <th>IE Phone</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>4.4</td>
-   <td>{{CompatGeckoMobile("1.9.1")}}</td>
-   <td>1.0.1</td>
-   <td>10</td>
-   <td>11.5</td>
-   <td>5.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>A interface {{domxref("AbstractWorker")}} a que pertence.</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/ambient_light_events/index.html b/files/pt-br/orphaned/web/api/ambient_light_events/index.html
deleted file mode 100644
index 92bcf75e04..0000000000
--- a/files/pt-br/orphaned/web/api/ambient_light_events/index.html
+++ /dev/null
@@ -1,117 +0,0 @@
----
-title: Ambient Light Events
-slug: orphaned/Web/API/Ambient_Light_Events
-tags:
-  - Ambiente de luz
-  - Ambiente de luz API
-  - Ambiente e luz HTML5 API
-translation_of: Web/API/Ambient_Light_Events
-original_slug: Web/API/Ambient_Light_Events
----
-<div>Os eventos de luz ambiente são uma maneira útil de tornar uma página da Web ou uma aplicação consciente de qualquer alteração na intensidade da luz. Isso permite que eles reajam a tal mudança, por exemplo alterando o contraste de cores da interface do usuário (UI) ou alterando a exposição necessária para tirar uma foto.</div>
-
-<div> </div>
-
-<h2 id="Eventos_de_luz">Eventos de  luz</h2>
-
-<p>Quando o sensor de luz de um dispositivo detecta uma mudança no nível de luz, ele notifica o navegador dessa alteração. Quando o navegador obtém tal notificação, ele dispara um evento <a href="https://developer.mozilla.org/en-US/docs/Web/API/DeviceLightEvent">DeviceLightEvent </a>que fornece informações sobre a intensidade da luz exata.</p>
-
-<p>Este evento pode ser capturado no nível do objeto da janela usando o método <a href="https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener">addEventListener </a>(usando o nome do evento <a href="https://developer.mozilla.org/en-US/docs/Web/Events/devicelight">devicelight</a>) ou anexando um manipulador de eventos à propriedade <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/ondevicelight">window.ondevicelight</a>.</p>
-
-<p>Uma vez capturado, o objeto de evento dá acesso à intensidade da luz expressa em <a href="http://en.wikipedia.org/wiki/Lux">lux </a>através da propriedade <a href="https://developer.mozilla.org/en-US/docs/Web/API/DeviceLightEvent/value">DeviceLightEvent.value</a>.</p>
-
-<h2 id="Exemplo">Exemplo</h2>
-
-<pre class="brush: js">window.addEventListener('devicelight', function(event) {
-  var html = document.getElementsByTagName('html')[0];
-
-  if (event.value &lt; 50) {
-    html.classList.add('darklight');
-    html.classList.remove('brightlight');
-  } else {
-    html.classList.add('brightlight');
-    html.classList.remove('darklight');
-  }
-});</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estatus</th>
-   <th scope="col">Comentário</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="https://w3c.github.io/ambient-light/">Sensor de luz ambiente A definição de "Ambient Light Events" nessa especificação</a>.</td>
-   <td>
-    <p>Rascunho do Editor</p>
-   </td>
-   <td>Definição inicial</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>{{domxref("DeviceLightEvent")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatGeckoDesktop("22.0")}}<sup>[1]</sup></td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>{{domxref("DeviceLightEvent")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>support</td>
-   <td>{{CompatGeckoMobile("15.0")}}<sup>[1]</sup></td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p>[1] O evento "<a href="https://developer.mozilla.org/en-US/docs/Web/Events/devicelight">devicelight</a>" é implementado e a preferência ativada por padrão no Firefox Mobile para Android (15.0) e no Firefox OS (B2G). Começando com Gecko 22.0 geckoRelease ("22.0"), uma implementação de desktop para Mac OS X também está disponível. O suporte para o Windows 7 está em andamento (veja <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=754199">bug (754199)</a>).</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/DeviceLightEvent">DeviceLightEvent</a></li>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/Events/devicelight">event("devicelight")</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/body/index.html b/files/pt-br/orphaned/web/api/body/index.html
deleted file mode 100644
index fb7edd01c1..0000000000
--- a/files/pt-br/orphaned/web/api/body/index.html
+++ /dev/null
@@ -1,98 +0,0 @@
----
-title: Body
-slug: orphaned/Web/API/Body
-tags:
-  - API
-  - BODY
-  - Experimental
-  - Fetch
-  - Fetch API
-  - Interface
-  - NeedsTranslation
-  - Reference
-  - TopicStub
-  - request
-translation_of: Web/API/Body
-original_slug: Web/API/Body
----
-<div>{{ APIRef("Fetch") }}</div>
-
-<p><span class="seoSummary">The <strong><code>Body</code></strong> {{glossary("mixin")}} of the <a href="/en-US/docs/Web/API/Fetch_API">Fetch API</a> represents the body of the response/request, allowing you to declare what its content type is and how it should be handled.</span></p>
-
-<p><code>Body</code> is implemented by both {{domxref("Request")}} and {{domxref("Response")}}. This provides these objects with an associated <dfn>body</dfn> (a <a href="/en-US/docs/Web/API/Streams_API">stream</a>), a <dfn>used flag</dfn> (initially unset), and a <dfn>MIME type</dfn> (initially the empty byte sequence).</p>
-
-<h2 id="Properties">Properties</h2>
-
-<dl>
- <dt>{{domxref("Body.body")}} {{readonlyInline}}</dt>
- <dd>A simple getter used to expose a {{domxref("ReadableStream")}} of the body contents.</dd>
- <dt>{{domxref("Body.bodyUsed")}} {{readonlyInline}}</dt>
- <dd>A {{jsxref("Boolean")}} that indicates whether the body has been read.</dd>
-</dl>
-
-<h2 id="Methods">Methods</h2>
-
-<dl>
- <dt>{{domxref("Body.arrayBuffer()")}}</dt>
- <dd>Takes a {{domxref("Response")}} stream and reads it to completion. It returns a promise that resolves with an {{jsxref("ArrayBuffer")}}.</dd>
- <dt>{{domxref("Body.blob()")}}</dt>
- <dd>Takes a {{domxref("Response")}} stream and reads it to completion. It returns a promise that resolves with a {{domxref("Blob")}}.</dd>
- <dt>{{domxref("Body.formData()")}}</dt>
- <dd>Takes a {{domxref("Response")}} stream and reads it to completion. It returns a promise that resolves with a {{domxref("FormData")}} object.</dd>
- <dt>{{domxref("Body.json()")}}</dt>
- <dd>Takes a {{domxref("Response")}} stream and reads it to completion. It returns a promise that resolves with the result of parsing the body text as {{jsxref("JSON")}}.</dd>
- <dt>{{domxref("Body.text()")}}</dt>
- <dd>Takes a {{domxref("Response")}} stream and reads it to completion. It returns a promise that resolves with a {{domxref("USVString")}} (text). The response is <em>always</em> decoded using UTF-8.</dd>
-</dl>
-
-<h2 id="Examples">Examples</h2>
-
-<p>The example below uses a simple fetch call to grab an image and display it in an {{htmlelement("img")}} tag. You'll notice that since we are requesting an image, we need to run {{domxref("Body.blob","Body.blob()")}} ({{domxref("Response")}} implements body) to give the response its correct MIME type.</p>
-
-<h3 id="HTML_Content">HTML Content</h3>
-
-<pre class="brush: html notranslate">&lt;img class="my-image" src="https://wikipedia.org/static/images/project-logos/frwiki-1.5x.png"&gt;
-</pre>
-
-<h3 id="JS_Content">JS Content</h3>
-
-<pre class="brush: js notranslate">const myImage = document.querySelector('.my-image');
-fetch('https://upload.wikimedia.org/wikipedia/commons/7/77/Delete_key1.jpg')
-	.then(res =&gt; res.blob())
-	.then(res =&gt; {
-		const objectURL = URL.createObjectURL(res);
-		myImage.src = objectURL;
-});</pre>
-
-<p>{{ EmbedLiveSample('Examples', '100%', '250px') }}</p>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('Fetch','#body-mixin','Body')}}</td>
-   <td>{{Spec2('Fetch')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-
-
-<p>{{Compat("api.Body")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/API/ServiceWorker_API">ServiceWorker API</a></li>
- <li><a href="/en-US/docs/Web/HTTP/CORS">HTTP access control (CORS)</a></li>
- <li><a href="/en-US/docs/Web/HTTP">HTTP</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/body/json/index.html b/files/pt-br/orphaned/web/api/body/json/index.html
deleted file mode 100644
index e49273e9ba..0000000000
--- a/files/pt-br/orphaned/web/api/body/json/index.html
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: Body.json()
-slug: orphaned/Web/API/Body/json
-tags:
-  - API
-  - Experimental
-  - Fetch
-  - JSON
-  - Referencia
-translation_of: Web/API/Body/json
-original_slug: Web/API/Body/json
----
-<div>{{APIRef("Fetch API")}}</div>
-
-<p>O método <strong><code>json()</code></strong>  do mixin {{DOMxRef("Body")}} usa uma stream do objeto {{DOMxRef("Response")}} para tratar. O método <strong>json() </strong>retorna uma Promise como resultado do processamento da stream, retornando um objeto {{JSxRef("JSON")}} em caso de sucesso.</p>
-
-<h2 id="Syntaxe">Syntaxe</h2>
-
-<pre class="syntaxbox notranslate"><em>response</em>.json().then(<em>data</em> =&gt; {
-  // do something with your data
-});</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<p>Nenhum.</p>
-
-<h3 id="Retorno">Retorno</h3>
-
-<p>Uma {{jsxref("Promise")}} que retorna um objeto Javascript no método <strong>resolve()</strong>. Pode ser qualquer tipo que pode ser representado com JSON — objeto, array, string, numeral...</p>
-
-<h2 id="Exemplo">Exemplo</h2>
-
-<p>Em nosso <a href="https://github.com/mdn/fetch-examples/tree/master/fetch-json">exemplo de fetch em json</a> (teste <a href="http://mdn.github.io/fetch-examples/fetch-json/">aqui a busca em json com fetch</a>), nós criamos uma nova requisição usando o constructor de {{DOMxRef("Request.Request", "Request()")}}, e em seguimos a usamos para buscar um arquivo <code>.json</code>. Quando o fetch é bem-sucedido, nós lemos e tratamos a stream com o método <code>json()</code>, lê os valores em forma de objeto retornados como esperado e inserimos na lista para exibir os dados dos produtos.</p>
-
-<pre class="brush: js highlight[5] notranslate">const myList = document.querySelector('ul');
-const myRequest = new Request('products.json');
-
-fetch(myRequest)
-  .then(response =&gt; response.json())
-  .then(data =&gt; {
-    for (const product of data.products) {
-      let listItem = document.createElement('li');
-      listItem.appendChild(
-        document.createElement('strong')
-      ).textContent = product.Name;
-      listItem.append(
-        ` can be found in ${
-          product.Location
-        }. Cost: `
-      );
-      listItem.appendChild(
-        document.createElement('strong')
-      ).textContent = `£${product.Price}`;
-      myList.appendChild(listItem);
-    }
-  })
-  .catch(console.error);</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specificações</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentários</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName("Fetch", "#dom-body-json", "Body.json()")}}</td>
-   <td>{{Spec2("Fetch")}}</td>
-   <td>Definição Inicial</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_Navegador">Compatibilidade de Navegador</h2>
-
-
-
-<p>{{Compat("api.Body.json")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/API/ServiceWorker_API">ServiceWorker API</a></li>
- <li><a href="/en-US/docs/Web/HTTP/CORS">Cross-Origin Resource Sharing (CORS)</a></li>
- <li><a href="/en-US/docs/Web/HTTP">HTTP</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/childnode/after/index.html b/files/pt-br/orphaned/web/api/childnode/after/index.html
deleted file mode 100644
index 8fa84d11ee..0000000000
--- a/files/pt-br/orphaned/web/api/childnode/after/index.html
+++ /dev/null
@@ -1,186 +0,0 @@
----
-title: ChildNode.after()
-slug: orphaned/Web/API/ChildNode/after
-tags:
-  - API
-  - DOM
-  - Experimental
-  - Nó
-  - Referencia
-  - metodo
-translation_of: Web/API/ChildNode/after
-original_slug: Web/API/ChildNode/after
----
-<div>{{APIRef("DOM")}} {{SeeCompatTable}}</div>
-
-<p>The <code><strong>ChildNode</strong></code><strong><code>.after()</code></strong> method inserts a set of {{domxref("Node")}} or {{domxref("DOMString")}} objects in the children list of this <code>ChildNode</code>'s parent, just after this <code>ChildNode</code>. {{domxref("DOMString")}} objects are inserted as equivalent {{domxref("Text")}} nodes.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">[Throws, Unscopable]
-void ChildNode.after((Node or DOMString)... nodes);
-</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>nós</code></dt>
- <dd>A set of {{domxref("Node")}} or {{domxref("DOMString")}} objects to insert.</dd>
-</dl>
-
-<h3 id="Exceções">Exceções</h3>
-
-<ul>
- <li>{{domxref("HierarchyRequestError")}}: Nó não pode ser inserido até que seja especificado o ponto da hierarquia. </li>
-</ul>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Inserindo_uum_elemento">Inserindo uum elemento</h3>
-
-<pre class="brush: js">var parente = document.createElement("div");
-var filho = document.createElement("p");
-parente.appendChild(filho);
-var span = document.createElement("span");
-
-filho.after(span);
-
-console.log(parente.outerHTML);
-// "&lt;div&gt;&lt;p&gt;&lt;/p&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;"
-</pre>
-
-<h3 id="Inserindo_texto">Inserindo texto</h3>
-
-<pre class="brush: js">var parente = document.createElement("div");
-var filho = document.createElement("p");
-parente.appendChild(filho);
-
-filho.after("Text");
-
-console.log(parente.outerHTML);
-// "&lt;div&gt;&lt;p&gt;&lt;/p&gt;Text&lt;/div&gt;"</pre>
-
-<h3 id="Inserindo_um_elemento_e_um_texto">Inserindo um elemento e um texto </h3>
-
-<pre class="brush: js">var parente = document.createElement("div");
-var filho = document.createElement("p");
-parente.appendChild(filho);
-var span = document.createElement("span");
-
-filho.after(span, "Text");
-
-console.log(parente.outerHTML);
-// "&lt;div&gt;&lt;p&gt;&lt;/p&gt;&lt;span&gt;&lt;/span&gt;Text&lt;/div&gt;"</pre>
-
-<h3 id="ChildNode.after()_is_unscopable"><code>ChildNode.after()</code> is unscopable</h3>
-
-<p>The <code>after()</code> method is not scoped into the <code>with</code> statement. Veja {{jsxref("Symbol.unscopables")}} para maior infomação.</p>
-
-<pre class="brush: js">with(node) {
-  after("foo");
-}
-// ReferenceError: after is not defined </pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<p>Você pode usar polyfill com  o método <code> after() </code> no Internet Explorer 9 e com o seguinte código:</p>
-
-<pre class="brush: js">//from: https://github.com/jserz/js_piece/blob/master/DOM/ChildNode/after()/after().md
-(function (arr) {
-  arr.forEach(function (item) {
-    if (item.hasOwnProperty('after')) {
-      return;
-    }
-    Object.defineProperty(item, 'after', {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value: function after() {
-        var argArr = Array.prototype.slice.call(arguments),
-          docFrag = document.createDocumentFragment();
-
-        argArr.forEach(function (argItem) {
-          var isNode = argItem instanceof Node;
-          docFrag.appendChild(isNode ? argItem : document.createTextNode(String(argItem)));
-        });
-
-        this.parentNode.insertBefore(docFrag, this.nextSibling);
-      }
-    });
-  });
-})([Element.prototype, CharacterData.prototype, DocumentType.prototype]);</pre>
-
-<h2 id="_Polyfill_Element.prototype.after" name="_Polyfill_Element.prototype.after"> </h2>
-
-<pre class="brush: js">//https://github.com/FabioVergani/js-Polyfill_Element.prototype.after/blob/master/after.js
-
-(function(x){
- var o=x.prototype,p='after';
- if(!o[p]){
-    o[p]=function(){
-     var e, m=arguments, l=m.length, i=0, t=this, p=t.parentNode, n=Node, s=String, d=document;
-     if(p!==null){
-        while(i&lt;l){
-         e=m[i];
-         if(e instanceof n){
-            t=t.nextSibling;
-            if(t!==null){
-                p.insertBefore(e,t);
-            }else{
-                p.appendChild(e);
-            };
-         }else{
-            p.appendChild(d.createTextNode(s(e)));
-         };
-         ++i;
-        };
-     };
-    };
- };
-})(Element);
-
-
-
-/*
-min:
-
-(function(x){
- var o=x.prototype;
- o.after||(o.after=function(){var e,m=arguments,l=m.length,i=0,t=this,p=t.parentNode,n=Node,s=String,d=document;if(p!==null){while(i&lt;l){((e=m[i]) instanceof n)?(((t=t.nextSibling )!==null)?p.insertBefore(e,t):p.appendChild(e)):p.appendChild(d.createTextNode(s(e)));++i;}}});
-}(Element));
-
-*/
-</pre>
-
-<h3 id="sect1"> </h3>
-
-<h2 id="Especificação">Especificação</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-childnode-after', 'ChildNode.after()')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Initial definition.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("api.ChildNode.after")}}</p>
-
-<h2 id="Veja_mais">Veja mais</h2>
-
-<ul>
- <li>{{domxref("ChildNode")}} and {{domxref("ParentNode")}}</li>
- <li>{{domxref("ChildNode.before()")}}</li>
- <li>{{domxref("ParentNode.append()")}}</li>
- <li>{{domxref("Node.appendChild()")}}</li>
- <li>{{domxref("NodeList")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/childnode/index.html b/files/pt-br/orphaned/web/api/childnode/index.html
deleted file mode 100644
index 282b89ee3a..0000000000
--- a/files/pt-br/orphaned/web/api/childnode/index.html
+++ /dev/null
@@ -1,79 +0,0 @@
----
-title: ChildNode
-slug: orphaned/Web/API/ChildNode
-tags:
-  - API
-  - DOM
-  - Experimental
-  - Interface
-  - NeedsTranslation
-  - Node
-  - TopicStub
-translation_of: Web/API/ChildNode
-original_slug: Web/API/ChildNode
----
-<div>{{APIRef("DOM")}}</div>
-
-<div>A interface <code><strong>ChildNode</strong></code> contém métodos que são particulares para os objetos</div>
-
-<p>{{domxref("Node")}} que podem ter um pai.</p>
-
-<p><code>ChildNode</code> é uma interface bruta e nenhum objeto desse tipo pode ser criado; eles são implementados pelos objetos {{domxref("Element")}}, {{domxref("DocumentType")}}, e {{domxref("CharacterData")}}.</p>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<p><em><font><font>Não há propriedades herdadas nem específicas.</font></font></em></p>
-
-<h2 id="Métodos">Métodos</h2>
-
-<p><em>Não há métodos herdados.</em></p>
-
-<dl>
- <dt>{{domxref("ChildNode.remove()")}} {{experimental_inline}}</dt>
- <dd>Removes this <code>ChildNode</code> from the children list of its parent.</dd>
- <dt>{{domxref("ChildNode.before()")}} {{experimental_inline}}</dt>
- <dd>Inserts a set of {{domxref("Node")}} or {{domxref("DOMString")}} objects in the children list of this <code>ChildNode</code>'s parent, just before this <code>ChildNode</code>. {{domxref("DOMString")}} objects are inserted as equivalent {{domxref("Text")}} nodes.</dd>
- <dt>{{domxref("ChildNode.after()")}} {{experimental_inline}}</dt>
- <dd>Inserts a set of {{domxref("Node")}} or {{domxref("DOMString")}} objects in the children list of this <code>ChildNode</code>'s parent, just after this <code>ChildNode</code>. {{domxref("DOMString")}} objects are inserted as equivalent {{domxref("Text")}} nodes.</dd>
- <dt>{{domxref("ChildNode.replaceWith()")}} {{experimental_inline}}</dt>
- <dd>Replaces this <code>ChildNode</code> in the children list of its parent with a set of {{domxref("Node")}} or {{domxref("DOMString")}} objects. {{domxref("DOMString")}} objects are inserted as equivalent {{domxref("Text")}} nodes.</dd>
-</dl>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#interface-childnode', 'ChildNode')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Split the <code>ElementTraversal</code> interface in {{domxref("ParentNode")}} and <code>ChildNode</code>. <code>previousElementSibling</code> and <code>nextElementSibling</code> are now defined on the latter. The {{domxref("CharacterData")}} and {{domxref("DocumentType")}} implemented the new interfaces. Added the <code>remove()</code>, <code>before()</code>, <code>after()</code> and <code>replaceWith()</code> methods.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('Element Traversal', '#interface-elementTraversal', 'ElementTraversal')}}</td>
-   <td>{{Spec2('Element Traversal')}}</td>
-   <td>Added the initial definition of its properties to the <code>ElementTraversal</code> pure interface and use it on {{domxref("Element")}}.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<p>External on github: <a href="https://github.com/seznam/JAK/blob/master/lib/polyfills/childNode.js">childNode.js</a></p>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("api.ChildNode")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>The {{domxref("ParentNode")}} pure interface.</li>
- <li>
-  <div class="syntaxbox">Object types implementing this pure interface: {{domxref("CharacterData")}}, {{domxref("Element")}}, and {{domxref("DocumentType")}}.</div>
- </li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/childnode/remove/index.html b/files/pt-br/orphaned/web/api/childnode/remove/index.html
deleted file mode 100644
index 57dcc06698..0000000000
--- a/files/pt-br/orphaned/web/api/childnode/remove/index.html
+++ /dev/null
@@ -1,101 +0,0 @@
----
-title: ChildNode.remove()
-slug: orphaned/Web/API/ChildNode/remove
-tags:
-  - API
-  - ChildNode
-  - DOM
-  - Experimental
-  - Método(2)
-  - remove
-translation_of: Web/API/ChildNode/remove
-original_slug: Web/API/ChildNode/remove
----
-<div>{{APIRef("DOM")}}</div>
-
-<p>O método <code><strong>ChildNode.remove()</strong></code> remove o objeto da árvore a que ele pertence.</p>
-
-<h2 id="Sintase">Sintase</h2>
-
-<pre class="syntaxbox"><em>elementNodeReference</em>.remove();
-</pre>
-
-<h2 id="Exemplo">Exemplo</h2>
-
-<h3 id="Usando_remove()">Usando <code>remove()</code></h3>
-
-<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;
-&lt;div id="div-03"&gt;Here is div-03&lt;/div&gt;
-</pre>
-
-<pre class="brush: js">var el = document.getElementById('div-01');
-el.nextElementSibling.remove(); // Remove o div com o id 'div-02'
-</pre>
-
-<h3 id="ChildNode.remove()_não_tem_escopo"><code>ChildNode.remove()</code> não tem escopo</h3>
-
-<p>O método <code>remove()</code> não tem escopo na função <code>with</code>. Veja {{jsxref("Symbol.unscopables")}} para mais informação.</p>
-
-<pre class="brush: js">with(node) {
-  remove();
-}
-// ReferenceError: remove is not defined </pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<p>Você pode evitar incompatibilidade ao usar o método <code>remove() no</code> Internet Explorer 9 em diante com o seguinte código:</p>
-
-<pre class="brush: js">// de: https://github.com/jserz/js_piece/blob/master/DOM/ChildNode/remove()/remove().md
-(function (arr) {
-  arr.forEach(function (item) {
-    if (item.hasOwnProperty('remove')) {
-      return;
-    }
-    Object.defineProperty(item, 'remove', {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value: function remove() {
-        this.parentNode.removeChild(this);
-      }
-    });
-  });
-})([Element.prototype, CharacterData.prototype, DocumentType.prototype]);</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Situação</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-childnode-remove', 'ChildNode.remove')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Definição Inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM4', '#dom-childnode-remove', 'ChildNode.remove')}}</td>
-   <td>{{Spec2('DOM4')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-<div>{{Compat("api.ChildNode.remove")}}</div>
-
-<p> </p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>A interface pura {{domxref("ChildNode")}}.</li>
- <li>
-  <div class="syntaxbox">Tipos de objeto implementando esta interface pura: {{domxref("CharacterData")}}, {{domxref("Element")}}, e {{domxref("DocumentType")}}.</div>
- </li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/document_object_model/events/index.html b/files/pt-br/orphaned/web/api/document_object_model/events/index.html
deleted file mode 100644
index 76e6ec64e1..0000000000
--- a/files/pt-br/orphaned/web/api/document_object_model/events/index.html
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: Events and the DOM
-slug: orphaned/Web/API/Document_Object_Model/Events
-translation_of: Web/API/Document_Object_Model/Events
-original_slug: Web/API/Document_Object_Model/Events
----
-<div>{{DefaultAPISidebar("DOM")}}</div>
-
-<h2 id="Introduction" name="Introduction">Introdução</h2>
-
-<p>Este capítulo descreve o Modelo de Eventos do DOM. A interface de <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-Event" rel="noopener">Eventos</a> é descrita, assim como a interface para registro de eventos em nodes(ou nódulos) no DOM, e <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener">event listeners</a>, e vários outros exemplos que mostram como diversas interfaces de evento se relacionam uma com a outraThere is an excellent diagram that clearly explains the three phases of event flow through the DOM in the <a href="http://www.w3.org/TR/DOM-Level-3-Events/#dom-event-architecture">DOM Level 3 Events draft</a>.</p>
-
-<p>Existe um excelente diagrama que explica claramente as três fases do percurso de eventos no DOM em <a href="http://www.w3.org/TR/DOM-Level-3-Events/#dom-event-architecture" rel="noopener">DOM Level 3 Events draft</a>.</p>
-
-<h2 id="DOM_event_handler_List" name="DOM_event_handler_List">Registrando event listeners</h2>
-
-<p>Existem 3 formas de registrar uma manipulação de eventos para um elemento DOM.</p>
-
-<h3 id="EventTarget.addEventListener" name="EventTarget.addEventListener">{{domxref("EventTarget.addEventListener")}}</h3>
-
-<pre class="brush: js notranslate">// Assuming myButton is a button element
-myButton.addEventListener('click', greet, false)
-function greet(event){
-    // print and have a look at the event object
-    // always print arguments in case of overlooking any other arguments
-    console.log('greet:', arguments)
-    alert('hello world')
-}
-</pre>
-
-<p>Este é o método que você deve usar em páginas web modernas.</p>
-
-<div class="blockIndicator note">
-<p><strong>Nota:</strong> Internet Explorer 6–8 não suportavam este método, oferecendo uma API {{domxref("EventTarget.attachEvent")}} parecida no lugar. Para compatibilidade cross-browser, use uma das muitas bibliotecas JavaScript disponíveis.</p>
-</div>
-
-<p>Mais detalhes podem encontrada na página de referência {{domxref("EventTarget.addEventListener")}}.</p>
-
-<h3 id="HTML_attribute" name="HTML_attribute"><a href="/en-US/docs/Web/Guide/HTML/Event_attributes">atributo HTML</a></h3>
-
-<pre class="brush: html notranslate">&lt;button onclick="alert('Hello world!')"&gt;
-</pre>
-
-<p>O código JavaScript no atributo é passado para o objeto Evento através do parâmetro <code>event</code> . <a href="http://dev.w3.org/html5/spec/webappapis.html#the-event-handler-processing-algorithm">O valor return é tratado de uma maneira especial, descrita na especificação HTML.</a></p>
-
-<div class="blockIndicator warning">
-<p><strong>Cuidado:</strong> Este método deve ser evitado! Ele suja a marcação, e a faz menos legível. Preocupações com o conteúdo/estrutura e comportamento não são bem separadas, tornando mais díficil encontrar um bug.</p>
-</div>
-
-<h3 id="DOM_element_properties" name="DOM_element_properties">DOM element properties</h3>
-
-<pre class="brush: js notranslate">// Supondo que myButton seja um elemento button
-myButton.onclick = function(event){alert('Hello world')}
-</pre>
-
-<p>A função pode ser definida para receber um parâmetro <code>event</code> . <a href="http://dev.w3.org/html5/spec/webappapis.html#the-event-handler-processing-algorithm">O valor return é tratado de maneira especial, descrita na especificação HTML.</a></p>
-
-<p>O problema deste método é que apenas uma manipulação pode ser definida por elemento e por evento.</p>
-
-<h2 id="Acessando_interfaces_doEvento">Acessando interfaces doEvento</h2>
-
-<p>Manipulações do Evento podem ser atribuídas a vários objetos (incluindo elementos DOM, documentos, o {{domxref("window")}} object, etc.). Quando um evento ocorre, o objeto do evento é criado e passado sequencialmente ao event listeners.</p>
-
-<p>A interface {{domxref("Event")}} é acessível de dentro da função manipuladora, atrás do objeto evento passado como primeiro argumento. O seguinte exemplo simples mostra como um objeto evento é passado á função manipuladora do evento, e pode usado de dentro de tal função.</p>
-
-<pre class="brush: js notranslate">function print(evt) {
-  // the evt parameter is automatically assigned the event object
-  // take care of the differences between console.log &amp; alert
-  console.log('print:', evt)
-  alert(evt)
-}
-// any function should have an appropriate name, that's what called semantic
-table_el.onclick = print
-</pre>
-
-<h2 id="Subnav">Subnav</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/API/Document_Object_Model">DOM Reference</a></li>
- <li><a href="/en-US/docs/Web/API/Document_Object_Model/Introduction">Introduction to the DOM</a></li>
- <li><a href="/en-US/docs/Web/API/Document_Object_Model/Events">Events and the DOM</a></li>
- <li><a href="/en-US/docs/Web/API/Document_Object_Model/Examples">Examples</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/htmlorforeignelement/dataset/index.html b/files/pt-br/orphaned/web/api/htmlorforeignelement/dataset/index.html
deleted file mode 100644
index 43394c700b..0000000000
--- a/files/pt-br/orphaned/web/api/htmlorforeignelement/dataset/index.html
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: HTMLElement.dataset
-slug: orphaned/Web/API/HTMLOrForeignElement/dataset
-translation_of: Web/API/HTMLOrForeignElement/dataset
-original_slug: Web/API/HTMLOrForeignElement/dataset
----
-<p>{{ APIRef }}</p>
-
-<p>A propriedade <code><strong>HTMLElement.dataset</strong></code> permite o acesso, em modo de leitura e escrita, a todos os <a href="/en/HTML/Global_attributes#attr-data-*" title="https://developer.mozilla.org/en/HTML/Global_attributes#attr-data-*">atributos de dados personalizado</a> (<em>data-*</em>) no elemento. Ele é um mapa de <a href="/en/DOM/DOMStringMap" title="en/DOM/DOMStringMap">DOMString</a>, com uma entrada para cada atributo de dados personalizado.</p>
-
-<p>O nome de um atributo de dados customizado inicia com <code>data-</code>. Ele deve conter somente letras, números e os seguintes caracteres: dash (<code>-</code>), dot (<code>.</code>), collon(<code>:</code>), underscore (<code>_</code>). Além disso, ele não deve conter letras ASCII captalizadas (<code>A</code> à <code>Z</code>).</p>
-
-<p>Um atributo de dados personalizado é transformado em uma chave para uma entrada no {{ domxref("DOMStringMap") }} de acordo com as seguintes regras</p>
-
-<ul>
- <li>O prefixo <code>data-</code> é removido (incluindo o dash);</li>
- <li>Para qualquer dash (<code>U+002D</code>) seguido por uma ASCII letra minúscula (<code>a</code><span style="line-height: 1.5;"> à </span><code>z</code>)<span style="line-height: 1.5;">, o dash é removido e a letra que segue é tranformada em maíscula;</span></li>
- <li>outros caracteres (incluindo outros dash) são deixados inalterados.</li>
-</ul>
-
-<p>A transformação oposta, que mapeia uma chave para um nome de atributo, usa as seguintes regras:</p>
-
-<ul>
- <li>Restrição: um dash pode não ser imediatamente seguido de uma letra ASCII minúscula (<code>a</code> à <code>z</code>)(antes da transformação);</li>
- <li>Um prefixo <code>data-</code> é adicionado;</li>
- <li>Qualquer caractere ASCII maiúsculo (<code>A</code> à <code>Z</code>) é transformado em um dash seguido pela sua forma mínúscula;</li>
- <li>outros caracteres são deixados inalterados.</li>
-</ul>
-
-<p>A restrição nas regras acima garantem que as duas trasnformações são inversa uma da outra.</p>
-
-<p>Por exemplo, o atributo <code>data-abc-def</code> corresponde a chave <code>abcDef</code>.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><em>string</em> = <em>element</em>.dataset.<em>camelCasedName</em>;
-<em>element.</em>dataset.<em>camelCasedName</em> = <em>string</em>;</pre>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<pre class="brush: js">&lt;div id="user" data-id="1234567890" data-user="johndoe" data-date-of-birth&gt;John Doe
-&lt;/div&gt;
-
-var el = document.querySelector('#user');
-
-// el.id == 'user'
-// el.dataset.id === '1234567890'
-// el.dataset.user === 'johndoe'
-// el.dataset.dateOfBirth === ''
-
-el.dataset.dateOfBirth = '1960-10-03'; // set the DOB.
-
-// 'someDataAttr' in el.dataset === false
-
-el.dataset.someDataAttr = 'mydata';
-// 'someDataAttr' in el.dataset === true
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Espeficicação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('HTML WHATWG', "dom.html#dom-dataset", "HTMLElement.dataset")}}</td>
-   <td>{{Spec2('HTML WHATWG')}}</td>
-   <td>Sem mudanças desde o último  snapshot, {{SpecName('HTML5.1')}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('HTML5.1', "dom.html#dom-dataset", "HTMLElement.dataset")}}</td>
-   <td>{{Spec2('HTML5.1')}}</td>
-   <td>Snapshot de {{SpecName('HTML WHATWG')}}, sem mudanças desde {{SpecName('HTML5 W3C')}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('HTML5 W3C', "dom.html#dom-dataset", "HTMLElement.dataset")}}</td>
-   <td>{{Spec2('HTML5 W3C')}}</td>
-   <td>Snapshot de {{SpecName('HTML WHATWG')}}, definição inicial.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("api.HTMLElement.dataset")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>A classe HTML <a href="/en-US/docs/Web/HTML/Global_attributes/data-*"><strong>data-*</strong></a> de atributos globais.</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/indexeddb_api/basic_concepts_behind_indexeddb/index.html b/files/pt-br/orphaned/web/api/indexeddb_api/basic_concepts_behind_indexeddb/index.html
deleted file mode 100644
index ae5b41c66d..0000000000
--- a/files/pt-br/orphaned/web/api/indexeddb_api/basic_concepts_behind_indexeddb/index.html
+++ /dev/null
@@ -1,250 +0,0 @@
----
-title: Conceitos Básicos sobre IndexedDb
-slug: orphaned/Web/API/IndexedDB_API/Basic_Concepts_Behind_IndexedDB
-tags:
-  - Avançado
-  - IndexedDB
-  - conceitos
-translation_of: Web/API/IndexedDB_API/Basic_Concepts_Behind_IndexedDB
-original_slug: Web/API/IndexedDB_API/Basic_Concepts_Behind_IndexedDB
----
-<p>{{DefaultAPISidebar("IndexedDB")}}</p>
-
-<div class="summary">
-<p><strong>IndexedDB</strong> é uma forma de você armazenar dados no browser do usuário. <span lang="pt-PT">Permite criar aplicativos da Web com habilidades de consulta ricas, independentemente da disponibilidade da rede, esses aplicativos podem trabalhar on-line e off-line. IndexedDB é útil para aplicativos que armazenam uma grande quantidade de dados (por exemplo, um catálogo de DVDs em uma biblioteca de empréstimos) e aplicativos que não precisam de conectividade persistente à Internet para trabalhar (por exemplo, clientes de e-mail, listas de tarefas e Blocos de notas).</span></p>
-</div>
-
-<h2 class="western" id="Sobre_esse_documento">Sobre esse documento</h2>
-
-<p>Essa introdução discute conceitos essenciais e a terminologia do IndexedDB. Ele vai ter dar um visão geral e explicar conceitos chaves.</p>
-
-<p>Você vai achar útil:</p>
-
-<ul>
- <li>
-  <p style="margin-bottom: 0cm;">Para aprender mais sobre termos do IndexedDB, veja a seção <a href="#definitions">Definições</a>.</p>
- </li>
- <li>
-  <p style="margin-bottom: 0cm;">Para um tutorial detalhado de como usar a API, veja <a href="https://developer.mozilla.org/pt-BR/docs/IndexedDB/Usando_IndexedDB">Usando IndexedDB</a>.</p>
- </li>
- <li>
-  <p style="margin-bottom: 0cm;">Para obter a documentação da referência da API IndexedDB, volte para o artigo principal <a href="https://developer.mozilla.org/pt-BR/docs/IndexedDB">IndexedDB API</a> e suas sub-páginas, que documentam os tipos de objetos suportados pelo IndexedDB.</p>
- </li>
- <li>
-  <p>Para mais informações  de como o navegador armazena seus dados em segundo plano, leia <a href="https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Browser_storage_limits_and_eviction_criteria">Browser storage limits and eviction criteria</a>.</p>
- </li>
-</ul>
-
-<h2 class="western" id="Visão_geral_do_IndexedDB">Visão geral do IndexedDB</h2>
-
-<p>IndexedDB permite você armazenar e consultar objetos que são indexados com uma chave. Todas as mudanças na base dados são feitas por transações. Como a maioria soluções de armazenamento web, IndexedDB segue a <a href="http://www.w3.org/Security/wiki/Same_Origin_Policy">política de mesma origem</a>. Então enquanto você pode acessar dados armazenados em um domínio, você não pode acessar em diferentes domínios.</p>
-
-<p>IndexedDB é uma API <a>assíncrona</a> que pode ser usada em diversos contextos, incluindo <a>WebWorkers</a>. Isso permite o uso de uma versão <a>síncrona</a> também, para o uso em web workers, mas isso foi removido da especificação por falta de interesse da comunidade web.</p>
-
-<p><br>
- IndexedDB foi pensado para ser uma especificação concorrente ao banco de dados WebSQL, mas o W3C depreciou o WebSQL em 18 de novembro de 2010. Embora IndexedDB e WebSQL sejam soluções para armazenamento, eles não oferecem as mesmas funcionalidades. WebSQL Database é um sistema de acesso a banco de dados relacional, enquanto que IndexedDB é um sistema de tabelas indexadas.</p>
-
-<h2 class="western" id="Principais_conceitos">Principais conceitos</h2>
-
-<p> Se você já trabalhou com outros tipos de banco de dados, você pode esquecer enquanto trabalha com IndexedDB. E tenha esses importantes conceitos em mente:</p>
-
-<ul>
- <li>
-  <p><strong>Bases de dados IndexedDB armazenam pares chave-valor.</strong> Os valores podem ser objetos de estruturas complexas, e chaves podem ser propriedades desses objetos. Você pode criar índices que usam qualquer propriedade dos objetos para pesquisa rápida, bem como enumerações ordenadas. As chaves podem ser objetos binários.</p>
- </li>
- <li>
-  <p><strong>IndexedDB é </strong><strong>construído</strong><strong> em um modelo de base de dado</strong><strong>s</strong><strong> transacional</strong>. Tudo o que você faz no IndexedDB sempre acontece no contexo de uma <a href="#gloss_transaction">transaction</a>. A API IndexedDB fornece uma série de objetos que representam índices, tabelas, cursores, assim por diante, mas cada um vinculado a uma transação. Assim, você não pode executar comandos ou abrir cursores fora de uma transação. As transações têm um tempo de vida bem definido, portanto, tentar usar uma transação após concluída irá gerar exceções. Além disso, as transações fazem commits automaticamente sem opção de se fazer manualmente.</p>
-
-  <p>Esse modelo de transação é muito útil se você considerar que o usuário pode abrir duas instâncias da sua aplicação em duas diferentes abas simultaneamente. Sem as operações de transação, As duas instâncias poderiam interferir outras modificações. Se você não está familiarizado com transações no banco de dados, leia o  <a href="https://en.wikipedia.org/wiki/Database_transaction">Wikipedia article on transactions</a>. Também veja <a href="#gloss_transaction">transaction</a> na seção de definições.</p>
- </li>
-</ul>
-
-<p style="margin-bottom: 0cm; line-height: 100%;"> </p>
-
-<ul>
- <li>
-  <p><strong><span id="result_box" lang="pt"><span>A API IndexedDB é na maior parte assíncrona</span></span>.</strong> A API não retorna dados usando valores; em vez disso você deve passar uma função <a href="https://developer.mozilla.org/en-US/docs/Mozilla/js-ctypes/Using_js-ctypes/Declaring_and_Using_Callbacks">callback</a>. <span id="result_box" lang="pt"><span>Você não "armazena" um valor no banco de dados, ou "recupera" um valor do banco de dados através de meios síncronos.</span> <span>Em vez disso, você "solicita" que uma operação de banco de dados aconteça.</span> <span>Você será notificado por um evento DOM quando a operação for concluída e o tipo de evento recebido informará se a operação foi bem-sucedida ou falhou.</span> <span>Isto soa um pouco complicado no início, mas faz sentido no fundo. Não é tão diferente da maneira que </span></span><a href="/en/DOM/XMLHttpRequest" title="https://developer.mozilla.org/en/xmlhttprequest">XMLHttpRequest</a> funciona.</p>
- </li>
- <li>
-  <p><strong>IndexedDB usa várias requisições. </strong> <span id="result_box" lang="pt"><span>As </span></span>requisições <span lang="pt"><span>são objetos que recebem os eventos  de sucesso ou falha do DOM mencionados anteriormente</span></span> . Eles têm propriedades <code style="font-size: 14px;">onsuccess</code> e <code style="font-size: 14px;">onerror</code>, e você pode chamar  <code style="font-size: 14px;">addEventListener()</code> e <code style="font-size: 14px;">removeEventListener()</code> neles. Eles também tem as propriedades <code style="font-size: 14px;">readyState</code>, <code style="font-size: 14px;">result</code>, e <code style="font-size: 14px;">errorCode</code> que informam o status da requisição. A propriedade <code style="font-size: 14px;">result</code> é particurlamente mágica, pode ser muitas coisas diferentes , depende de como a requisção foi feita (por exemplo, uma instancia <code style="font-size: 14px;">IDBCursor</code>,  ou uma chave para um valor que você inseriu na base).</p>
- </li>
- <li>
-  <p><span id="result_box" lang="pt"><span><strong>IndexedDB usa eventos DOM para notificá-lo quando os resultados estão disponíveis</strong>.</span> <span>Eventos DOM sempre têm um tipo propriedade (em IndexedDB, é mais comumente definido como "sucesso" ou "erro").</span> <span>Os eventos DOM também têm uma propriedade de destino que indica para onde o evento é dirigido.</span> <span>Na maioria dos casos, o destino de um evento é o objeto IDBRequest que foi gerado como resultado de alguma operação no banco de dados.</span> <span>Eventos de sucesso não disparam um evento em bolha (bubble up) e não podem ser cancelados.</span> <span>Eventos de erro, por outro lado, criam evento bolha  que podem ser cancelados.</span> <span>Isso é muito importante, pois eventos de erro podem cancelar qualquer transações em que estejam rodando, a menos que elas sejam canceladas.</span></span></p>
- </li>
- <li>
-  <p><span id="result_box" lang="pt"><span><strong>IndexedDB é orientado a objetos</strong>.</span> <span>IndexedDB não é um banco de dados relacional com tabelas que representam coleções de linhas e colunas.</span> <span>Esta diferença importante e fundamental afeta a maneira como você projeta e constrói suas aplicações.</span></span></p>
-
-  <p><span id="result_box" lang="pt"><span>Em um banco de dados relacional tradicional, você teria uma tabela que armazena uma coleção de linhas de dados e colunas de tipos de dados nomeados.</span> <span>IndexedDB, por outro lado, requer que você crie um armazenamento de objetos para um tipo de dado e simplesmente persista objetos JavaScript nesse armazenamento.</span> <span>Cada armazenamento de objeto pode ter uma coleção de índices que o torna eficiente para consultar e iterar</span></span>. Se você não está familiarizado  com sitemas de banco de dados orientados a objetos, leia o artigo <a class="external" href="https://en.wikipedia.org/wiki/Object_database" title="http://en.wikipedia.org/wiki/Object_database">Wikipedia article on object database</a>.</p>
- </li>
- <li>
-  <p><strong>IndexedDB não usa Structured Query Language (<abbr>SQL</abbr>).</strong> <span id="result_box" lang="pt"><span>Ele usa consultas em um índice que produz um cursor, que você usa para iterar em todo o conjunto de resultados.</span> <span>Se você não estiver familiarizado com os sistemas NoSQL, leia o artigo</span></span> <a class="external" href="https://en.wikipedia.org/wiki/NoSQL" title="http://en.wikipedia.org/wiki/NoSQL">Wikipedia article on NoSQL</a>.</p>
- </li>
- <li>
-  <p><strong>IndexedDB segue a política de mesma origem</strong>. Uma origem equivale a um domínio, um protocolo de camada de aplicação e porta de uma URL de um documento de onde um script está sendo executado. Cada origem tem seu próprio conjunto de bancos de dados associados. Cada banco de dados tem um nome que o identifica dentro da origem.<br>
-   <br>
-   A restrição de segurança imposta sobre o IndexedDB previne que aplicações acessem dados de uma origem diferente. Por exemplo, enquanto um app ou página em <a class="external" href="http://www.example.com/app/" rel="freelink">http://www.exemplo.com/app/</a> pode obter dados de <a class="external" href="http://www.example.com/app/" rel="freelink">http://www.exemplo.com/dir/</a>, porque compartilham a mesma origem, ela não pode obter dados de <a class="external" href="http://www.example.com/app/" rel="freelink">http://www.exemplo.com:8080/app</a> (porta diferente) ou <a class="external" href="http://www.example.com/app/" rel="freelink">https://www.exemplo.com/app</a> (protocolo diferente), porque possuem diferentes origens.<br>
-    </p>
-
-  <div class="note"><strong>Nota</strong>: O conteúdo de janelas de terceiros (por exemplo, {{htmlelement ("iframe")}} conteúdo) pode acessar o armazenamento IndexedDB para a origem em que está incorporado, a menos que o navegador esteja configurado para <a href="https://support.mozilla.org/en-US/kb/disable-third-party-cookies">nunca aceitar cookies de terceiros</a> (veja {{bug ("1147821 ")}}.)</div>
- </li>
-</ul>
-
-<h2 id="definitions" name="definitions">Definições</h2>
-
-<p>Essa seção define e explica os termos usado na API IndexedDB.</p>
-
-<h3 id="database" name="database">Base de dados</h3>
-
-<dl>
- <dt>Base de dados</dt>
- <dd>Um repositório de informação, normalmente é composto por um ou mais <a href="#gloss_object_store" title="#gloss_object_store"><em>object stores</em></a>. cada base de dados deve possuir:
- <ul>
-  <li>Name. This identifies the database within a specific origin and stays constant throughout its lifetime. The name can be any string value (including an empty string).</li>
-  <li>
-   <p>Current <a href="#gloss_version"><em>version</em></a>. When a database is first created, its version is the integer 1 if not specified otherwise. Each database can have only one version at any given time.</p>
-  </li>
- </ul>
- </dd>
- <dt><a name="durable">durable</a></dt>
- <dd>
- <p>In Firefox, IndexedDB used to be <strong>durable</strong>, meaning that in a readwrite transaction {{domxref("IDBTransaction.oncomplete")}} was fired only when all data was guaranteed to have been flushed to disk.</p>
-
- <p>As of Firefox 40, IndexedDB transactions have relaxed durability guarantees to increase performance (see {{Bug("1112702")}}), which is the same behaviour as other IndexedDB-supporting browsers. In this case the {{Event("complete")}} event is fired after the OS has been told to write the data but potentially before that data has actually been flushed to disk. The event may thus be delivered quicker than before, however, there exists a small chance that the entire transaction will be lost if the OS crashes or there is a loss of system power before the data is flushed to disk. Since such catastrophic events are rare, most consumers should not need to concern themselves further.</p>
-
- <div class="note">
- <p><strong>Note</strong>: In Firefox, if you wish to ensure durability for some reason (e.g. you're storing critical data that cannot be recomputed later) you can force a transaction to flush to disk before delivering the <code>complete</code> event by creating a transaction using the experimental (non-standard) <code>readwriteflush</code> mode (see {{domxref("IDBDatabase.transaction")}}.) This is currently experimental, and can only be used if the <code>dom.indexedDB.experimental</code> pref is set to <code>true</code> in <code>about:config</code>.</p>
- </div>
- </dd>
- <dt><a name="gloss_object_store">object store</a></dt>
- <dd>
- <p>The mechanism by which data is stored in the database. The object store persistently holds records, which are key-value pairs. Records within an object store are sorted according to the <em><a href="#gloss_key">keys</a></em> in an ascending order.</p>
-
- <p>Every object store must have a name that is unique within its database. The object store can optionally have a <em><a href="#gloss_keygenerator">key generator</a></em> and a <em><a href="#gloss_keypath">key path</a></em>. If the object store has a key path, it is using <em><a href="#gloss_inline_key">in-line keys</a></em>; otherwise, it is using <em><a href="#gloss_outofline_key">out-of-line keys</a></em>.</p>
-
- <p>For the reference documentation on object store, see <a href="../../../../en/IndexedDB/IDBObjectStore" rel="internal">IDBObjectStore</a> or <a href="../../../../en/IndexedDB/IDBObjectStoreSync" rel="internal">IDBObjectStoreSync</a>.</p>
- </dd>
- <dt><a name="gloss_version">version</a></dt>
- <dd>When a database is first created, its version is the integer 1. Each database has one version at a time; a database can't exist in multiple versions at once. The only way to change the version is by opening it with a greater version than the current one. This will start a <a href="/en-US/docs/Web/API/IDBVersionChangeRequest"><code>versionchange</code></a> <em>transaction</em> and fire an <a href="/en-US/docs/Web/Reference/Events/upgradeneeded_indexedDB"><code>upgradeneeded</code></a> event. The only place where the schema of the database can be updated is inside the handler of that event.</dd>
- <dd>Note: This definition describes the <a class="external" href="http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html">most recent specification</a>, which is only implemented in up-to-date browsers. Old browsers implemented the now deprecated and removed <a href="/en-US/docs/IndexedDB/IDBDatabase#setVersion()" title="/en-US/docs/IndexedDB/IDBDatabase#setVersion()"><code>IDBDatabase.setVersion()</code></a> method.</dd>
- <dt><a name="gloss_database_connection">database connection</a></dt>
- <dd>An operation created by opening a <em><a href="#gloss_database">database</a></em>. A given database can have multiple connections at the same time.</dd>
- <dt><a name="gloss_transaction">transaction</a></dt>
- <dd>
- <p>An atomic set of data-access and data-modification operations on a particular database. It is how you interact with the data in a database. In fact, any reading or changing of data in the database must happen in a transaction.</p>
-
- <p>A database connection can have several active transaction associated with it at a time, so long as the writing transactions do not have overlapping <a href="#scope"><em>scopes</em></a>. The scope of transactions, which is defined at creation, determines which object stores the transaction can interact with and remains constant for the lifetime of the transaction. So, for example, if a database connection already has a writing transaction with a scope that just covers the <code>flyingMonkey</code> object store, you can start a second transaction with a scope of the <code>unicornCentaur</code> and <code>unicornPegasus</code> object stores. As for reading transactions, you can have several of them — even overlapping ones.</p>
-
- <p>Transactions are expected to be short-lived, so the browser can terminate a transaction that takes too long, in order to free up storage resources that the long-running transaction has locked. You can abort the transaction, which rolls back the changes made to the database in the transaction. And you don't even have to wait for the transaction to start or be active to abort it.</p>
-
- <p>The three modes of transactions are: <code>readwrite</code>, <code>readonly</code>, and <code>versionchange</code>. The only way to create and delete object stores and indexes is by using a <a href="/en-US/docs/Web/Reference/Events/versionchange_indexedDB"><code>versionchange</code></a> transaction. To learn more about transaction types, see the reference article for <a href="/en/IndexedDB" title="https://developer.mozilla.org/en/IndexedDB">IndexedDB</a>.</p>
-
- <p>Because everything happens within a transaction, it is a very important concept in IndexedDB. To learn more about transactions, especially on how they relate to versioning, see <a href="../../../../en/IndexedDB/IDBTransaction" rel="internal">IDBTransaction</a>, which also has reference documentation. For the documentation on the synchronous API, see <a href="../../../../en/IndexedDB/IDBTransactionSync" rel="internal">IDBTransactionSync</a>.</p>
- </dd>
- <dt><a name="gloss_request">request</a></dt>
- <dd>The operation by which reading and writing on a database is done. Every request represents one read or write operation.</dd>
- <dt><a name="gloss_index">index</a></dt>
- <dd>
- <p>An index is a specialized object store for looking up records in another object store, called the <em>referenced object store</em>. The index is a persistent key-value storage where the value part of its records is the key part of a record in the referenced object store. The records in an index are automatically populated whenever records in the referenced object store are inserted, updated, or deleted. Each record in an index can point to only one record in its referenced object store, but several indexes can reference the same object store. When the object store changes, all indexes that refer to the object store are automatically updated.</p>
-
- <p>Alternatively, you can also look up records in an object store using the <a href="#gloss_key"> key</a><em>.</em></p>
-
- <p>To learn more on using indexes, see <a href="/en/IndexedDB/Using_IndexedDB#Using_an_index" title="en/IndexedDB/Using_IndexedDB#Using_an_index">Using IndexedDB</a>. For the reference documentation on index, see <a href="../../../../en/IndexedDB/IDBKeyRange" rel="internal">IDBKeyRange</a>.</p>
- </dd>
-</dl>
-
-<h3 id="key" name="key">Chave e valor</h3>
-
-<dl>
- <dt><a name="gloss_key">key</a></dt>
- <dd>
- <p>A data value by which stored values are organized and retrieved in the object store. The object store can derive the key from one of three sources: a <em><a href="#gloss_keygenerator">key generator</a></em>, a <em><a href="#gloss_keypath">key path</a></em>, or an explicitly specified value. The key must be of a data type that has a number that is greater than the one before it. Each record in an object store must have a key that is unique within the same store, so you cannot have multiple records with the same key in a given object store.</p>
-
- <p>A key can be one of the following types: <a href="/en/JavaScript/Reference/Global_Objects/String" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String">string</a>, <a href="/en/JavaScript/Reference/Global_Objects/Date" title="en/JavaScript/Reference/Global Objects/Date">date</a>, float, a binary blob, and <a href="/en/JavaScript/Reference/Global_Objects/Array" title="en/JavaScript/Reference/Global Objects/Array">array</a>. For arrays, the key can range from an empty value to infinity. And you can include an array within an array.</p>
-
- <p>Alternatively, you can also look up records in an object store using the <em><a href="#gloss_index">index</a>.</em></p>
- </dd>
- <dt><a name="gloss_keygenerator">key generator</a></dt>
- <dd>A mechanism for producing new keys in an ordered sequence. If an object store does not have a key generator, then the application must provide keys for records being stored. Generators are not shared between stores. This is more a browser implementation detail, because in web development, you don't really create or access key generators.</dd>
- <dt><a name="gloss_inline_key">in-line key</a></dt>
- <dd>A key that is stored as part of the stored value. It is found using a <em>key path</em>. An in-line key can be generated using a generator. After the key has been generated, it can then be stored in the value using the key path or it can also be used as a key.</dd>
- <dt><a name="gloss_outofline_key">out-of-line key</a></dt>
- <dd>A key that is stored separately from the value being stored.</dd>
- <dt><a name="gloss_keypath">key path</a></dt>
- <dd>Defines where the browser should extract the key from in the object store or index. A valid key path can include one of the following: an empty string, a JavaScript identifier, or multiple JavaScript identifiers separated by periods or an array containing any of those. It cannot include spaces.</dd>
- <dt><a name="gloss_value">value</a></dt>
- <dd>
- <p>Each record has a value, which could include anything that can be expressed in JavaScript, including <a href="/en/JavaScript/Reference/Global_Objects/Boolean" rel="internal" title="en/JavaScript/Reference/Global_Objects/Boolean">boolean</a>, <a href="/en/JavaScript/Reference/Global_Objects/Number" rel="internal" title="en/JavaScript/Reference/Global_Objects/Number">number</a>, <a href="/en/JavaScript/Reference/Global_Objects/String" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String">string</a>, <a href="/en/JavaScript/Reference/Global_Objects/Date" title="en/JavaScript/Reference/Global Objects/Date">date</a>, <a href="/en/JavaScript/Reference/Global_Objects/Object" title="en/JavaScript/Reference/Global Objects/Object">object</a>, <a href="/en/JavaScript/Reference/Global_Objects/Array" rel="internal" title="en/JavaScript/Reference/Global_Objects/Array">array</a>, <a href="/en/JavaScript/Reference/Global_Objects/RegExp" rel="internal" title="en/JavaScript/Reference/Global_Objects/RegExp">regexp</a>, <a href="/en/JavaScript/Reference/Global_Objects/undefined" title="en/JavaScript/Reference/Global_Objects/undefined">undefined</a>, and null.</p>
-
- <p>When an object or array is stored, the properties and values in that object or array can also be anything that is a valid value.</p>
-
- <p><a href="/en/DOM/Blob" title="en/DOM/Blob">Blobs</a> and files can be stored, cf. <a class="external" href="http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html">specification</a>.</p>
- </dd>
-</dl>
-
-<h3 id="range" name="range">Intervalo e escopo</h3>
-
-<dl>
- <dt id="scope"><a id="gloss_scope" name="gloss_scope">scope</a></dt>
- <dd>The set of object stores and indexes to which a transaction applies. The scopes of read-only transactions can overlap and execute at the same time. On the other hand, the scopes of writing transactions cannot overlap. You can still start several transactions with the same scope at the same time, but they just queue up and execute one after another.</dd>
- <dt id="cursor"><a id="gloss_cursor" name="gloss_cursor">cursor</a></dt>
- <dd>A mechanism for iterating over multiple records with a <em>key range</em>. The cursor has a source that indicates which index or object store it is iterating. It has a position within the range, and moves in a direction that is increasing or decreasing in the order of record keys. For the reference documentation on cursors, see <a href="../../../../en/IndexedDB/IDBCursor" rel="internal">IDBCursor</a> or <a href="../../../../en/IndexedDB/IDBCursorSync" rel="internal">IDBCursorSync</a>.</dd>
- <dt id="key_range"><a id="gloss_keyrange" name="gloss_keyrange">key range</a></dt>
- <dd>
- <p>A continuous interval over some data type used for keys. Records can be retrieved from object stores and indexes using keys or a range of keys. You can limit or filter the range using lower and upper bounds. For example, you can iterate over all values of a key between x and y.</p>
-
- <p>For the reference documentation on key range, see <a href="../../../../en/IndexedDB/IDBKeyRange" rel="internal">IDBKeyRange</a>.</p>
- </dd>
-</dl>
-
-<h2 id="limitations" name="limitations">Limitações</h2>
-
-<p>IndexedDB is designed to cover most cases that need client-side storage. However, it is not designed for a few cases like the following:</p>
-
-<ul>
- <li>Internationalized sorting. Not all languages sort strings in the same way, so internationalized sorting is not supported. While the database can't store data in a specific internationalized order, you can sort the data that you've read out of the database yourself. Note, however, that <a href="/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB#Locale-aware_sorting">locale-aware sorting</a> has been allowed with an experimental flag enabled (currently for Firefox only) since Firefox 43.</li>
- <li>Synchronizing. The API is not designed to take care of synchronizing with a server-side database. You have to write code that synchronizes a client-side indexedDB database with a server-side database.</li>
- <li>Full text searching. The API<span style="direction: ltr;"> does not have an</span><span style="direction: ltr;"> equivalent of the <code>LIKE</code> operator in SQL. </span></li>
-</ul>
-
-<p>In addition, be aware that browsers can wipe out the database, such as in the following conditions:</p>
-
-<ul>
- <li>The user requests a wipe out. Many browsers have settings that let users wipe all data stored for a given website, including cookies, bookmarks, stored passwords, and IndexedDB data.</li>
- <li>The browser is in private browsing mode. Some browsers, have "private browsing" (Firefox) or "incognito" (Chrome) modes. At the end of the session, the browser wipes out the database.</li>
- <li>The disk or quota limit has been reached.</li>
- <li>The data is corrupt.</li>
- <li>An incompatible change is made to the feature.</li>
-</ul>
-
-<p>The exact circumstances and browser capabilities change over time, but the general philosophy of the browser vendors is to make the best effort to keep the data when possible.</p>
-
-<h2 id="next" name="next">Próximos passos</h2>
-
-<p>With these big concepts under our belts, we can get to more concrete stuff. For a tutorial on how to use the API, see <a href="/en/IndexedDB/Using_IndexedDB" title="en/IndexedDB/IndexedDB primer">Using IndexedDB</a>.</p>
-
-<h2 id="See_also">See also</h2>
-
-<p>Especificação</p>
-
-<ul>
- <li><a href="http://www.w3.org/TR/IndexedDB/" title="http://www.w3.org/TR/IndexedDB/"><span style="direction: ltr;">Indexed Database API Specification</span></a></li>
-</ul>
-
-<p>Referência</p>
-
-<ul>
- <li><a href="/en/IndexedDB" title="https://developer.mozilla.org/en/IndexedDB">IndexedDB API Reference</a></li>
-</ul>
-
-<p>Tutoriais</p>
-
-<ul>
- <li><a href="/en/IndexedDB/Using_IndexedDB" title="en/IndexedDB/IndexedDB primer">Using IndexedDB</a></li>
- <li><a class="external" href="http://www.html5rocks.com/en/tutorials/indexeddb/todo/" title="http://www.html5rocks.com/tutorials/indexeddb/todo/">A simple TODO list using HTML5 IndexedDB</a><span class="external">. </span><span class="external"> {{ Note("This example uses an old version of the spec and does not work on up-to-date browsers - it still uses the removed <code>setVersion()</code> method.") }}</span></li>
-</ul>
-
-<p>Artigo relacionado</p>
-
-<ul>
- <li><a class="external" href="http://msdn.microsoft.com/en-us/scriptjunkie/gg679063.aspx" title="http://msdn.microsoft.com/en-us/scriptjunkie/gg679063.aspx">IndexedDB — The Store in Your Browser</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_método_appendchild-javascript/index.html b/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_método_appendchild-javascript/index.html
deleted file mode 100644
index a068a36455..0000000000
--- a/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_método_appendchild-javascript/index.html
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: Entendendo o uso do método appendChild em javascript
-slug: orphaned/Web/API/Node/Entendendo_o_uso_do_método_AppendChild-javascript
-original_slug: Web/API/Node/Entendendo_o_uso_do_método_AppendChild-javascript
----
-<div>{{ApiRef("DOM")}}</div>
-
-<h2 id="Summary" name="Summary">Resumo</h2>
-
-<p>Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.</p>
-
-<h2 id="Syntax" name="Syntax">Sintaxe</h2>
-
-<pre class="syntaxbox">var filho = <em>elemento</em>.appendChild(<em>filho</em>);</pre>
-
-<ul>
- <li><code>elemento</code> é o <a href="/pt-BR/docs/DOM/element" title="/en-US/docs/DOM/element">elemento</a> pai.</li>
- <li><code>filho</code> é o nó a ser adicionado como filho de <code>elemento</code>. Também é devolvido.</li>
-</ul>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O método <code>appendChild</code> devolve uma referência ao nó adicionado.</p>
-
-<h2 id="Example" name="Example">Exemplo</h2>
-
-<pre class="brush:js">// Cria um novo elemento de parágrafo e adiciona-o ao final do documento
-var p = document.createElement("p");
-document.body.appendChild(p);</pre>
-
-<h2 id="Notes" name="Notes">Notas</h2>
-
-<p>Se <code>filho</code> é uma referência a um nó existente no documento, <code>appendChild</code> vai movê-lo de sua posição atual para a nova posição (i.e, não é necessário remover o nó de seu pai atual antes de adicioná-lo a outro nó).</p>
-
-<p>Isso também significa que um nó não pode estar em dois lugares do documento ao mesmo tempo. Assim, se o nó já tem um pai, ele é primeiro removido para, <em>só então</em>, ser adicionado na nova posição.</p>
-
-<p>Você pode usar o método {{domxref("Node.cloneNode")}} para criar uma cópia do nó antes de adicioná-lo ao novo pai. (Note que cópias feitas com o método <code>cloneNode</code> <strong>não </strong>serão mantidas sincronizadas automaticamente)</p>
-
-<p>Este método não permite mover nós entre documentos diferentes. Se você quiser adicionar um nó de um documento diferente (por exemplo para mostrar o resultado de uma requisição AJAX), você precisa primeiro usar o método {{domxref("document.importNode")}}.</p>
-
-<p><code>appendChild()</code> é um dos métodos fundamentais da programação para a web usando o DOM. O método <code>appendChild()</code> insere um novo nó na estrutura do DOM de um documento, e é a segunda parte do processo criar-e-adicionar tão importante na construção de páginas web programaticamente.</p>
-
-<h2 id="Specification" name="Specification">Especificação</h2>
-
-<ul>
- <li><a class="external" href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-184E7107" title="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-184E7107">DOM Level 3 Core: appendChild</a></li>
-</ul>
-
-<h2 id="See_also" name="See_also">Ver também</h2>
-
-<ul>
- <li>{{domxref("Node.removeChild")}}</li>
- <li>{{domxref("Node.replaceChild")}}</li>
- <li>{{domxref("Node.insertBefore")}}</li>
- <li>{{domxref("Node.hasChildNodes")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/parentnode/children/index.html b/files/pt-br/orphaned/web/api/parentnode/children/index.html
deleted file mode 100644
index 64c0f40d68..0000000000
--- a/files/pt-br/orphaned/web/api/parentnode/children/index.html
+++ /dev/null
@@ -1,132 +0,0 @@
----
-title: ParentNode.children
-slug: orphaned/Web/API/ParentNode/children
-translation_of: Web/API/ParentNode/children
-original_slug: Web/API/ParentNode/children
----
-<p>{{ APIRef("DOM") }}</p>
-
-<p><code><strong>Node.children</strong></code> é uma propriedade exclusivamente de leitura que retorna uma coleção {{domxref("HTMLCollection")}} dos elementos filhos do <code>nó</code>.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre>var <em>elList</em> = elementNodeReference.children; </pre>
-
-<p><code><var>elList</var></code> é uma {{ domxref("HTMLCollection") }}, que é uma lista ordenada de uma coleção de elementos do DOM que são filhos do <code>elementNodeReference</code>. Se não existir nenhum elemento filho, o <code>elList</code> não terá elemento algum sua propriedade <code>length</code> será 0.</p>
-
-<h2 id="Exemplo">Exemplo</h2>
-
-<pre class="brush: js">// pEl é uma referência à um elemento &lt;p&gt;
-var elementChildren = pEl.children;
-for (var i = 0; i &lt; elementChildren.length; i++) {
-    console.log(elementChildren[i].tagName);
-    // NOTE: elementChildren é uma lista viva, adicionar ou remover filhos de pEl
-    // mudará instantaneamente o valor retornado por elementChildren
-}
-</pre>
-
-<h2 id="Especificação">Especificação</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-parentnode-children', 'ParentNode.children')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-<p>{{ CompatibilityTable() }}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Edge</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support (on {{domxref("Element")}})</td>
-   <td>1.0</td>
-   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
-   <td>9.0 [1]</td>
-   <td>38.0</td>
-   <td>10.0</td>
-   <td>4.0</td>
-  </tr>
-  <tr>
-   <td>Support on {{domxref("Document")}} and {{domxref("DocumentFragment")}} {{experimental_inline}}</td>
-   <td>29.0</td>
-   <td>{{CompatGeckoDesktop("25.0")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>16.0</td>
-   <td>{{CompatNo}}</td>
-  </tr>
-  <tr>
-   <td>Support on {{domxref("SVGElement")}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support (on {{domxref("Element")}})</td>
-   <td>{{ CompatVersionUnknown() }}</td>
-   <td>{{CompatGeckoMobile("1.9.1")}}</td>
-   <td>{{ CompatVersionUnknown() }}</td>
-   <td>{{ CompatVersionUnknown() }}</td>
-   <td>{{ CompatVersionUnknown() }}</td>
-  </tr>
-  <tr>
-   <td>Support on {{domxref("Document")}} and {{domxref("DocumentFragment")}} {{experimental_inline}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoMobile("25.0")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>16.0</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p>[1] Internet Explorer 6, 7 e 8 suportaram esse método, mas erroneamente incluiam nós de {{domxref("Comment")}}.</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>As interfaces de {{domxref("ParentNode")}} e {{domxref("ChildNode")}}.</li>
- <li>
-  <div class="syntaxbox">Tipos de objetos implementando esta interface: {{domxref("Document")}}, {{domxref("Element")}}, e {{domxref("DocumentFragment")}}.</div>
- </li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/parentnode/index.html b/files/pt-br/orphaned/web/api/parentnode/index.html
deleted file mode 100644
index fd327f7adf..0000000000
--- a/files/pt-br/orphaned/web/api/parentnode/index.html
+++ /dev/null
@@ -1,164 +0,0 @@
----
-title: ParentNode
-slug: orphaned/Web/API/ParentNode
-tags:
-  - API
-  - DOM
-  - NeedsTranslation
-  - TopicStub
-translation_of: Web/API/ParentNode
-original_slug: Web/API/ParentNode
----
-<div>{{APIRef("DOM")}}</div>
-
-<p>The <code><strong>ParentNode</strong></code> interface contains methods that are particular to {{domxref("Node")}} objects that can have children.</p>
-
-<p><code>ParentNode</code> is a raw interface and no object of this type can be created; it is implemented by {{domxref("Element")}}, {{domxref("Document")}}, and {{domxref("DocumentFragment")}} objects.</p>
-
-<h2 id="Properties">Properties</h2>
-
-<dl>
- <dt>{{ domxref("ParentNode.children") }} {{experimental_inline}} {{readonlyInline}}</dt>
- <dd>Returns a live {{domxref("HTMLCollection")}} containing all objects of type {{domxref("Element")}} that are children of this <code>ParentNode</code>.</dd>
- <dt>{{ domxref("ParentNode.firstElementChild") }} {{experimental_inline}} {{readonlyInline}}</dt>
- <dd>Returns the {{domxref("Element")}} that is the first child of this <code>ParentNode</code>, or <code>null</code> if there is none.</dd>
- <dt>{{ domxref("ParentNode.lastElementChild") }} {{experimental_inline}} {{readonlyInline}}</dt>
- <dd>Returns the {{domxref("Element")}} that is the last child of this <code>ParentNode</code>, or <code>null</code> if there is none.</dd>
- <dt>{{ domxref("ParentNode.childElementCount") }} {{experimental_inline}} {{readonlyInline}}</dt>
- <dd>Returns an <code>unsigned long</code> giving the amount of children that the object has.</dd>
-</dl>
-
-<h2 id="Methods">Methods</h2>
-
-<dl>
- <dt>{{ domxref("ParentNode.append()") }} {{experimental_inline}}</dt>
- <dd>Inserts a set of {{domxref("Node")}} objects or {{domxref("DOMString")}} objects after the last child of the <code>ParentNode</code>. {{domxref("DOMString")}} objects are inserted as equivalent {{domxref("Text")}} nodes.</dd>
- <dt>{{ domxref("ParentNode.prepend()") }} {{experimental_inline}}</dt>
- <dd>Inserts a set of {{domxref("Node")}} objects or {{domxref("DOMString")}} objects before the first child of the <code>ParentNode</code>. {{domxref("DOMString")}} objects are inserted as equivalent {{domxref("Text")}} nodes.</dd>
-</dl>
-
-<h2 id="Specification">Specification</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('DOM WHATWG', '#dom-parentnode-firstelementchild', 'ParentNode.firstElementChild')}}</td>
-   <td>{{Spec2('DOM WHATWG')}}</td>
-   <td>Splitted the <code>ElementTraversal</code> interface in {{domxref("ChildNode")}} and <code>ParentNode</code>. The <code>firstElementChild</code>, <code>lastElementChild</code>, and <code>childElementCount</code> properties are now defined on the latter.<br>
-    The {{domxref("Document")}} and {{domxref("DocumentFragment")}} implemented the new interfaces.<br>
-    Added the <code>children</code> property.<br>
-    Added the <code>append()</code> and <code>prepend()</code> methods.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('Element Traversal', '#interface-elementTraversal', 'ElementTraversal')}}</td>
-   <td>{{Spec2('Element Traversal')}}</td>
-   <td>Added the initial definition of its properties to the <code>ElementTraversal</code> pure interface and use it on {{domxref("Element")}}.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support (on {{domxref("Element")}})</td>
-   <td>{{CompatChrome(1.0)}}</td>
-   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
-   <td>9.0 [1]</td>
-   <td>10.0</td>
-   <td>4.0</td>
-  </tr>
-  <tr>
-   <td>Support on {{domxref("Document")}} and {{domxref("DocumentFragment")}} {{experimental_inline}}</td>
-   <td>{{CompatChrome(29.0)}}</td>
-   <td>{{CompatGeckoDesktop(25)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>16.0</td>
-   <td>{{CompatNo}}</td>
-  </tr>
-  <tr>
-   <td><code>append()</code> and <code>prepend()</code> {{experimental_inline}}</td>
-   <td>{{CompatChrome(54.0)}}</td>
-   <td>{{CompatGeckoDesktop(49)}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatOpera(39)}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Android Webview</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-   <th>Chrome for Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support (on {{domxref("Element")}})</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoMobile("1.9.1")}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Support on {{domxref("Document")}} and {{domxref("DocumentFragment")}} {{experimental_inline}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoMobile(25)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>16.0</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
-  <tr>
-   <td><code>append()</code> and <code>prepend()</code> {{experimental_inline}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatChrome(54.0)}}</td>
-   <td>{{CompatGeckoMobile(49)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatOperaMobile(39)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatChrome(54.0)}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p>[1] Internet Explorer 6, 7 and 8 supported it, but erroneously returns {{domxref("Comment")}} nodes as part of the results.</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>The {{domxref("ChildNode")}} pure interface.</li>
- <li>
-  <div class="syntaxbox">Object types implementing this pure interface: {{domxref("Document")}}, {{domxref("Element")}}, and {{domxref("DocumentFragment")}}.</div>
- </li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/parentnode/queryselector/index.html b/files/pt-br/orphaned/web/api/parentnode/queryselector/index.html
deleted file mode 100644
index db43662895..0000000000
--- a/files/pt-br/orphaned/web/api/parentnode/queryselector/index.html
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: ParentNode.querySelector()
-slug: orphaned/Web/API/ParentNode/querySelector
-tags:
-  - PrecisaDeExemplo
-  - Projeto
-  - Referencia
-  - Seletores
-  - metodo
-translation_of: Web/API/ParentNode/querySelector
-original_slug: Web/API/ParentNode/querySelector
----
-<p>{{APIRef("DOM")}}{{Draft}}</p>
-
-<p>O {{DOMxRef("ParentNode")}} mixin define o <code><strong>querySelector()</strong></code> método como retornar um {{DOMxRef("Element")}} representando o primeiro elemento que corresponde ao grupo especificado de seletores que são descendentes do objeto no qual o método foi chamado.</p>
-
-<p>Se você precisar de todos os elementos correspondentes à lista de seletores, use{{DOMxRef("ParentNode.querySelectorAll", "querySelectorAll()")}} instead.</p>
-
-<div class="blockIndicator note">
-<p>Nota: Este método é implementado como {{DOMxRef("Document.querySelector()")}}, {{DOMxRef("DocumentFragment.querySelector()")}} e {{DOMxRef("Element.querySelector()")}}.</p>
-</div>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><var>element</var> = <em>parentNode</em>.querySelector(<var>selectors</var>);
-</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>selectors</code></dt>
- <dd>Um {{DOMxRef("DOMString")}} contendo um ou mais seletores para comparar. Essa sequência deve ser um válido <a href="/en-US/docs/Web/CSS/CSS_Selectors">lista de seletores compostos</a> suportado pelo navegador; se não for, um <code>SyntaxError</code> exceção é lançada. Veja <a href="/en-US/docs/Web/API/Document_object_model/Locating_DOM_elements_using_selectors">Localizando elementos DOM usando seletores</a> para obter mais informações sobre o uso de seletores para identificar elementos. Vários seletores podem ser especificados, separando-os usando vírgulas.</dd>
-</dl>
-
-<div class="blockIndicator note">
-<p><strong>Nota:</strong> Os caracteres que não fazem parte da sintaxe CSS padrão devem ser escapados usando um caractere de barra invertida. Como o JavaScript também usa escape de backspace, deve-se tomar cuidado especial ao escrever literais de string usando esses caracteres. Veja {{anch("Escaping special characters")}} Para maiores informações.</p>
-</div>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>O primeiro {{DOMxRef("Element")}} que corresponda a pelo menos um dos seletores ou <code>null</code> se esse elemento não for encontrado.</p>
-
-<div class="blockIndicator note">
-<p><strong>Nota:</strong> Se o especificado <code>selectors</code> inclua um <a href="/en-US/docs/Web/CSS/Pseudo-elements">CSS pseudo-elemento</a>, o valor retornado é sempre <code>null</code>.</p>
-</div>
-
-<h3 id="Exceções">Exceções</h3>
-
-<dl>
- <dt><code>SyntaxError</code></dt>
- <dd>A sintaxe do especificado <code>selectors</code> string não é válida.</dd>
-</dl>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName("DOM WHATWG", "#dom-parentnode-queryselector", "ParentNode.querySelector()")}}</td>
-   <td>{{Spec2("DOM WHATWG")}}</td>
-   <td>Padrão de vida</td>
-  </tr>
-  <tr>
-   <td>{{SpecName("Selectors API Level 2", "#dom-parentnode-queryselector", "ParentNode.querySelector()")}}</td>
-   <td>{{Spec2("Selectors API Level 2")}}</td>
-   <td>Sem alteração</td>
-  </tr>
-  <tr>
-   <td>{{SpecName("DOM4", "#dom-parentnode-queryselector", "ParentNode.querySelector()")}}</td>
-   <td>{{Spec2("DOM4")}}</td>
-   <td>Definição inicial</td>
-  </tr>
-  <tr>
-   <td>{{SpecName("Selectors API Level 1", "#interface-definitions", "document.querySelector()")}}</td>
-   <td>{{Spec2("Selectors API Level 1")}}</td>
-   <td>Definição original</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("api.ParentNode.querySelector")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/API/Document_object_model/Locating_DOM_elements_using_selectors">Localizando elementos DOM usando seletores</a></li>
- <li><a href="/en-US/docs/Code_snippets/QuerySelector">Snippets de código para  <code>querySelector()</code></a></li>
- <li><a href="/en-US/docs/Web/CSS/Attribute_selectors">Seletores de atributos</a> no guia CSS</li>
- <li><a href="/en-US/docs/Learn/CSS/Introduction_to_CSS/Attribute_selectors">Seletores de atributos </a>na MDN Área de Aprendizagem</li>
- <li>Seu método está disponível como {{DOMxRef("Element.querySelector()")}}, {{DOMxRef("Document.querySelector()")}}, and {{DOMxRef("DocumentFragment.querySelector()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/api/window/ondevicelight/index.html b/files/pt-br/orphaned/web/api/window/ondevicelight/index.html
deleted file mode 100644
index 6e8733e6cb..0000000000
--- a/files/pt-br/orphaned/web/api/window/ondevicelight/index.html
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: Window.ondevicelight
-slug: orphaned/Web/API/Window/ondevicelight
-translation_of: Web/API/Window/ondevicelight
-original_slug: Web/API/Window/ondevicelight
----
-<div>{{APIRef}}</div>
-
-<p>Especifica um event listener para receber eventos {{event("devicelight")}}. Esses eventos ocorrem quando um dispositivo com sensores de nível de luz detecta uma mudança na intensidade do nível de luz do ambiente.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">window.ondevicelight = <var>funcRef</var></pre>
-
-<p>Onde <code><em>funcRef</em></code> é a função a ser chamada quando o evento {{event("devicelight")}} ocorre. Estes eventos são do tipo {{domxref("DeviceLightEvent")}}.</p>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('AmbientLight', '#event-handlers', 'Ambient Light Events')}}</td>
-   <td>{{Spec2('AmbientLight')}}</td>
-   <td>Initial definition</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_Navegadores">Compatibilidade com os Navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Edge</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoDesktop("22.0")}}<sup>[1]</sup></td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Edge</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile("15.0")}}<sup>[1]</sup></td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p>[1] The {{event("devicelight")}} event is implemented and by preference enabled by default in Firefox Mobile for Android (15.0) and in Firefox OS (B2G). Starting with Gecko 22.0 {{geckoRelease("22.0")}}, a desktop implementation for Mac OS X is also available. Support for Windows 7 is in progress (see {{bug(754199)}}).</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{event("devicelight")}}</li>
- <li>{{domxref("DeviceLightEvent")}}</li>
- <li><a href="/en-US/docs/Web/API/DeviceLightEvent/Using_light_events">Using Light Events</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/css/image-set()/index.html b/files/pt-br/orphaned/web/css/image-set()/index.html
deleted file mode 100644
index b85425c4f1..0000000000
--- a/files/pt-br/orphaned/web/css/image-set()/index.html
+++ /dev/null
@@ -1,77 +0,0 @@
----
-title: image-set()
-slug: orphaned/Web/CSS/image-set()
-translation_of: Web/CSS/image-set()
-original_slug: Web/CSS/image-set()
----
-<div>{{cssref}}</div>
-
-<p class="summary">A notação de função CSS <code>image-set()</code> é um método de deixar o navegador escolher a imagem CSS mais apropriada de um dado conjunto, principalmente para telas de alta densidade de pixels.</p>
-
-<p>Resolução e largura de banda diferem por dispositivo e acesso à rede. A função <code>image-set()</code> oferece a resolução de imagem mais apropriada para o dispositivo de um usuário, fornecendo um conjunto de opções de imagem — cada uma com uma declaração de resolução associada — da qual o navegador escolhe o mais apropriado para o dispositivo e as configurações. A resolução pode ser usada como um proxy para o tamanho do arquivo — um agente de usuário em uma conexão móvel lenta, com uma tela de alta resolução, pode preferir receber imagens de baixa resolução em vez de aguardar uma imagem de alta resolução carregar.</p>
-
-<p><code>image-set()</code> permite que o autor forneça opções em vez de determinar o que cada usuário individual precisa.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox notranslate">image-set() = image-set( &lt;image-set-option&gt;# )
-where &lt;image-set-option&gt; = [ &lt;image&gt; | &lt;string&gt; ] &lt;resolution&gt; and
-      &lt;string&gt; is an &lt;url&gt;
-</pre>
-
-<h3 id="Valores">Valores</h3>
-
-<p>Mais comumente, você verá um valor de  <code>url()</code> <code>&lt;string&gt;</code>, mas o <code><a href="/en-US/docs/Web/CSS/image">&lt;image&gt;</a></code> pode ser qualquer tipo de imagem, exceto para um conjunto de imagens. A função <code>image-set()</code> não pode ser aninhada dentro de outra função <code>image-set()</code>.</p>
-
-<p>unidades <code><a href="/en-US/docs/Web/CSS/resolution">&lt;resolution&gt;</a></code> incluem <code>x </code>ou <code>ddpx,</code> para pontos por unidade de pixel, <code>dpi</code>, para pontos por polegada, e <code>dpcm</code> para pontos per centímetro. Toda imagem dentro de <code>image-set()</code> deve ter uma única resolução.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<pre class="brush: css notranslate">background-image: image-set( "cat.png" 1x,
-                             "cat-2x.png" 2x);</pre>
-
-<p>Este exemplo mostra como usar <code><a class="css" href="https://drafts.csswg.org/css-images-4/#funcdef-image-set" id="ref-for-funcdef-image-set⑨">image-set()</a></code> para fornecer duas opções alternativas {{cssxref("background-image")}}, escolhidas dependendo da resolução necessária: uma versão normal e uma versão de alta-resolução.</p>
-
-<h2 id="Preocupações_de_Acessibilidade">Preocupações de Acessibilidade</h2>
-
-<p>Tecnologia assistiva não pode analisar imagens de fundo. Se a imagem contiver informações críticas para entender a finalidade geral da página, é melhor descrevê-la semanticamente no documento.</p>
-
-<ul>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/Accessibility/Understanding_WCAG/Perceivable#Guideline_1.1_%E2%80%94_Providing_text_alternatives_for_non-text_content">MDN Understanding WCAG, Guideline 1.1 explanations</a></li>
- <li><a class="external external-icon" href="https://www.w3.org/TR/2016/NOTE-UNDERSTANDING-WCAG20-20161007/text-equiv-all.html" rel="noopener">Understanding Success Criterion 1.1.1  | W3C Understanding WCAG 2.0</a></li>
-</ul>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th>Especificação</th>
-   <th>Status</th>
-   <th>Comentário</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('CSS4 Images', '#image-set-notation', 'The image-set() notation')}}</td>
-   <td>{{Spec2('CSS4 Images')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("css.types.image.image-set")}}</p>
-
-<h2 id="See_also" name="See_also">Veja também</h2>
-
-<ul>
- <li>{{cssxref("image")}}</li>
- <li>{{cssxref("_image", "image()")}}</li>
- <li>{{cssxref("element")}}</li>
- <li>{{cssxref("url")}}</li>
- <li>{{cssxref("&lt;gradient&gt;")}}</li>
- <li>{{cssxref("image-set","image-set()")}}</li>
- <li>{{cssxref("cross-fade")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/css/radial-gradient()/index.html b/files/pt-br/orphaned/web/css/radial-gradient()/index.html
deleted file mode 100644
index 094be5d107..0000000000
--- a/files/pt-br/orphaned/web/css/radial-gradient()/index.html
+++ /dev/null
@@ -1,210 +0,0 @@
----
-title: radial-gradient()
-slug: orphaned/Web/CSS/radial-gradient()
-translation_of: Web/CSS/radial-gradient()
-original_slug: Web/CSS/radial-gradient()
----
-<p>{{ CSSRef() }}</p>
-
-<h2 id="Resumo">Resumo</h2>
-
-<p>A função do CSS <code>radial-gradient()</code> cria uma {{cssxref("&lt;image&gt;")}} que representa um gradiente de cores irradiando de uma origem, o <em>centro</em> do gradiente. O resultado dessa função é um objeto do CSS do tipo {{cssxref("&lt;gradient&gt;")}}.</p>
-
-<p><img alt="" src="/files/3795/radial%20gradient.png" style="float: left; height: 176px; width: 396px;">Gradientes radiais são definidos pelo seu <em>centro</em>, o contorno e a posição da <em>forma de fechamento (ending shape)</em> e as <em>paradas de cor (color stops)</em>. O gradiente radial consiste de formas concêntricas uniformemente escaladas partindo do centro até sua forma de fechamento, indo potencialmente além, com a mesma forma da forma de fechamento. As paradas de cor são posicionadas num <em>raio de gradiente virtual</em> saindo do centro horizontalmente para a direita. O posicionamento das porcentagens das paradas de cor são relativas à interseção entre a forma de fechamento e esse raio de gradiente representando <code>100%</code>. Cada forma é monocromática e a cor, definida pela cor no raio de gradiente que intersecta.</p>
-
-<p>Formas de fechamento podem ser apenas círculo <code>(circle)</code> ou elipse <code>(ellipse)</code>.</p>
-
-<p>Como qualquer outro gradiente, um gradiente radial do CSS não é uma <a href="color_value" rel="custom"><code>&lt;cor&gt;</code></a> do CSS, mas uma imagem <a href="/en/CSS/image#no_intrinsic" title="en/CSS/image#no_intrinsic">sem dimensões intrínsecas</a>, i. e. uma imagem sem tamanho natural ou preferencial, tampouco proporção. Seu tamanho concreto será idêntico ao tamanho do elemento ao qual for aplicado.</p>
-
-<p>A função <code>radial-gradient</code> não permite criar gradientes repetitivos. Para esse efeito, use a função do CSS {{ Cssxref("repeating-radial-gradient") }}.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre style=""><code>Gramática formal: radial-gradient( [ circle || <a href="/en-US/docs/CSS/length" title="/en-US/docs/CSS/length">&lt;length&gt;</a> ] [ at <a href="/en-US/CSS/position_value" title="/en-US/CSS/position_value">&lt;position&gt;</a> ]? ,
-| [ ellipse || [<a href="/en-US/docs/CSS/length" title="/en-US/docs/CSS/length">&lt;length&gt;</a> | <a href="/en-US/docs/CSS/percentage" title="/en-US/docs/CSS/percentage">&lt;percentage&gt;</a> ]{2}] [ at <a href="/en-US/CSS/position_value" title="/en-US/CSS/position_value">&lt;position&gt;</a> ]? ,
-| [ [ circle | ellipse ] || &lt;extent-keyword&gt; ] [ at <a href="/en-US/CSS/position_value" title="/en-US/CSS/position_value">&lt;position&gt;</a> ]? ,
-| at <a href="/en-US/CSS/position_value" title="/en-US/CSS/position_value">&lt;position&gt;</a> ,
-&lt;color-stop&gt; [ , &lt;color-stop&gt; ]+ )
-</code></pre>
-
-<h3 id="Valores">Valores</h3>
-
-<dl>
- <dt><code>&lt;position&gt;</code></dt>
- <dd>Uma {{cssxref("&lt;position&gt;")}}, interpretada da mesma forma que {{Cssxref("background-position")}} ou {{Cssxref("transform-origin")}}. Se omitida, assume o padrão <code>center</code>.</dd>
- <dt><code>&lt;shape&gt;</code></dt>
- <dd>A forma do gradiente. Esse valor é <code>circle</code> (indicando que a forma do gradiente é um círculo com raio constante) ou <code>ellipse</code> (indicando que a forma é uma elipse com os eixos alinhados ao elemento). O valor padrão é <code>ellipse</code>.</dd>
- <dt><code>&lt;size&gt;</code></dt>
- <dd>O tamanho do gradiente. Essa valor é uma das {{anch("Restrições de tamanho")}} listada abaixo.</dd>
- <dt><code>&lt;color-stop&gt;</code></dt>
- <dd>Representando uma cor fixa num determinado ponto, esse valor é composto por um valor {{cssxref("&lt;color&gt;")}}, seguido de uma posição de parada opcional (uma {{cssxref("&lt;percentage&gt;")}} ou uma {{cssxref("&lt;length&gt;")}} referente ao raio de gradiente virtual). Uma porcentagem de <code>0%</code>, ou um tamanho de <code>0</code> representa o centro do gradiente e o valor <code>100%</code> a interseção da forma de fechamento com o raio de gradiente virtual. Valores de porcentagem intermediários são posicionados linearmente no raio de gradiente.</dd>
- <dt><code>&lt;extent-keyword&gt;</code></dt>
- <dd>Palavras-chave descrevendo quão grande a forma de fechamento deve ser. Os possíveis valores são:</dd>
- <dd>
- <table class="standard-table">
-  <tbody>
-   <tr>
-    <th>Constante</th>
-    <th>Descrição</th>
-   </tr>
-   <tr>
-    <td><code>closest-side</code></td>
-    <td>A forma de fechamento do gradiente encontra o lado do elemento mais próximo ao seu centro (para círculos) ou encontra ambos os lados vertical e horizontal mais próximos ao centro (para elipses).</td>
-   </tr>
-   <tr>
-    <td><code>closest-corner</code></td>
-    <td>A forma de fechamento do gradiente tem o tamanho exato para encontrar o canto da caixa mais próximo ao seu centro.</td>
-   </tr>
-   <tr>
-    <td><code>farthest-side</code></td>
-    <td>Similar ao closest-side, mas a forma de fechamento fica com o tamanho necessário para encontrar o lado do elemento mais distante do centro do gradiente (ou lados vertical e horizontal).</td>
-   </tr>
-   <tr>
-    <td><code>farthest-corner</code></td>
-    <td>A forma de fechamento do gradiente tem o tamanho exato para encontrar o canto da caixa mais distante de seu centro.</td>
-   </tr>
-  </tbody>
- </table>
- Rascunhos preliminares incluiam outras palavras-chave (<code>cover</code> e <code>contain</code>) como sinônimos dos valores do padrão <span class="st"><code>farthest-corner</code></span> e <code>closest-side</code> respectivamente. Use somente os valores do padrão, uma vez que algumas implementações podem já ter removido suporte a esses valores mais antigos.</dd>
-</dl>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<div style="">ellipse farthest-corner</div>
-
-<pre class="notranslate">background-image: radial-gradient(ellipse farthest-corner at 45px 45px , #00FFFF 0%, rgba(0, 0, 255, 0) 50%, #0000FF 95%);
-</pre>
-
-<div style="">470px 47px</div>
-
-<pre class="notranslate">background-image: radial-gradient(ellipse farthest-corner at 470px 47px , #FFFF80 20%, rgba(204, 153, 153, 0.4) 30%, #E6E6FF 60%);
-</pre>
-
-<div style="">farthest-corner</div>
-
-<pre class="notranslate">background-image: radial-gradient(farthest-corner at 45px 45px , #FF0000 0%, #0000FF 100%);</pre>
-
-<div style="">16px radius fuzzy circle</div>
-
-<pre class="notranslate">background-image: radial-gradient(16px at 60px 50% , #000000 0%, #000000 14px, rgba(0, 0, 0, 0.3) 18px, rgba(0, 0, 0, 0) 19px);
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentários</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{ SpecName('CSS3 Images', '#radial-gradients', 'radial-gradients()') }}</td>
-   <td>{{ Spec2('CSS3 Images') }}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Firefox (Gecko)</th>
-   <th>Chrome</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico (suporte à função <code>radial-gradient()</code>, mas não necessariamente com a sintaxe final)</td>
-   <td>{{ CompatGeckoDesktop("1.9.2") }}{{ property_prefix("-moz") }} <sup><a href="#bc3">[3]</a></sup><br>
-    {{ CompatGeckoDesktop("16") }}</td>
-   <td>10.0 (534.16){{ property_prefix("-webkit") }} <sup><a href="#bc2">[2]</a></sup><sup><a href="#bc3">[3]</a></sup></td>
-   <td>10.0 <sup><a href="#bc1">[1]</a></sup></td>
-   <td>11.60{{ property_prefix("-o") }}</td>
-   <td>5.1{{ property_prefix("-webkit") }}<sup><a href="#bc2">[2]</a></sup></td>
-  </tr>
-  <tr>
-   <td><a class="external" href="http://www.webkit.org/blog/175/introducing-css-gradients/">Sintaxe legada do webkit</a> {{ non-standard_inline() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>3{{ property_prefix("-webkit") }} <sup><a href="#bc2">[2]</a></sup></td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>4.0{{ property_prefix("-webkit") }} <sup><a href="#bc2">[2]</a></sup></td>
-  </tr>
-  <tr>
-   <td>Sintaxe <code>at</code> (sintaxe do padrão final)</td>
-   <td>{{ CompatGeckoDesktop("10") }}{{ property_prefix("-moz") }} <sup><a href="#bc3">[3]</a></sup><br>
-    {{ CompatGeckoDesktop("16") }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>10.0</td>
-   <td>11.60{{ property_prefix("-o") }} <sup><a href="#bc3">[3]</a></sup><br>
-    Presto 2.12 will remove the prefix.</td>
-   <td>{{ CompatNo() }}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Phone</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico (suporte à função radial-gradient(), mas não necessariamente com a sintaxe final)</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{ CompatGeckoMobile("1.9.2") }}{{ property_prefix("-moz") }} <sup><a href="#bc3">[3]</a></sup><br>
-    {{ CompatGeckoMobile("16") }}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
-  <tr>
-   <td><a class="external" href="http://www.webkit.org/blog/175/introducing-css-gradients/">Sintaxe legada do webkit</a> {{ non-standard_inline() }}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Sintaxe <code>at</code> (sintaxe do padrão final)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{ CompatGeckoMobile("10") }}{{ property_prefix("-moz") }} <sup><a href="#bc3">[3]</a></sup><br>
-    {{ CompatGeckoMobile("16") }}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p><sup><a name="bc1">[1]</a></sup> Internet Explorer 5.5 a 9.0 suportam a funcionalidade proprietária <a class="external" href="http://msdn.microsoft.com/en-us/library/ms532997(VS.85,loband).aspx"><code>filter: progid:DXImageTransform.Microsoft.Gradient()</code> filter</a>.</p>
-
-<p><sup><a name="bc2">[2]</a></sup> WebKit desde 528 suporta a função legada <a class="external" href="https://developer.apple.com/library/safari/documentation/InternetWeb/Conceptual/SafariVisualEffectsProgGuide/Gradients/Gradient.html#//apple_ref/doc/uid/TP40008032-CH10-SW34"><code>-webkit-gradient(radial,…)</code></a>. Veja também o <a href="https://developer.apple.com/library/safari/#documentation/InternetWeb/Conceptual/SafariVisualEffectsProgGuide/Gradients/Gradient.html#//apple_ref/doc/uid/TP40008032-CH10-SW15" title="https://developer.apple.com/library/safari/#documentation/InternetWeb/Conceptual/SafariVisualEffectsProgGuide/Gradients/Gradient.html#//apple_ref/doc/uid/TP40008032-CH10-SW15">suporte atual</a> para gradientes radiais.</p>
-
-<p><sup><a name="bc3">[3]</a></sup> Firefox 3.6 e Webkit implementaram uma sintaxe anterior, prefixada.</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li><a href="/en/CSS/Using_CSS_gradients" title="en/Using gradients">Using CSS gradients</a>, {{ cssxref("repeating-radial-gradient") }}, {{ cssxref("linear-gradient") }}</li>
- <li>Proposta original do WebKit: <a class="external" href="http://webkit.org/blog/175/introducing-css-gradients/" title="http://webkit.org/blog/175/introducing-css-gradients/">http://webkit.org/blog/175/introducing-css-gradients/</a></li>
- <li>Nova implementação do WebKit: <a class="external" href="http://webkit.org/blog/1424/css3-gradients/" title="http://webkit.org/blog/1424/css3-gradients/">http://webkit.org/blog/1424/css3-gradients/</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/css/repeating-linear-gradient()/index.html b/files/pt-br/orphaned/web/css/repeating-linear-gradient()/index.html
deleted file mode 100644
index 259e9fe941..0000000000
--- a/files/pt-br/orphaned/web/css/repeating-linear-gradient()/index.html
+++ /dev/null
@@ -1,154 +0,0 @@
----
-title: repeating-linear-gradient
-slug: orphaned/Web/CSS/repeating-linear-gradient()
-translation_of: Web/CSS/repeating-linear-gradient()
-original_slug: Web/CSS/repeating-linear-gradient()
----
-<p>{{ CSSRef() }}</p>
-
-<h2 id="Summary">Summary</h2>
-
-<p>A função CSS <code>repeating-linear-gradient</code> cria uma {{cssxref("&lt;image&gt;")}} de repetidos gradientes. Isso funciona da mesma forma, e recebe os mesmos argumentos dos gradientes lineares básicos, como descrito em {{ cssxref("linear-gradient") }}, mas ele automaticamente repete as paradas das cores infinitamente em ambas as direções, com suas posições trocadas por múltiplos da diferença entre a posição da última parada de cor e a posição da primeira.</p>
-
-<p>The consequence is that an end color of a gradient always coincide with a start color. If both are not identical, this will result in a sharp transition.</p>
-
-<p>Like any other gradient, a repeating CSS linear gradient is not a CSS <span class="lang lang-en"><code><a href="color_value" rel="custom">&lt;color&gt;</a></code> </span> but an image with <a href="/en/CSS/image#no_intrinsic" title="en/CSS/image#no_intrinsic">no intrinsic dimensions</a>; that is, it has no natural or preferred size, nor ratio. Its concrete size will match the one of the element it applies to.</p>
-
-<p>Mozilla currently only supports CSS gradients as values of the {{ Cssxref("background-image") }} property, as well as within the shorthand {{ Cssxref("background") }}. You specify a gradient value instead of an image URL.</p>
-
-<h2 id="Syntax">Syntax</h2>
-
-<pre class="twopartsyntaxbox notranslate">Formal grammar: repeating-linear-gradient(  [ <a href="/en-US/CSS/angle" title="angle">&lt;angle&gt;</a> | to &lt;side-or-corner&gt; ,]? &lt;color-stop&gt; [, &lt;color-stop&gt;]+ )
-                                            \---------------------------------/ \----------------------------/
-                                              Definition of the gradient line         List of color stops
-
-                              where <code>&lt;side-or-corner&gt; = [left | right] || [top | bottom]</code>
-                                and <code>&lt;color-stop&gt;     = &lt;color&gt; [ &lt;percentage&gt; | &lt;length&gt; ]?</code>
-</pre>
-
-<pre class="notranslate">repeating-linear-gradient( 45deg, blue, red );           /* A repeating gradient on 45deg axe starting blue and finishing red */
-repeating-linear-gradient( to left top, blue, red);      /* A repeating gradient going from the bottom right to the top left
-                                                            starting blue and finishing red */
-
-repeating-linear-gradient( 0deg, blue, green 40%, red ); /* A repeating gradient going from the bottom to top, starting blue,
-                                                            being green after 40% and finishing red */
-</pre>
-
-<h3 id="Values">Values</h3>
-
-<dl>
- <dt><code>&lt;side-or-corner&gt;</code></dt>
- <dd>Represents the position of the starting-point of the gradient line. It consists of two keywords: the first one indicates the horizontal side, <code>left</code> or <code>right</code>, and the second one the vertical side, <code>top</code> or <code>bottom</code>. The order is not relevant and each of the keyword is optional.<br>
- The values <code>to top</code>, <code>to bottom</code>, <code>to left</code> and <code>to right</code> are translated into the angles <code>0deg</code>, <code>180deg</code>, <code>270deg</code>, <code>90deg</code> respectively. The others are translated into an angle that let the starting-point to be in the same quadrant than the described corner and so that the line defined by the starting-point and the corner is perpendicular to the gradient line. That way, the color described by the <code>&lt;color-stop&gt;</code> will exactly apply to the corner point. This is sometimes called the "<em>magic corner</em>" property. The end-point of the gradient line is the symmetrical point of the starting-point on the other direction of the center box.</dd>
- <dt><code>&lt;angle&gt;</code></dt>
- <dd>An angle of direction for the gradient. See {{ cssxref("&lt;angle&gt;") }}.</dd>
- <dt><code>&lt;color-stop&gt;</code></dt>
- <dd>This value is comprised of a {{cssxref("&lt;color&gt;")}} value, followed by an optional stop position (either a percentage between 0% and 100% or a {{cssxref("&lt;length&gt;")}} along the gradient axis).<br>
- Rendering of color-stops in CSS gradients follows the same rules as color-stops in SVG gradients.</dd>
-</dl>
-
-<h2 id="Examples">Examples</h2>
-
-<pre class="brush: css notranslate">background: repeating-linear-gradient(to bottom right, red, red 5px, white 5px, white 10px);
-</pre>
-
-<h2 id="Specifications" name="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('CSS3 Images', '#repeating-gradients', 'repeating-linear-gradient()') }}</td>
-   <td>{{ Spec2('CSS3 Images') }}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_Compatibility" name="Browser_Compatibility">Browser compatibility</h2>
-
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Firefox (Gecko)</th>
-   <th>Chrome</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support (on {{ cssxref("background") }} and {{ cssxref("background-image") }})</td>
-   <td>{{ CompatGeckoDesktop("1.9.2") }}{{ property_prefix("-moz") }}<sup><a href="#bc3">[3]</a></sup><br>
-    {{ CompatGeckoDesktop("16") }}</td>
-   <td>10.0 (534.16){{ property_prefix("-webkit") }} <sup><a href="#bc2">[2]</a></sup><sup><a href="#bc3">[3]</a></sup></td>
-   <td>10.0 <sup><a href="#bc1">[1]</a></sup></td>
-   <td>11.10{{ property_prefix("-o") }} <sup><a href="#bc3">[3]</a></sup></td>
-   <td>5.1{{ property_prefix("-webkit") }}<sup><a href="#bc2">[2]</a></sup><sup><a href="#bc3">[3]</a></sup></td>
-  </tr>
-  <tr>
-   <td>On any properties that accept {{cssxref("&lt;image&gt;")}}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatVersionUnknown() }}</td>
-   <td>{{ CompatUnknown() }}</td>
-   <td>{{ CompatUnknown() }}</td>
-   <td>{{ CompatVersionUnknown() }}</td>
-  </tr>
-  <tr>
-   <td><a class="external" href="http://www.webkit.org/blog/175/introducing-css-gradients/">Legacy webkit syntax</a>{{ non-standard_inline() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>3{{ property_prefix("-webkit") }} <sup><a href="#bc2">[2]</a></sup></td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>4.0{{ property_prefix("-webkit") }}<sup><a href="#bc2">[2]</a></sup></td>
-  </tr>
-  <tr>
-   <td>Legacy <em>from </em>syntax (without <code>to</code>){{ non-standard_inline() }}</td>
-   <td>{{ CompatGeckoDesktop("1.9.2") }}{{ property_prefix("-moz") }} <sup><a href="#bc4">[4]</a></sup><br>
-    Removed in {{ CompatGeckoDesktop("16") }}</td>
-   <td>10.0 (534.16){{ property_prefix("-webkit") }} <sup><a href="#bc2">[2]</a></sup></td>
-   <td>10.0</td>
-   <td>11.10{{ property_prefix("-o") }}<sup><a href="#bc4">[4]</a></sup></td>
-   <td>5.1{{ property_prefix("-webkit") }}<sup><a href="#bc2%3E">[2]</a></sup></td>
-  </tr>
-  <tr>
-   <td><code>to </code>syntax</td>
-   <td>{{ CompatGeckoDesktop("10") }}{{ property_prefix("-moz") }}<sup><a href="#bc4">[4]</a></sup><br>
-    {{ CompatGeckoDesktop("16") }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>10.0</td>
-   <td>11.60{{ property_prefix("-o") }}<sup><a href="#bc4">[4]</a></sup><br>
-    Presto 2.12 will remove the prefix.</td>
-   <td>{{ CompatNo() }}</td>
-  </tr>
- </tbody>
-</table>
-
-<p><sup><a name="bc1">[1]</a></sup> Internet Explorer 5.5 through 9.0 supports proprietary <a class="external" href="http://msdn.microsoft.com/en-us/library/ms532997(VS.85,loband).aspx"><code>filter: progid:DXImageTransform.Microsoft.Gradient()</code> filter</a>.</p>
-
-<p><sup><a name="bc2">[2]</a></sup> WebKit since 528 supports the legacy <a class="external" href="http://developer.apple.com/safari/library/documentation/InternetWeb/Conceptual/SafariVisualEffectsProgGuide/Gradients/Gradients.html"><code>-webkit-gradient(linear,…)</code> function</a>. As of WebKit 534.16, it also supports the standard gradient syntax. Unlike in Gecko, in legacy WebKit you cannot specify both a position and angle in <code>-webkit-linear-gradient()</code>. You can achieve the same effect by offsetting the color stops.</p>
-
-<p><sup><a name="bc3">[3]</a></sup> Gecko, Opera &amp; Webkit considers {{cssxref("&lt;angle&gt;")}} to start to the right, instead of the top. I.e. it considered an angle of to start to the right, instead of the top. I.e. it considered an angle of <code>0deg</code> as a direction indicator pointing to the right. This is different from the latest specification where an angle of <code>0deg</code> as a direction indicator points to the top.</p>
-
-<p><sup><a name="bc4">[4]</a></sup> Firefox 3.6 and Opera 11.10 implemented, prefixed, an early syntax where the starting corner or side was indicated without the <code>to</code> keyword, and effectively considered as a <em>from</em> position. The <code>to</code> syntax has been added in Firefox 10 and Opera 11.60 , at first without removing the deprecated syntax and translation between the two is trivial:</p>
-
-<pre class="notranslate">-moz-repeating-linear-gradient(to top left, blue, red);</pre>
-
-<p>is the same as:</p>
-
-<pre class="notranslate">-moz-repeating-linear-gradient(bottom right, blue, red);</pre>
-
-<p>The legacy syntax, without <code>to</code>, is planned to go away when the prefix is removed.</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/en/CSS/Using_CSS_gradients" title="en/Using gradients">Using CSS gradients</a>, {{ cssxref("radial-gradient", "radial-gradient()") }}, {{ cssxref("linear-gradient", "linear-gradient()") }}, {{ cssxref("repeating-radial-gradient", "repeating-radial-gradient()") }};</li>
- <li>Some properties where it can be used: {{ cssxref("background-image") }}, {{ cssxref("background") }}.</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_mídia_em_css)/index.html b/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_mídia_em_css)/index.html
deleted file mode 100644
index ac24931ebe..0000000000
--- a/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_mídia_em_css)/index.html
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: Usando CSS media queries (consultas de mídia em CSS)
-slug: orphaned/Web/Guide/CSS/CSS_media_queries_(consultas_de_mídia_em_CSS)
-tags:
-  - CSS
-  - Guía
-  - Iniciante
-  - media query
-original_slug: Web/Guide/CSS/CSS_media_queries_(consultas_de_mídia_em_CSS)
----
-<p><span class="seoSummary">Uma media query (consulta de mídia) consiste de um tipo de mídia e de, ao menos, uma expressão que restringe o escopo dos estilos CSS pelo uso de propriedades de mídia, como width (largura), height (altura) e color (cor). Media queries, incluídas na especificação CSS3, permitem que a apresentação do conteúdo se adapte a uma variedade de dispositivos de exibição sem a necessidade de mudar o próprio conteúdo.</span></p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<p>Consultas de mídia consistem em tipos de mídia opcional e podem, de acordo com a especificação CSS3, conter entre nenhuma ou mais expressões, declararadas como propriedades de mídia, que podem conter condições de estado verdadeiras ou falsas. O resultado de uma query (consulta) será verdadeiro se o tipo de mídia especificado nela corresponder ao tipo do dispositivo onde o documento é exibido e todas as expressões contidas na consulta forem verdadeiras.</p>
-
-<p>Fonte:</p>
-
-<p><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries">https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries</a></p>
-
-<p> </p>
diff --git a/files/pt-br/orphaned/web/guide/events/creating_and_triggering_events/index.html b/files/pt-br/orphaned/web/guide/events/creating_and_triggering_events/index.html
deleted file mode 100644
index ec531e58e0..0000000000
--- a/files/pt-br/orphaned/web/guide/events/creating_and_triggering_events/index.html
+++ /dev/null
@@ -1,146 +0,0 @@
----
-title: Criando e disparando eventos
-slug: orphaned/Web/Guide/Events/Creating_and_triggering_events
-tags:
-  - Avançado
-  - DOM
-  - Guía
-  - JavaScript
-  - eventos
-translation_of: Web/Guide/Events/Creating_and_triggering_events
-original_slug: Web/Guide/Events/Creating_and_triggering_events
----
-<p>Este artigo demonstra como criar e disparar eventos DOM. Tais eventos são comumente chamados <strong>eventos sintéticos</strong>, oposto aos eventos disparados pelo próprio navegador.</p>
-
-<h2 id="Criando_eventos_customizados">Criando eventos customizados</h2>
-
-<p>Eventos podem ser criados com o construtor <a href="/en-US/docs/Web/API/Event"><code>Event</code></a> da seguinte forma:</p>
-
-<pre class="brush: js">var event = new Event('build');
-
-// Ouve pelo evento.
-elem.addEventListener('build', function (e) { ... }, false);
-
-// Dispara o evento.
-elem.dispatchEvent(event);</pre>
-
-<p>Este construtor é suportado na maioria dos navegadores modernos (com o Internet Explorer sendo exceção). Para uma abordagem mais verbosa (a qual é suportada pelo Internet Explorer), veja <a href="#The_old-fashioned_way" title="#The_old-fashioned_way">a forma antiga</a> abaixo.</p>
-
-<h3 id="Adicionando_dados_customizados_–_CustomEvent()">Adicionando dados customizados – CustomEvent()</h3>
-
-<p>Para adicionar mais dados ao objeto do evento, usa-se a interface <a href="/en-US/docs/Web/API/CustomEvent">CustomEvent</a>, a qual possui a propriedade <u><strong>detail</strong></u> que pode ser utilizada para fornecer dados customizados.</p>
-
-<p><span style="line-height: 1.5;">Por exemplo, o evento pode ser criado da seguinte forma:</span></p>
-
-<pre class="brush: js">var event = new CustomEvent('build', { 'detail': elem.dataset.time });</pre>
-
-<p>Isso permitirá que você acesse dados customizados no listener do evento:</p>
-
-<pre class="brush: js">function eventHandler(e) {
-  console.log('The time is: ' + e.detail);
-}
-</pre>
-
-<h3 id="A_forma_antiga">A forma antiga</h3>
-
-<p>A forma antiga de criar eventos possui uma abordagem mais verbosa, tendo APIs inspiradas em Java. Abaixo temos um exemplo:</p>
-
-<pre class="brush: js">// Cria o evento.
-var event = <a href="/en-US/docs/Web/API/Document/createEvent">document.createEvent</a>('Event');
-
-// Define que o nome do evento é 'build'.
-event.initEvent('build', true, true);
-
-// Ouve pelo evento.
-elem.addEventListener('build', function (e) {
-  // e.target é igual a elem, neste caso
-}, false);
-
-// O alvo do evento pode ser qualquer instância de Element ou EventTarget.
-elem.dispatchEvent(event);
-
-</pre>
-
-<h2 id="Disparando_eventos_nativos">Disparando eventos nativos</h2>
-
-<p>Este exemplo mostra a simulação de um clique (isto é, gera um um clique de forma programatica) sobre um checkbox usando métodos DOM. <a class="external" href="http://developer.mozilla.org/samples/domref/dispatchEvent.html">Veja o exemplo em ação.</a></p>
-
-<pre class="brush: js">function simulateClick() {
-  var event = new MouseEvent('click', {
-    'view': window,
-    'bubbles': true,
-    'cancelable': true
-  });
-
-  var cb = document.getElementById('checkbox');
-  var cancelled = !cb.dispatchEvent(event);
-
-  if (cancelled) {
-    // Um listener invocou o método preventDefault.
-    alert("Cancelado");
-  } else {
-    // Nenhum listener invocou o método preventDefault.
-    alert("Não cancelado");
-  }
-}</pre>
-
-<h2 id="Browser_compatibility" name="Browser_compatibility" style="line-height: 30px; font-size: 2.14285714285714rem;">Compatibilidade com navegadores</h2>
-
-<p>{{ CompatibilityTable() }}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th style="line-height: 16px;">Feature</th>
-   <th style="line-height: 16px;">Chrome</th>
-   <th style="line-height: 16px;">Firefox (Gecko)</th>
-   <th style="line-height: 16px;">Edge</th>
-   <th style="line-height: 16px;">Internet Explorer</th>
-   <th style="line-height: 16px;">Opera</th>
-   <th style="line-height: 16px;">Safari (WebKit)</th>
-  </tr>
-  <tr>
-   <td><code>construtor Event()</code></td>
-   <td>15</td>
-   <td>11</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>11</td>
-   <td>11.60</td>
-   <td>6</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th style="line-height: 16px;">Feature</th>
-   <th style="line-height: 16px;">Android</th>
-   <th style="line-height: 16px;">Firefox Mobile (Gecko)</th>
-   <th style="line-height: 16px;">IE Mobile</th>
-   <th style="line-height: 16px;">Opera Mobile</th>
-   <th style="line-height: 16px;">Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{ CompatUnknown() }}</td>
-   <td>{{ CompatUnknown() }}</td>
-   <td>{{ CompatUnknown() }}</td>
-   <td>{{ CompatUnknown() }}</td>
-   <td>6</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{domxref("document.createEvent()")}}</li>
- <li>{{domxref("Event.initEvent()")}}</li>
- <li>{{domxref("EventTarget.dispatchEvent()")}}</li>
- <li>{{domxref("EventTarget.addEventListener()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/guide/events/event_handlers/index.html b/files/pt-br/orphaned/web/guide/events/event_handlers/index.html
deleted file mode 100644
index 34fdcb15f8..0000000000
--- a/files/pt-br/orphaned/web/guide/events/event_handlers/index.html
+++ /dev/null
@@ -1,165 +0,0 @@
----
-title: DOM onevent handlers
-slug: orphaned/Web/Guide/Events/Event_handlers
-translation_of: Web/Guide/Events/Event_handlers
-original_slug: Web/Guide/Events/Event_handlers
----
-<p>A plataforma web oferece várias maneiras de trabalhar com o <span class="seoSummary"><a href="/en-US/docs/Web/Events">DOM events</a>. </span>Duas abordagens comuns são:<span class="seoSummary"> {{domxref("EventTarget.addEventListener", "addEventListener()")}} e o específico <code>on<em>event</em></code> que dispara um evento.</span> Este artigo se concentra em como o último funciona.</p>
-
-<h2 id="Registering_onevent_handlers">Registering onevent handlers</h2>
-
-<p>The <strong><code>on<em>event</em></code></strong> handlers are properties on certain DOM elements to manage how that element reacts to events. Elements can be interactive (links, buttons, images, forms, and so forth) or non-interactive (such as the base <code>&lt;body&gt;</code> element). Events are actions like:</p>
-
-<ul>
- <li>Being clicked</li>
- <li>Detecting pressed keys</li>
- <li>Getting focus</li>
-</ul>
-
-<p>The on-event handler is usually named with the event it reacts to, like <code>on<em>click</em></code>, <code>on<em>keypress</em></code>, <code>on<em>focus</em></code>, etc.</p>
-
-<p>You can specify an <code>on<em>&lt;…&gt;</em></code> event handler for a particular event (such as {{event("click")}}) for a given object in different ways:</p>
-
-<ul>
- <li>Adding an HTML {{Glossary("attribute")}} named <code>on<em>&lt;eventtype&gt;</em></code>:<br>
-  <code>&lt;button <strong>onclick="handleClick()"</strong>&gt;</code>,</li>
- <li>Or by setting the corresponding {{Glossary("property/JavaScript", "property")}} from JavaScript:<br>
-  <code>document.querySelector("button")<strong>.onclick = function(event) { … }</strong></code>.</li>
-</ul>
-
-<p>An <code>on<em>event</em></code> event handler property serves as a placeholder of sorts, to which a single event handler can be assigned. In order to allow multiple handlers to be installed for the same event on a given object, you can call its {{domxref("EventTarget.addEventListener", "addEventListener()")}} method, which manages a list of handlers for the given event on the object. A handler can then be removed from the object by calling its {{domxref("EventTarget.removeEventListener", "removeEventListener()")}} function.</p>
-
-<p>When an event occurs that applies to an element, each of its event handlers is called to allow them to handle the event, one after another. You don't need to call them yourself, although you can do so in many cases to easily simulate an event taking place. For example, given a button object <code>myButton</code>, you can do <code>myButton.onclick(myEventObject)</code> to call the event handler directly. If the event handler doesn't access any data form the event object, you can leave out the event when calling <code>onclick()</code>.</p>
-
-<p>This continues until every handler has been called, unless one of the event handlers explicitly halts the processing of the event by calling {{domxref("Event.stopPropagation", "stopPropagation()")}} on the event object itself.</p>
-
-<h3 id="Non-element_objects">Non-element objects</h3>
-
-<p>Event handlers can also be set with properties on non-element objects that generate events, like {{ domxref("window") }}, {{ domxref("document") }}, {{ domxref("XMLHttpRequest") }}, and others. For example, for the <code>progress</code> event on instances of <code>XMLHttpRequest</code>:</p>
-
-<pre class="brush: js notranslate">const xhr = new XMLHttpRequest();
-xhr.onprogress = function() { … };</pre>
-
-<h2 id="HTML_onevent_attributes">HTML onevent attributes</h2>
-
-<p>HTML elements have attributes named <code>on<em>event</em></code> which can be used to register a handler for an event directly within the HTML code. When the element is built from the HTML, the value of its <code>on<em>event</em></code> attributes are copied to the DOM object that represents the element, so that accessing the attributes' values using JavaScript will get the value set in the HTML.</p>
-
-<p>Further changes to the HTML attribute value can be done via the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Element/setAttribute"><code>setAttribute</code> </a>method; Making changes to the JavaScript property will have no effect.</p>
-
-<h3 id="HTML">HTML</h3>
-
-<p>Given this HTML document:</p>
-
-<pre class="brush: html notranslate">&lt;p&gt;Demonstrating quirks of &lt;code&gt;on&lt;em&gt;event&lt;/em&gt;&lt;/code&gt; HTML attributes on
-   &lt;a onclick="log('Click!')"&gt;these three words&lt;/a&gt;.
-&lt;/p&gt;
-
-&lt;div&gt;&lt;/div&gt;</pre>
-
-<h3 id="JavaScript">JavaScript</h3>
-
-<p>Then this JavaScript demonstrates that the value of the HTML attribute is unaffected by changes to the JavaScript object's property.</p>
-
-<pre class="brush: js notranslate">let logElement = document.querySelector('div');
-let el = document.querySelector("a");
-
-function log(msg) { logElement.innerHTML += `${msg}&lt;br&gt;` };
-function anchorOnClick(event) { log("Changed onclick handler") };
-
-// Original Handler
-log(`Element's onclick as a JavaScript property: &lt;code&gt; ${el.onclick.toString()} &lt;/code&gt;`);
-
-//Changing handler using .onclick
-log('&lt;br&gt;Changing onclick handler using &lt;strong&gt; onclick property &lt;/strong&gt; ');
-
-el.onclick = anchorOnClick;
-
-log(`Changed the property to: &lt;code&gt; ${el.onclick.toString()} &lt;/code&gt;`);
-log(`But the HTML attribute is unchanged: &lt;code&gt; ${el.getAttribute("onclick")} &lt;/code&gt;&lt;br&gt;`);
-
-//Changing handler using .setAttribute
-log('&lt;hr/&gt;&lt;br&gt; Changing onclick handler using &lt;strong&gt; setAttribute method &lt;/strong&gt; ');
-el.setAttribute("onclick", 'anchorOnClick(event)');
-
-log(`Changed the property to: &lt;code&gt; ${el.onclick.toString()} &lt;/code&gt;`);
-log(`Now even the HTML attribute has changed: &lt;code&gt; ${el.getAttribute("onclick")} &lt;/code&gt;&lt;br&gt;`);</pre>
-
-<h3 id="Result">Result</h3>
-
-<p>{{ EmbedLiveSample('HTML_onevent_attributes', '', '', '', 'Web/Guide/Events/Event_handlers') }}</p>
-
-<p>For historical reasons, some attributes/properties on the {{HTMLElement("body")}} and {{HTMLElement("frameset")}} elements instead set event handlers on their parent {{domxref("Window")}} object. (The HTML specification names these: <code><a href="/en-US/docs/Web/API/GlobalEventHandlers/onblur">onblur</a></code>, <code><a href="/en-US/docs/Web/API/GlobalEventHandlers/onerror">onerror</a></code>, <code><a href="/en-US/docs/Web/API/GlobalEventHandlers/onfocus">onfocus</a></code>, <code><a href="/en-US/docs/Web/API/GlobalEventHandlers/onload">onload</a></code>, and <code><a href="/en-US/docs/Web/API/GlobalEventHandlers/onscroll">onscroll</a></code>.)</p>
-
-<h3 id="Event_handlers_parameters_this_binding_and_the_return_value">Event handler's parameters, <code>this</code> binding, and the return value</h3>
-
-<p>When the event handler is specified as <strong>an HTML attribute</strong>, the specified code is wrapped into a function with <strong>the following parameters</strong>:</p>
-
-<ul>
- <li><code>event</code> — for all event handlers except {{domxref("GlobalEventHandlers.onerror", "onerror")}}.</li>
- <li><code>event</code>, <code>source</code>, <code>lineno</code>, <code>colno</code>, and <code>error</code> for the {{domxref("GlobalEventHandlers.onerror", "onerror")}} event handler. Note that the <code>event</code> parameter actually contains the error message as a string.</li>
-</ul>
-
-<p>When the event handler is invoked, the <code>this</code> keyword inside the handler is set to the DOM element on which the handler is registered. For more details, see <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this#In_an_inline_event_handler">the <code>this</code> keyword documentation</a>.</p>
-
-<p>The return value from the handler determines if the event is canceled. The specific handling of the return value depends on the kind of event; for details, see <a href="https://html.spec.whatwg.org/multipage/webappapis.html#the-event-handler-processing-algorithm">"The event handler processing algorithm" in the HTML specification</a>.</p>
-
-<h3 id="When_the_event_handler_is_invoked">When the event handler is invoked</h3>
-
-<div class="blockIndicator note">
-<p>TBD (non-capturing listener)</p>
-</div>
-
-<h3 id="Terminology">Terminology</h3>
-
-<p>The term <strong>event handler</strong> may refer to:</p>
-
-<ul>
- <li>Any function or object that is registered to be notified of events</li>
- <li>Or more specifically, to the mechanism of registering event listeners via <code>on…</code> attributes in HTML or properties in Web APIs, such as <code>&lt;button onclick="alert(this)"&gt;</code> or <code>window.onload = function() { … }</code>.</li>
-</ul>
-
-<p>When discussing the various methods of listening to events:</p>
-
-<ul>
- <li><strong>Event listener</strong> refers to a function or object registered via {{domxref("EventTarget.addEventListener()")}}</li>
- <li><strong>Event handler</strong> refers to a function registered via <code>on…</code> attributes or properties</li>
-</ul>
-
-<h2 id="Specifications" name="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('HTML WHATWG', 'webappapis.html#event-handler-attributes', 'event handlers')}}</td>
-   <td>{{Spec2('HTML WHATWG')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('HTML5 W3C', 'webappapis.html#event-handler-attributes', 'event handlers')}}</td>
-   <td>{{Spec2('HTML5 W3C')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_Compatibility" name="Browser_Compatibility">Browser compatibility</h2>
-
-<h4 id="Detecting_the_presence_of_event_handler_properties">Detecting the presence of event handler properties</h4>
-
-<p>You can detect the presence of an event handler property with the JavaScript <a href="/en-US/JavaScript/Reference/Operators/in" title="en/JavaScript/Reference/Operators/in"><code>in</code></a> operator. For example:</p>
-
-<pre class="brush: js notranslate">if ("onsomenewfeature" in window) {
-  /* do something amazing */
-}
-</pre>
-
-<h4 id="Event_handlers_and_prototypes">Event handlers and prototypes</h4>
-
-<p>You can't set or access the values of any IDL-defined attributes on DOM prototype objects. That means you can't, for example, change <code>Window.prototype.onload</code>. In the past, event handlers (<code>onload</code>, etc.) weren't implemented as IDL attributes in Gecko, so you were able to do this for those. Now you can't. This improves compatibility.</p>
diff --git a/files/pt-br/orphaned/web/guide/events/index.html b/files/pt-br/orphaned/web/guide/events/index.html
deleted file mode 100644
index d705b4757c..0000000000
--- a/files/pt-br/orphaned/web/guide/events/index.html
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Event developer guide
-slug: orphaned/Web/Guide/Events
-tags:
-  - DOM
-  - Event
-  - Guide
-  - NeedsTranslation
-  - TopicStub
-  - events
-translation_of: Web/Guide/Events
-original_slug: Web/Guide/Events
----
-<p>{{draft()}}</p>
-<p>Events refers both to a design pattern used for the asynchronous handling of various incidents which occur in the lifetime of a web page and to the naming, characterization, and use of a large number of incidents of different types.</p>
-<p>The <a href="/en-US/docs/Web/Guide/API/DOM/Events/Overview_of_Events_and_Handlers">overview page</a> provides an introduction to the design pattern and a summary of the types of incidents which are defined and reacted to by modern web browsers.</p>
-<p>The <a href="/en-US/docs/Web/Guide/API/DOM/Events/Creating_and_triggering_events">custom events page</a> describes how the event code design pattern can be used in custom code to define new event types emitted by user objects, register listener functions to handle those events, and trigger the events in user code.</p>
-<p>The remaining pages describe how to use events of different kinds defined by web browsers. Unfortunately, these events have been defined piece by piece as web browsers have evolved so that there is no satisfying systematic characterization of the events built-in or defined by modern web browsers.</p>
-<p>The <strong>device</strong> on which the web browser is running can trigger events, for example due to a change in its position and orientation in the real world, as discussed partially by the <a href="/en-US/docs/Web/Guide/API/DOM/Events/Orientation_and_motion_data_explained">page on orientation coordinate systems</a> and the <a href="/en-US/docs/Web/Guide/API/DOM/Events/Using_device_orientation_with_3D_transforms">page on the use of 3D transforms</a>. That is different, but similar, to the change in device vertical orientation. </p>
-<p>The <strong>window</strong> in which the browser is displayed which might trigger events, for example, change size if the user maximizes the window or otherwise changes it.</p>
-<p>The <strong>process</strong> loading of a web page might trigger events in response to the completion of different steps in the downloading, parsing, and rendering of the web page for display to the user.</p>
-<p>The <strong>user interaction</strong> with the web page contents might trigger events. The events triggered by user interaction evolved during the early years of browser design and include a complicated system defining the sequence in which events will be called and the manner in which that sequence can be controlled. The different types of user interaction driven events include:</p>
-<ul>
- <li>the original 'click' event,</li>
- <li>mouse events,</li>
- <li><a href="/en-US/docs/Web/Guide/API/DOM/Events/Mouse_gesture_events">mouse gesture events</a>, and</li>
- <li>both <a href="/en-US/docs/Web/Guide/API/DOM/Events/Touch_events">touch events</a> and the earlier, but deprecated, <a href="/en-US/docs/Web/Guide/API/DOM/Events/Touch_events_(Mozilla_experimental)">mozilla experimental touch events</a>.</li>
-</ul>
-<p>The <strong>modification of the web page</strong> in structure or content might trigger some events, as is explained in the <a href="/en-US/docs/Web/Guide/API/DOM/Events/Mutation_events">mutation events page</a>, but the use of these events has been deprecated in favour of the lighter <a href="/en-US/docs/Web/API/MutationObserver">Mutation Observer</a> approach.</p>
-<p>The <strong>media streams</strong> embedded in the HTML documents might trigger some events, as explained in the <a href="/en-US/docs/Web/Guide/API/DOM/Events/Media_events">media events</a> page.</p>
-<p>The <strong>network requests</strong> made by a web page might trigger some events.</p>
-<p>There are many other sources of events defined by web browsers for which pages are not yet available in this guide.</p>
-<div class="note">
- <p>Note: This Event Developer Guide needs substantial work. The structure needs to be reorganized and the pages rewritten. Our hope is that everything you need to know about events will go under here.</p>
-</div>
-<h2 id="Docs">Docs</h2>
-<p>{{LandingPageListSubpages}}</p>
diff --git a/files/pt-br/orphaned/web/guide/events/mutation_events/index.html b/files/pt-br/orphaned/web/guide/events/mutation_events/index.html
deleted file mode 100644
index c60653c55c..0000000000
--- a/files/pt-br/orphaned/web/guide/events/mutation_events/index.html
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: Mutation events
-slug: orphaned/Web/Guide/Events/Mutation_events
-translation_of: Web/Guide/Events/Mutation_events
-original_slug: Web/Guide/Events/Mutation_events
----
-<p>{{deprecated_header()}}</p>
-
-<p><strong>Mutation events</strong> fornecem um mecanismo, para uma página web ou uma extensão, de notificação sobre as alterações feitas no DOM. <span style="background-color: #ffff00;">Utilize ao invés, se possível, <a href="/en-US/docs/Web/API/MutationObserver" title="/en-US/docs/Web/API/MutationObserver">Mutation Observers</a>.</span></p>
-
-<h2 id="Prefácio">Prefácio</h2>
-
-<p>Os eventos de mutação foram marcados como em desuso na <a class="external" href="http://www.w3.org/TR/DOM-Level-3-Events/#events-mutationevents">DOM Events specification</a> pelo fato do projeto da API ser falho (veja detalhes no "DOM Mutation Events Replacement: The Story So Far / Existing Points of Consensus" publicado em <span id="to"><a class="external" href="http://lists.w3.org/Archives/Public/public-webapps/2011JulSep/0779.html">public-webapps</a>)</span>.</p>
-
-<p id="Replacement.3A_mutation_observers"><a href="/en-US/docs/Web/API/MutationObserver">Mutation Observers</a> são a proposta de substituição para eventos de mutação no DOM4. Eles devem ser incluídos no Firefox 14 e <a class="external" href="http://updates.html5rocks.com/2012/02/Detect-DOM-changes-with-Mutation-Observers" title="http://updates.html5rocks.com/2012/02/Detect-DOM-changes-with-Mutation-Observers">Chrome 18</a>.</p>
-
-<p>As razões práticas para evitar os eventos de mutação são <strong>problemas de desempenho</strong> e suporte <strong>cross-browser.</strong></p>
-
-<h3 id="Performance">Performance</h3>
-
-<p>Adicionando listeners de mutação do DOM a um documento <a class="external" href="http://groups.google.com/group/mozilla.dev.platform/browse_thread/thread/2f42f1d75bb906fb?pli=1" rel="external" title="http://groups.google.com/group/mozilla.dev.platform/browse_thread/thread/2f42f1d75bb906fb?pli=1">degrada o desempenho profundamente</a> de outras modificações DOM para esse documento (tornando-os 1.5 - 7 vezes mais lento!). Além disso, remover os listeners não reverte o dano.</p>
-
-<p>O efeito de desempenho é <a class="link-https" href="https://groups.google.com/forum/#!topic/mozilla.dev.platform/UH2VqFQRTDA" title="https://groups.google.com/forum/#!topic/mozilla.dev.platform/UH2VqFQRTDA">limitado aos documentos que têm os listeners de evento de mutação</a>.</p>
-
-<h3 id="Suporte_cross-browser">Suporte cross-browser</h3>
-
-<p>Esses eventos não são implementados de forma consistente entre os diferentes navegadores, por exemplo:</p>
-
-<ul>
- <li>IE anteriores à versão 9 não suportavam os eventos de mutação por completo e em alguns aspectos não implementa corretamente na versão 9 (<a class="external" href="http://help.dottoro.com/ljmcxjla.php" title="http://help.dottoro.com/ljmcxjla.php">por exemplo, DOMNodeInserted</a>)</li>
- <li>WebKit não suporta DOMAttrModified (veja <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=8191" title="https://bugs.webkit.org/show_bug.cgi?id=8191">webkit bug 8191</a> e <a class="external" href="http://about.silkapp.com/page/Mutation%20Events:%20What%20Happen" title="http://about.silkapp.com/page/Mutation%20Events:%20What%20Happen">the workaround</a>)</li>
- <li>"mutation name events", por exemplo DOMElementNameChanged e DOMAttributeNameChanged não são suportados no Firefox (a partir da versão 11), e provavelmente em outros navagedores também.</li>
- <li>...</li>
-</ul>
-
-<p>Dottoro <a class="external" href="http://help.dottoro.com/ljfvvdnm.php#additionalEvents" title="http://help.dottoro.com/ljfvvdnm.php#additionalEvents">suporte a eventos de mutação nos navegadores</a>.</p>
-
-<h2 id="Lista_de_mutation_events">Lista de mutation events</h2>
-
-<p>Listado a seguir todos os eventos de mutação, como definido no <a class="external" href="http://www.w3.org/TR/DOM-Level-3-Events/#events-mutationevents" title="http://www.w3.org/TR/DOM-Level-3-Events/#events-mutationevents">DOM Level 3 Events specification</a>:</p>
-
-<ul>
- <li><code>DOMAttrModified</code></li>
- <li><code>DOMAttributeNameChanged</code></li>
- <li><code>DOMCharacterDataModified</code></li>
- <li><code>DOMElementNameChanged</code></li>
- <li><code>DOMNodeInserted</code></li>
- <li><code>DOMNodeInsertedIntoDocument</code></li>
- <li><code>DOMNodeRemoved</code></li>
- <li><code>DOMNodeRemovedFromDocument</code></li>
- <li><code>DOMSubtreeModified</code></li>
-</ul>
-
-<h2 id="Uso">Uso</h2>
-
-<p>Você pode registrar um listener para eventos de mutação usando <a href="/en/DOM/element.addEventListener" title="en/DOM/element.addEventListener">element.addEventListener</a>, como mostrado a seguir:</p>
-
-<pre><code>element.addEventListener("DOMNodeInserted", function (event) {</code>
-  // ...
-<code>}, false);</code>
-</pre>
-
-<p>O objeto event é transmitido para o listener em um {{ domxref("MutationEvent") }} (veja <a class="external" href="http://www.w3.org/TR/DOM-Level-3-Events/#events-MutationEvent" title="http://www.w3.org/TR/DOM-Level-3-Events/#events-MutationEvent">sua definição na especificação</a>) para a maioria dos eventos, e {{ domxref("MutationNameEvent") }} para <code>DOMAttributeNameChanged</code> e <code>DOMElementNameChanged</code>.</p>
diff --git a/files/pt-br/orphaned/web/guide/events/overview_of_events_and_handlers/index.html b/files/pt-br/orphaned/web/guide/events/overview_of_events_and_handlers/index.html
deleted file mode 100644
index 950ddd0b4f..0000000000
--- a/files/pt-br/orphaned/web/guide/events/overview_of_events_and_handlers/index.html
+++ /dev/null
@@ -1,133 +0,0 @@
----
-title: Uma visão geral sobre Events e Handlers
-slug: orphaned/Web/Guide/Events/Overview_of_Events_and_Handlers
-translation_of: Web/Guide/Events/Overview_of_Events_and_Handlers
-original_slug: Web/Guide/Events/Overview_of_Events_and_Handlers
----
-<div class="summary">
-<p>Este artigo apresenta uma visão geral sobre o design pattern usado para reagir a alterações que ocorrem quando o navegador acessa uma página, e dá um resumo sobre como os navegadores modernos reagem a eles.</p>
-</div>
-
-<p>Eventos e a manipulação de eventos fornecem uma técnica essencial em JavaScript para reagir a algum incidente quando o navegador acessa uma página, incluindo eventos de preparação para exibir a página, ou interação com algum conteúdo da página que estejam relacionados com o dispositivo onde o navagador está rodando, e muitas outras, como reprodução de áudio ou vídeo.</p>
-
-<p>A manipulação de eventos tornou-se imprescindível com a evolução e mudança na arquitetura de renderização dos navegadores em relação a forma de busca e carregamento de informações na página. No início, os navegadores esperavam e recebiam os dados e recursos associados a página para analisar, processar e apresentar a página ao usuário. A página permanecia inalterada até uma requisição para um novo link. Atualmente, com a mudança para páginas dinâmicas, os navegadores estão sempre em um loop contínuo, processando, desenhando, apresentando conteúdo e esperando de algum novo evento. Os gatilhos (triggers) de evento podem ser a conclusão do carregamento de um arquivo na rede, por exemplo, uma imagem que agora pode ser mostrada na tela, a conclusão da análise de um recurso pelo navegador, o processamento do conteúdo HTML de uma página, a interação de um usuário com o conteúdo da página, com o clique em um botão. Douglas Crockford explica essa mudança de maneira eficaz em sua palestra, <em>An Inconvenient API: The Theory of the DOM.</em></p>
-
-<p>With the change to dynamic page rendering, browsers loop continuously between processing, drawing, presenting content, and waiting for some new event trigger. Event triggers include the completion of the loading of a resource on the network <em>e.g.,</em> downloads an image that can now be drawn on the screen, the completion of parsing a resource by the browser <em>e.g.</em>, processes the HTML content of a page, the interaction of a user with the contents of the page <em>e.g.,</em> clicks a button. Douglas Crockford explains this change effectively in several lectures, notably his talk, <em>An Inconvenient API: The Theory of the DOM,</em> which shows the change in flow from the original browser flow</p>
-
-<div style="margin: 0 auto; width: 68%;"><img alt="A comparison of the sequential and event-driven browser load sequences." src="https://mdn.mozillademos.org/files/6641/Browser_sequence_comparitive.svg" style="height: 454px; width: 1857px;"></div>
-
-<p>to the event driven browser. The latter approach changes the last steps from a single flow into a perpetual loop, where waiting for and handling the incidence of new events follows painting. The innovation of the dynamic approach allows for a page to be partially rendered even when the browser has not finished retrieving all resources; this approach also allows for event driven actions, which JavaScript leverages. (The talk is available from several sources, including <a href="http://www.youtube.com/watch?v=Y2Y0U-2qJMs">this one</a>.) Currently, all execution environments for JavaScript code use events and event handling.</p>
-
-<h2 id="The_event_design_pattern">The event design pattern</h2>
-
-<p>The event system, at its core, is simply a programming design pattern. The pattern starts with an agreement over a kind of event and:</p>
-
-<ul>
- <li>the name String used for the event,</li>
- <li>the type of the data structure used to represent the key properties of that event, and</li>
- <li>the JavaScript object which will 'emit' that event.</li>
-</ul>
-
-<p>The pattern is implemented by</p>
-
-<ul>
- <li>defining a JavaScript function which takes as an argument the data structure which was agreed upon, and</li>
- <li>registering the function using the name String with the object which will emit the event.</li>
-</ul>
-
-<p>The function is said to be a 'listener' or a 'handler' with both names used interchangeably. This pattern can easily be followed using completely custom code, as explained in the <a href="/en-US/docs/Web/Guide/API/DOM/Events/Creating_and_triggering_events">article on custom events</a>. The pattern is also used by modern web browsers which define many events emitted in response to user input or browser activity.</p>
-
-<p>Modern web browsers follow the event pattern using a standardized approach. Browsers use as the data structure for the properties of the event, an object derived from the <code>EventPrototype</code> object. Browsers use as the registration method for the function which will handle those data structures a method called <code>addEventListener</code> which expects as arguments a string event type name and the handler function. Finally, browsers define a large number of objects as event emitters and define a wide variety of event types generated by the objects.</p>
-
-<h2 id="Button_Event_Handler" name="Button_Event_Handler">Button Event Handler Demo</h2>
-
-<p>For example, browser <code>button</code> elements are intended to emit events named <code>'click'</code> in response to a mouse click or, when displayed in touch sensitive surfaces, to a finger tap. We could define in the HTML page a <code>button</code> as:</p>
-
-<pre class="brush: html notranslate">&lt;button id="buttonOne"&gt;Click here to emit a 'click' event&lt;/button&gt;</pre>
-
-<p>and, in our JavaScript code, we could first define a function to listen to that <code>'click'</code> event:</p>
-
-<pre class="brush: js notranslate">var example_click_handler = function (ev){
-    var objKind = (ev instanceof Event) ? "EventPrototype" : "ObjectPrototype";
-    alert("We got a click event at " + ev.timeStamp + " with an argument object derived from: " + objKind );
-};</pre>
-
-<p>and second register our function with the the <code>Button</code> object, either on the scripting side using the DOM (Document Object Model) representation of the HTML page:</p>
-
-<pre class="brush: js notranslate">var buttonDOMElement = document.querySelector('#buttonOne');
-buttonDOMElement.addEventListener('click', example_click_handler);</pre>
-
-<p>or within the HTML page by adding the function as the value of the <code>'onclick'</code> attribute, although this second approach is usually only used in very simple web pages.</p>
-
-<p>{{ EmbedLiveSample('Button_Event_Handler') }}</p>
-
-<p>This code relies on the agreement that there is a kind of event called <code>'click'</code> which will call any listener (or 'handler') function with an <code>Event</code> object argument (actually, in this case a derivative <code>MouseEvent</code> object) and which will be fired by HTML <code>button</code> elements after user interaction. The code has no visible effect until a user interacts with the button either by placing the mouse pointer over the HTML button and clicking on the left mouse button or by placing a finger or stylus of some kind on the screen above the HTML button; when that happens, the <code>buttonDOMElement</code> JavaScript object would call the <code>example_click_handler</code> function with an <code>Event</code> object as an argument. The function, in turn, would perform whatever action was chosen by the programmer, in this case to open an HTML alert dialog. Note that the handler has access to the <code>ev</code> object since it is passed as an argument; the object has information about the event, notably the time at which the event occurred.</p>
-
-<p>As a second example, much modern JavaScript integrated into web pages is wrapped into an event function call to ensure that the code is only executed when the HTML has been processed and is available for alteration or decoration. For example, code might be attached as:</p>
-
-<pre class="brush: js notranslate">var funcInit = function(){
-    // user code goes here and can safely address all the HTML elements from the page
-    // since the document has successfully been 'loaded'
-}
-document.addEventListener('DOMContentLoaded', funcInit);
-</pre>
-
-<p>so that this code will only be executed after the <code>document</code> object emits the <code>'DOMContentLoaded'</code> event because the HTML has been parsed and Javasript objects created representing each of the nodes of the HTML document. Note that in this example, the code does not even name the event argument to the function because the code never needs to use the data structure describing the event; rather, the code merely needs to wait to run until after then event has happened.</p>
-
-<p>The pattern is therefore easy to learn and implement. The difficulty with events comes from learning the wide variety of events which are generated in modern web browsers. There is also some subtlety in learning how to write the handler functions since such code works asynchronously and potentially will run repeatedly but in slightly different situations.</p>
-
-<h2 id="Notable_events">Notable events</h2>
-
-<p>Web browsers define a large number of events so it is not practical to list them all. The <a href="/en-US/docs/Web/Reference/Events">Event Reference</a> attempts to maintain a list of the standard Events used in modern web browsers.</p>
-
-<p>In general, we can distinguish events of different kinds based on the object emitting the event including:</p>
-
-<ul>
- <li>the <code>window</code> object, such as due to resizing the browser,</li>
- <li>the <code>window.screen</code> object, such as due to changes in device orientation,</li>
- <li>the <code>document</code> object, including the loading, modification, user interaction, and unloading of the page,</li>
- <li>the objects in the DOM (document object model) tree including user interactions or modifications,</li>
- <li>the <code>XMLHttpRequest</code> objects used for network requests, and</li>
- <li>the media objects such as <code>audio</code> and <code>video</code>, when the media stream players change state.</li>
-</ul>
-
-<p>although this list is currently incomplete.</p>
-
-<p>Some notable events are:</p>
-
-<div class="note">
-<p><strong>Note:</strong> This list of events will need work to make relevant; that work is awaiting some global reorganization work on the documents. This will also need finding a good explanation of the events involved during page loading, such as discussed partially in <em><a href="http://ablogaboutcode.com/2011/06/14/how-javascript-loading-works-domcontentloaded-and-onload">this web page</a> or in <a href="http://stackoverflow.com/questions/1795438/load-and-execution-sequence-of-a-web-page">this Stack Overflow question</a>. </em></p>
-</div>
-
-<ul>
- <li>the global object <a href="/en-US/docs/Web/API/Window"><code>window</code></a> emits an event called <a href="/en-US/docs/Web/Reference/Events/load_(ProgressEvent)"><code>'load'</code></a> when the page has finished rendering, meaning that all resources have been downloaded and acted upon, so that the scripts have been run and the images displayed,</li>
- <li>the global object <a href="/en-US/docs/Web/API/Window"><code>window</code></a> emits an event called <a href="/en-US/docs/Web/Reference/Events/resize"><code>'resize'</code></a> when the height or the width of the browser window is changed by a user,</li>
- <li>the DOM object <a href="/en-US/docs/Web/API/Document"><code>document</code></a> representing the HTML document emits an event called<code> <a href="/en-US/docs/Web/Reference/Events/DOMContentLoaded">'DOMContentLoaded'</a></code> when the document has finished loading,</li>
- <li>the DOM node objects such as <a href="/en-US/docs/Web/HTML/Element/div"><code>div</code></a> or <a href="/en-US/docs/Web/HTML/Element/button"><code>button</code></a> emit an event called <a href="/en-US/docs/Web/Reference/Events/click"><code>'click'</code></a> when the user presses the mouse button while the mouse pointer is on top of the DOM node in the HTML page.</li>
-</ul>
-
-
-
-<h2 id="The_Event_object_hierarchy">The Event object hierarchy</h2>
-
-<p>The web browser defines many events of different kinds. Each definition includes, as the data structure passed to the handler function, an object which inherits from the <code>EventPrototype</code> object.</p>
-
-<p>A partial diagram of the class hierarchy of event objects is:</p>
-
-<div class="note">
-<p><strong>Note:</strong> This diagram is incomplete.</p>
-</div>
-
-<p><img alt="" src="https://mdn.mozillademos.org/files/6633/Js_Event_Object_Hierarchy.svg" style="height: 496px; width: 1417px;"></p>
-
-<p>The Web API Documentation contains <a href="/en-US/docs/Web/API/Event">a page defining the Event object</a> which also includes the known DOM event subclasses of the <code>Event</code> object.</p>
-
-<h2 id="Documents">Documents</h2>
-
-<p>Three sources on the MDN (Mozilla Developer Network) web site are particularly useful for programmers wanting to work with events:</p>
-
-<ul>
- <li>this <a href="/en-US/docs/Web/Guide/API/DOM/Events">Event Guide</a> which is part of the <a href="/en-US/docs/Web/Guide">Web Developers' Guide</a>,</li>
- <li>the <a href="/en-US/docs/Web/Reference/Events">Event Reference</a>,</li>
- <li>the Web API documentation for the <a href="/en-US/docs/Web/API/Event"><code>Event</code></a> object.</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/guide/html/html5/index.html b/files/pt-br/orphaned/web/guide/html/html5/index.html
deleted file mode 100644
index 70e852c9cb..0000000000
--- a/files/pt-br/orphaned/web/guide/html/html5/index.html
+++ /dev/null
@@ -1,300 +0,0 @@
----
-title: HTML5
-slug: orphaned/Web/Guide/HTML/HTML5
-tags:
-  - Desenvolvimento Web
-  - Guía
-  - HTML
-  - HTML5
-  - Visão Geral
-  - Web
-translation_of: Web/Guide/HTML/HTML5
-original_slug: Web/Guide/HTML/HTML5
----
-<p>HTML5 é a mais recente evolução do padrão que define o <a href="https://developer.mozilla.org/pt-BR/docs/HTML" title="https://developer.mozilla.org/pt-BR/docs/HTML">HTML</a>. O termo representa dois conceitos diferentes:</p>
-
-<ul>
- <li>É uma nova versão da <em>linguagem </em>HTML, com novos elementos, atributos, e comportamentos</li>
- <li>e um conjunto maior de tecnologias que permite o desenvolvimento de aplicações e web sites mais diversos e poderosos. Este conjunto é chamado <em>HTML5 &amp; friends</em> e muitas vezes abreviado apenas como <em>HTML5.</em></li>
-</ul>
-
-<p>Criada para ser utilizável por todos os desenvolvedores da Web Aberta, essa página de referências faz ligações a inúmeros recursos do HTML5, classificados em diversos grupos, baseando-se em suas funções;</p>
-
-<ul>
- <li><em>Semântica</em>: permite você descrever mais precisamente o seu conteúdo.</li>
- <li>Conectividade: permite uma comunicação com o servidor de formas modernas e inovadoras.</li>
- <li>Offline e armazenamento: Permite que páginas web armazenem dados localmente do lado do cliente e opere de forma offline mais eficientemente.</li>
- <li>Multimídia: Viabiliza a utilização de áudio e vídeo de forma primorosa na Web Aberta.</li>
- <li>Gráficos e efeitos 2D/3D: viabiliza um leque diversificado de opções de representação gráfica. </li>
- <li>Performance e integração: fornece grande otimização de velocidade e melhor utilização do hardware do computador.</li>
- <li>Acesso ao dispositivo: viabiliza a utilização de diversos métodos e dispositivos de entrada e saída.</li>
- <li>Estilização: permite aos autores a escrita de temas mais sofisticados.</li>
-</ul>
-
-<div class="twocolumns">
-
-</div>
-
-<h2 id="Semântica"><img alt="" src="https://mdn.mozillademos.org/files/3827/HTML5_Semantics_512.png" style="height: 50px; width: 50px;"> Semântica </h2>
-
-<dl>
- <dt><strong><a href="https://developer.mozilla.org/pt-BR/docs/Sections_and_Outlines_of_an_HTML5_document">Seções e estruturas em HTML</a></strong></dt>
- <dd>Uma visão geral sobre as novas estruturas e novos elementos de seção do HTML5: {{HTMLElement("section")}}, {{HTMLElement("article")}}, {{HTMLElement("nav")}}, {{HTMLElement("header")}}, {{HTMLElement("footer")}} e {{HTMLElement("aside")}}</dd>
- <dt><strong><a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Using_HTML5_audio_and_video">Utilizando áudio e vídeo com HTML5</a></strong></dt>
- <dd>Os elementos {{HTMLElement("audio")}} e {{HTMLElement("video")}} incorporam e permitem manipulação de novos conteúdos multimídia. </dd>
- <dt><strong><a href="https://developer.mozilla.org/pt-BR/docs/HTML/Forms_in_HTML">Formulários em HTML5</a></strong> </dt>
- <dd>Uma visão geral sobre as melhorias dos formulários web com o HTML5: a API de validação de restrição, novos valores para o atributo {{htmlattrxref("type", "input")}} dos {{HTMLElement("input")}} e o novo elemento {{HTMLElement("output")}}.</dd>
- <dt><strong>Novos elementos semânticos</strong></dt>
- <dd>Seções laterais, mídia e elementos de formulário: há diversos novos elementos, como {{HTMLElement("mark")}}, {{HTMLElement("figure")}}, {{HTMLElement("figcaption")}}, {{HTMLElement("data")}}, {{HTMLElement("time")}}, {{HTMLElement("output")}}, {{HTMLElement("progress")}}, ou {{HTMLElement("meter")}} e {{HTMLElement("main")}}, incrementando o montante de <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element">elementos válidos do HTML5</a>.</dd>
- <dt><strong>Melhorias no {{HTMLElement("iframe")}}</strong></dt>
- <dd>Usando os atributos {{htmlattrxref("sandbox", "iframe")}}, {{htmlattrxref("seamless", "iframe")}}, e {{htmlattrxref("srcdoc", "iframe")}} , autores podem ser precisos sobre o nível de segurança e a renderização desejada de um elemento <strong>{{HTMLElement("iframe")}}.</strong></dd>
- <dt><a href="https://developer.mozilla.org/pt-BR/docs/Web/MathML">MathML</a></dt>
- <dd>Viabiliza a inserção direta de fórmulas matemáticas no código HTML5.</dd>
- <dt><a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5/Introduction_to_HTML5">Introdução ao HTML5</a></dt>
- <dd>Este artigo introduz como indicar para o navegador que você está usando HTML5 em sua página ou aplicação web. </dd>
- <dt><a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5/Parser_HTML5">HTML5 parser compatível</a></dt>
- <dd>O parser, que torna os bytes de um HTML em DOM, foi extendido e agora define precisamente o comportamento em todos os casos, mesmo quando se depara com código HTML inválido. Isso viabiliza uma grandiosa previsibilidade e interoperabilidade entre navegadores compatíveis com o HTML5.</dd>
-</dl>
-
-<h2 id="Conectividade"><img alt="" src="https://mdn.mozillademos.org/files/3839/HTML5_Connectivity_512.png" style="height: 50px; width: 50px;">Conectividade</h2>
-
-<dl>
- <dt><a href="https://developer.mozilla.org/pt-BR/docs/WebSockets">Web Sockets</a></dt>
- <dd>Permite a criação de uma conexão permanente entre a página e o servidor para que estes possam trocar dados através desta ligação.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events">Eventos do servidor</a></dt>
- <dd>Permite que o servidor envie eventos para um cliente, ao contrário do paradigma clássico onde o servidor pode enviar apenas dados em resposta às requests do cliente.</dd>
- <dt><a href="https://developer.mozilla.org/pt-BR/docs/Web/Guide/API/WebRTC">WebRTC</a></dt>
- <dd>WebRTC (Comunicação em tempo real), permite conexões entre usuários e controle de videoconferência diretamente no browser, sem necessidade de um plugin ou aplicação externa.</dd>
-</dl>
-
-<h2 id="Offline_e_armazenamento"><img alt="" src="https://mdn.mozillademos.org/files/3833/HTML5_Offline_Storage_512.png" style="height: 50px; width: 50px;">Offline e armazenamento</h2>
-
-<dl>
- <dt><a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Using_the_application_cache">Recursos offline: cache de aplicação</a></dt>
- <dd>Firefox possui suporte completo às especificações dos recursos offlines do HTML5. A maioria dos outros navegadores suportam apenas parte deste recurso.</dd>
- <dt>Eventos online e offline</dt>
- <dd>
- <p>Firefox 3 dá suporte aos eventos WHATWG online e offline, o que permite que aplicações e extensões percebam quando há conexão de Internet, assim como permite a detecção das oscilações de conexão. </p>
- </dd>
- <dt>WHATWG </dt>
- <dd>Sessão <em>client-side</em> e armazenamento persistente permite que aplicações web armazenem dados de forma estruturada no lado do cliente.</dd>
- <dt>IndexedDB</dt>
- <dd>É um padrão web para armazenamento de quantidades significativas de dados estruturados no navegador e para alta performace de busca nestes dados, usando índices.</dd>
- <dt>Uso de arquivos de aplicações web</dt>
- <dd>Foi adicionado ao <a href="https://developer.mozilla.org/pt-BR/docs/Mozilla/Gecko">Gecko</a> o suporte à nova API de arquivos do HTML5, tornando possível o acesso de arquivos locais pelas aplicações. Isso inclui suporte para seleções de múltiplos arquivos usando {{HTMLElement("input")}} do novo <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/Input#attr-type">tipo</a> <span style="font-family: courier;">file</span> do HTML5. Há também o <a href="https://developer.mozilla.org/pt-BR/docs/Web/API/FileReader">FileReader</a>.</dd>
-</dl>
-
-<h2 id="Multimídia"><img alt="" src="https://mdn.mozillademos.org/files/3835/HTML5_Multimedia_512.png" style="height: 50px; width: 50px;">Multimídia</h2>
-
-<dl>
- <dt>Utilizando áudio e vídeo com HTML5</dt>
- <dd>Os elementos {{HTMLElement("audio")}} e {{HTMLElement("video")}} incluem e permitem a manipulação de novos conteúdos multimídia.</dd>
- <dt>WebRTC</dt>
- <dd>Permite conexões entre usuários e controle de videoconferência diretamente no browser, sem necessidade de um <em>plugin</em> ou aplicação externa.</dd>
- <dt>API da câmera</dt>
- <dd>Permite o uso, manipulação e armazenamento de uma imagem diretamente da câmera do computador.</dd>
- <dt>Track e WebVTT</dt>
- <dd>O elemento {{HTMLElement("track")}} permite legendas e capítulos. WebVTT é o formato de texto do track {{HTMLElement("track")}}.</dd>
-</dl>
-
-<h2 id="Gráficos_e_efeitos_3D"><img alt="" src="https://mdn.mozillademos.org/files/3841/HTML5_3D_Effects_512.png" style="height: 50px; width: 50px;">Gráficos e efeitos 3D</h2>
-
-<dl>
- <dt><a href="https://developer.mozilla.org/pt-BR/docs/Web/Guide/HTML/Canvas_tutorial">Canvas</a></dt>
- <dd>Aprenda sobre o novo elemento {{HTMLElement("canvas")}} e como utilizá-lo para desenhar gráficos e objetos no Firefox.</dd>
- <dt>API de texto para {{HTMLElement("canvas")}}</dt>
- <dd>O elemento {{HTMLElement("canvas")}} agora dá suporte à  API de texto do HTML5.</dd>
- <dt>WebGL</dt>
- <dd>WebGL traz gráficos 3D à Web, introduzindo uma API que se aproxima bastante à OpenGL ES 2.0, que pode ser usada em elementos {{HTMLElement("canvas")}}.</dd>
- <dt>SVG</dt>
- <dd>Um formato de imagens vetoriais baseada em XML que pode ser diretamente embutido no HTML5.</dd>
-</dl>
-
-<h2 id="Performance_e_integração"><img alt="" src="https://developer.mozilla.org/files/3831/HTML5_Performance_512.png" style="height: 50px; width: 50px;">Performance e integração</h2>
-
-<dl>
- <dt><a href="https://developer.mozilla.org/en-US/docs/DOM/Using_web_workers" title="Using web workers">Web Workers</a></dt>
- <dd>Permite a delegação da evolução do JavaScript para threads em segundo plano, permitindo que essas atividades sejam prevenidas e assim não deixando as interações dos eventos lentas.</dd>
- <dt><code><a href="https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest" title="XMLHttpRequest">XMLHttpRequest</a></code> level 2</dt>
- <dd>Permite buscar de forma <span id="result_box" lang="pt"><span>assíncrona</span></span> algumas partes da página, permitindo apresentar na tela conteúdo dinâmico, variando de acordo com o tempo e ações do usuário. Está é a tecnologia por trás do <a href="https://developer.mozilla.org/en-US/docs/AJAX" title="AJAX">Ajax</a>.</dd>
- <dt>Motor JIT-compiling para JavaScript</dt>
- <dd>A nova e poderosa geração de motores JavaScript é muito mais poderosa, levando para uma maior performance.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/DOM/Manipulating_the_browser_history" title="DOM/Manipulating_the_browser_history">History API</a></dt>
- <dd>Permite a manipulação do histórico do navegador. Isso é especialmente útil para páginas que carregam novas informações interativas.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/HTML/Content_Editable" title="HTML/Content Editable">O atributo contentEditable: Transforme seu website em uma wiki!</a></dt>
- <dd>O HTML5 padronizou o atributo contentEditable. Saiba mais sobre este recurso.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/DragDrop/Drag_and_Drop" title="DragDrop/Drag_and_Drop">Arrastar e soltar</a></dt>
- <dd>A API do HTML5 permite suportar o recurso de arrastar e soltar (<em>dragging and dropping</em>) items dentro e entre sites da web. Isso também fornece uma simples API para fazer o uso de extensões e aplicações baseadas na Mozilla.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/Focus_management_in_HTML" title="Focus_management_in_HTML">Foco de gestão em HTML</a></dt>
- <dd>O novo HTML5 <code>activeElement</code> e <code>hasFocus</code> são atributos suportados.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/Web-based_protocol_handlers" title="Web-based_protocol_handlers">Manipuladores de protocolos beseados na web</a></dt>
- <dd>Agora você pode registrar aplicações web com manipuladores de protocolos utilizando o método the<code>navigator.registerProtocolHandler()</code>.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/requestAnimationFrame" title="Web-based_protocol_handlers">requestAnimationFrame</a></dt>
- <dd>Permite o controle de animações de renderização para obter a performance ideal.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/DOM/Using_full-screen_mode" title="DOM/Using_full-screen_mode">API Fullscreen</a></dt>
- <dd>Controla o uso de toda a tela para uma página web ou aplicação, sem mostrar a interface de UI do navegador.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/API/Pointer_Lock_API" title="API/Pointer_Lock_API">API bloqueio de ponteiro</a></dt>
- <dd>Permite o bloqueio do ponteiro para o conteúdo, para jogos e aplicações semelhantes para não perder o foco quanto o ponteiro atinge o limite da janela.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/Online_and_offline_events" title="Online_and_offline_events">Eventos online e offline</a></dt>
- <dd>A fim de construir uma boa aplicação web offline, você precisa saber quando sua aplicação é realmente offline. Aliás, você também precisa saber quando sua aplicação foi retornada por um status online novamente.</dd>
-</dl>
-
-<h2 id="Acesso_à_dispositivos"><img alt="" src="https://developer.mozilla.org/files/3837/HTML5_Device_Access_512.png" style="height: 50px; width: 50px;">Acesso à dispositivos</h2>
-
-<dl>
- <dt><a href="https://developer.mozilla.org/en-US/docs/DOM/Using_the_Camera_API" title="DOM/Using_the_Camera_API">Usando a API da câmera</a></dt>
- <dd>É permitido o uso, manipulação, e armazenar imagens através câmeras dos computadores.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/DOM/Touch_events" title="DOM/Touch_events">Eventos touch</a></dt>
- <dd>Manipuladores para reagir a eventos criados por um usuário ao pressionar em telas sensíveis ao toque (<em>touch screens</em>).</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/Using_geolocation" title="Using geolocation">Utilizando geolocalização</a></dt>
- <dd>Deixa que os navegadores localizem a posição do usuário utilizando a geolocalização.</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/Detecting_device_orientation" title="Detecting_device_orientation">Detectando a orientaçåo do dispositivo</a></dt>
- <dd>Coleta a informação quando o dispositivo em que o browser está rodando muda sua orientação de tela. Isto pode ser utilizado como um dispositivo de entrada (por exemplo, para fazer jogos que utiliza à posiçao do dispositivo) ou para adaptar o layout de uma pagina para a orientaçao da tela (vertical ou horizontal).</dd>
- <dt><a href="https://developer.mozilla.org/en-US/docs/API/Pointer_Lock_API" title="API/Pointer_Lock_API">Pointer Lock API</a></dt>
- <dd>Permite que o cursor fique limitado às medidas do conteúdo da aplicação, assim, jogos e outras aplicações não perdem o foto quando o cursos ultrapassa os limites do conteúdo.</dd>
-</dl>
-
-<h2 id="Estilização"><img alt="" src="https://developer.mozilla.org/files/3829/HTML5_Styling_512.png" style="height: 50px; width: 50px;">Estilização</h2>
-
-<p id="CSS_has_been_extended_to_be_able_to_style_elements_in_a_much_more_complex_way._This_is_often_referred_as_CSS3_though_CSS_is_not_a_monolithic_specification_any_more_and_the_different_modules_are_not_all_at_level_3_some_are_at_level_1_and_others_at_level_4_with_all_the_intermediate_levels_covered."><a href="https://developer.mozilla.org/en-US/docs/CSS" title="CSS">CSS</a> <span id="result_box" lang="pt"><span>foi estendido para</span> <span>ser</span> <span>capaz de estilo</span> <span>elementos</span> <span>de uma forma</span> <span>muito mais complexa</span></span>. Sua extensão, também conhecido como <a href="https://developer.mozilla.org/en-US/docs/CSS/CSS3" title="CSS/CSS3">CSS3</a>, mas, como o CSS não segue uma especificação padrão, alguns módulos podem não estar necessariamente na versão 3,. Alguns estão na versão 3 e outros até na 1. Chamar de CSS3 é apenas uma convenção.</p>
-
-<dl>
- <dt>Novas caracteristicas dos estilos de background</dt>
- <dd>Agora é possível determinar uma sombra à um elemento, usando a propriedade <code><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow" title="The box-shadow property describes one or more shadow effects as a comma-separated list.">box-shadow</a> </code>e também podemos definir <a href="https://developer.mozilla.org/en-US/docs/CSS/Multiple_backgrounds">diversos backgrounds</a> para um elemento.</dd>
- <dt>More fancy borders</dt>
- <dd>Também é possível utilizar imagens para estilizar bordas, usando a propriedade <code>border-image. </code>Bordas arredondadas são suportadas através da propriedade <code>border-radius.</code></dd>
- <dt>Animating your style</dt>
- <dd>Utilizando <code>transition </code>para animar diferentes estágios de determinadas propriedades ou usando <code>animation </code>para animar trechos da página sem precisar usar o JavaScript com algum evento vinculado, permitindo total controle sobre movimentação de elementos. </dd>
- <dd>Using <a href="https://developer.mozilla.org/en-US/docs/CSS/Using_CSS_transitions" title="CSS/Using_CSS_transitions">CSS Transitions</a> to animate between different states or using <a href="https://developer.mozilla.org/en-US/docs/CSS/Using_CSS_animations" title="CSS/Using_CSS_animations">CSS Animations</a>to animate parts of the page without a triggering event, you can now control mobile elements on your page.</dd>
- <dt>Typography improvement</dt>
- <dd>Authors have better control to reach better typography. Eles podem controlar <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow" title="The text-overflow property determines how overflowed content that is not displayed is signaled to users. It can be clipped, display an ellipsis ('…', U+2026 Horizontal Ellipsis), or display a custom string."><code>text-overflow</code></a> e <a href="https://developer.mozilla.org/en-US/docs/CSS/hyphens" title="CSS/hyphens">hyphenation</a>, mas tambem pode adicionar um <a href="https://developer.mozilla.org/en-US/docs/CSS/text-shadow" title="CSS/text-shadow">shadow</a> a ele ou controlar mais precisamente a sua <a href="https://developer.mozilla.org/en-US/docs/CSS/text-decoration" title="SVG/Attribute/text-decoration">decorations</a>. Tipos de letras personalizadas podem ser baixadas e aplicadas gracas a nova<a href="https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face" title="The @font-face CSS at-rule allows authors to specify online fonts to display text on their web pages. By allowing authors to provide their own fonts, @font-face eliminates the need to depend on the limited number of fonts users have installed on their computers. The @font-face at-rule may be used not only at the top level of a CSS, but also inside any CSS conditional-group at-rule."><code>@font-face</code></a> at-rule.</dd>
- <dt>Novos layouts de apresentaçoes</dt>
- <dd>A fim de melhorar a flexibilidade dos modelos, foram adicionados, dois novos esquemas: o <a href="https://developer.mozilla.org/en-US/docs/CSS/Using_CSS_multi-column_layouts" title="CSS/Using_CSS_multi-column_layouts">CSS multi-column layouts</a> e <a href="https://developer.mozilla.org/en-US/docs/CSS/Flexbox" title="CSS/Flexbox">CSS flexible box layout</a>.</dd>
-</dl>
-
-
-
-<p>(Alguns <a href="/en/HTML/HTML5/HTML5_Thematic_Classification" title="en/HTML/HTML5/HTML5 Thematic Classification">outros artigos relacionados com HTML5</a>.)</p>
-
-<h2 id="Introdução_ao_HTML5">Introdução ao HTML5</h2>
-
-<dl>
- <dt><a href="/en/HTML/HTML5/Introduction_to_HTML5" title="en/HTML/Introduction to HTML5"><strong>Introdução ao HTML5</strong></a></dt>
- <dd>Este artigo introduz como utilizar HTML5 no desenho de site ou de sua aplicação.</dd>
-</dl>
-
-<h2 id="Elementos_do_HTML5">Elementos do HTML5</h2>
-
-<dl>
- <dt><a href="/en/HTML/HTML5/HTML5_element_list" title="en"><strong>Lista de tags / elementos do HTML5</strong></a></dt>
- <dd>Esta página contém uma tabela com todos os elementos (tags) baseado no rascunho atual das especificações do HTML5.</dd>
-</dl>
-
-<dl>
- <dt><a href="/en/Using_HTML5_audio_and_video" title="En/Using_audio_and_video_in_Firefox">Utilizando audio e video</a></dt>
- <dd>Adicionando suporte aos elementos do HTML5 {{ HTMLElement("audio") }} e {{ HTMLElement("video") }} ao Firefox 3.5.</dd>
- <dt><a href="/en/HTML/Forms_in_HTML" title="en/HTML/HTML5/Forms in HTML5">Formulários em HTML5</a></dt>
- <dd><span id="result_box" lang="pt"><span class="hps">Veja as</span> <span class="hps">melhorias para</span> <span class="hps">formulários web</span> <span class="hps">em</span> <span class="hps">HTML5</span><span>: a</span> <span class="hps">API</span> de <span class="hps">validação de restrição</span><span>, vários</span> <span class="hps">novos atributos,</span> <span class="hps">novos valores</span> <span class="hps">para </span></span>{{ HTMLElement("input") }} atributo {{ htmlattrxref("type", "input") }}<span id="result_box" lang="pt"> <span class="hps">e os</span> <span class="hps">novo</span> <span class="hps">elemento </span></span>{{ HTMLElement("output") }}.<span id="result_box" lang="pt"> </span></dd>
- <dt><a href="/en/Sections_and_Outlines_of_an_HTML5_document" title="en/Sections and Outlines of an HTML5 document">Seções e esboços em HTML5</a></dt>
- <dd><span id="result_box" lang="pt"><span class="hps">Veja os novos elementos para </span><span class="hps">delinear</span> e seccionar <span class="hps">em</span> <span class="hps">HTML5:</span></span> {{ HTMLElement("section") }}, {{ HTMLElement("article") }}, {{ HTMLElement("nav") }}, {{ HTMLElement("header") }}, {{ HTMLElement("footer") }}, {{ HTMLElement("aside") }} and {{ HTMLElement("hgroup") }}.</dd>
- <dt>O elemento {{ HTMLElement("mark") }}</dt>
- <dd>Este elemento é usado para marcar em destaque um texto de especial relevância.</dd>
- <dt>O elemento {{ HTMLElement("figure") }} e {{ HTMLElement("figcaption") }}</dt>
- <dd>Este elemento permite adicionar figuras e ilustrações, com uma eventual legenda, <span id="result_box" lang="pt">colocado a<span class="hps">baixo d</span><span class="hps">o texto principal</span><span>.</span></span></dd>
-</dl>
-
-<h3 id="Suporte_Canvas">Suporte Canvas</h3>
-
-<dl>
- <dt><a href="/en/Canvas_tutorial" title="https://developer.mozilla.org/en/Canvas_tutorial">Tutorial Canvas </a></dt>
- <dd> Apreda sobre o novo elemento<code> {{ HTMLElement("canvas") }} </code>e como desenhar gráficos e outros objetos no Firefox.</dd>
- <dt><a href="/en/Drawing_text_using_a_canvas" title="en/Drawing_text_using_a_canvas">HTML5 API texto para elemento &lt;canvas&gt;</a></dt>
- <dd><span id="result_box" lang="pt">HTML5 <span class="hps">API</span> <span class="hps">texto</span> <span class="hps">agora é suportado</span> <span class="atn hps">pelo </span></span>{{ HTMLElement("canvas") }}<span id="result_box" lang="pt"><span class="hps">.</span></span></dd>
-</dl>
-
-<div class="twocolumns">
-<h2 id="Recursos_de_aplicações_web">Recursos de aplicações web</h2>
-</div>
-
-<dl>
- <dt><a href="/en/HTML/Using_the_application_cache" title="en/Offline_resources_in_Firefox">Recursos Offline</a></dt>
- <dd><span id="result_box" lang="pt">O <span class="hps">Firefox</span> suporta completamente <span class="hps">as</span> <span class="hps">especificações de</span> <span class="hps">HTML5 para </span> <span class="hps">recurso</span> <span class="hps">offline.</span> <span class="hps">A maioria dos outros</span> navegadores <span class="hps">tem</span> algum nível de suporte aos <span class="hps">recursos offline</span></span>.</dd>
- <dt><a href="/en/Online_and_offline_events" title="en/Online_and_offline_events">Eventos online e offline</a></dt>
- <dd><span id="result_box" lang="pt"><span class="hps">O Firefox 3 suporta</span> <span class="hps">WHATWG</span> <span class="hps">eventos online e offline</span><span>, que permitem que</span> <span class="hps">aplicações e extensões</span> <span class="hps">detectem se</span> <span class="hps">há ou não</span> <span class="hps">uma conexão ativa com Internet</span><span>, bem como</span> <span class="hps">detecta</span> <span class="hps">quando a conexão</span> conecta e desconecta.</span></dd>
- <dt><a href="/en/DOM/Storage" title="en/DOM/Storage">Sessão WHATWG do lado cliente e armazenamento persistente (aka DOM Storage)</a></dt>
- <dd><span id="result_box" lang="pt"><span class="hps">A sessão do lado cliente</span> <span class="hps">e</span> o <span class="hps">armazenamento persistente</span> <span class="hps">permitem que as aplicações web</span> <span class="hps">armazenem</span> <span class="hps">dados estruturados</span> <span class="hps">no lado  cliente</span><span>.</span></span></dd>
- <dt><a href="/en/HTML/Content_Editable" title="en/HTML/Content Editable">O atributo contentEditable: transforma seu website em um wiki!</a></dt>
- <dd><span id="result_box" lang="pt"><span class="hps">O HTML5</span> <span class="hps">tem</span> um<span class="hps"> atributo</span> <span class="hps">padronizado</span> <span class="hps">contentEditable</span><span>.</span> <span class="hps">Saiba mais sobre</span> <span class="hps">este recurso.</span></span></dd>
- <dt><a href="/en/Using_files_from_web_applications" title="en/Using_files_from_web_applications">Usando arquivos de aplicações web</a></dt>
- <dd><span id="result_box" lang="pt"><span class="hps">Suporta para </span><span class="hps">a nova HTML5 API de arquivo</span> <span class="hps">foi adicionada ao</span> <span class="hps">Gecko,</span> <span class="hps">tornando possível </span><span class="hps">as aplicações web</span> <span class="hps">para acessarem arquivos</span> <span class="hps">locais</span> <span class="hps">selecionados pelo usuário</span><span>.</span> <span class="hps">Isso inclui suporte</span> <span class="hps">para selecionar vários arquivos</span> <span class="hps">usando o novo element</span>o HTML </span><span style="font-family: monospace;">{{ HTMLElement("input") }}</span> do <a href="/en/HTML/Element/Input#attr-type" title="en/HTML/Element/input#attr-type"><strong>type</strong></a> <span style="font-family: courier new;">arquivo</span> <span id="result_box" lang="pt"><span>de</span> </span><a href="/en/HTML/Element/Input#attr-multiple" title="en/HTML/Element/input#attr-multiple"><strong>multiplos</strong></a> atributos.</dd>
-</dl>
-
-<h2 id="Recursos_DOM">Recursos DOM</h2>
-
-<dl>
- <dt><a href="/en/DOM/document.getElementsByClassName" title="en/DOM/document.getElementsByClassName">getElementsByClassName</a></dt>
- <dd>O método getElementsByClassName no Document e Element nodes são suportados. Estes métodos permitem encontrar elementos de uma classe ou de uma lista de classes.</dd>
- <dt><a href="/En/DragDrop/Drag_and_Drop" title="En/DragDrop/Drag_and_Drop">Arrastar e soltar</a></dt>
- <dd>A HTML5 API drag and drop permite suporte para arrastar e soltar itens dentro e entre web sites. <span id="result_box" lang="pt"><span class="hps">Isto também proporciona</span> <span class="hps">uma API simples</span> <span class="hps">para uso de extensões</span> <span class="hps">e</span> <span class="hps">aplicativos baseados em</span> <span class="hps">Mozilla</span><span>.</span></span></dd>
- <dt><a href="/en/Focus_management_in_HTML" title="en/Focus_management_in_HTML">Foco na gestão do HTML</a></dt>
- <dd><span id="result_box" lang="pt">Os novos</span> <code>activeElement</code> e <code>hasFocus</code> são atributos suportados pelo HTML5..</dd>
- <dt><a href="/en/Web-based_protocol_handlers" title="en/Web-based_protocol_handlers">Manipuladores de protocolo baseado em web</a></dt>
- <dd>Agora você pode registrar uma aplicação web como um manipulador de protocolo usando o método  <code>navigator.registerProtocolHandler()</code>.</dd>
-</dl>
-
-<h2 id="HTML_parser">HTML parser</h2>
-
-<p>O Gecko é <a href="/en/HTML/HTML5/HTML5_Parser" title="en/HTML/HTML5/HTML5 parser">compatível com HTML5 parser</a>—que transforma os bytes de documento HTML em um DOM—foi ativado por padrão a partir de maio de 2010. (Note que a versão do HTML5 parser que foi incluída no Gecko 1.9.2 / Firefox 3.6 tem bastante erros e não é recomendado para uso real.)</p>
-
-<h2 id="Alterações_adicionais">Alterações adicionais</h2>
-
-<ul>
- <li><code>localName</code> e <code>namespaceURI</code> em documentos HTML agora  se comportam como em documentos XML: <code>localName</code> retorna em minúsculas e  <code>namespaceURI</code> para elementos HTML é <code>"<a class="external" href="http://www.w3.org/1999/xhtml" rel="external nofollow" title="http://www.w3.org/1999/xhtml">http://www.w3.org/1999/xhtml</a>" </code></li>
- <li>Quando a URI da página muda o identificador de fragmento de documento (a parte depois do caracter "#" (hash)), um novo evento <code>hashchange</code> é enviado para a página. Veja <a href="/en/DOM/window.onhashchange" title="en/DOM/window.onhashchange">window.onhashchange</a> para mais informação.</li>
- <li>Suporte para <code><a href="/en/DOM/element.classList" title="en/DOM/element.classList">element.classList</a></code> para facilitar o manuseio de atributo de classe.</li>
- <li>evnto de documento pronto <a href="/en/DOM/document.onreadystatechange" title="en/DOM/document.onreadystatechange">document.onreadystatechange</a>  e <a href="/en/DOM/document.readyState" title="en/DOM/document.readyState">document.readyState</a> são propriedades suportadas.</li>
- <li><span id="result_box" lang="pt"><span class="hps">Cores em</span> <span class="hps">atributos de apresentação</span> <span class="hps">são interpretados</span> <span class="hps">de acordo com o</span> <span class="hps">HTML5.</span></span></li>
-</ul>
-
-<h2 id="Tecnologias_muitas_vezes_chamado_de_parte_do_HTML5_que_não_são"><span id="result_box" lang="pt"><span class="hps">Tecnologias</span> <span class="hps">muitas vezes chamado de</span> <span class="hps">parte do</span> <span class="hps">HTML5</span> <span class="hps">que não</span> <span class="hps">são</span></span></h2>
-
-<p><span id="result_box" lang="pt"><span class="hps">Estas</span> são <span class="hps">muitas vezes </span><span class="hps">consideradas em conjunto com</span> <span class="hps">um uso</span> <span class="hps">amplo</span> <span class="hps">termo</span> <span class="atn hps">de "</span><span>HTML5</span><span>", mas</span> <span class="hps">não são</span> <span class="hps">realmente parte do</span> </span><a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/" rel="external" title="W3C HTML5 Spec">W3C HTML5 Spec</a>.</p>
-
-<ul>
- <li><a href="/en/WebGL" title="en/WebGL">WebGL</a></li>
- <li><a href="/en/DOM/FileReader" title="en/DOM/FileReader"><code>FileReader</code></a></li>
- <li><code><a href="/en/DOM/XMLHttpRequest" title="en/XMLHttpRequest">XMLHttpRequest</a></code></li>
- <li><code><a href="/en/DOM/Locating_DOM_elements_using_selectors" title="En/DOM/Locating DOM elements using selectors">querySelector()</a></code></li>
- <li><a href="/En/Using_geolocation" title="En/Using geolocation">Geolocation</a></li>
- <li><a href="/en/JavaScript/ECMAScript_5_support_in_Mozilla" title="En/JavaScript/ECMAScript 5 support in Mozilla">ECMAScript5</a></li>
- <li><a href="/en/CSS/CSS3" title="CSS3">CSS3</a></li>
- <li><a href="/en/XBL2_specification_(external)" title="en/XBL2 specification (external)">XBL2</a></li>
- <li><a href="/En/DOM/Using_web_workers" title="En/Using web workers">Web Workers</a></li>
- <li><a href="/en/WebSockets" title="https://developer.mozilla.org/en/WebSockets">Web Sockets</a></li>
- <li>Faster JavaScript</li>
-</ul>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<p><span id="result_box" lang="pt"><span class="hps">Alterações</span> <span class="hps">nas versões</span> <span class="hps">do Firefox</span> <span class="hps">que afetam</span> <span class="hps">os desenvolvedores</span> <span class="hps">da Web:</span></span></p>
-
-<ul>
- <li><a href="/en/Firefox_12_for_developers" title="Firefox 12 for developers">Firefox 12</a></li>
- <li><a href="/en/Firefox_11_for_developers" title="Firefox 11 for developers">Firefox 11</a></li>
- <li><a href="/en/Firefox_10_for_developers" title="Firefox 10 for developers">Firefox 10</a></li>
- <li><a href="/en/Firefox_9_for_developers" title="Firefox 9 for developers">Firefox 9</a></li>
- <li><a href="/en/Firefox_8_for_developers" title="Firefox 8 for developers">Firefox 8</a></li>
- <li><a href="/en/Firefox_7_for_developers" title="Firefox 7 for developers">Firefox 7</a></li>
- <li><a href="/en/Firefox_6_for_developers" title="Firefox 6 for developers">Firefox 6</a></li>
- <li><a href="/en/Firefox_5_for_developers" title="Firefox 5 for developers">Firefox 5</a></li>
- <li><a href="../../../../en/Firefox_4_for_developers" rel="internal">Firefox 4 </a></li>
- <li><a href="/en/Firefox_3.6_for_developers" title="en/Firefox 3.6 for developers">Firefox 3.6 </a></li>
- <li><a href="/En/Firefox_3.5_for_developers" title="En/Firefox 3.5 for developers">Firefox 3.5 </a></li>
- <li><a href="/en/Firefox_3_for_developers" title="en/Firefox 3 for developers">Firefox 3 </a></li>
- <li><a href="/en/Firefox_2_for_developers" title="en/Firefox 2 for developers">Firefox 2 </a></li>
- <li><a href="/en/Firefox_1.5_for_developers" title="en/Firefox 1.5 for developers">Firefox 1.5 </a></li>
-</ul>
-
-<div class="noinclude">
-<p>{{ languages( {"es": "es/HTML/HTML5", "fr": "fr/HTML/HTML5", "ja": "ja/HTML/HTML5" , "ko": "ko/HTML/HTML5" , "pl": "pl/HTML/HTML5", "pt": "pt/HTML/HTML5", "zh-cn": "cn/HTML/HTML5", "zh-tw": "zh_tw/HTML/HTML5", "pt-br": "pt-br/HTML/HTML5"} ) }}</p>
-</div>
diff --git a/files/pt-br/orphaned/web/guide/html/html5/introduction_to_html5/index.html b/files/pt-br/orphaned/web/guide/html/html5/introduction_to_html5/index.html
deleted file mode 100644
index a36dbb612f..0000000000
--- a/files/pt-br/orphaned/web/guide/html/html5/introduction_to_html5/index.html
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: Introdução ao HTML5
-slug: orphaned/Web/Guide/HTML/HTML5/Introduction_to_HTML5
-translation_of: Web/Guide/HTML/HTML5/Introduction_to_HTML5
-original_slug: Web/Guide/HTML/HTML5/Introduction_to_HTML5
----
-<p><a class="external" href="http://www.whatwg.org/specs/web-apps/current-work/" title="http://www.whatwg.org/specs/web-apps/current-work/">HTML5</a> é a mais nova versão do padrão HTML. Ele oferece novas funcionalidades para proporcionar não somente mídias diversas, mas para melhorar o suporte para criar aplicações web que possam interagir com o usuário, seus dados locais, e servidores mais facilmente e efetivamente.</p>
-
-<p>Pelo fato do HTML5 estar ainda no estágio de projeto, mudanças nas especificações são inevitáveis. Por isso, nem todas as funcionalidades são fornecidas por todos os navegadores. Entretanto, o Gecko (e por consequência, o Firefox) tem um bom suporte inicial para o HTML5, e o trabalho continua rumo a fornecer mais e mais de suas funcionalidades. O Gecko começou a fornecer algumas funcionalidades do HTML5 na versão 1.8.1. Você também pode encontrar uma lista das funcionalides do HTML5 que o Gecko suporta na <a href="/en/HTML/HTML5" title="en/HTML/HTML5">página principal do HTML5</a>. Para informação detalhada sobre o suporte de vários navegadores quanto às funcionalidades do HTML5, veja o site <a class="external" href="http://caniuse.com/#cats=HTML5" title="http://caniuse.com/#cats=HTML5">CanIUse</a>.</p>
-
-<p>Seu primeiro passo: O doctype do HTML5</p>
-
-<p>O doctype para o HTML5 é muito simples. Para indicar que seu conteúdo HTML usa HTML5, simplesmente use:</p>
-
-<pre>&lt;!DOCTYPE html&gt;
-</pre>
-
-<p>Esse simples doctype causará até os navegadores que não oferecem suporte ao HTML5 a entrar no modo dos padrões, isso significa que eles interpretarão as partes já estabelecidas pelo HTML em um modo "compatível" com HTML5, ignorando as novas funcionalidades que ele não suporta.</p>
-
-<div class="noinclude">
-<p>{{ languages( {"ja": "ja/HTML/HTML5/Introduction to HTML5", "fr":"fr/HTML/Introduction_à_HTML5", "pt": "pt/HTML/HTML5/Introdução_ao_HTML5", "pt-BR": "pt-BR/HTML/HTML5/Introdução_ao_HTML5"} ) }}</p>
-</div>
-
-<p> </p>
diff --git a/files/pt-br/orphaned/web/guide/html/using_html_sections_and_outlines/index.html b/files/pt-br/orphaned/web/guide/html/using_html_sections_and_outlines/index.html
deleted file mode 100644
index 09144f9ce4..0000000000
--- a/files/pt-br/orphaned/web/guide/html/using_html_sections_and_outlines/index.html
+++ /dev/null
@@ -1,411 +0,0 @@
----
-title: Seções e estrutura de um documento HTML5
-slug: orphaned/Web/Guide/HTML/Using_HTML_sections_and_outlines
-translation_of: Web/Guide/HTML/Using_HTML_sections_and_outlines
-original_slug: Web/Guide/HTML/Using_HTML_sections_and_outlines
----
-<div class="warning">
-<p><strong>Importante</strong>: Atualmente não há implementações conhecidas do algorítmo de estrutura em navegadores gráficos ou <em>user agents</em> de tecnologia assistiva, apesar disso o algorítmo é implementado em outro software como em verificadores de conformidade. Assim, ao algorítmo de estrutura não pode ser confiada a  entrega da estrutura do documento para os usuários. Autores são aconselhados a usar níveis de cabeçalho (h1-h6) para transmitir a estrutura do documento.</p>
-</div>
-
-<p>A especificação HTML5 traz diversos novos elementos aos desenvolvedores web, permitindo-os descrever a estrutura de um documento web com semânticas padronizadas. Este documento descreve esses elementos e como utilizá-los para definir a estrutura desejada para qualquer documento.</p>
-
-<h2 id="Estrutura_de_um_documento_em_HTML4">Estrutura de um documento em HTML4</h2>
-
-<p>A estrutura de um documento, ou seja, a estrutura semântica do que está entre <span style="font-family: courier new;">&lt;body&gt;</span> e <span style="font-family: courier new;">&lt;/body&gt;</span>, é fundamental para a apresentação da página ao usuário. O HTML4 usa a noção de seções e subseções de um documento para descrever sua estrutura. Uma seção é definida por um Elemento HTML de Divisão ({{ HTMLElement("div") }}) com Elementos HTML de Cabeçalho ({{ HTMLElement("h1") }}, {{ HTMLElement("h2") }}, {{ HTMLElement("h3") }}, {{ HTMLElement("h4") }}, {{ HTMLElement("h5") }}, ou {{ HTMLElement("h6") }}) dentro de si, definindo seu título. As relações desses elementos levam à estrutura do documento.</p>
-
-<p>Então a seguinte marcação:</p>
-
-<pre class="brush: html notranslate">&lt;div class="section" id="elefantes-da-floresta" &gt;
-&lt;h1&gt;Elefantes da floresta&lt;/h1&gt;
-&lt;p&gt;Nesta seção, discutiremos os poucos conhecidos elefantes da floresta.
-<em>...esta seção continua...</em>
-&lt;div class="subsection" id="floresta-habitat"&gt;
-&lt;h2&gt;Habitat&lt;/h2&gt;
-&lt;p&gt;Os elefantes da floresta não vivem em árvores mas sim entre elas.
-<em>...esta subseção continua...</em>
-&lt;/div&gt;
-&lt;/div&gt;
-</pre>
-
-<p>leva à seguinte estrutura (sem os marcadores 1. e 1.1 de nível) :</p>
-
-<pre class="notranslate">1. Elefantes da floresta
-   1.1 Habitat
-</pre>
-
-<p>Os elementos {{ HTMLElement("div") }} não são obrigatórios para definir uma nova seção. A mera presença de um Elemento de Cabeçalho HTML é suficiente para implicar uma nova seção. Portanto,</p>
-
-<pre class="brush: html notranslate">&lt;h1&gt;Elefantes da floresta&lt;/h1&gt;
-&lt;p&gt;Nesta seção, discutiremos os pouco conhecidos elefantes da floresta.
-<em>...esta seção continua...</em>
-&lt;h2&gt;Habitat&lt;/h2&gt;
-&lt;p&gt;Os elefantes da floresta não vivem em árvores mas sim entre elas.
-<em>...esta subseção continua...</em>
-&lt;h2&gt;Dieta&lt;/h2&gt;
-&lt;h1&gt;Esquilo da mongólia&lt;/h1&gt;
-</pre>
-
-<p>leva à:</p>
-
-<pre class="notranslate">1. Elefantes da floresta
-   1.1 Habitat
-   1.2 Dieta
-2. Esquilo da mongólia
-</pre>
-
-<h2 id="Problemas_resolvidos_pelo_HTML5">Problemas resolvidos pelo HTML5</h2>
-
-<p>A definição HTML 4 da estrutura de um documento e seu algoritmo de estruturação implícita é muito irregular e leva a inúmeros problemas:</p>
-
-<ol>
- <li>O uso do {{HTMLElement("div")}} para definir seções semânticas, sem definir valores específicos para o atributo <strong>class</strong> torna a automação do algoritmo de saída inviável ("Este{{HTMLElement("div")}}é parte  da estrutura da página, definindo uma seção ou uma subsseção?" ou "é apenas um  {{HTMLElement("div")}} representativo, usado apenas para definição de estilo?"). Em outras palavras, a perspectiva do HTML4 é muito imprecisa em relação a o que é uma seção e como seu escopo é definido. Geração automática de estrutura é importante, especialmente para <a href="https://pt.wikipedia.org/wiki/Tecnologia_assistiva">tecnologias assistivas</a>, que são apropriadas para adaptar a forma de apresentação da informação para os usuários de acordo com a estrutura do documento. O HTML5 elimina a necessidade dos elementos {{HTMLElement("div")}} do algoritmo de estruturação introduzindo um novo elemento, O  {{HTMLElement("section")}}, o elemento de Seção do HTML. </li>
- <li>Mesclar diversos documentos é uma tarefa complicada: a inclusão de um subdocumento em um documento principal significa pequenas alterações nos <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/Heading_Elements">elementos de cabeçalho</a> de modo que a estrutura geral do novo documento continue sólida. Isso é resolvido no HTML5 com a introdução dos elementos de seção ({{HTMLElement("article")}}, {{HTMLElement("section")}}, {{HTMLElement("nav")}} e {{HTMLElement("aside")}}), que são sempre subseções das seções ancestrais mais próximas, independentemente das seções criadas pelos elementos de cabeçalhos internos de cada subseção.</li>
- <li>No HTML4, toda seção é parte da estrutura do documento. Mas documentos não lineares são frequentes. Um documento pode ter seções especiais contendo informações que não fazem parte, a não ser que seja relatado, do conteúdo principal, como um bloco de avisos ou uma caixa de explicação. O HTML5 introduz o elemento {{HTMLElement("aside")}}, permitindo assim que tal seção não seja parte da estrutura principal do documento.</li>
- <li>Novamente, no HTML4 pelo fato de todas as seções semânticas com a tag {{HTMLElement("div")}} fazerem parte da estrutura do documento, não há formas de haver seções que contenham informações relacionadas não ao documento em si, mas ao site no geral, como logos, menus, tabelas de conteúdos, copyright ou avisos legais. Com esse propósito, o HTML5 introduz três novos elementos: {{HTMLElement("nav")}} para coleções de links (tal como uma tabela de conteúdos), {{HTMLElement("footer")}} e {{HTMLElement("header")}} para informações relacionadas ao site. Perceba que {{HTMLElement("footer")}} e {{HTMLElement("header")}} não são conteúdos de seção como o {{HTMLElement("section")}}, ao invés disso, eles existem para delimitar semanticamente partes de uma seção.</li>
-</ol>
-
-<h2 id="sect1"></h2>
-
-<p>Resumindo, o HTML5 traz precisão às divisões do documento em seções e aos recursos de cabeçalho, permitindo que a estrutura seja previsível e possa ser usada para melhorar a experiência do usuário.</p>
-
-<h2 id="The_HTML5_Outline_Algorithm">The HTML5 Outline Algorithm</h2>
-
-<h3 id="Definindo_seções_em_HTML5">Definindo seções em HTML5</h3>
-
-<p>Todo conteúdo que está dentro do elemento {{ HTMLElement("body") }}  é parte de uma seção. Seções em  HTML5 podem ser encaixadas(aninhadas). Com base na seção principal, definida pelo elemento {{ HTMLElement("body") }}, section os limites são definidos tanto explicitamente ou implicitamente. Explicitly-defined sections are the content within {{ HTMLElement("body") }},  {{ HTMLElement("section") }},  {{ HTMLElement("article") }},  {{ HTMLElement("aside") }}, {{ HTMLElement("footer") }},  {{ HTMLElement("header") }}, and {{ HTMLElement("nav") }} tags. </p>
-
-<div class="note"><strong>Nota: </strong>Cada seção pode ter sua própria hierarquia de cabeçalho  {{ HTMLElement("h1") }}. Veja <a href="/en/Sections_and_Outlines_of_an_HTML5_document#Defining_Headings_in_HTML5" title="en/Sections_and_Outlines_of_an_HTML5_document#Defining_Headings_in_HTML5">D</a><a href="/en/Sections_and_Outlines_of_an_HTML5_document#Defining_Headings_in_HTML5">efinindo cabeçalhos com HTML5</a>.</div>
-
-<p>Exemplo:</p>
-
-<pre class="brush: html notranslate">&lt;section&gt;
-  &lt;h1&gt;Elefantes da floresta&lt;/h1&gt;
-  &lt;section&gt;
-    &lt;h1&gt;Introdução&lt;/h1&gt;
-    &lt;p&gt;Nesta seção, nós discutimos os menores elefantes florestais conhecidos.&lt;p&gt;
-  &lt;/section&gt;
-  &lt;section&gt;
-    &lt;h1&gt;<span><span>Habitat</span><span>&lt;/</span><span>h1</span><span>&gt;
-    </span></span><span><span>&lt;</span><span>P</span><span>&gt;</span><span>Elefantes florestais não vivem em árvores mas entre eles.&lt;/p&gt;
-  &lt;/section&gt;
-  &lt;aside&gt;
-    &lt;p&gt;Bloco publicitário&lt;/p&gt;
-  &lt;/aside&gt;
-&lt;/section&gt;
-&lt;footer&gt;
-  &lt;p&gt;(c) 2010 O Exemplo de empresa&lt;/p&gt;
-&lt;/footer&gt;</span></span>
-</pre>
-
-<p>Esse <a href="https://tableless.com.br/produtividade-editores-e-snippets/">snippet</a> HTML define duas seções de nível superior:</p>
-
-<pre class="brush: html notranslate"><span> &lt;section&gt;
-  &lt;h1&gt; Elefantes da floresta &lt;/h1&gt;
-  &lt;section&gt;
-    &lt;h1&gt; Introdução &lt;/h1&gt;
-    &lt;p&gt; Nesta seção, discutiremos os elefantes da floresta menos conhecidos.&lt;/p&gt;
-  &lt;/section&gt;
-  &lt;section&gt;
-    &lt;h1&gt; Habitat &lt;/h1&gt;
-    &lt;p&gt;Os elefantes da floresta não vivem em árvores, mas entre eles.&lt;/p&gt;
-  &lt;/section&gt;
-  &lt;aside&gt;
-    &lt;p&gt; bloco de publicidade&lt;/p&gt;
-  &lt;/aside&gt;
-&lt;/section&gt;
-&lt;footer&gt;
-  &lt;p&gt; (c) 2010 A empresa exemplo&lt;/p&gt;
-&lt;/footer&gt;</span></pre>
-
-<p>A primeira seção possui três subseções:</p>
-
-<pre class="brush: html notranslate"><span>&lt;section&gt;
-   &lt;h1&gt;Forest elephants&lt;/h1&gt;
- </span><span>  &lt;section&gt;
-     &lt;h1&gt;Introduction&lt;/h1&gt;
-     &lt;p&gt;In this section, we discuss the lesser known forest elephants.
-   &lt;/section&gt;
- </span><span>  &lt;section&gt;
-     &lt;h1&gt;<span><span>Habitat</span><span>&lt;/</span><span>h1</span><span>&gt;
-     </span></span><span><span>&lt;</span><span>P</span><span>&gt;</span><span>Forest elephants do not live in trees but among them.
-   &lt;/section&gt;
-  </span><span> &lt;aside&gt;
-     &lt;p&gt;advertising block
-   &lt;/aside&gt;
- </span><span>&lt;/section&gt;
- &lt;footer&gt;
-   &lt;p&gt;(c) 2010 The Example company
- &lt;/footer&gt;</span></span></span></pre>
-
-<p>Isso leva à seguinte estrutura:</p>
-
-<pre class="notranslate">1. Forest elephants
-   1.1 Introduction
-   1.2 Habitat
-   1.3 Section (aside)
-</pre>
-
-<h3 id="Definindo_cabeçalho_com_HTML5">Definindo cabeçalho com HTML5</h3>
-
-<p>Enquanto os elementos de corte em HTML definem a estrutura do documento, um esboço também precisa de títulos para ser útil. A regra básica é simples: o primeiro elemento de cabeçalho HTML (um de {{HTMLElement ("h1")}}, {{HTMLElement ("h2")}}, {{HTMLElement ("h3")}}, {{HTMLElement ("h4")}}, {{HTMLElement ("h5")}}, {{HTMLElement ("h6")}}) define o cabeçalho da seção atual.</p>
-
-<p>Os elementos de cabeçalho têm uma classificação fornecida pelo número no nome do elemento, onde {{HTMLElement ("h1")}} tem a classificação mais alta e {{HTMLElement ("h6")}}} tem a classificação mais baixa. A classificação relativa é importante apenas dentro de uma seção; a estrutura das seções determina o contorno, não a classificação do cabeçalho das seções. Por exemplo, este código:</p>
-
-<pre class="brush: html notranslate">&lt;section&gt;
-  &lt;h1&gt;Forest elephants&lt;/h1&gt;
-  &lt;p&gt;In this section, we discuss the lesser known forest elephants.
-<span>     </span><em>...this section continues...</em>
-  &lt;section&gt;
-     &lt;h2&gt;Habitat&lt;/h2&gt;
-     &lt;p&gt;Forest elephants do not live in trees but among them.
-<span>        </span><em>...this subsection continues...</em>
-  &lt;/section&gt;
-&lt;/section&gt;
-&lt;section&gt;
-  &lt;h3&gt;Mongolian gerbils&lt;/h3&gt;
-  &lt;p&gt;In this section, we discuss the famous mongolian gerbils.
-<span>     </span><em>...this section continues...</em>
-&lt;/section&gt;
-</pre>
-
-<p>leva ao seguinte esboço:</p>
-
-<pre class="notranslate">1. Elefantes da floresta
-   1.1 Habitat
-2. Gerbos da Mongólia</pre>
-
-<p>Observe que a classificação do elemento de cabeçalho (no exemplo {{HTMLElement ("h1")}}} para a primeira seção de nível superior, {{HTMLElement ("h2")}} para a subseção e {{HTMLElement ("h3 ")}} para a segunda seção de nível superior) não é importante. (Qualquer classificação pode ser usada como cabeçalho de uma seção definida explicitamente, embora essa prática não seja recomendada.)</p>
-
-<h3 id="Seção_implícita">Seção implícita</h3>
-
-<p>Como os Elementos de Seção HTML5 não são obrigatórios para definir um esboço, para manter a compatibilidade com a Web existente dominada pelo HTML4, existe uma maneira de definir seções sem eles. Isso é chamado de corte implícito.</p>
-
-<p>Os elementos de cabeçalhos HTML ({{HTMLElement ("h1")}} a {{HTMLElement ("h6")}}) definem uma nova seção implícita quando eles não são o primeiro cabeçalho de suas seções pai, explícitas. A maneira como esta seção implícita é posicionada no contorno é definida por sua classificação relativa com o cabeçalho anterior na seção pai. Se tiver uma classificação inferior à do título do cabeçalho anterior, abrirá uma subseção implícita da seção. Este código:</p>
-
-<pre class="brush: html notranslate">&lt;section&gt;
-  &lt;h1&gt; Elefantes da floresta &lt;/h1&gt;
-  &lt;p&gt; Nesta seção, discutiremos os elefantes da floresta menos conhecidos.
-    ... esta seção continua ...
-  &lt;h3 class = "subseção implícita"&gt; Habitat &lt;/h3&gt;
-    &lt;p&gt;Os elefantes da floresta não vivem em árvores, mas entre elas.
-      ... esta subseção continua ...&lt;/p&gt;
-&lt;/section&gt;
-</pre>
-
-<p>levando ao seguinte esboço:</p>
-
-<pre class="notranslate">1. Elefantes da floresta
-   1.1 Habitat (definido implicitamente pelo elemento h3)
-</pre>
-
-<p>Se for da mesma classificação que o título do cabeçalho anterior, fecha a seção anterior (que pode ter sido explícita!) e abre uma nova implícita no mesmo nível:</p>
-
-<pre class="brush: html notranslate">&lt;section&gt;
-  &lt;h1&gt; Elefantes da floresta &lt;/h1&gt;
-  &lt;p&gt; Nesta seção, discutiremos os elefantes da floresta menos conhecidos.
-    ... esta seção continua ...
-  &lt;h1 class = "seção implícita"&gt; Gerbos da Mongólia &lt;/h1&gt;
-  &lt;p&gt;Os gerbos da Mongólia são pequenos mamíferos fofos.
-    ... esta seção continua ...&lt;/p&gt;
-&lt;/section&gt;
-</pre>
-
-<p>levando ao seguinte esboço:</p>
-
-<pre class="notranslate">1. Elefantes da floresta
-2. Gerbos da Mongólia (implicitamente definidos pelo elemento h1, que fechou a seção anterior ao mesmo tempo)
-</pre>
-
-<p>Se tiver uma classificação mais alta que o título do cabeçalho anterior, fecha a seção anterior e abre uma nova implícita no nível mais alto:</p>
-
-<pre class="brush: html notranslate">&lt;body&gt;
-  &lt;h1&gt; Mamíferos &lt;/h1&gt;
-  &lt;h2&gt; Baleias &lt;/h2&gt;
-  &lt;p&gt; Nesta seção, discutimos as baleias nadadoras.
-    ... esta seção continua ...&lt;/p&gt;
-  &lt;section&gt;
-    &lt;h3&gt; Elefantes da floresta &lt;/h3&gt;
-    &lt;p&gt; Nesta seção, discutiremos os elefantes da floresta menos conhecidos.
-      ... esta seção continua ...&lt;/p&gt;
-    &lt;h3&gt; Gerbos da Mongólia &lt;/h3&gt;
-      &lt;p&gt; Hordas de gerbos se espalharam muito além da Mongólia.
-        ... esta subseção continua ...&lt;/p&gt;
-    &lt;h2&gt; Répteis &lt;/h2&gt;
-      &lt;p&gt;Répteis são animais com sangue frio.
-        ... esta subseção continua ...&lt;/p&gt;
-  &lt;/section&gt;
-&lt;/body&gt;
-</pre>
-
-<p>levando ao seguinte esboço:</p>
-
-<pre class="notranslate">1. Mamíferos
-   1.1 Baleias (definidos implicitamente pelo elemento h2)
-   1.2 Elefantes da floresta (definidos explicitamente pelo elemento de seção)
-   1.3 Gerbos da Mongólia (implicitamente definidos pelo elemento h3, que fecha a seção anterior ao mesmo tempo)
-   1.4 Répteis (definidos implicitamente pelo elemento h2, que fecha a seção anterior ao mesmo tempo)
-
-</pre>
-
-<p>Este não é o esquema que se pode esperar olhando rapidamente para as tags de cabeçalho. Para tornar sua marcação compreensível por humanos, é uma boa prática usar tags explícitas para abrir e fechar seções e corresponder a classificação do cabeçalho ao nível de aninhamento de seção pretendido. No entanto, isso não é exigido pela especificação do HTML5. Se você achar que os navegadores estão processando o esboço do documento de maneiras inesperadas, verifique se há seções que estão implicitamente fechadas pelos elementos de cabeçalho.</p>
-
-<p>Uma exceção à regra geral de que a classificação do cabeçalho deve corresponder ao nível de aninhamento de seção é para seções que podem ser reutilizadas em vários documentos. Por exemplo, uma seção pode ser armazenada em um CMS (Content Management System) e montada em documentos em tempo de execução. Nesse caso, uma boa prática é começar em {{HTMLElement ("h1")}} para o nível de cabeçalho superior da seção reutilizável. O nível de aninhamento da seção reutilizável será determinado pela hierarquia da seção do documento em que ela aparece. Tags de seção explícitas ainda são úteis nesse caso.</p>
-
-<h3 id="Sobrepondo_seções_implícitas">Sobrepondo seções implícitas</h3>
-
-<p> Às vezes, uma seção precisa ter vários títulos. Alguns casos comuns são:</p>
-
-<ul>
- <li>uma seção sobre um livro ou filme que possui um título secundário:
-  <pre class="brush: html notranslate">&lt;section&gt;
-  &lt;h1&gt; Justine &lt;/h1&gt;
-  &lt;h2&gt; Os Infortúnios da Virtude &lt;/h2&gt;
-&lt;/section&gt;</pre>
-
-  <p>leva ao seguinte esboço:</p>
-
-  <pre class="notranslate">1. Justine
-   1.1 Os Infortúnios da Virtude
-</pre>
- </li>
- <li>o cabeçalho secundário pode ser usado para uma lista de tags:
-  <pre class="brush: html notranslate">&lt;section&gt;
-  &lt;h1&gt; Seção e esboços de um documento &lt;/h1&gt;
-  &lt;h2&gt; HTML, HTML5, seções, contornos &lt;/h2&gt;
-&lt;/section&gt;</pre>
-
-  <p>levando ao seguinte esboço:</p>
-
-  <pre class="notranslate">1. Seção e linhas gerais de um documento
-   1.1 HTML, HTML5, Seções, Esboços</pre>
- </li>
-</ul>
-
-<p>Devido ao corte implícito, isso não é possível sem a ajuda do Elemento do Grupo de Cabeçalhos HTML ({{HTMLElement ("hgroup")}} introduzido no HTML5). Ele oculta todos os títulos de cabeçalhos do esboço, exceto o primeiro, permitindo uma substituição do corte implícito. Com esse elemento, o exemplo do livro secundário:</p>
-
-<pre class="brush: html notranslate">&lt;section&gt;
-  &lt;hgroup&gt;
-    &lt;h1&gt;Justine&lt;/h1&gt;
-    &lt;h2&gt;Les Malheurs de la vertu&lt;/h2&gt;
-  &lt;/hgroup&gt;
-&lt;/section&gt;
-</pre>
-
-<p>leads to the following outline:</p>
-
-<pre class="notranslate">1. Justine
-</pre>
-
-<h3 id="Caminhos_de_seção"><a>Caminhos de seção</a></h3>
-
-<p> Uma raiz de seção é um elemento HTML que pode ter seu próprio esboço, mas as seções e os títulos de cabeçalho dentro deles não contribuem para o esboço de seus ancestrais. Ao lado de {{HTMLElement ("body")}}, que é a raiz de seção lógica de um documento, geralmente são elementos que introduzem conteúdo externo na página: {{HTMLElement ("blockquote")}}, {{HTMLElement ("detalhes ")}}, {{HTMLElement (" fieldset ")}}, {{HTMLElement (" figura ")}} e {{HTMLElement (" td ")}}.</p>
-
-<p>Exemplo:</p>
-
-<pre class="brush: html notranslate">&lt;section&gt;
-  &lt;h1&gt; Elefantes da floresta &lt;/h1&gt;
-  &lt;section&gt;
-    &lt;h2&gt; Introdução &lt;/h2&gt;
-    &lt;p&gt; Nesta seção, discutiremos os elefantes da floresta menos conhecidos&lt;/p&gt;
-  &lt;/section&gt;
-  &lt;section&gt;
-    &lt;h2&gt; Habitat &lt;/h2&gt;
-    &lt;p&gt;Os elefantes da floresta não vivem em árvores, mas entre eles. Vamos
-      veja o que os cientistas estão dizendo em "&lt;cite&gt; O elefante da floresta em Bornéu &lt;/cite&gt;":
-    &lt;blockquote&gt;
-      &lt;h1&gt; Bornéu&lt;/h1&gt;
-      &lt;p&gt; O elemento florestal vive em Bornéu ...&lt;/p&gt;
-    &lt;/blockquote&gt;
-  &lt;/section&gt;
-&lt;/section&gt;
-</pre>
-
-<p>Este exemplo resulta no seguinte esboço:</p>
-
-<pre class="notranslate">1. Elefantes da floresta
-   1.1 Introdução
-   1.2 Habitat
-</pre>
-
-<p>Este esboço não contém o esboço interno do elemento {{HTMLElement ("blockquote")}}, que, sendo uma citação externa, é uma raiz de seção e isola seu esboço interno.</p>
-
-<h3 id="Seções_de_fora_da_estrutura">Seções de fora da estrutura</h3>
-
-<p>O HTML5 apresenta quatro novos elementos que permitem definir seções que não pertencem ao esquema principal de um documento da web:</p>
-
-<ol>
- <li>O elemento HTML Aside Section ({{HTMLElement ("apart")}})) define uma seção que, embora relacionada ao elemento principal, não pertence ao fluxo principal, como uma caixa de explicação ou um anúncio. Ele tem seu próprio esboço, mas não pertence ao principal.</li>
- <li>O elemento de seção de navegação HTML ({{HTMLElement ("nav")}}) define uma seção que contém links de navegação. Pode haver vários deles em um documento, por exemplo, um com links internos da página, como uma tabela de conteúdo, e outro com links de navegação no site. Esses links não fazem parte do fluxo e estrutura de tópicos principais e geralmente não podem ser renderizados inicialmente pelo leitor de tela e tecnologia assistida semelhante.</li>
- <li>O elemento da seção de cabeçalho HTML ({{HTMLElement ("header")}}) define um cabeçalho da página, geralmente contendo o logotipo e o nome do site e, possivelmente, um menu horizontal. Apesar do nome, ele não está necessariamente posicionado no início da página.</li>
- <li>O elemento HTML da seção do rodapé ({{HTMLElement ("rodapé")}}) define um rodapé da página, normalmente contendo os direitos autorais e legais observados e algumas vezes alguns links. Apesar do nome, ele não está necessariamente posicionado na parte inferior da página.</li>
-</ol>
-
-<h2 id="Endereços_e_horário_de_publicação_nos_elementos_de_seção">Endereços e horário de publicação nos elementos de seção</h2>
-
-<p>O autor de um documento geralmente deseja publicar algumas informações de contato, como o nome e o endereço do autor. O HTML4 permitiu isso por meio do elemento {{HTMLElement ("address")}}, que foi estendido no HTML5.</p>
-
-<p>Um documento pode ser feito de seções diferentes de diferentes autores. Uma seção de outro autor que não a da página principal é definida usando o elemento {{HTMLElement ("article")}}. Consequentemente, o elemento {{HTMLElement ("address")}} agora está vinculado ao seu ancestral mais próximo {{HTMLElement ("body")}} ou {{HTMLElement ("article")}}.</p>
-
-<p>Da mesma forma, o novo elemento HTML5 {{HTMLElement ("time")}}, com seu conjunto de atributos booleanos {{htmlattrxref ("pubdate", "time")}}, representa a data de publicação associada ao documento inteiro, respectivamente ao artigo, relacionado ao ancestral mais próximo {{HTMLElement ("body")}} ou {{HTMLElement ("article")}}.</p>
-
-<h2 id="Usando_elementos_HTML5_em_navegadores_não-HTML5">Usando elementos HTML5 em navegadores não-HTML5</h2>
-
-<p>Os elementos de seções e títulos devem funcionar na maioria dos navegadores não HTML5. Embora não sejam suportados, eles não precisam de uma interface <a href="https://developer.mozilla.org/pt-BR/docs/DOM/Referencia_do_DOM">DOM (Document Object Model)</a> especial e precisam apenas de um estilo CSS específico, pois elementos desconhecidos são estilizados como display: inline por padrão:</p>
-
-<pre class="brush: css notranslate">section, article, aside, footer, header, nav, hgroup {
-  display:block;
-}
-</pre>
-
-<p>É claro que o Desenvolvedor Web pode estilizá-los de maneira diferente, mas lembre-se de que em um navegador que não dar suporte ao HTML5, o estilo padrão é diferente do esperado para esses elementos. Observe também que o elemento {{HTMLElement ("time")}} não foi incluído, porque o estilo padrão para ele em um navegador que não suporta HTML5 é o mesmo que em um navegador compatível com HTML5.</p>
-
-<p>Esse método tem sua limitação, pois alguns navegadores não permitem o estilo de elementos não suportados. Que é o caso do Internet Explorer (versão 8 e anterior), que precisa de um script específico para permitir isso:</p>
-
-<pre class="brush: html notranslate">&lt;!--[if lt IE 9]&gt;
-  &lt;script&gt;
-    <code class="js">document.createElement(<span class="js__string">"header"</span> );
-    document.createElement(<span class="js__string">"footer" </span>);
-    document.createElement(<span class="js__string">"section"</span>);
-    document.createElement(<span class="js__string">"aside"</span>  );
-    document.createElement(<span class="js__string">"nav"</span>    );
-    document.createElement(<span class="js__string">"article"</span>);
-    document.createElement(<span class="js__string">"hgroup"</span> );
-    document.createElement(<span class="js__string">"time"</span>   );
-  &lt;/script&gt;
-</code><code class="html"><span class="html__ie_style">&lt;![endif]--&gt;</span></code>
-</pre>
-
-<p>Esse script significa que, no caso do Internet Explorer (8 e versões anteriores), o script deve ser ativado para exibir os elementos de seção e títulos do HTML5 corretamente. Caso contrário, eles não serão exibidos, o que pode ser problemático, pois esses elementos provavelmente definem a estrutura da página inteira. É por isso que um elemento explícito {{HTMLElement ("noscript")}} deve ser adicionado para este caso:</p>
-
-<pre class="brush: html notranslate">&lt;noscript&gt;
-  &lt;strong&gt; Aviso! &lt;/strong&gt;
-  Como o seu navegador não suporta HTML5, alguns elementos são simulados usando o JScript.
-  Infelizmente, seu navegador desativou o script. Ative-o para exibir esta página.
-&lt;/noscript&gt;
-</pre>
-
-<p>Isso leva ao código a seguir para permitir o suporte das seções e elementos dos cabeçalhos HTML5 em navegadores que não suportam HTML5, mesmo para o Internet Explorer (8 e versões anteriores), com um <strong>plano b</strong> adequado para o caso em que este último navegador está configurado para não usar scripts :</p>
-
-<pre class="brush: html notranslate">&lt;!--[if lt IE 9]&gt;
-  &lt;script&gt;
-    <code class="js">document.createElement(<span class="js__string">"header"</span> );
-    document.createElement(<span class="js__string">"footer" </span>);
-    document.createElement(<span class="js__string">"section"</span>);
-    document.createElement(<span class="js__string">"aside"</span>  );
-    document.createElement(<span class="js__string">"nav"</span>    );
-    document.createElement(<span class="js__string">"article"</span>);
-    document.createElement(<span class="js__string">"hgroup"</span> );
-    document.createElement(<span class="js__string">"time"</span>   );
-  &lt;/script&gt;</code>
-<code class="html"><span class="html__ie_style">  &lt;noscript&gt;
-     &lt;strong&gt;Aviso !&lt;/strong&gt;
-     Seu navegador web não suporta HTML5, e devido a isso alguns recursos são simulados usando JScript.
-     Infelizmente seu navegador desativou a execução de scripts. Por favor ative esse recurso para que esta página seja exibida corretamente.
-  &lt;/noscript&gt;</span></code>
-<code class="html"><span class="html__ie_style">&lt;![endif]-<span style="font-family: courier new,andale mono,monospace;">-<span style="font-family: monospace;">&gt;</span></span></span> </code>
-</pre>
-
-<h2 id="Conclusão">Conclusão</h2>
-
-<p>Os novos elementos de seção e cabeçalho introduzidos no HTML5 trazem consigo a habilidade de descrever a estrutura de um documento web de modo padronizado. Eles trazem uma grande vantagem para pessoas com navegadores HTML5 e que precisam da estrutura para ajudá-las a entender a página, por exemplo pessoas que utilizam alguma tecnologia assistiva. Esses novos elementos semânticos são simples de usar e, com pouquíssimo trabalho, podem funcionar também em navegadores não-HTML5. Portanto eles devem ser utilizados sem restrição.</p>
diff --git a/files/pt-br/orphaned/web/html/element/command/index.html b/files/pt-br/orphaned/web/html/element/command/index.html
deleted file mode 100644
index 849232e71d..0000000000
--- a/files/pt-br/orphaned/web/html/element/command/index.html
+++ /dev/null
@@ -1,130 +0,0 @@
----
-title: command
-slug: orphaned/Web/HTML/Element/command
-translation_of: Web/HTML/Element/command
-original_slug: Web/HTML/Element/command
----
-<h2 class="editable" id="Sumário">Sumário</h2>
-
-<p>O elemento <code>command </code>representa um comando que o usuário pode chamar.</p>
-
-<h2 id="Contexto_de_uso">Contexto de uso</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td>Categorias de conteúdo</td>
-   <td><a href="/en/HTML/Content_categories#Flow_content" title="en/HTML/Content categories#Flow content">Flow content</a>, <a href="/en/HTML/Content_categories#Phrasing_content" title="en/HTML/Content categories#Phrasing content">phrasing content</a></td>
-  </tr>
-  <tr>
-   <td>Elementos permitidos</td>
-   <td>Nenhum, é um elemento vazio.</td>
-  </tr>
-  <tr>
-   <td>Omissão de tag</td>
-   <td>Deve ter uma tag inicial, mas não deve ter uma tag final.</td>
-  </tr>
-  <tr>
-   <td>Elementos pais permitidos</td>
-   <td>Qualquer elemento que aceite <a href="/en/HTML/Content_categories#Phrasing_content" title="https://developer.mozilla.org/en/HTML/Content_categories#Phrasing_content">phrasing content</a>.</td>
-  </tr>
-  <tr>
-   <td>Documento normativo</td>
-   <td><a class="external" href="http://dev.w3.org/html5/spec/Overview.html#the-command" title="http://dev.w3.org/html5/spec/Overview.html#the-command">HTML5, section 4.11.3</a></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Atributos">Atributos</h2>
-
-<p>Como todos ou outros elementos HTML, esse elemento suporta os <a href="/en/HTML/Global_attributes" title="en/HTML/Global attributes">global attributes</a>.</p>
-
-<dl>
- <dt>{{ htmlattrdef("checked") }}</dt>
- <dd>Indica se o comando está selecionado ou não. Deve ser omitido a não ser que o atributo <code>type</code> seja <code>checkbox </code>ou <code>radio</code>.</dd>
- <dt>{{ htmlattrdef("disabled") }}</dt>
- <dd>Indica que o elemento não está disponível.</dd>
- <dt>{{ htmlattrdef("icon") }}</dt>
- <dd>Atribui uma figura para representar o comando.</dd>
- <dt>{{ htmlattrdef("label") }}</dt>
- <dd>O nome do comando, como será mostrado para o usuário.</dd>
- <dt>{{ htmlattrdef("radiogroup") }}</dt>
- <dd>Esse atributo dá o nome de um grupo de comandos, com <code>type</code> sendo <code>radio</code>, que vai ser ativado quando o comando for ativado. Esse atributo deve ser omitido a não ser que o atributo <code>type</code> seja <code>radio</code>.</dd>
- <dt>{{ htmlattrdef("type") }}</dt>
- <dd>Esse atributo indica o tipo do comando. Pode ter somente os seguintes valores:
- <ul>
-  <li>
-   <p><code>command</code> ou vazio que é o estado padrão e indica que é um comando normal.</p>
-  </li>
-  <li>
-   <p><code>checkbox</code> indica que o comando pode ser alternado utilizando uma caixa de seleção.</p>
-  </li>
-  <li>
-   <p><code>radio</code> indica que o comando pode ser alternado utilizando uma radiobutton.</p>
-  </li>
- </ul>
- </dd>
-</dl>
-
-<h2 id="Interface_do_DOM">Interface do DOM</h2>
-
-<p>Esse elemetno implementa a interface <code><a href="/en/DOM/HTMLCommandElement" rel="internal">HTMLCommandElement</a></code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<pre class="brush: html">&lt;command type="command" label="Save" icon="icons/save.png" onclick="save()"&gt;
-</pre>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-<p>{{ CompatibilityTable() }}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Recurso</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Recurso</th>
-   <th>Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p> </p>
-
-<p>{{ languages( { "zh-cn": "zh-cn/HTML/Element/command" } ) }}</p>
diff --git a/files/pt-br/orphaned/web/html/favicon/index.html b/files/pt-br/orphaned/web/html/favicon/index.html
deleted file mode 100644
index 019f336089..0000000000
--- a/files/pt-br/orphaned/web/html/favicon/index.html
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: favicon
-slug: orphaned/Web/HTML/favicon
-original_slug: Web/HTML/favicon
----
-<p> </p>
-
-<h3 id="sect1"> </h3>
-
-<h3 id="Comentário_da_revisão">Comentário da revisão <a class="revision-comment-link" href="https://developer.mozilla.org/pt-BR/docs/MDN/Contribute/Editor/Basics#The_revision_comment_box" title="Saiba como usar os comentários da revisão"> </a></h3>
-
-<section class="wiki-block" id="page-comment">
-<h3 id="sect2"> </h3>
-
-<p>Diga-nos porque fez adições e alterações. É opcional, mas irá fazer com que o histórico da página seja mais fácil de entender.</p>
-<input></section>
-
-<div class="wiki-block">
-<h3 id="É_necessário_revisão">É necessário revisão?</h3>
-
-<ul id="id_review_tags">
- <li><label><input> Técnico - exemplos de código, APIs ou tecnologias</label></li>
- <li><label><input> Editorial - prosa, gramática, ou conteúdo</label></li>
-</ul>
-</div>
-
-<section class="page-tags wiki-block" id="page-tags">
-<h3 id="sect3"> </h3>
-</section>
-
-<h3 id="Tags">Tags</h3>
-
-<p> </p>
diff --git a/files/pt-br/orphaned/web/html/preloading_content/index.html b/files/pt-br/orphaned/web/html/preloading_content/index.html
deleted file mode 100644
index 3c9e184272..0000000000
--- a/files/pt-br/orphaned/web/html/preloading_content/index.html
+++ /dev/null
@@ -1,238 +0,0 @@
----
-title: Preloading content with rel="preload"
-slug: orphaned/Web/HTML/Preloading_content
-translation_of: Web/HTML/Preloading_content
-original_slug: Web/HTML/Preloading_content
----
-<p class="summary">O valor <code>preload</code> do atributo <code><a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/link#attr-rel">rel</a></code> do elemento <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/link" title="O Elemento HTML &lt;link> especifica as relações entre o documento atual e um recurso externo. Possíveis usos para este elemento incluem a definição de uma estrutura relacional para navegação. Este elemento é mais usado para vincular as folhas de estilo."><code>&lt;link&gt;</code></a> permite que você escreva solicitações de busca declarativas em seu elemento <a href="https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/head" title="The HTML &lt;head> elemento providencia informações gerais (metadados) sobre  document, incluindo seu título e links para scripts e folhas de estilos."><code>&lt;head&gt;</code></a> do HTML, especificando recursos que suas páginas vão precisar logo após o carregamento. Você também pode querer que estes recursos sejam pré-carregados no início do ciclo de vida da página e depois que o mecanismo de renderização do navegador comece a agir. Isso garante que estarão disponíveis mais cedo e que seja menos provável que sua página seja bloqueada do processo de renderizar. Isso aumenta a performance da página. Este artigo oferece um guia básico de como <code>preload</code> funciona.</p>
-
-<h2 id="O_básico">O básico</h2>
-
-<p>Você comumente usa o elemento <code>&lt;link&gt;</code> quando carrega um arquivo de estilo CSS para sua pagina com:</p>
-
-<pre class="brush: html notranslate">&lt;link rel="stylesheet" href="styles/main.css"&gt;</pre>
-
-<p>No entanto, aqui nós usamos <code>rel</code> com valor <code>preload</code>, que transforma o elemento <code>&lt;link&gt;</code> em um <em>preloader</em> para praticamente qualquer recurso que você precisar. Você também precisa especificar</p>
-
-<ul>
- <li>o caminho para o recurso a ser pré-carregado, no atributo {{htmlattrxref("href", "link")}}</li>
- <li>o tipo de recurso que vc esta pré-carregando, no atributo {{htmlattrxref("as", "link")}}.</li>
-</ul>
-
-<p>Um exemplo simples pode se parecer com o seguinte (veja seus <a href="https://github.com/mdn/html-examples/tree/master/link-rel-preload/js-and-css">JS and CSS example source</a>, e <a href="https://mdn.github.io/html-examples/link-rel-preload/js-and-css/">also live</a>):</p>
-
-<pre class="brush: html notranslate">&lt;head&gt;
-  &lt;meta charset="utf-8"&gt;
-  &lt;title&gt;JS and CSS preload example&lt;/title&gt;
-
-  &lt;link rel="preload" href="style.css" as="style"&gt;
-  &lt;link rel="preload" href="main.js" as="script"&gt;
-
-  &lt;link rel="stylesheet" href="style.css"&gt;
-&lt;/head&gt;
-
-&lt;body&gt;
-  &lt;h1&gt;bouncing balls&lt;/h1&gt;
-  &lt;canvas&gt;&lt;/canvas&gt;
-
-  &lt;script src="main.js"&gt;&lt;/script&gt;
-&lt;/body&gt;</pre>
-
-<p>Aqui estamos pré-carregando seus arquivos CSS e JavaScript de forma que estarão disponíveis assim que forem necessários mais tarde durante a renderização da página. Este exemplo é um pouco trivial, visto que o browser provavelmente descobre os elementos <code>&lt;link rel="stylesheet"&gt;</code>  e <code>&lt;script&gt;</code> no mesmo pedaço de HTML que os preloads, mas o benefício pode ser visto mais claramente, quanto mais tarde os recursos são descobertos e quanto maiores forem eles. Por exemplo:</p>
-
-<ul>
- <li>Os recursos apontados de dentro de um arquivo CSS, como fontes ou imagens;</li>
- <li>Recursos que podem ser solicitados pelo JavaScript, como JSON, scripts importados ou web workers;</li>
- <li>Imagens maiores e arquivos de vídeo.</li>
-</ul>
-
-<p><code>preload</code> também possui outras vantagens. Usando o atributo <code>as</code> para especificar o tipo de conteúdo a ser pre-carregado permite que o browser:</p>
-
-<ul>
- <li>Priorize o carregamento de recursos com maior precisão;</li>
- <li id="tw-target-text">Corresponda solicitações futuras, reutilizando o mesmo recurso, se apropriado;</li>
- <li>Aplique a <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP">content security policy</a> adequada ao recurso;</li>
- <li>Defina os cabeçalhos corretos de {{HTTPHeader("Accept")}}.</li>
-</ul>
-
-<h3 id="Qual_tipo_de_conteúdo_pode_ser_pré-carregado">Qual tipo de conteúdo pode ser pré-carregado?</h3>
-
-<p>Muitos diferentes tipos de conteúdo podem ser pré-carregados. Os valores possíveis para o atributo <code>as</code> são os seguintes:</p>
-
-<ul>
- <li><code>audio</code>: Arquivo de áudio, como usados geralmente em {{htmlelement("audio")}} .</li>
- <li><code>document</code>: Um documento HTML destinado a ser incorporado dentro de um {{htmlelement("frame")}} ou {{htmlelement("iframe")}}.</li>
- <li><code>embed</code>: Recurso destinado a ser incorporado dentro de um elemento {{htmlelement("embed")}}.</li>
- <li><code>fetch</code>: Recurso a ser acessado por um fetch ou XHR request, como um ArrayBuffer ou arquivo JSON.</li>
- <li><code>font</code>: Arquivo de fonte.</li>
- <li><code>image</code>: Arquivo de imagem.</li>
- <li><code>object</code>: Recurso a ser incorporado dentro de um elemento {{htmlelement("object")}}.</li>
- <li><code>script</code>: Arquivo JavaScript.</li>
- <li><code>style</code>: Estilo CSS.</li>
- <li><code>track</code>: Arquivo webVTT.</li>
- <li><code>worker</code>: Um web worker JavaScript ou shared worker.</li>
- <li><code>video</code>: Arquivo de vídeo, usualmente usado em {{htmlelement("video")}} .</li>
-</ul>
-
-<div class="note">
-<p><strong>Nota</strong>: Você pode ler um pouco mais sobre estes valores e os recursos da web que eles esperam consumir na especificação Preload — veja <a href="https://w3c.github.io/preload/#link-element-extensions">link element extensions</a>. Observe também que a lista completa de valores que o atributo <code>as</code>  pode assumir é regida pelas definiçoes nas especificaçoes Fetch — veja <a href="https://fetch.spec.whatwg.org/#concept-request-destination">request destinations</a>.</p>
-</div>
-
-<h2 id="Incluindo_um_tipo_MIME">Incluindo um tipo MIME</h2>
-
-<p><code>&lt;link&gt;</code> pode aceitar um atributo {{htmlattrxref("type", "link")}}, o qual contém o MIME type do recurso para o qual o elemento está apontando. Isto é especialmente útil quando pre-carregando recursos — o browser usará o valor do atributo <code>type</code> para trabalhar se ele suportar o recurso, e irá somente iniciar o carregamento se este for o caso, ignorando se não for.</p>
-
-<p>Você pode ver um exemplo disto no nosso exemplo de video (veja o <a href="https://github.com/mdn/html-examples/tree/master/link-rel-preload/video">full source code</a>, e também <a href="https://mdn.github.io/html-examples/link-rel-preload/video/">the live version</a>):</p>
-
-<pre class="brush: html notranslate">&lt;head&gt;
-  &lt;meta charset="utf-8"&gt;
-  &lt;title&gt;Video preload example&lt;/title&gt;
-
-  &lt;link rel="preload" href="sintel-short.mp4" as="video" type="video/mp4"&gt;
-&lt;/head&gt;
-&lt;body&gt;
-  &lt;video controls&gt;
-    &lt;source src="sintel-short.mp4" type="video/mp4"&gt;
-    &lt;source src="sintel-short.webm" type="video/webm"&gt;
-    &lt;p&gt;Your browser doesn't support HTML5 video. Here is a &lt;a href="sintel-short.mp4"&gt;link to the video&lt;/a&gt; instead.&lt;/p&gt;
-  &lt;/video&gt;
-&lt;/body&gt;</pre>
-
-<p>Então neste caso, navegadores que suportem MP4s vão pré-carregar e usar MP4, fazendo o reprodutor de video esperançosamente mais suave/mais responsivo para os usuários. Browsers que não suportem MP4 podem continuar carregando versao WebM, mas não tem as vantagens do pré-carregamento. Isto mostra como conteudo pré-carregado pode ser combinado com a filosofia de aprimoramento progressivo.</p>
-
-<h2 id="Buscas_de_origem_cruzada">Buscas de origem cruzada</h2>
-
-<p>Se você tem no seu site as configurações de <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS">CORS</a> funcionando corretamente, você pode pré-carregar com sucesso recursos de origem cruzada, desde que você defina um atributo {{htmlattrxref("crossorigin","link")}} no seu elemento <code>&lt;link&gt;</code>.</p>
-
-<p dir="ltr" id="tw-target-text">Um caso interessante em que isso se aplica mesmo se a busca não é de origem cruzada é arquivos de fonte. Por várias razões, elas precisam ser buscadas usando o modo anônimo CORS (veja <a href="https://drafts.csswg.org/css-fonts/#font-fetching-requirements">Font fetching requirements</a> se você esta interesado em todos os detalhes).</p>
-
-<p>Vamos usar este caso como um exemplo, em primeiro lugar porque o carregamento de fontes é realmente um bom caso de uso para pré-carregamento e, em segundo lugar, porque é mais fácil do que configurar um exemplo de solicitação de origem cruzada. Voce pode ver o exemplo completo no <a href="https://github.com/mdn/html-examples/tree/master/link-rel-preload/fonts">source code on GitHub</a> (<a href="https://mdn.github.io/html-examples/link-rel-preload/fonts/">also see it live</a>):</p>
-
-<pre class="brush: html notranslate">&lt;head&gt;
-  &lt;meta charset="utf-8"&gt;
-  &lt;title&gt;Web font example&lt;/title&gt;
-
-  &lt;link rel="preload" href="fonts/cicle_fina-webfont.woff2" as="font" type="font/woff2" crossorigin="anonymous"&gt;
-  &lt;link rel="preload" href="fonts/zantroke-webfont.woff2" as="font" type="font/woff2" crossorigin="anonymous"&gt;
-
-  &lt;link href="style.css" rel="stylesheet" type="text/css"&gt;
-&lt;/head&gt;
-&lt;body&gt;
-  ...
-&lt;/body&gt;</pre>
-
-<p>Você verá aqui que não apenas estamos fornecendo as dicas do tipo MIME nos atributos de tipo, mas também estamos fornecendo o atributo  <code>crossorigin</code> para lidar com os problemas de CORS..</p>
-
-<h2 id="Adicionando_media">Adicionando media</h2>
-
-<p>Um bom recurso de alemento <code>&lt;link&gt;</code> é sua abilidade de aceitar atributos {{htmlattrxref("media", "link")}}. Estes podem aceitar <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/@media#Media_types">media types</a> ou full-blown <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries">media queries</a>, permitindo que você faça o pré-carregamento responsivo!</p>
-
-<p>Vamos ver um exemplo simples (see it on GitHub — <a href="https://github.com/mdn/html-examples/tree/master/link-rel-preload/media">source code</a>, <a href="https://mdn.github.io/html-examples/link-rel-preload/media/">live example</a>):</p>
-
-<pre class="brush: html notranslate">&lt;head&gt;
-  &lt;meta charset="utf-8"&gt;
-  &lt;title&gt;Responsive preload example&lt;/title&gt;
-
-  &lt;link rel="preload" href="bg-image-narrow.png" as="image" media="(max-width: 600px)"&gt;
-  &lt;link rel="preload" href="bg-image-wide.png" as="image" media="(min-width: 601px)"&gt;
-
-  &lt;link rel="stylesheet" href="main.css"&gt;
-&lt;/head&gt;
-&lt;body&gt;
-  &lt;header&gt;
-    &lt;h1&gt;My site&lt;/h1&gt;
-  &lt;/header&gt;
-
-  &lt;script&gt;
-    var mediaQueryList = window.matchMedia("(max-width: 600px)");
-    var header = document.querySelector('header');
-
-    if(mediaQueryList.matches) {
-      header.style.backgroundImage = 'url(bg-image-narrow.png)';
-    } else {
-      header.style.backgroundImage = 'url(bg-image-wide.png)';
-    }
-  &lt;/script&gt;
-&lt;/body&gt;</pre>
-
-<p>Você verá que estamos incluindo atributos de mídia em nossos &lt;link&gt; elementos, de modo que um estreita imagem é pre-carregada se o usuario estiver em um dispositivo de tela estreita, e uma imagem mais ampla é carregada se eles estiverem em um dispositivo de tela maior. Ainda precisamos anexar a imagem correta ao cabeçalho, dependendo do resultado — nos usamos {{domxref("Window.matchMedia")}} / {{domxref("MediaQueryList")}} para fazer isso (veja <a href="https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Testing_media_queries">Testing media queries</a> para mais informaçoes sobre isso).</p>
-
-<p>Isso torna muito mais provável que a fonte estará disponível no momento em que a renderização da página for concluída, reduzindo os problemas de FOUT (flash de texto sem estilo).</p>
-
-<p>Note que isso não precisa ser limitado a imagens, ou até mesmo arquivos do mesmo tipo - pense grande! Talvez você pré-carregue e exiba um diagrama SVG simples se o usuário estiver em uma tela estreita em que a largura de banda e CPU é potencialmente mais limitada ou pré-carregue um bloco complexo de JavaScript e use-o para renderizar um modelo 3D interativo se os recursos do usuário forem mais abundantes.</p>
-
-<h2 id="Scripting_and_preloads">Scripting and preloads</h2>
-
-<p>Outra coisa legal sobre preloads é que você pode executá-los completamente com script, se desejar. Por exemplo, aqui estamos criando uma instancia {{domxref("HTMLLinkElement")}}, em seguida anexando-o ao DOM:</p>
-
-<pre class="brush: js notranslate"><code class="language-javascript"><span class="keyword token">var</span> preloadLink <span class="operator token">=</span> document<span class="punctuation token">.</span><span class="function token">createElement</span><span class="punctuation token">(</span><span class="string token">"link"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-preloadLink<span class="punctuation token">.</span>href <span class="operator token">=</span> <span class="string token">"myscript.js"</span><span class="punctuation token">;</span>
-preloadLink<span class="punctuation token">.</span>rel <span class="operator token">=</span> <span class="string token">"preload"</span><span class="punctuation token">;</span>
-preloadLink<span class="punctuation token">.</span><span class="keyword token">as</span> <span class="operator token">=</span> <span class="string token">"script"</span><span class="punctuation token">;</span>
-document<span class="punctuation token">.</span>head<span class="punctuation token">.</span><span class="function token">appendChild</span><span class="punctuation token">(</span>preloadLink<span class="punctuation token">)</span><span class="punctuation token">;</span>
-</code></pre>
-
-<p>Isso significa que o navegador pré-carregará o arquivo JavaScript, mas ainda não o utilizará.</p>
-
-<p>Para usalo, você poderia fazer isso quando desejado:</p>
-
-<pre class="brush: js notranslate"><code class="language-javascript"><span class="keyword token">var</span> preloadedScript <span class="operator token">=</span> document<span class="punctuation token">.</span><span class="function token">createElement</span><span class="punctuation token">(</span><span class="string token">"script"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-preloadedScript<span class="punctuation token">.</span>src <span class="operator token">=</span> <span class="string token">"myscript.js"</span><span class="punctuation token">;</span>
-document<span class="punctuation token">.</span>body<span class="punctuation token">.</span><span class="function token">appendChild</span><span class="punctuation token">(</span>preloadedScript<span class="punctuation token">)</span><span class="punctuation token">;</span>
-</code></pre>
-
-<p>Isso é útil quando você deseja pré-carregar um script, mas adia executá-lo até exatamente quando precisar.</p>
-
-<h2 id="Outros_mecanismos_de_pré-carregamento_de_recursos">Outros mecanismos de pré-carregamento de recursos</h2>
-
-<p dir="ltr" id="tw-target-text">Existem outros recursos de pré-carregamento, mas nenhum é tão adequado ao propósito  <code>&lt;link rel="preload"&gt;</code>:</p>
-
-<ul>
- <li><code>&lt;link rel="prefetch"&gt;</code><br>
-  tem sido suportado nos navegadores por um longo tempo, mas destina-se à pré-busca de recursos que serão usados na próxima navegação / carregamento da página (por exemplo, quando você vai para a próxima página). Isso é bom, mas não é útil para a página atual! Além disso, os navegadores darão aos recursos de pré-busca uma prioridade menor que os pré-carregados - a página atual é mais importante que a próxima. veja <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Link_prefetching_FAQ">Link prefetching FAQ</a> para mais detalhes.</li>
- <li><code>&lt;link rel="prerender"&gt;</code>
-  <p dir="ltr" id="tw-target-text">é usado para renderizar a página da Web especificada em segundo plano, acelerando o carregamento da página se o usuário navegar para ela. Devido ao potencial de desperdiçar largura de banda dos usuários, Chrome trata<code>prerender</code> como um <a href="https://developers.google.com/web/updates/2018/07/nostate-prefetch">NoState prefetch</a>.</p>
- </li>
- <li><code>&lt;link rel="subresource"&gt;</code> {{non-standard_inline}}
-  <p dir="ltr" id="tw-target-text">foi suportado no Chrome há algum tempo e tinha a intenção de lidar com recursos de pré-carregamento para o carregamento da página / navegação atual, mas tinha um problema - não havia como calcular uma prioridade para buscar os itens (como não existia naquela época ), então todos acabaram sendo buscados com pouca prioridade, o que não ajudou a situação.</p>
- </li>
- <li>
-  <p dir="ltr">Há vários carregadores de recursos baseados em script disponíveis, mas eles não têm nenhum poder sobre a fila de priorização de busca do navegador e estão sujeitos aos mesmos problemas de desempenho.</p>
- </li>
-</ul>
-
-<h2 id="Specifications" name="Specifications">Especificações</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('Preload','#x2.link-type-preload','preload')}}</td>
-   <td>{{Spec2('Preload')}}</td>
-   <td>mais detalhes sobre  <code>preload</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('HTML WHATWG', 'link-type-preload', 'rel=preload')}}</td>
-   <td>{{Spec2('HTML WHATWG')}}</td>
-   <td>definições de <code>rel=preload</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("html.elements.link.rel.preload")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li><a href="https://www.smashingmagazine.com/2016/02/preload-what-is-it-good-for/">Preload: What Is It Good For?</a> by Yoav Weiss</li>
-</ul>
-
-<p>{{QuickLinksWithSubpages("/en-US/docs/Web/HTML")}}</p>
diff --git a/files/pt-br/orphaned/web/javascript/guide/coleções_chaveadas/index.html b/files/pt-br/orphaned/web/javascript/guide/coleções_chaveadas/index.html
deleted file mode 100644
index 0328d76216..0000000000
--- a/files/pt-br/orphaned/web/javascript/guide/coleções_chaveadas/index.html
+++ /dev/null
@@ -1,150 +0,0 @@
----
-title: Coleções chaveadas
-slug: orphaned/Web/JavaScript/Guide/Coleções_chaveadas
-tags:
-  - Coleções
-  - Guía
-  - JavaScript
-  - Mapas
-original_slug: Web/JavaScript/Guide/Coleções_chaveadas
----
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}</div>
-
-<p class="summary">This chapter introduces collections of data which are ordered by a key; Map and Set objects contain elements which are iterable in the order of insertion.</p>
-
-<h2 id="Maps">Maps</h2>
-
-<h3 id="Map_object"><code>Map</code> object</h3>
-
-<p>ECMAScript 6 introduces a new data structure to map values to values. A {{jsxref("Map")}} object is a simple key/value map and can iterate its elements in insertion order</p>
-
-<p>The following code shows some basic operations with a <code>Map</code>. See also the {{jsxref("Map")}} reference page for more examples and the complete API. You can use a {{jsxref("Statements/for...of","for...of")}} loop to return an array of <code>[key, value]</code> for each iteration.</p>
-
-<pre class="brush: js">var sayings = new Map();
-sayings.set("dog", "woof");
-sayings.set("cat", "meow");
-sayings.set("elephant", "toot");
-sayings.size; // 3
-sayings.get("fox"); // undefined
-sayings.has("bird"); // false
-sayings.delete("dog");
-
-for (var [key, value] of sayings) {
-  console.log(key + " goes " + value);
-}
-// "cat goes meow"
-// "elephant goes toot"
-</pre>
-
-<h3 id="Object_and_Map_compared"><code>Object</code> and <code>Map</code> compared</h3>
-
-<p>Traditionally, {{jsxref("Object", "objects", "", 1)}} have been used to map strings to values. Objects allow you to set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. <code>Map</code> objects, however, have a few more advantages that make them better maps.</p>
-
-<ul>
- <li>The keys of an <code>Object</code> are {{jsxref("Global_Objects/String","Strings")}}, where they can be of any value for a <code>Map</code>.</li>
- <li>You can get the size of a <code>Map</code> easily while you have to manually keep track of size for an <code>Object</code>.</li>
- <li>The iteration of maps is in insertion order of the elements.</li>
- <li>An <code>Object</code> has a prototype, so there are default keys in the map. (this can be bypassed using <code>map = Object.create(null)</code>).</li>
-</ul>
-
-<p>These two tips can help you to decide whether to use a <code>Map</code> or an <code>Object</code>:</p>
-
-<ul>
- <li>Use maps over objects when keys are unknown until run time, and when all keys are the same type and all values are the same type.</li>
- <li>Use objects when there is logic that operates on individual elements.</li>
-</ul>
-
-<h3 id="WeakMap_object"><code>WeakMap</code> object</h3>
-
-<p>The {{jsxref("WeakMap")}} object is a collection of key/value pairs in which the <strong>keys are objects only</strong> and the values can be arbitrary values. The object references in the keys are held <em>weakly</em> meaning that they are target of garbage collection (GC) if there is no other reference to the object anymore. The <code>WeakMap</code> API is the same as the <code>Map</code> API.</p>
-
-<p>One difference to <code>Map</code> objects is that <code>WeakMap</code> keys are not enumerable (i.e. there is no method giving you a list of the keys). If they were, the list would depend on the state of garbage collection, introducing non-determinism.</p>
-
-<p>For more information and example code, see also "Why <em>Weak</em>Map?" on the {{jsxref("WeakMap")}} reference page.</p>
-
-<p>One use case of <code>WeakMap</code> objects is to store private data for an object or to hide implementation details. The following example is from Nick Fitzgerald blog post <a href="http://fitzgeraldnick.com/weblog/53/">"Hiding Implementation Details with ECMAScript 6 WeakMaps"</a>. The private data and methods belong inside the object and are stored in the <code>privates</code> WeakMap object. Everything exposed on the instance and prototype is public; everything else is inaccessible from the outside world because <code>privates</code> is not exported from the module</p>
-
-<pre class="brush: js">const privates = new WeakMap();
-
-function Public() {
-  const me = {
-    // Private data goes here
-  };
-  privates.set(this, me);
-}
-
-Public.prototype.method = function () {
-  const me = privates.get(this);
-  // Do stuff with private data in `me`...
-};
-
-module.exports = Public;
-</pre>
-
-<h2 id="Sets">Sets</h2>
-
-<h3 id="Set_object"><code>Set</code> object</h3>
-
-<p>{{jsxref("Set")}} objects are collections of values. You can iterate its elements in insertion order. A value in a <code>Set</code> may only occur once; it is unique in the <code>Set</code>'s collection.</p>
-
-<p>The following code shows some basic operations with a <code>Set</code>. See also the {{jsxref("Set")}} reference page for more examples and the complete API.</p>
-
-<pre class="brush: js">var mySet = new Set();
-mySet.add(1);
-mySet.add("some text");
-mySet.add("foo");
-
-mySet.has(1); // true
-mySet.delete("foo");
-mySet.size; // 2
-
-for (let item of mySet) console.log(item);
-// 1
-// "some text"
-</pre>
-
-<h3 id="Converting_between_Array_and_Set">Converting between Array and Set</h3>
-
-<p>You can create an {{jsxref("Array")}} from a Set using {{jsxref("Array.from")}} or the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a>. Also, the <code>Set</code> constructor accepts an <code>Array</code> to convert in the other direction. Note again that <code>Set</code> objects store unique values, so any duplicate elements from an Array are deleted when converting.</p>
-
-<pre class="brush: js">Array.from(mySet);
-[...mySet2];
-
-mySet2 = new Set([1,2,3,4]);
-</pre>
-
-<h3 id="Array_and_Set_compared"><code>Array</code> and <code>Set</code> compared</h3>
-
-<p>Traditionally, a set of elements has been stored in arrays in JavaScript in a lot of situations. The new <code>Set</code> object, however, has some advantages:</p>
-
-<ul>
- <li>Checking whether an element exists in an collection using {{jsxref("Array.indexOf", "indexOf")}} for arrays is slow.</li>
- <li><code>Set</code> objects let you delete elements by their value. With an array you would have to splice based on a element's index.</li>
- <li>The value {{jsxref("NaN")}} can not be found with <code>indexOf</code> in array.</li>
- <li><code>Set</code> objects store unique values, you don't have to keep track of duplicates by yourself.</li>
-</ul>
-
-<h3 id="WeakSet_object"><code>WeakSet</code> object</h3>
-
-<p>{{jsxref("WeakSet")}} objects are collections of objects. An object in the <code>WeakSet</code> may only occur once; it is unique in the <code>WeakSet</code>'s collection and objects are not enumerable.</p>
-
-<p>The main differences to the {{jsxref("Set")}} object are:</p>
-
-<ul>
- <li>In contrast to <code>Sets</code>, <code>WeakSets</code> are <strong>collections of objects only</strong> and not of arbitrary values of any type.</li>
- <li>The <code>WeakSet</code> is <em>weak</em>: References to objects in the collection are held weakly. If there is no other reference to an object stored in the <code>WeakSet</code>, they can be garbage collected. That also means that there is no list of current objects stored in the collection. <code>WeakSets</code> are not enumerable.</li>
-</ul>
-
-<p>The use cases of <code>WeakSet</code> objects are limited. They will not leak memory so it can be safe to use DOM elements as a key and mark them for tracking purposes, for example.</p>
-
-<h2 id="Key_and_value_equality_of_Map_and_Set">Key and value equality of <code>Map</code> and <code>Set</code></h2>
-
-<p>Both, the key equality of <code>Map</code> objects and the value equality of <code>Set</code> objects, are based on the "<a href="https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero">same-value-zero algorithm</a>":</p>
-
-<ul>
- <li>Equality works like the identity comparison operator <code>===</code>.</li>
- <li><code>-0</code> and <code>+0</code> are considered equal.</li>
- <li>{{jsxref("NaN")}} is considered equal to itself (contrary to <code>===</code>).</li>
-</ul>
-
-<p>{{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}</p>
diff --git a/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html b/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html
deleted file mode 100644
index 2bf5fe39b9..0000000000
--- a/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html
+++ /dev/null
@@ -1,584 +0,0 @@
----
-title: Sintaxe e tipos
-slug: orphaned/Web/JavaScript/Guide/Sintaxe_e_tipos
-original_slug: Web/JavaScript/Guide/Sintaxe_e_tipos
----
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</div>
-
-<p class="summary">Este capítulo trata sobre a sintaxe básica do JavaScript, declarações de variáveis, tipos de dados e literais.</p>
-
-<h2 id="Basics" name="Basics">Sintaxe básica</h2>
-
-<p>JavaScript pega emprestado a maior parte de sua sintaxe do Java, mas também é influenciado por Awk, Perl e Python.</p>
-
-<p>JavaScript é <strong>case-sensitive</strong> e usa o conjunto de caracteres <strong>Unicode.</strong></p>
-
-<p>No JavaScript, instruções são chamadas de {{Glossary("Statement", "declarações")}} e são separadas por um ponto e vírgula (;). Espaços, tabulação e uma nova linha são chamados de espaços em branco. O código fonte dos scripts em JavaScript são lidos da esquerda para a direita e são convertidos em uma sequência de elementos de entrada como simbolos, caracteres de controle, terminadores de linha, comentários ou espaço em branco. ECMAScript também define determinadas palavras-chave e literais, e tem regras para inserção automática de ponto e vírgula (<a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">ASI</a>) para terminar as declarações. No entanto, recomenda-se sempre adicionar ponto e vírgula no final de suas declarações; isso evitará alguns imprevistos. Para obter mais informações, consulte a referência detalhada sobre a <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar">gramática léxica</a> do JavaScript.</p>
-
-<h2 id="Comentários">Comentários</h2>
-
-<p>A sintaxe dos comentários em JavaScript é semelhante como em C++ e em muitas outras linguagens:</p>
-
-<pre class="brush: js">// comentário de uma linha
-
-/* isto é um comentário longo
-   de múltiplas linhas.
- */
-
-/* Você não pode, porém, /* aninhar comentários */ SyntaxError */</pre>
-
-<h2 id="Declarations" name="Declarations">Declarações</h2>
-
-<p>Existem três tipos de declarações em JavaScript.</p>
-
-<dl>
- <dt>{{jsxref("Statements/var", "var")}}</dt>
- <dd>Declara uma variável, opcionalmente, inicializando-a com um valor.</dd>
- <dt>{{experimental_inline}} {{jsxref("Statements/let", "let")}}</dt>
- <dd>Declara uma variável local de escopo do bloco, opcionalmente, inicializando-a com um valor.</dd>
- <dt>{{experimental_inline}} {{jsxref("Statements/const", "const")}}</dt>
- <dd>Declara uma constante apenas de leitura.</dd>
-</dl>
-
-<h3 id="Variáveis">Variáveis</h3>
-
-<p>Você usa variáveis como nomes simbólicos para os valores em sua aplicação. O nome das variáveis, chamados de {{Glossary("Identifier", "identificadores")}}, obedecem determinadas regras.</p>
-
-<p>Um identificador JavaScript deve começar com uma letra, underline (<code>_</code>), ou cifrão (<code>$</code>); os caracteres subsequentes podem também ser números (0-9). Devido JavaScript ser case-sensitive, letras incluem caracteres de "A" a "Z" (maiúsculos) e caracteres de "a" a "z" (minúsculos).</p>
-
-<p>Você pode usar a ISO 8859-1 ou caracteres Unicode tal como os identificadores å e ü. Você pode também usar as <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">sequências de escape Unicode</a> como caracteres e identificadores.</p>
-
-<p>Alguns exemplos de nomes legais são <code>Numeros_visitas</code>, <code>temp99</code>, e<code> _nome</code>.</p>
-
-<h3 id="Declarando_variáveis">Declarando variáveis</h3>
-
-<p>Você pode declarar uma variável de três formas:</p>
-
-<ul>
- <li>Com a palavra chave {{jsxref("Statements/var", "var")}}. Por exemplo, var <code>x = 42</code>. Esta sintaxe pode ser usada para declarar tanto variáveis locais como variáveis global.</li>
- <li>Por simples adição de valor. Por exemplo, <code>x = 42</code>. Isso declara uma variável global. Essa declaração gera um aviso de advertência no JavaScript. Você não deve usar essa variante.</li>
- <li>Com a palavra chave {{jsxref("Statements/let", "let")}}. Por exemplo, <code>let y = 13</code>. Essa sintaxe pode ser usada para declarar uma variável local de escopo de bloco. Veja <a href="/pt-BR/docs/Web/JavaScript/Guide/Grammar_and_Types#Variable_scope">escopo de variável</a> abaixo.</li>
-</ul>
-
-<h3 id="Classificando_variáveis">Classificando variáveis</h3>
-
-<p>Uma variável declarada usando a declaração <code>var</code> ou <code>let</code> sem especificar o valor inicial tem o valor  {{jsxref("undefined")}}.</p>
-
-<p>Uma tentativa de acessar uma variável não declarada resultará no lançamento de uma exceção {{jsxref("ReferenceError")}}:</p>
-
-<pre class="brush: js">var a;
-console.log("O valor de a é " + a); // saída "O valor de a é undefined"
-console.log("O valor de b é " + b); // throws ReferenceError exception
-</pre>
-
-<p>Você pode usar <code>undefined</code> para determinar se uma variável tem um valor. No código a seguir, não é atribuído um valor de entrada na variável e a declaração <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/if...else">if</a></code> será avaliada como verdadeira (<code>true</code>).</p>
-
-<pre class="brush: js">var input;
-if(input === undefined){
-  facaIsto();
-} else {
-  facaAquilo();
-}
-</pre>
-
-<p>O valor <code>undefined</code> se comporta como falso (<code>false</code>), quando usado em um contexto booleano. Por exemplo, o código a seguir executa a função <code>myFunction</code> devido o elemento <code>myArray</code> ser undefined:</p>
-
-<pre class="brush: js">var myArray = [];
-if (!myArray[0]) myFunction();
-</pre>
-
-<p>O valor <code>undefined</code> converte-se para <code>NaN</code> quando usado no contexto numérico.</p>
-
-<pre class="brush: js">var a;
-a + 2;  // Avaliado como NaN
-</pre>
-
-<p>Quando você avalia uma variável nula, o valor nulo se comporta como 0 em contextos numéricos e como falso em contextos booleanos. Por exemplo:</p>
-
-<pre class="brush: js">var n = null;
-console.log(n * 32); // a saída para o console será 0.
-</pre>
-
-<h3 id="Variable_scope" name="Variable_scope">Escopo de variável</h3>
-
-<p>Quando você declara uma váriavel fora de qualquer função, ela é chamada de variável <em>global</em>, porque está disponível para qualquer outro código no documento atual. Quando você declara uma variável dentro de uma função, é chamada de variável <em>local</em>,  pois ela está disponível somente dentro dessa função.</p>
-
-<p>JavaScript antes do ECMAScript 6 não possuía escopo de <a href="/pt-BR/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Block_statement">declaração de bloco</a>; pelo contrário, uma variável declarada dentro de um bloco de uma <em>função </em>é uma variável local (ou contexto <em>global</em>) do bloco que está inserido a função. Por exemplo o código a seguir exibirá 5, porque o escopo de <code>x</code> está na função (ou contexto global) no qual <code>x</code> é declarado, não o bloco, que neste caso é a declaração <code>if</code>. </p>
-
-<pre class="brush: js">if (true) {
-  var x = 5;
-}
-console.log(x);  // 5
-</pre>
-
-<p>Esse comportamento é alterado, quando usado a declaração <code>let</code> introduzida pelo ECMAScript 6.</p>
-
-<pre class="brush: js">if (true) {
-  let y = 5;
-}
-console.log(y);  // ReferenceError: y não está definido
-</pre>
-
-<h3 id="Variable_hoisting" name="Variable_hoisting">Hoisting</h3>
-
-<p>Outra coisa incomum sobre variáveis em JavaScript é que você pode utilizar a variável e declará-la depois, sem obter uma exceção. Este conceito é conhecido como <strong>hoisting</strong>; variáveis em JavaScript são num sentido "hoisted" ou lançada para o topo da função ou declaração. No entanto, as variáveis que são "hoisted" retornarão um valor <code>undefined</code>. Então, mesmo se você usar ou referir a variável e depois declará-la e inicializá-la, ela ainda retornará undefined.</p>
-
-<pre class="brush: js">/**
- * Exemplo 1
- */
-console.log(x === undefined); // exibe "true"
-var x = 3;
-
-/**
- * Exemplo 2
- */
-// returnará um valor undefined
-var myvar = "my value";
-
-(function() {
-  console.log(myvar); // undefined
-  var myvar = "local value";
-})();
-</pre>
-
-<p>Os exemplos acima serão interpretados como:</p>
-
-<pre class="brush: js">/**
- * Exemplo 1
- */
-var x;
-console.log(x === undefined); // exibe "true"
-x = 3;
-
-/**
- * Exemplo 2
- */
-var myvar = "um valor";
-
-(function() {
-  var myvar;
-  console.log(myvar); // undefined
-  myvar = "valor local";
-})();
-</pre>
-
-<p>Devido o hoisting, todas as declarações <code>var</code> em uma função devem ser colocadas no início da função. Essa recomendação de prática deixa o código mais legível.</p>
-
-<h3 id="Variáveis_Globais">Variáveis Globais</h3>
-
-<p>Variáveis globais são propriedades do <em>objeto global</em>. Em páginas web o objeto global é a {{domxref("window")}}, assim você pode configurar e acessar variáveis globais utilizando a sintaxe <code>window.variavel.</code> </p>
-
-<p>Consequentemente, você pode acessar variáveis globais declaradas em uma janela ou frame ou frame de outra janela. Por exemplo, se uma variável chamada phoneNumber é declarada em um documento, você pode consultar esta variável de um frame como <code>parent.phoneNumber</code>.</p>
-
-<h3 id="Constantes">Constantes</h3>
-
-<p>Você pode criar uma constante apenas de leitura por meio da palavra-chave {{jsxref("Statements/const", "const")}}. A sintaxe de um identificador de uma constante é semelhante ao identificador de uma variável: deve começar com uma letra, underline ou cifrão e pode conter caracteres alfabético, numérico ou underline.</p>
-
-<pre class="brush: js">const prefix = '212';
-</pre>
-
-<p>Uma constante não pode alterar seu valor por meio de uma atribuição ou ao ser declarada novamente enquanto o script é executado. Deve ser inicializada com um valor.</p>
-
-<p>As regras de escopo para as constantes são as mesmas para as váriaveis <code>let</code> de escopo de bloco. Se a palavra-chave <code>const</code> for omitida, o identificado é adotado para representar uma variável.</p>
-
-<p>Você não pode declarar uma constante com o mesmo nome de uma função ou variável que estão no mesmo escopo. Por exemplo: </p>
-
-<pre class="example-bad brush: js">// Isto irá causar um  erro
-function f() {};
-const f = 5;
-
-// Isto também irá causar um erro.
-function f() {
-  const g = 5;
-  var g;
-
-  //declarações
-}
-</pre>
-
-<h2 id="Data_structures_and_types" name="Data_structures_and_types">Estrutura de dados e tipos</h2>
-
-<h3 id="Tipos_de_dados">Tipos de dados</h3>
-
-<p>O mais recente padrão ECMAScript define sete tipos de dados:</p>
-
-<ul>
- <li>Seis tipos de dados são os chamados {{Glossary("Primitive", "primitivos")}}:
-  <ul>
-   <li>{{Glossary("Boolean")}}. <code>true</code> e <code>false</code>.</li>
-   <li>{{Glossary("null")}}. Uma palavra-chave que indica valor nulo. Devido JavaScript ser case-sensitive, <code>null</code> não é o mesmo que <code>Null</code>, <code>NULL</code>, ou ainda outra variação.</li>
-   <li>{{Glossary("undefined")}}. Uma propriedade superior cujo valor é indefinido.</li>
-   <li>{{Glossary("Number")}}. <code>42</code> ou <code>3.14159</code>.</li>
-   <li>{{Glossary("String")}}. "Howdy"</li>
-   <li>{{Glossary("Symbol")}} (novo em ECMAScript 6). Um tipo de dado cuja as instâncias são únicas e imutáveis.</li>
-  </ul>
- </li>
- <li>e {{Glossary("Object")}}</li>
-</ul>
-
-<p>Embora esses tipos de dados sejam uma quantidade relativamente pequena, eles permitem realizar funções úteis em suas aplicações.  <span style="line-height: 1.5;">{{jsxref("Object", "Objetos")}} e {{jsxref("Function", "funçõess")}} são outros elementos fundamentais na linguagem. Você pode pensar em objetos como recipientes para os valores, e funções como métodos que suas aplicações podem executar.</span></p>
-
-<h3 id="Conversão_de_tipos_de_dados">Conversão de tipos de dados</h3>
-
-<p>JavaScript é uma linguagem dinamicamente tipada. Isso significa que você não precisa especificar o tipo de dado de uma variável quando declará-la, e tipos de dados são convertidos automaticamente conforme a necessidade durante a execução do script. Então, por exemplo, você pode definir uma variável da seguinte forma:</p>
-
-<pre class="brush: js">var answer = 42;
-</pre>
-
-<p>E depois, você pode atribuir uma string para a mesma variável, por exemplo:</p>
-
-<pre class="brush: js">answer = "Obrigado pelos peixes...";
-</pre>
-
-<p>Devido JavaScript ser dinamicamente tipado, essa declaração não gera uma mensagem de erro.</p>
-
-<p>Em expressões envolvendo valores numérico e string com o operador +, JavaScript converte valores numérico para strings. Por exemplo, considere a seguinte declaração:</p>
-
-<pre class="brush: js">x = "A resposta é " + 42 // "A resposta é 42"
-y = 42 + " é a resposta" // "42 é a resposta"
-</pre>
-
-<p>Nas declarações envolvendo outros operadores,  JavaScript não converte valores numérico para strings. Por exemplo:</p>
-
-<pre class="brush: js">"37" - 7 // 30
-"37" + 7 // "377"
-</pre>
-
-<h3 id="Convertendo_strings_para_números">Convertendo strings para números</h3>
-
-<p>No caso de um valor que representa um número está armazenado na memória como uma string, existem métodos para a conversão.</p>
-
-<ul>
- <li id="parseInt()_and_parseFloat()">{{jsxref("parseInt", "parseInt()")}}</li>
- <li>{{jsxref("parseFloat", "parseFloat()")}}</li>
-</ul>
-
-<p>parseInt irá retornar apenas números inteiros, então seu uso é restrito para a casa dos decimais. Além disso, é uma boa prática ao usar parseInt incluir o parâmetro da base. O parâmetro da base é usado para especificar qual sistema númerico deve ser usado.</p>
-
-<p><font face="Consolas, Liberation Mono, Courier, monospace">Uma método alternativo de conversão de um número em forma de string é com o operador <code>+</code> (operador soma):</font></p>
-
-<pre class="brush: js">"1.1" + "1.1" = "1.11.1"
-(+"1.1") + (+"1.1") = 2.2
-// Nota: Os parênteses foram usados para deixar mais legível o código, ele não é requirido.</pre>
-
-<h2 id="Literals" name="Literals">Literais</h2>
-
-<p>Você usa literais para representar valores em JavaScript. Estes são valores fixados, não variáveis, que você <code>literalmente</code> insere em seu script. Esta seção descreve os seguintes tipos literais:</p>
-
-<ul>
- <li>{{anch("Array literal")}}</li>
- <li>{{anch("Literais boolean")}}</li>
- <li>{{anch("Literais de ponto flutuante")}}</li>
- <li>{{anch("Inteiros")}}</li>
- <li>{{anch("Objeto literal")}}</li>
- <li>{{anch("String literal")}}</li>
-</ul>
-
-<h3 id="Array_literal">Array literal</h3>
-
-<p>Um literal de array é uma lista de zero ou mais expressões, onde cada uma delas representam um elemento do array, inseridas entre colchetes (<code>[]</code>). Quando você cria um array usando um array literal, ele é inicializado  com os valores especificados como seus elementos, e seu comprimento é definido com o  número de elementos especificados.</p>
-
-<p>O exemplo a seguir cria um array <code>coffees</code> com três elementos e um comprimento de três:</p>
-
-<pre class="brush: js">var coffees = ["French Roast", "Colombian", "Kona"];
-</pre>
-
-<div class="note">
-<p><strong>Nota :</strong> Um array literal é um tipo de inicializador de objetos. Veja <a href="/pt-BR/docs/Web/JavaScript/Guide/Working_with_Objects#Using_object_initializers" title="en-US/docs/JavaScript/Guide/Working with Objects#Using Object Initializers">Usando inicializadores de Objetos</a>.</p>
-</div>
-
-<p>Se um array é criado usando um literal no topo do script, JavaScript interpreta o array cada vez que avalia a expressão que contêm o array literal. Além disso, um literal usado em uma função é criado cada vez que a função é chamada.</p>
-
-<p>Array literal são também um array de objetos. Veja  {{jsxref("Array")}} e <a href="/pt-BR/docs/Web/JavaScript/Guide/Indexed_collections">Coleções indexadas</a> para detalhes sobre array de objetos.</p>
-
-<h4 id="Vírgulas_extras_em_array_literal">Vírgulas extras em array literal</h4>
-
-<p>Você não precisa especificar todos os elementos em um array literal. Se você colocar duas vírgulas em uma linha, o array é criado com <code>undefined</code> para os elementos não especificados. O exemplo a seguir cria um array chamado <code>fish</code>:</p>
-
-<pre class="brush: js">var fish = ["Lion", , "Angel"];
-</pre>
-
-<p>Esse array tem dois elementos com valores e um elemento vazio (<code>fish[0]</code> é "Lion", <code>fish[1]</code> é <code>undefined</code>, e <code>fish[2]</code> é "Angel" ).</p>
-
-<p>Se você incluir uma vírgula à direita no final da lista dos elementos, a vírgula é ignorada. No exemplo a seguir, o comprimento do array é três. Não há nenhum <code>myList[3]</code>. Todas as outras vírgulas na lista indicam um novo elemento.</p>
-
-<div class="note">
-<p><strong>Nota :</strong> Vírgulas à direita podem criar erros em algumas versões de navegadores web antigos, é recomendável removê-las.</p>
-</div>
-
-<pre class="brush: js">var myList = ['home', , 'school', ];
-</pre>
-
-<p>No exemplo a seguir, o comprimento do array é quatro, e <code>myList[0]</code> e <code>myList[2]</code> são <code>undefined</code>.</p>
-
-<pre class="brush: js">var myList = [ , 'home', , 'school'];
-</pre>
-
-<p>No exemplo a seguir, o comprimento do array é quatro, e <code>myList[1]</code> e <code>myList[3]</code> são <code>undefined</code>. Apenas a última vírgula é ignorada.</p>
-
-<pre class="brush: js">var myList = ['home', , 'school', , ];
-</pre>
-
-<p>Entender o comportamento de vírgulas extras é importante para a compreensão da linguagem JavaScript, no entanto, quando você escrever seu próprio código: declarar explicitamente os elementos em falta como <code>undefined</code> vai aumentar a clareza do código, e consequentemente na sua manutenção.</p>
-
-<h3 id="Literais_Boolean">Literais Boolean</h3>
-
-<p>O tipo Boolean tem dois valores literal: <code>true</code> e <code>false</code>.</p>
-
-<p>Não confunda os valores primitivos Boolean <code>true</code> e <code>false</code> com os valores <code>true</code> e <code>false</code> do objeto Boolean. O objeto Boolean é um invólucro em torno do tipo de dado primitivo. Veja {{jsxref("Boolean")}} para mais informação.</p>
-
-<h3 id="Inteiros">Inteiros</h3>
-
-<p>Inteiros podem sem expressos em decimal (base 10), hexadecimal (base 16), octal (base 8) e binário (base 2).</p>
-
-<ul>
- <li>Decimal inteiro literal consiste em uma sequência de dígitos sem um 0 (zero).</li>
- <li>0 (zero) em um inteiro literal indica que ele está em octal. Octal pode incluir somente os dígitos 0-7.</li>
- <li>0x (ou 0X) indica um hexadecimal. Inteiros hexadecimais podem incluir dígitos (0-9) e as letras a-f e A-F.</li>
- <li>0b (ou 0B) indica um binário. Inteiros binário podem incluir apenas os dígitos 0 e 1.</li>
-</ul>
-
-<p>Alguns exemplos de inteiros literal são:</p>
-
-<pre class="eval">0, 117 and -345 (decimal, base 10)
-015, 0001 and -077 (octal, base 8)
-0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)
-0b11, 0b0011 and -0b11 (binário, base 2)
-</pre>
-
-<p>Para maiores informações, veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#Numeric_literals">Literais numérico na referência Léxica</a>.</p>
-
-<h3 id="Literais_de_ponto_flutuante">Literais de ponto flutuante</h3>
-
-<p>Um literal de ponto flutuante pode ter as seguintes partes:</p>
-
-<ul>
- <li>Um inteiro decimal que pode ter sinal (precedido por "<code>+</code>" ou "<code>-</code>"),</li>
- <li>Um ponto decimal ("<code>.</code>"),</li>
- <li>Uma fração (outro número decimal),</li>
- <li>Um expoente.</li>
-</ul>
-
-<p>O expoente é um "e" ou "E" seguido por um inteiro, que pode ter sinal (precedido por "+" ou "-"). Um literal de ponto flutuante  deve ter no mínimo um dígito e um ponto decimal ou "e" (ou "E").</p>
-
-<p>Mais sucintamente, a sintaxe é:</p>
-
-<pre class="eval">[(+|-)][digitos][.digitos][(E|e)[(+|-)]digitos]
-</pre>
-
-<p>Por exemplo:</p>
-
-<pre class="eval">3.1415926
--.123456789
--3.1E+12
-.1e-23
-</pre>
-
-<h3 id="Objeto_literal">Objeto literal</h3>
-
-<p>Um objeto literal é uma lista de zero ou mais pares de nomes de propriedades e valores associados de de um objeto, colocado entre chaves (<code>{}</code>). Você não deve usar um objeto literal no início de uma declaração. Isso levará a um erro ou não se comportará conforme o esperado, porque o <code>{</code> será interpretado como início de um bloco.</p>
-
-<p>Segue um exemplo de um objeto literal. O primeiro elemento do objeto <code>car </code>define uma propriedade, <code>myCar</code>, e atribui para ele uma nova string, "Saturn"; o segundo elemento, a propriedade <code>getCar</code>, é imediatamente atribuído o resultado de chamar uma função (<code>carTypes("Honda")</code>); o terceiro elemento, a propriedade especial, usa uma variável existente (<code>sales)</code>.</p>
-
-<pre class="brush: js">var sales = "Toyota";
-
-function carTypes(name) {
-  if (name == "Honda") {
-    return name;
-  } else {
-    return "Sorry, we don't sell " + name + ".";
-  }
-}
-
-var car = { myCar: "Saturn", getCar: carTypes("Honda"), special: sales };
-
-console.log(car.myCar);   // Saturn
-console.log(car.getCar);  // Honda
-console.log(car.special); // Toyota
-</pre>
-
-<p>Além disso, você pode usar um literal numérico ou string para o nome de uma propriedade ou aninhar um objeto dentro do outro. O exemplo a seguir usar essas opções.</p>
-
-<pre class="brush: js">var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
-
-console.log(car.manyCars.b); // Jeep
-console.log(car[7]); // Mazda
-</pre>
-
-<p>Nomes de propriedades de objeto podem ser qualquer string, incluindo uma string vazia. Caso o nome da propriedade não seja um {{Glossary("Identifier","identificador")}} JavaScript ou número, ele deve ser colocado entre aspas. Nomes de propriedades que não possuem identificadores válido, também não podem ser acessadas pela propriedade de ponto (<code>.</code>), mas podem ser acessadas e definidas com a notação do tipo array ("<code>[]</code>").</p>
-
-<pre class="brush: js">var unusualPropertyNames = {
-  "": "Uma string vazia",
-  "!": "Bang!"
-}
-console.log(unusualPropertyNames."");   // SyntaxError: string inesperada
-console.log(unusualPropertyNames[""]);  // Um string vazia
-console.log(unusualPropertyNames.!);    // SyntaxError: símbolo ! inesperado
-console.log(unusualPropertyNames["!"]); // Bang!</pre>
-
-<p>Observe:</p>
-
-<pre class="brush: js">var foo = {a: "alpha", 2: "two"};
-console.log(foo.a);    // alpha
-console.log(foo[2]);   // two
-//console.log(foo.2);  // Error: missing ) after argument list
-//console.log(foo[a]); // Error: a não está definido
-console.log(foo["a"]); // alpha
-console.log(foo["2"]); // two
-</pre>
-
-<h3 id="String_Literal">String Literal</h3>
-
-<p>Uma string literal são zero ou mais caracteres dispostos em aspas duplas (<code>"</code>) ou aspas simples (<code>'</code>). Uma sequência de caracteres deve ser delimitada por aspas do mesmo tipo; ou seja,  as duas aspas simples ou ambas aspas duplas. A seguir um exemplo de strings literais.</p>
-
-<pre class="eval">"foo"
-'bar'
-"1234"
-"um linha \n outra linha"
-"John's cat"
-</pre>
-
-<p>Você pode chamar qualquer um dos métodos do objeto string em uma string literal - JavaScript automaticamente converte a string literal para um objeto string temporário, chama o método, em seguida, descarta o objeto string temporário. Você também pode usar a propriedade <code>String.length</code> com uma string literal:</p>
-
-<pre class="brush: js">console.log("John's cat".length)
-// Irá exibir a quantidade de caracteres na string incluindo o espaço em branco.
-// Nesse caso, 10 caracteres.
-</pre>
-
-<p>Você deve usar string literal, a não ser que você precise usar um objeto string. Veja {{jsxref("String")}} para detalhes sobre objetos de strings.</p>
-
-<h4 id="Uso_de_caracteres_especiais_em_string">Uso de caracteres especiais em string</h4>
-
-<p>Além dos caracteres comuns, você também pode incluir caracteres especiais em strings, como mostrado no exemplo a seguir.</p>
-
-<pre class="brush: js">"uma linha \n outra linha"
-</pre>
-
-<p>A tabela a seguir lista os caracteres especiais que podem ser usados em strings no JavaScript.</p>
-
-<table class="standard-table">
- <caption>Tabela: Caracteres especiais no JavaScript</caption>
- <thead>
-  <tr>
-   <th scope="col">Caracter</th>
-   <th scope="col">Descrição</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\0</code></td>
-   <td>Byte nulo</td>
-  </tr>
-  <tr>
-   <td><code>\b</code></td>
-   <td>Backspace</td>
-  </tr>
-  <tr>
-   <td><code>\f</code></td>
-   <td>Alimentador de formulário</td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>Nova linha</td>
-  </tr>
-  <tr>
-   <td><code>\r</code></td>
-   <td>Retorno do carro</td>
-  </tr>
-  <tr>
-   <td><code>\t</code></td>
-   <td>Tabulação</td>
-  </tr>
-  <tr>
-   <td><code>\v</code></td>
-   <td>Tabulação vertical</td>
-  </tr>
-  <tr>
-   <td><code>\'</code></td>
-   <td>Apóstrofo ou aspas simples</td>
-  </tr>
-  <tr>
-   <td><code>\"</code></td>
-   <td>Aspas dupla</td>
-  </tr>
-  <tr>
-   <td><code>\\</code></td>
-   <td>Caractere de barra invertida</td>
-  </tr>
-  <tr>
-   <td><code>\<em>XXX</em></code></td>
-   <td>
-    <p>Caractere com a codificação Latin-1 especificada por três dígitos octal <em>XXX </em>entre 0 e 377. Por exemplo, \251 é sequência octal para o símbolo de direitos autorais.</p>
-   </td>
-  </tr>
-  <tr>
-  </tr>
-  <tr>
-   <td><code>\x<em>XX</em></code></td>
-   <td>
-    <p>Caractere com a codificação Latin-1 especificada por dois dígitos hexadecimal <em>XX</em> entre 00 e FF. Por exemplo, \xA9 é a sequência hexadecimal para o símbolo de direitos autorais.</p>
-   </td>
-  </tr>
-  <tr>
-  </tr>
-  <tr>
-   <td><code>\u<em>XXXX</em></code></td>
-   <td>
-    <p>Caractere Unicode especificado por quatro dígitos hexadecimal <em>XXXX</em>. Por exemplo, \u00A9 é a sequência Unicode para o símbolo de direitos autorais. Veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">sequências de escape Unicode</a>.</p>
-   </td>
-  </tr>
- </tbody>
-</table>
-
-<h4 id="Caracteres_de_escape">Caracteres de escape</h4>
-
-<p>Para caracteres não listados na tabela, se precedidos de barra invertida ela é ignorada, seu uso está absoleto e deve ser ignorado.</p>
-
-<p>Você pode inserir uma aspa dentro de uma string precendendo-a com uma barra invertida. Isso  é conhecido como <em>escaping</em> das aspas. Por exemplo:</p>
-
-<pre class="brush: js">var quote = "Ele lê \"The Cremation of Sam McGee\" de R.W. Service.";
-console.log(quote);
-</pre>
-
-<p>O resultado disso seria:</p>
-
-<pre class="eval">Ele lê "The Cremation of Sam McGee" de R.W. Service.
-</pre>
-
-<p>Para incluir uma barra invertida dentro de uma string, você deve escapar o caractere de barra invertida. Por exemplo, para atribuir o caminho do arquivo <code>c:\temp </code>para uma string, utilize o seguinte:</p>
-
-<pre class="brush: js">var home = "c:\\temp";
-</pre>
-
-<p>Você também pode escapar quebras de linhas, precedendo-as com barra invertida. A barra invertida e a quebra de linha são ambas removidas da string.</p>
-
-<pre class="brush: js">var str = "esta string \
-está quebrada \
-em várias\
-linhas."
-console.log(str);   // esta string está quebrada em várias linhas.
-</pre>
-
-<p>Embora JavaScript não tenha sintaxe "heredoc", você pode adicionar uma quebra de linha e um escape de quebra de linha no final de cada linha:</p>
-
-<pre class="brush: js">var poem =
-"Rosas são vermelhas,\n\
-Violetas são azul.\n\
-Eu sou esquizofrênico,\n\
-e é isso que sou."
-</pre>
-
-<h2 id="Mais_informação">Mais informação</h2>
-
-<p>Este capítulo focou na sintaxe básica das declarações e tipos. Para saber mais sobre a linguagem JavaScript, veja também os seguintes capítulos deste guia:</p>
-
-<ul>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Control_flow_and_error_handling">Controle de fluxo e manipulação de erro</a></li>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Loops_and_iteration">Laços e iteração</a></li>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Functions">Funções</a></li>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators">Expressões e operadores</a></li>
-</ul>
-
-<p>No próximo capítulo, veremos a construção de controle de fluxos e manipulação de erro.</p>
-
-<p>{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</p>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html
deleted file mode 100644
index e7084dd594..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html
+++ /dev/null
@@ -1,207 +0,0 @@
----
-title: Array.prototype
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Array/prototype
-tags:
-  - Array
-  - JavaScript
-  - Propriedade
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/Array/prototype
----
-<div>{{JSRef}}</div>
-
-<h2 id="Description" name="Description">Descrição</h2>
-
-<p>Instâncias de {{jsxref("Global_Objects/Array", "Array")}} herdam de <code>Array.prototype</code>. Como em todos os construtores, você pode mudar o  protótipo desse construtor para modificar todas as instâncias de {{jsxref("Global_Objects/Array", "Array")}}.</p>
-
-<p>Contudo, a adição de métodos não-padronizados ao objeto array pode causar problemas futuros, seja com seu próprio código, ou na <a href="https://developers.google.com/web/updates/2018/03/smooshgate">adição de novas funcionalidades ao JavaScript</a>.</p>
-
-<p>Um fato pouco conhecido: O próprio <code>Array.prototype </code>é um {{jsxref("Global_Objects/Array", "Array")}}</p>
-
-<pre class="brush: js">Array.isArray(Array.prototype); // true
-</pre>
-
-<h2 id="Properties" name="Properties">Propriedades</h2>
-
-<dl>
- <dt><code>Array.prototype.constructor</code></dt>
- <dd>Especifica a função que cria um objeto do protótipo.<br>
-  </dd>
- <dt>{{jsxref("Array.prototype.length")}}</dt>
- <dd>Reflete o número de elementos em um array.</dd>
-</dl>
-
-<h2 id="Methods" name="Methods">Métodos</h2>
-
-<h3 id="Mutator_methods" name="Mutator_methods">Métodos modificadores</h3>
-
-<p>Esses métodos modificam o array:</p>
-
-<dl>
- <dt>{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}</dt>
- <dd>Copia uma sequência de elementos do array dentro do array.</dd>
- <dt>{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}</dt>
- <dd>Preenche todos os elementos de um array com um elemento estático, começando de um índice inicial até um índice final.</dd>
- <dt>{{jsxref("Array.prototype.pop()")}}</dt>
- <dd>Remove e retorna o último elemento de um array.</dd>
- <dt>{{jsxref("Array.prototype.push()")}}</dt>
- <dd>Adiciona um ou mais elementos ao fim de um array e retorna o novo comprimeiro do array.</dd>
- <dt>{{jsxref("Array.prototype.reverse()")}}</dt>
- <dd>Reverte a ordem dos elementos de um array - o primeiro vira o último e o último vira o primeiro.</dd>
- <dt>{{jsxref("Array.prototype.shift()")}}</dt>
- <dd>Remove o primeiro elemento de um array e o retorna.</dd>
- <dt>{{jsxref("Array.prototype.sort()")}}</dt>
- <dd>Ordena os elementos do array em questão e retorna o array.</dd>
- <dt>{{jsxref("Array.prototype.splice()")}}</dt>
- <dd>Adiciona e/ou remove elementos de um array.</dd>
- <dt>{{jsxref("Array.prototype.unshift()")}}</dt>
- <dd>Adiciona um ou mais elementos ao início de um array e retorna o novo comprimento do array.</dd>
-</dl>
-
-<h3 id="Accessor_methods" name="Accessor_methods">Métodos de acesso</h3>
-
-<p>Esses métodos não modificam o array, mas sim retornam alguma representação dele.</p>
-
-<dl>
- <dt>{{jsxref("Array.prototype.concat()")}}</dt>
- <dd>Retorna um novo array formado por esse array concatenado com outro(s) array(s) e/ou valores.</dd>
- <dt>{{jsxref("Array.prototype.contains()")}} {{experimental_inline}}</dt>
- <dd>Verifica se o array possui cer, retornando<code>true</code> ou <code>false</code> apropriadamente.</dd>
- <dt>{{jsxref("Array.prototype.join()")}}</dt>
- <dd>Retorna uma string com todos os elementos do array</dd>
- <dt>{{jsxref("Array.prototype.slice()")}}</dt>
- <dd>Retorna um novo array com uma parte do array sobre o qual o método foi chamado</dd>
- <dt>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Retorna um array literal representando o array especificado; você pode usar esse valor para criar um novo array. Esse método sobrescreve o método {{jsxref("Object.prototype.toSource()")}}.</dd>
- <dt>{{jsxref("Array.prototype.toString()")}}</dt>
- <dd>Retonar uma string representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toString()")}}.</dd>
- <dt>{{jsxref("Array.prototype.toLocaleString()")}}</dt>
- <dd>Retonar uma string adequada ao idioma do usuário representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toLocaleString()")}}.</dd>
- <dt>{{jsxref("Array.prototype.indexOf()")}}</dt>
- <dd>Representa o índice da primeira ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array.</dd>
- <dt>{{jsxref("Array.prototype.lastIndexOf()")}}</dt>
- <dd>Representa o índice da última ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array</dd>
-</dl>
-
-<h3 id="Iteration_methods" name="Iteration_methods">Métodos de iteração</h3>
-
-<p>Vários métodos tomam como funções de argumento para serem chamados de volta ao processar o array. Quando esses métodos são chamados, o `<code>length` do array</code> é amostrado e qualquer elemento adicionado além deste comprimento (length)  de dentro da função (callback) não é visitado. Outras alterações para o array (Definindo o valor de ou apagando um elemento) pode afetar os resultados da operação se o método visita o elemento alterado posteriormente. Enquanto o comportamento específico destes métodos nestes casos é bem definido, não se deve confiar nisso para não confundir os outros que possoam ler seu código. Em vez disso, deve-se copiar para um novo array para modificá-lo.</p>
-
-<dl>
- <dt>{{jsxref("Array.prototype.forEach()")}}</dt>
- <dd>Chama a função para cada elemento no array.</dd>
- <dt>{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}</dt>
- <dd>Retorna um novo objeto <code>Array Iterator</code> que contem o par chave/valor para cada índice no array.</dd>
- <dt>{{jsxref("Array.prototype.every()")}}</dt>
- <dd>Retorna true se todos elementos no array satisfizer a função de teste fornecida.</dd>
- <dt>{{jsxref("Array.prototype.some()")}}</dt>
- <dd>Retorna true se pelo menos um elemento no array satisfizer a função de teste fornecida.</dd>
- <dt>{{jsxref("Array.prototype.filter()")}}</dt>
- <dd>Cria um novo array com todos os elementos do array para qual a função de filtragem fornecida retorne true.</dd>
- <dt>{{jsxref("Array.prototype.find()")}} {{experimental_inline}}</dt>
- <dd>Retorna o valor encontrado no array, se um elemento no array satisfizer a funçào de teste fornecida ou  `<code>undefined` </code>se não for encontrado.</dd>
- <dt>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</dt>
- <dd>Retorna o índice no array, se um elemento no array satisfizer a função de teste fornecida ou -1 se não for encontrado.</dd>
- <dt>{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}</dt>
- <dd>Retorna um novo <code>Array Iterator</code> que contem a chave para cada índice no array.</dd>
- <dt>{{jsxref("Array.prototype.map()")}}</dt>
- <dd>Cria um novo array com os resultados da função fornecida chamada em cada elemento na array.</dd>
- <dt>{{jsxref("Array.prototype.reduce()")}}</dt>
- <dd>Aplica uma função contra um acumulador e cada valor do array (da esquerda para direita) para reduzi-los a um único valor.</dd>
- <dt>{{jsxref("Array.prototype.reduceRight()")}}</dt>
- <dd>Aplica uma função contra um acumulador e cada valor do array (da direita para esquerda) para reduzi-los a um único valor.</dd>
- <dt>{{jsxref("Array.prototype.values()")}} {{experimental_inline}}</dt>
- <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd>
- <dt>{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}</dt>
- <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd>
-</dl>
-
-<h3 id="Generic_methods" name="Generic_methods">Métodos genéricos</h3>
-
-<p>Vários métodos do objeto Array em Javascript foram feitos para serem aplicados genericamentes em todos os objetos que "pareçam" Arrays. Isso é, eles podem ser usados em qualquer objeto que possuam uma propriedade <code>length</code> (comprimento), e que possa ser usado a partir de propriedades numéricas (como índices no formato <code>array[5]</code>). Alguns métodos, como {{jsxref("Array.join", "join")}}, apenas lêem e as propriedades numéricas do objeto sobre o qual eles sãochamados. Outros, como {{jsxref("Array.reverse", "reverse")}}, exigem que as propriedades numéricas e <code>length </code>sejam mutáveis; sendo assim, esses métodos não podem ser chamados em objetos como {{jsxref("Global_Objects/String", "String")}}, que não permitem que nenhuma das duas propriedades sejam modificadas.</p>
-
-<h2 id="Specifications" name="Specifications">Especifiações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Situação</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>ECMAScript 1st Edition.</td>
-   <td>Padrão</td>
-   <td>Definição inicial</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com Navegadores</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also" name="See_also">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html
deleted file mode 100644
index 7b5395be96..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html
+++ /dev/null
@@ -1,60 +0,0 @@
----
-title: BigInt.prototype
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/BigInt/prototype
-tags:
-  - BigInt
-  - JavaScript
-  - Propriedade
-  - Prototipo
-  - Referencia
-translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/BigInt/prototype
----
-<div>{{JSRef}}</div>
-
-<p>A propriedade <strong><code>BigInt.prototype</code></strong> representa o protótipo para o  construtor {{JSxRef("BigInt")}} .</p>
-
-<p>{{JS_Property_Attributes(0, 0, 0)}}</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Todas instância de {{JSxRef("BigInt")}} herdam de <code>BigInt.prototype</code>. O objeto protótipo do construtor {{JSxRef("BigInt")}} pode ser modificado para afetar todas instâncias de {{JSxRef( "BigInt")}} .</p>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt><code>BigInt.prototype.constructor</code></dt>
- <dd>Retorna a função que cria instâncias deste objeto. Por padrão é o objeto<br>
- {{JSxRef("BigInt")}}.</dd>
-</dl>
-
-<h2 id="Métodos">Métodos</h2>
-
-<dl>
- <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt>
- <dd>Retorna uma string com uma representação sensível ao idioma para este número. Sobrescreve o método {{JSxRef("Object.prototype.toLocaleString()")}}<br>
-  </dd>
- <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt>
- <dd>Retorna uma string respresentando o objeto específicado em um base específica. Sobrescreve o método {{JSxRef("Object.prototype.toString()")}} .</dd>
- <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt>
- <dd>Retorna o valor primitivo de um objeto específicado. Sobrescreve o método {{JSxRef("Object.prototype.valueOf()")}}.</dd>
-</dl>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificações</th>
-   <th scope="col">Estado</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-bigint.prototype', 'BigInt.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("javascript.builtins.BigInt.prototype")}}</p>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/clear/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/clear/index.html
deleted file mode 100644
index 393ee10017..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/clear/index.html
+++ /dev/null
@@ -1,120 +0,0 @@
----
-title: Map.prototype.clear()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/clear
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Mapa
-  - Prototipo
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/clear
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>clear()</strong></code> remove todos os elementos de um objeto <code>Map</code>.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>meuMapa</em>.clear();</code></pre>
-
-<h3 id="Valor_retornado">Valor retornado</h3>
-
-<p>{{jsxref("undefined")}}.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_o_método_clear">Usando o método <code>clear</code></h3>
-
-<pre class="brush: js">var meuMapa = new Map();
-meuMapa.set('bar', 'baz');
-meuMapa.set(1, 'foo');
-
-meuMapa.size;       // 2
-meuMapa.has('bar'); // true
-
-meuMapa.clear();
-
-meuMapa.size;       // 0
-meuMapa.has('bar')  // false
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>38</td>
-   <td>{{CompatGeckoDesktop("19.0")}}</td>
-   <td>11</td>
-   <td>25</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>38</td>
-   <td>{{CompatGeckoMobile("19.0")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/delete/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/delete/index.html
deleted file mode 100644
index 41631bb2cc..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/delete/index.html
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: Map.prototype.delete()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/delete
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Mapa
-  - Prototipo
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/delete
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>delete()</strong></code> remove o elemento especificado de um objeto <code>Map</code>.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="brush: js">meuMapa.delete(chave);</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt>key</dt>
- <dd>Obrigatório. A chave do elemento a ser removido do objeto <code>Map</code>.</dd>
-</dl>
-
-<h3 id="Valor_retornado">Valor retornado</h3>
-
-<p>Retorna <code>true</code> se um elemento existia no objeto <code>Map</code> e foi removido, ou <code>false</code> se o elemento não existia.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_o_método_delete">Usando o método <code>delete</code></h3>
-
-<pre class="brush: js">var meuMapa = new Map();
-meuMapa.set('bar', 'foo');
-
-meuMapa.delete('bar'); // Retorna true. Removido com sucesso.
-meuMapa.has('bar');    // Retorna false. O elemento com valor "bar" já não existe mais no mapa.
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>38</td>
-   <td>{{CompatGeckoDesktop("13.0")}}</td>
-   <td>11</td>
-   <td>25</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>38</td>
-   <td>{{CompatGeckoMobile("13.0")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/entries/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/entries/index.html
deleted file mode 100644
index 8ca232d906..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/entries/index.html
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: Map.prototype.entries()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/entries
-tags:
-  - ECMAScript 2015
-  - Iterador
-  - JavaScript
-  - Mapa
-  - Prototipo
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/entries
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>entries()</strong></code> retorna um novo objeto <strong><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterador</a></strong> que contém os pares <code>[chave, valor]</code> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>meuMapa</em>.entries()</code></pre>
-
-<h3 id="Retorna_o_valor">Retorna o valor</h3>
-
-<p>Um novo objeto iterador de {{jsxref("Map")}}.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_entries()">Usando <code>entries()</code></h3>
-
-<pre class="brush:js">var meuMap = new Map();
-meuMap.set('0', 'foo');
-meuMap.set(1, 'bar');
-meuMap.set({}, 'baz');
-
-var mapIter = myMap.entries();
-
-console.log(mapIter.next().value); // ["0", "foo"]
-console.log(mapIter.next().value); // [1, "bar"]
-console.log(mapIter.next().value); // [Object, "baz"]
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>38</td>
-   <td>{{ CompatGeckoDesktop("20") }}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>38</td>
-   <td>{{CompatGeckoMobile("20")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map.prototype.keys()")}}</li>
- <li>{{jsxref("Map.prototype.values()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/foreach/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/foreach/index.html
deleted file mode 100644
index c0387a1e74..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/foreach/index.html
+++ /dev/null
@@ -1,147 +0,0 @@
----
-title: Map.prototype.forEach()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/forEach
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Mapa
-  - Prototipo
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/forEach
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>forEach()</strong></code> executa uma função fornecida uma vez para cada par de chave/valor no objeto <code>Map</code>, pela ordem de inserção.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>meuMapa</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>callback</code></dt>
- <dd>Função a ser executada para cada elemento.</dd>
- <dt><code>thisArg</code></dt>
- <dd>Valor a utilizar como o <code>this</code> quando estiver executando o <code>callback</code>.</dd>
-</dl>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>{{jsxref("undefined")}}.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O método <code>forEach</code> executa o <code>callback</code> fornecido uma vez para cada chave existente no mapa. Ele não é invocado para as chaves que foram removidas. No entanto, ele é executado para ítens que estão presentes mesmo com o valor <code>undefined</code>.</p>
-
-<p><code>callback</code> é invocado com <strong>três argumentos</strong>:</p>
-
-<ul>
- <li>o <strong>valor do elemento</strong></li>
- <li>a <strong>chave do elemento</strong></li>
- <li>o <strong><code>Objeto Map</code> que está sendo atravessado</strong></li>
-</ul>
-
-<p>Se um parâmetro <code>thisArg</code> for fornecido ao <code>forEach</code>, ele será passado ao <code>callback</code> quando invocado, e será utilizado como o valor de seu <code>this</code>.  De outra forma, o valor <code>undefined</code> será passado como o valor de seu <code>this</code>.  O valor <code>this</code> observável em última instância por callback é determinado de acordo com <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">as regras comuns para determinar o <code>this</code> sendo visto por uma função</a>.</p>
-
-<p>Cada valor é visitado uma vez, exceto para o caso em que ele foi removido e re-adicionado antes do <code>forEach</code> ter acabado de ser executado. o <code>callback</code> não é invocado para valores removidos antes de serem visitados. Novos valores adicionados antes do <code>forEach</code> ter acabado serão visitados.</p>
-
-<p><code>forEach</code> executa a função de <code>callback</code> uma vez para cada elemento no objeto <code>Map</code>; ele não retorna um valor.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Imprimindo_o_conteúdo_de_um_objeto_Map">Imprimindo o conteúdo de um objeto <code>Map</code></h3>
-
-<p>O código a seguir registra uma linha de log para cada elemento no objeto <code>Map</code>:</p>
-
-<pre class="brush:js">function registrarElementosDoMapa(valor, chave, mapa) {
-    console.log(`m[${chave}] = ${valor}`);
-}
-new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(registrarElementosDoMapa);
-// logs:
-// "m[foo] = 3"
-// "m[bar] = [object Object]"
-// "m[baz] = undefined"
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>38</td>
-   <td>{{CompatGeckoDesktop("25.0")}}</td>
-   <td>11</td>
-   <td>25</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>38</td>
-   <td>{{CompatGeckoMobile("25.0")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Set.prototype.forEach()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/get/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/get/index.html
deleted file mode 100644
index 9c8b66e302..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/get/index.html
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: Map.prototype.get()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/get
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Map
-  - Prototype
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/get
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/get
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>get()</strong></code> retorna um elemento específico de um objeto de <code>Map</code>.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>myMap</em>.get(chave);</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt>chave</dt>
- <dd>Obrigatório. A chave do elemento para retornar do objeto de <code>Map</code>.</dd>
-</dl>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>Retorna o elemento associado com a chave específica ou <code>undefined</code> se a chave não puder ser encontrada no objeto de <code>Map</code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_o_métodoget">Usando o método<code>get</code></h3>
-
-<pre class="brush: js">var myMap = new Map();
-myMap.set('bar', 'foo');
-
-myMap.get('bar');  // Retorna "foo".
-myMap.get('baz');  // Retorna undefined.
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("javascript.builtins.Map.get")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Map.prototype.set()")}}</li>
- <li>{{jsxref("Map.prototype.has()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/has/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/has/index.html
deleted file mode 100644
index c929b131d7..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/has/index.html
+++ /dev/null
@@ -1,77 +0,0 @@
----
-title: Map.prototype.has()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/has
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/has
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/has
----
-<div>{{JSRef}}</div>
-
-<p>O método <strong><code>has()</code></strong> retorna um valor booleano indicando quando um elemento com a chave especificada existe ou não</p>
-
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div>
-
-
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>myMap</em>.has(key);</code></pre>
-
-<h3 id="Parametros">Parametros</h3>
-
-<dl>
- <dt>key</dt>
- <dd>Necessário. A chave para verificar a presença do elemento no objeto <code>Map</code>.</dd>
-</dl>
-
-<h3 id="Valor_retornado">Valor retornado</h3>
-
-<dl>
- <dt>Booleano</dt>
- <dd>Retorna <code>true</code> se um elemento com a chave especificada existe no objeto <code>Map</code>; caso contrário: <code>false</code>.</dd>
-</dl>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_o_método_has">Usando o método <code>has</code></h3>
-
-<pre class="brush: js">var myMap = new Map();
-myMap.set('bar', "foo");
-
-myMap.has('bar');  // retorna true
-myMap.has('foo'); // retorna false
-myMap.has('barz');  // retorna false
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{Compat("javascript.builtins.Map.has")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Map.prototype.set()")}}</li>
- <li>{{jsxref("Map.prototype.get()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/index.html
deleted file mode 100644
index cf8c3bfab2..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/index.html
+++ /dev/null
@@ -1,226 +0,0 @@
----
-title: Map
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Map
-  - Mapa
-translation_of: Web/JavaScript/Reference/Global_Objects/Map
-original_slug: Web/JavaScript/Reference/Global_Objects/Map
----
-<div>{{JSRef}}</div>
-
-<p>O objeto <strong><code>Map</code></strong> é um mapa simples de chave/valor. Qualquer valor (objeto e {{Glossary("Primitive", "valores primitivos")}}) pode ser usado como uma chave ou um valor.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox notranslate"><code>new Map([iterable])
-</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>iterable</code></dt>
- <dd>
- <p><code>Iterable</code> é um Array ou outro objeto iterável cujos elementos são pares de chave-valor (2-element Arrays). Cada par de chave-valor é adicionado ao novo Map. <code>null</code> é tratado como <code>undefined</code>.</p>
- </dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Um objeto Map itera seus elementos em ordem de inserção — um loop {{jsxref("Statements/for...of", "for...of")}} retorna um array de <code>[chave, valor]</code> para cada iteração.</p>
-
-<p>Deve-se notar que um Map que é um mapa de um objeto, especialmente, um dicionário de dicionários somente irá mapear apenas para a ordem de inserção -- que é aleatória e não ordenada.</p>
-
-<h3 id="Igualidade_de_valores">Igualidade de valores</h3>
-
-<p>A igualdade das chaves é baseada no algoritmo "SameValueZero" (mesmo valor): <code>NaN</code> é considerado igual à <code>NaN</code> (mesmo que <code>NaN !== NaN</code>) e todos os outros valores são considerados iguals de acordo com a semantica do operador ===. Em versões anteriores do rascunho ECMAScript 2015 draft <code>-0</code> and <code>+0</code> eram considerados diferentes (mesmo que <code>-0 === +0</code>), isto foi trocado em versões posteriores e foi aplicado no Gecko 29 {{geckoRelease("29")}} ({{bug("952870")}}) e em uma<a href="https://code.google.com/p/v8/issues/detail?id=3069"> build recente nightly do Chrome</a>.</p>
-
-<h3 id="Objetos_e_mapas_comparados">Objetos e mapas comparados</h3>
-
-<p>{{jsxref("Object", "Objects")}} são similares a Maps onde ambos deixam adicionar chaves para valores, recuperar estes valores, apagar chaves, e detectar quando algo foi adicionado em uma chave. Por causa disso (e porque não existem alternativas pré-construidas), <code>Objects</code> historicamente foram usados como <code>Maps</code>; no entanto, existem diferenças importantes entre <code>Objects</code> e <code>Maps</code> que fazem o uso do Map melhor:</p>
-
-<ul>
- <li>Um <code>Object</code> tem um prototype, então existem chaves padrão no mapa. Isto pode ser evitado usando um Map<code> = Object.create(null)</code> desde ES5, mas raramente é feito.</li>
- <li>As chaves de um <code>Object</code> são {{jsxref("String", "Strings")}} e {{jsxref("Symbol", "Symbols")}}, porém elas podem ser qualquer valor em um <code>Map</code>.</li>
- <li>Você pode obter o tamanho de um  <code>Map</code> facilmente enquanto em um <code>Object </code>é necessário ter este controle manualmente.</li>
-</ul>
-
-<p>Isto não significa que você deve usar <code>Map</code>s em todo lugar, objetos ainda serão usados na maioria dos casos. Instancias de <code>Map</code> são úteis somente para coleções, e você deve considerar adaptar seu codigo onde você usou objetos para isto anteriormente. Objects devem ser usados como registros, com campos e métodos.<br>
- Se você não tem certeza qual usar, pergunte-se as seguintes questões:</p>
-
-<ul>
- <li>As keys são desconhecidas até o tempo de execução, você precisa procurá-las dinamicamente?</li>
- <li>Todos os valores sempre serão do mesmo tipo, e podem ser usados de forma intercambiável?</li>
- <li>Você precisa de keys que não são strings?</li>
- <li>Os pares key-value são adicionados ou removidos frequentemente?</li>
- <li>Você tem uma quantidade de pares key-value arbitrária (de troca fácil) ?</li>
- <li>A coleção é iterada?</li>
-</ul>
-
-<p>Se você respondeu "sim" em qualquer uma dessas questões, é um sinal de que você quer utilizar um  <code>Map</code>. Se ao invés disto você tem um numero fixo de keys, trabalhe eles individualmente, e faça diferenciação entre o uso deles, você quer um objeto.</p>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt><code>Map.length</code></dt>
- <dd>O tamanho do mapa é 0.</dd>
- <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt>
- <dd>A função construtora que é usada para criar objetos derivados.</dd>
- <dt>{{jsxref("Map.prototype")}}</dt>
- <dd>Representa o prototype para o construtor de <code>Map</code>. Permite a adição de propriedades para todos os objetos <code>Map</code>.</dd>
-</dl>
-
-<h2 id="Instâncias_de_Map">Instâncias de <code>Map</code></h2>
-
-<p>Todas as instancias de <code>Map</code> herdam de {{jsxref("Map.prototype")}}.</p>
-
-<h3 id="Propriedades_2">Propriedades</h3>
-
-<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Map/prototype','Properties')}}</p>
-
-<h3 id="Métodos">Métodos</h3>
-
-<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Map/prototype','Methods')}}</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_o_objeto_Map">Usando o objeto <code>Map</code></h3>
-
-<pre class="brush: js notranslate">var myMap = new Map();
-
-var keyString = "uma string",
-    keyObj = {},
-    keyFunc = function () {};
-
-// configurando os valores
-myMap.set(keyString, "valor associado com 'uma string'");
-myMap.set(keyObj, "valor associado com keyObj");
-myMap.set(keyFunc, "valor associado com keyFunc");
-
-myMap.size; // 3
-
-// obtendo os valores
-myMap.get(keyString);    // "valor associado com 'uma string'"
-myMap.get(keyObj);       // "valor associado com keyObj"
-myMap.get(keyFunc);      // "valor associado com keyFunc"
-
-myMap.get("uma string"); // "valor associado com 'uma string'"
-                         // pois keyString === 'uma string'
-myMap.get({});           // undefined, pois keyObj !== {}
-myMap.get(function() {}) // undefined, pois keyFunc !== function () {}
-</pre>
-
-<h3 id="Usando_NaN_como_Map_keys">Usando <code>NaN</code> como <code>Map</code> keys</h3>
-
-<p><code>NaN</code> pode também ser usado como key. Mesmo que <code>NaN</code> não seja igual a ele mesmo (<code>NaN !== NaN</code>)  é true, o seguinte exemplo funciona, porquê <code>NaN</code>s são indistinguíveis uma para o outro:</p>
-
-<pre class="brush: js notranslate">var myMap = new Map();
-myMap.set(NaN, "not a number");
-
-myMap.get(NaN); // "not a number"
-
-var otherNaN = Number("foo");
-myMap.get(otherNaN); // "not a number"
-</pre>
-
-<h3 id="Iterando_Maps_com_for..of">Iterando <code>Maps</code> com <code>for..of</code></h3>
-
-<p>Maps podem ser iterados usando um <code>for..of</code> :</p>
-
-<pre class="brush: js notranslate">var myMap = new Map();
-myMap.set(0, "zero");
-myMap.set(1, "um");
-for (var [key, value] of myMap) {
-  console.log(key + " = " + value);
-}
-// 0 = zero
-// 1 = um
-
-for (var key of myMap.keys()) {
-  console.log(key);
-}
-// 0
-// 1
-
-for (var value of myMap.values()) {
-  console.log(value);
-}
-// zero
-// um
-
-for (var [key, value] of myMap.entries()) {
-  console.log(key + " = " + value);
-}
-// 0 = zero
-// 1 = um
-</pre>
-
-<h3 id="Iterando_Maps_com_forEach">Iterando <code>Maps</code> com <code>forEach()</code></h3>
-
-<p>Maps podem ser iterados usando um <code>forEach()</code>:</p>
-
-<pre class="brush: js notranslate">myMap.forEach(function(value, key) {
-  console.log(key + " = " + value);
-}, myMap)
-// Mostrará 2 logs; o primeiro com "0 = zero" e o segundo com "1 = um"
-</pre>
-
-<h3 id="Relação_com_objetos_Array">Relação com objetos <code>Array</code></h3>
-
-<pre class="brush: js notranslate">var kvArray = [["key1", "value1"], ["key2", "value2"]];
-
-// Utiliza o construtor padrão de Map para converter um Array de 2 dimensões de chave-valor Array em um mapa
-var myMap = new Map(kvArray);
-
-myMap.get("key1"); // retorna "value1"
-
-// Utiliza Array.from para converter um mapa em um Array de 2 dimensões de chave-valor
-console.log(Array.from(myMap)) // Mostrará exatamente o mesmo Array que kvArray
-
-// Uma forma mais sucinta de realizar a mesma conversão com o operador spread
-console.log([...myMap]);
-
-// Ou usa o operador spread nas chaves ou valores para o iterador pegar
-// um array com somente as chaves ou valores
-console.log([...myMap.keys()]); // Mostrará ["key1", "key2"]
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-map-objects', 'Map')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<p>{{Compat("javascript.builtins.Map")}}</p>
-
-<p>[1] Começando com Chrome 31, a feature ficou disponível sob modificação de configurações. Em <code>chrome://flags</code>, ative a entrada activate “Enable Experimental JavaScript”.</p>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Map and Set bug at Mozilla</a></li>
- <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">ECMAScript Harmony proposal</a></li>
- <li>{{jsxref("Set")}}</li>
- <li>{{jsxref("WeakMap")}}</li>
- <li>{{jsxref("WeakSet")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/keys/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/keys/index.html
deleted file mode 100644
index 1a68389071..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/keys/index.html
+++ /dev/null
@@ -1,116 +0,0 @@
----
-title: Map.prototype.keys()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/keys
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/keys
----
-<div>{{JSRef}}</div>
-
-<div>O método <code><strong>keys()</strong></code> retorna um novo objeto do tipo <code><strong>Iterator</strong></code> que contem uma chave para cada elemento dentro do objeto <code>Map </code>na ordem que foram inseridos.</div>
-
-<p> </p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre>
-
-<h3 id="Tipo_de_Retorno">Tipo de Retorno</h3>
-
-<p>Um novo objeto {{jsxref("Map")}}.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_keys()">Usando <code>keys()</code></h3>
-
-<pre class="brush:js">var myMap = new Map();
-myMap.set("0", "foo");
-myMap.set(1, "bar");
-myMap.set({}, "baz");
-
-var mapIter = myMap.keys();
-
-console.log(mapIter.next().value); // "0"
-console.log(mapIter.next().value); // 1
-console.log(mapIter.next().value); // Object
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>38</td>
-   <td>{{CompatGeckoDesktop("20")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>38</td>
-   <td>{{CompatGeckoMobile("20") }}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map.prototype.entries()")}}</li>
- <li>{{jsxref("Map.prototype.values()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/set/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/set/index.html
deleted file mode 100644
index e381342aba..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/set/index.html
+++ /dev/null
@@ -1,138 +0,0 @@
----
-title: Map.prototype.set()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/set
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Map
-  - Prototype
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/set
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/set
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>set()</strong></code> adiciona ou atualiza um elemento com uma <code>chave</code> e <code>valor</code> específicos a um objeto de <code>Map.</code></p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>myMap</em>.set(chave, valor);</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt>chave</dt>
- <dd>Obrigatório. A chave do elemento para adicionar ao objeto de <code>Map</code>.</dd>
- <dt>valor</dt>
- <dd>Obrigatório. O valor do elemento para adicionar ao objeto de <code>Map</code>.</dd>
-</dl>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>O objeto de <code>Map</code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_o_método_set">Usando o método <code>set</code> </h3>
-
-<pre class="brush: js">var myMap = new Map();
-
-// adiciona novos elementos ao map
-myMap.set('bar', 'foo');
-myMap.set(1, 'foobar');
-
-// Atualiza um elemento no map
-myMap.set('bar', 'baz');
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.set', 'Map.prototype.set')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td><span class="hidden"> </span>Definição    inicial.</td>
-  </tr>
-  <tr>
-   <td><span class="hidden"> </span>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Edge</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>38</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoDesktop("13.0")}}</td>
-   <td>11</td>
-   <td>25</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Edge</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>38</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoMobile("13.0")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Notas_sobre_compatibilidade">Notas sobre compatibilidade</h2>
-
-<ul>
- <li>Antes do Firefox 33 {{geckoRelease("33")}}, <code>Map.prototype.set</code> retornava <code>undefined</code> e não era encadeável. Isso foi corrigido ({{bug(1031632)}}). O comportamento também pode ser encontrado no Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">issue</a>) e IE11.</li>
-</ul>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
- <li>{{jsxref("Map.prototype.get()")}}</li>
- <li>{{jsxref("Map.prototype.has()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/size/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/size/index.html
deleted file mode 100644
index f174ba9976..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/size/index.html
+++ /dev/null
@@ -1,111 +0,0 @@
----
-title: Map.prototype.size
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/size
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/size
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/size
----
-<div>{{JSRef}}</div>
-
-<p>A propriedade de acesso <code><strong>size</strong></code> retorna o número de elementos em um objeto {{jsxref("Map")}}.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O valor de <code>size</code> é um integer representando quantas entradas o objeto <code>Map</code> tem. Uma function set de acesso ao size é <code>undefined</code>; você não pode trocar esta propriedade.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_size">Usando <code>size</code></h3>
-
-<pre class="brush:js">var myMap = new Map();
-myMap.set("a", "alpha");
-myMap.set("b", "beta");
-myMap.set("g", "gamma");
-
-myMap.size // 3
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Definição Inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>38</td>
-   <td>{{ CompatGeckoDesktop("19") }}</td>
-   <td>{{ CompatIE("11") }}</td>
-   <td>25</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>38</td>
-   <td>{{CompatGeckoMobile("19")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Gecko_-_Notas_específicas">Gecko - Notas específicas</h2>
-
-<ul>
- <li>Do Gecko 13 {{geckoRelease("13")}} ao Gecko 18 {{geckoRelease("18")}} a propriedade size foi implementada como um metodo <strong><code>Map.prototype.size()</code></strong>, isto foi trocado para uma propriedade em versões posteriores conforme a especificação ECMAScript 6 ({{bug("807001")}}).</li>
-</ul>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Map")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/values/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/map/values/index.html
deleted file mode 100644
index 67c68e2437..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/global_objects/map/values/index.html
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: Map.prototype.values()
-slug: orphaned/Web/JavaScript/Reference/Global_Objects/Map/values
-tags:
-  - Iterador
-  - Mapa
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Map/values
-original_slug: Web/JavaScript/Reference/Global_Objects/Map/values
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>values()</strong></code> retorna um novo objeto <strong><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong> que contém os valores de cada elemento do objeto <code>Map</code> em ordem de inserção.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div>
-
-
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><em>meuMap</em>.values()</code></pre>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>Um novo objeto iterador do {{jsxref("Map")}}.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_o_values()">Usando o <code>values()</code></h3>
-
-<pre class="brush:js">var meuMap = new Map();
-meuMap.set('0', 'foo');
-meuMap.set(1, 'bar');
-meuMap.set({}, 'baz');
-
-var mapIter = myMap.values();
-
-console.log(mapIter.next().value); // "foo"
-console.log(mapIter.next().value); // "bar"
-console.log(mapIter.next().value); // "baz"</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-map.prototype.values', 'Map.prototype.values')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-
-
-<p>{{Compat("javascript.builtins.Map.values")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Map.prototype.entries()")}}</li>
- <li>{{jsxref("Map.prototype.keys()")}}</li>
-</ul>
diff --git a/files/pt-br/orphaned/web/javascript/reference/operators/pipeline_operator/index.html b/files/pt-br/orphaned/web/javascript/reference/operators/pipeline_operator/index.html
deleted file mode 100644
index 84ea16c7bc..0000000000
--- a/files/pt-br/orphaned/web/javascript/reference/operators/pipeline_operator/index.html
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: Operador Pipeline
-slug: orphaned/Web/JavaScript/Reference/Operators/Pipeline_operator
-translation_of: Web/JavaScript/Reference/Operators/Pipeline_operator
-original_slug: Web/JavaScript/Reference/Operators/Pipeline_operator
----
-<div>{{jsSidebar("Operators")}} {{SeeCompatTable}}</div>
-
-<p>O operador experimental pipeline <code>|&gt;</code> (atualmente no estágio 1) permite a criação de chamadas de funções encadeadas de maneira legível. Basicamente, o operador de pipeline fornece açúcar sintático em uma chamada de função com um único argumento, permitindo que você escreva</p>
-
-<p><code>'%21' |&gt; decodeURI</code> ao invés de <code>decodeURI('%21')</code>.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">expressão |&gt; função</pre>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Chamadas_de_funções_encadeadas">Chamadas de funções encadeadas</h3>
-
-<p> </p>
-
-<p>O operador de pipeline pode melhorar a legibilidade ao encadear várias funções.</p>
-
-<pre class="brush: js">const double = (n) =&gt; n * 2;
-const increment = (n) =&gt; n + 1;
-
-// sem o perador pipeline
-double(increment(double(double(5)))); // 42
-
-// com o operador pipeline
-5 |&gt; double |&gt; double |&gt; increment |&gt; double; // 42
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><a href="https://tc39.github.io/proposal-pipeline-operator/#sec-intro">Pipeline operator draft</a></td>
-   <td>Estágio 1</td>
-   <td>Não faz parte da especificação ECMAScript ainda.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.operators.pipeline")}}</p>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li><a href="https://github.com/tc39/proposals">TC39 proposals</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/reference/api/index.html b/files/pt-br/orphaned/web/reference/api/index.html
deleted file mode 100644
index c776c696d5..0000000000
--- a/files/pt-br/orphaned/web/reference/api/index.html
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: Referências API Web
-slug: orphaned/Web/Reference/API
-translation_of: Web/Reference/API
-original_slug: Web/Reference/API
----
-<p>A internet oferece uma vasta gama de APIs para facilitar a execução de várias tarefas úteis. Elas podem ser usadas através de códigos JavaScript e permitem que você execute pequenos ajustes no elemento {{domxref("window")}} ou {{domxref("element")}} até gerar efeitos de vídeo e áudio usando APIs como <a href="/pt-BR/docs/Web/API/WebGL_API">WebGL</a> e <a href="/pt-BR/docs/Web/API/API_Web_Audio">Web Audio</a>.</p>
-
-<p>Todas as interfaces disponíveis pelas APIs estão listadas individualmente na página <a href="/pt-BR/docs/Web/API">de início.</a></p>
-
-<p><br>
- Existe também uma lista de com todos os eventos disponíveis na <a href="/en-US/docs/Web/Events">Referencia de Eventos</a>.</p>
-
-<div class="cleared topicpage-table">
-<div class="section">
-<dl>
- <dt><a href="/pt-br/docs/DOM">Document Object Model</a></dt>
- <dd><span id="result_box" lang="pt"><span class="hps">O DOM é</span> <span class="hps">uma API que permite</span> <span class="hps">acessar e modificar o documento atual. Permite a manipulação dos elementos </span></span>{{domxref("Node")}} e {{domxref("Element")}}<span lang="pt"><span class="hps"> do documento</span></span>. HTML, XML e SVG estenderam o DOM para manipular<span class="st"> </span>seus elementos específicos.</dd>
- <dt> </dt>
- <dt>APIs para dispositivos</dt>
- <dd><span id="result_box" lang="pt"><span class="hps">Estas </span><span class="hps">APIs</span> <span class="hps">permitem o acesso a</span> <span class="hps">vários recursos</span> <span class="hps">de hardware disponíveis</span> <span class="hps">para páginas</span> <span class="hps">Web e aplicações</span></span>, como por exemplo <a href="/pt-br/docs/WebAPI/Using_Light_Events">Ambient Light Sensor API</a>, <a href="/pt-BR/docs/WebAPI/Battery_Status" title="WebAPI/Battery_Status">Battery Status API</a>, <a href="/pt-BR/docs/Using_geolocation" title="Using_geolocation">Geolocation API</a>, <a href="/pt-br/docs/WebAPI/Pointer_Lock" title="API/Pointer_Lock_API">Pointer Lock API</a>, <a href="/pt-br/docs/WebAPI/Proximity" title="WebAPI/Proximity">Proximity API</a>, <a href="/pt-br/docs/WebAPI/Detecting_device_orientation" title="WebAPI/Detecting_device_orientation">Device Orientation API</a>, <a href="/pt-br/docs/WebAPI/Managing_screen_orientation" title="WebAPI/Detecting_device_orientation">Screen Orientation API</a> e <a href="/pt-br/docs/WebAPI/Vibration" title="WebAPI/WebBluetooth">Vibration API</a>.</dd>
- <dt>APIs de comunicação</dt>
- <dd>Estas APIs permitem a comunicação da página ou aplicativo web com outras páginas e dispositivos, como por exemplo <a href="/pt-BR/docs/WebAPI/Network_Information" title="WebAPI/Network_Information">Network Information API</a>, <a href="/en-US/docs/WebAPI/Using_Web_Notifications" title="/en-US/docs/WebAPI/Using_Web_Notifications">Web Notifications</a> e <a href="/en-US/docs/WebAPI/Simple_Push" title="WebAPI/Push_Notifications">Simple Push API</a>.</dd>
- <dt id="Data_management_APIs">APIs de gestão de dados</dt>
- <dd>Os dados de usuários podem ser manipulados e usados usando estas APIs, como por exemplo <a href="/en-US/docs/WebAPI/FileHandle_API" title="WebAPI/FileHandle_API">FileHandle API</a> e <a href="/pt-BR/docs/IndexedDB" title="IndexedDB">IndexedDB</a>.</dd>
-</dl>
-
-<p>Além das APIs citadas, que podem ser usadas para qualquer site ou aplicativo, um conjunto de APIs muito poderosas da Mozilla estão disponíveis para APIs privilegiadas e certificadas.</p>
-
-<dl>
- <dt>APIs Privilegiadas</dt>
- <dd>A aplicação privilegiada é um aplicativo instalado que tem seus direitos específicados pelo usuário. As APIs privilegiadas incluem <a href="/pt-BR/docs/WebAPI/TCP_Socket" title="WebAPI/TCP_Socket">TCP Socket API</a>, <a href="/en-US/docs/WebAPI/Contacts" title="WebAPI/Contacts">Contacts API</a>, <a href="/pt-BR/docs/WebAPI/Device_Storage" title="WebAPI/Device_Storage_API">Device Storage API</a>, <a href="/en-US/docs/DOM/Using_the_Browser_API" title="DOM/Using_the_Browser_API">Browser API</a> e <a href="/en-US/docs/WebAPI/Camera" title="WebAPI/Camera">Camera API</a>.</dd>
- <dt>APIs Certificadas</dt>
- <dd>A aplicação certificada é uma aplicação de baixo nível para realizar operações críticas e vitais em um sistema operacional como o Firefox OS, permitindo a interação de aplicações menos privilegiadas com as certificadas utilizando <a href="/pt-BR/docs/WebAPI/Web_Activities">Web Activities</a>. As APIs Certificadas incluem<a href="/en-US/docs/WebAPI/WebBluetooth" title="WebAPI/WebBluetooth"> Bluetooth API</a>, <a href="/pt-BR/docs/WebAPI/Mobile_Connection" title="WebAPI/Mobile_Connection">Mobile Connection API</a>, <a href="/pt-BR/docs/WebAPI/Network_Stats" title="WebAPI/Network_Stats">Network Stats API</a>, <a href="/pt-BR/docs/Web/Guide/API/Telephony" title="WebAPI/WebTelephony">Telephony</a>, <a href="/pt-BR/docs/WebAPI/WebSMS" title="WebAPI/WebSMS">WebSMS</a>, <a href="/en-US/docs/WebAPI/WiFi_Information" title="WebAPI/WiFi_Information">WiFi Information API</a>, <a href="/en-US/docs/WebAPI/Power_Management" title="WebAPI/Power_Management">Power Management API</a>, <a href="/en-US/docs/WebAPI/Settings" title="WebAPI/Settings">Settings API</a>, <a href="/pt-BR/docs/WebAPI/Idle" title="WebAPI/Device_Storage_API">Idle API</a>, <a href="/en-US/docs/WebAPI/Permissions" title="WebAPI/Permissions">Permissions API</a> e <a href="/en-US/docs/WebAPI/Time_and_Clock" title="WebAPI/Time_and_Clock">Time/Clock API</a>.</dd>
-</dl>
-</div>
-
-<div class="section">
-<h2 class="Community" id="Comunidade">Comunidade</h2>
-
-<p>Entre na comunidade Web API em nossas discussões ou grupos:</p>
-
-<ul>
- <li><a class="external" href="https://lists.mozilla.org/listinfo/dev-webapi">Listas de discussões</a></li>
- <li><a href="news://news.mozilla.org/mozilla.dev.webapi">Grupo de novidades</a></li>
- <li><a class="external" href="http://groups.google.com/group/mozilla.dev.webapi">Grupo da Google</a></li>
- <li><a class="external" href="http://groups.google.com/group/mozilla.dev.webapi/feeds">Web feed</a></li>
-</ul>
-
-<p>Alem disso você pode participar de discussões ao vivo no canal <a href="irc://irc.mozilla.org/webapi">#webapi</a> no <a class="external" href="https://wiki.mozilla.org/IRC">IRC</a>.</p>
-
-<h2 class="Related_Topics" id="Tópicos_relacionados">Tópicos relacionados</h2>
-
-<p>Estes tópicos podem ser interessantes para você:</p>
-
-<ul>
- <li><a href="/pt-BR/docs/Web/API">Referência da API Web</a></li>
-</ul>
-</div>
-</div>
-
-<p> </p>
diff --git a/files/pt-br/orphaned/web/reference/index.html b/files/pt-br/orphaned/web/reference/index.html
deleted file mode 100644
index 1206eceb45..0000000000
--- a/files/pt-br/orphaned/web/reference/index.html
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Referências de tecnologias Web
-slug: orphaned/Web/Reference
-tags:
-  - Landing
-  - Referências
-  - Tecnologias
-  - Web
-translation_of: Web/Reference
-original_slug: Web/Reference
----
-<p><span class="seoSummary">A web aberta é baseada em várias tecnologias que, juntas, podem ser usadas para criar tudo, desde sites simples até poderosas aplicações web. Abaixo, você encontrará uma seleção de links das principais documentações de cada um.</span></p>
-
-<div id="Web_technologies">
-<p>Se você é novo no desenvolvimento web, considere <a href="/pt-BR/docs/Aprender/Getting_started_with_the_web">começar pela nossa área de aprendizado</a>, que é recheada com tutoriais, passo a passo, que vai te guiar de um total iniciante no desenvolvimento web a pelo menos um semi-profissional!</p>
-
-<dl>
- <dt><a href="/pt-BR/docs/Glossario/HTML">HTML</a> — Estruturando a web</dt>
- <dd>A <strong>Linguagem de Marcação de Hipertexto</strong> (em inglês: <em><span lang="en">HyperText Markup Language</span></em>) é usada para definir e descrever semanticamente o conteúdo (<a href="/pt-BR/docs/Glossario/marcação">marcação</a>) de uma página web em um formato estruturado. O HTML fornece um meio de criar documentos compostos por blocos chamados de <a href="/pt-BR/docs/Web/HTML/Element">elementos HTML</a> que são marcados por <em><a href="/pt-BR/docs/Glossario/Tag">tags</a></em>, usando parênteses angulares <code>&lt; &gt;</code>. Alguns introduzem o conteúdo diretamente na página, outros fornecem informações sobre o texto do documento e podem incluir outras tags como subelementos. Obviamente, os navegadores não os exibem, pois são usados para interpretar o conteúdo da página.<br>
- <br>
- <a href="/pt-BR/docs/Aprender/HTML/Introducao_ao_HTML">Introdução ao HTML</a> | <a href="/pt-BR/docs/Aprender/HTML">Aprenda HTML</a> | <a href="/pt-BR/docs/Web/HTML/HTML5">HTML5</a> | <a href="/pt-BR/docs/Aprender/HTML">Guia para desenvolvedores</a> | <a href="/pt-BR/docs/Web/HTML/Element">Referência de elementos</a> | <a href="/pt-BR/docs/Web/HTML/ReferenciaHTML">Referência</a></dd>
- <dt><a href="/pt-BR/docs/Glossario/CSS">CSS</a> — Estilizando a web</dt>
- <dd>As <strong>Folhas de Estilo em Cascata</strong> (em inglês: <em><span lang="en">Cascading Style Sheets</span></em>) são usadas para descrever a aparência dos conteúdos web<br>
- <br>
- <a href="/pt-BR/docs/Learn/CSS/First_steps">Introdução ao CSS</a> | <a href="/pt-BR/docs/Learn/CSS/First_steps">Começando com o CSS</a> | <a href="/pt-BR/docs/Aprender/CSS">Aprenda CSS</a> | <a href="/pt-BR/docs/Learn/CSS/Howto/CSS_Perguntas_Frequentes">Questões comuns sobre o CSS</a> | <a href="/pt-BR/docs/Web/CSS/CSS_Reference">Referência</a></dd>
- <dt><a href="/pt-BR/docs/Glossario/JavaScript">JavaScript</a> — <span lang="en">Scripts</span> dinâmicos no lado do cliente</dt>
- <dd>O <strong>JavaScript</strong> é uma linguagem de programação usada para adicionar interatividade e outros recursos dinâmicos nos sites.</dd>
- <dd><a href="/pt-BR/docs/Aprender/JavaScript">Aprenda JavaScript</a> | <a href="/pt-BR/docs/Web/JavaScript/Guide">Guia para desenvolvedores</a> | <a href="/pt-BR/docs/Web/JavaScript/Reference">Referência</a></dd>
-</dl>
-</div>
diff --git a/files/pt-br/orphaned/web/security/information_security_basics/index.html b/files/pt-br/orphaned/web/security/information_security_basics/index.html
deleted file mode 100644
index 99607e0201..0000000000
--- a/files/pt-br/orphaned/web/security/information_security_basics/index.html
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Básico de Segurança da Informação
-slug: orphaned/Web/Security/Information_Security_Basics
-tags:
-  - Iniciante
-  - Segurança
-translation_of: Web/Security/Information_Security_Basics
-original_slug: Web/Security/Básico_de_Segurança_da_Informação
----
-<p>Entender o básico de segurança da informação pode ajudar você a evitar que seu software ou website estejam inseguros e vulneráveis a fraquezas que podem ser exploradas para ganhos financeiros ou outros motivos maliciosos<span id="result_box" lang="pt"><span>. </span></span><span id="result_box" lang="pt"><span>Estes artigos podem ajudar você a aprender o que você precisa. Com essa informação, você estará ciente do papel e importância da segurança no ciclo de desenvolvimento de software, além da distribuição do seu conteúdo.</span></span></p>
-
-<p><a href="/en-US/Learn/Confidentiality,_Integrity,_and_Availability">Confidencialidade, Integridade e Disponibilidade</a></p>
-
-<dl>
- <dd>Descreve os objetivos de segurança primários, que são absolutamente fundamentais para o entendimento de segurança</dd>
- <dt><a href="/en-US/Learn/Vulnerabilities">Vulnerabilidades</a></dt>
- <dd>Define as principais categorias de vulnerabilidades e discute a presença de vulnerabilidades em todo software</dd>
- <dt><a href="/en-US/Learn/Threats">Ameaças</a></dt>
- <dd>Introduz brevemente os principais conceitos de ameaças</dd>
- <dt><a href="/en-US/Learn/Security_Controls">Controles de Segurança</a></dt>
- <dd>Define as principais categorias de controle de segurança e discute suas potenciais desvantagens</dd>
- <dt><a href="/en-US/Learn/TCP_IP_Security">Segurança TCP/IP</a></dt>
- <dd>Uma visão geral do modelo TCP/IP, com um foco em considerações de segurança para SSL</dd>
-</dl>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li><a href="/en-US/docs/Mozilla/Security">Segurança no Browser</a></li>
- <li><a href="/en-US/docs/Web/Security">Segurança na Web</a></li>
- <li><a href="/en-US/docs/Web/Security/Securing_your_site">Protegendo seu site</a></li>
- <li><a href="/en-US/docs/Security/Firefox_Security_Basics_For_Developers">Básico de Segurança no Firefox para Desenvolvedores</a></li>
-</ul>
diff --git a/files/pt-br/orphaned/web/svg/element/color-profile/index.html b/files/pt-br/orphaned/web/svg/element/color-profile/index.html
deleted file mode 100644
index 31261469be..0000000000
--- a/files/pt-br/orphaned/web/svg/element/color-profile/index.html
+++ /dev/null
@@ -1,96 +0,0 @@
----
-title: color-profile
-slug: orphaned/Web/SVG/Element/color-profile
-tags:
-  - Elemento
-  - Perfil de Cor
-  - Referencia
-  - SVG
-translation_of: Web/SVG/Element/color-profile
-original_slug: Web/SVG/Element/color-profile
----
-<div>{{SVGRef}}</div>
-
-<p>O elemento permite descrever o perfil de cor utilizado para a imagem.</p>
-
-<h2 id="Contexto_de_uso">Contexto de uso</h2>
-
-<p>{{svginfo}}</p>
-
-<h2 id="Exemplo">Exemplo</h2>
-
-<h2 id="Atributos">Atributos</h2>
-
-<h3 id="Atributos_globais">Atributos globais</h3>
-
-<ul>
- <li><a href="/pt-BR/docs/SVG/Attribute#Core" title="en/SVG/Attribute#Core">Atributos principais</a> »</li>
- <li><a href="/pt-BR/docs/SVG/Attribute#XLink" title="en/SVG/Attribute#XLink">Atributos XLink</a> »</li>
-</ul>
-
-<h3 id="Atributos_específicos">Atributos específicos</h3>
-
-<ul>
- <li>{{ SVGAttr("local") }}</li>
- <li>{{ SVGAttr("name") }}</li>
- <li>{{ SVGAttr("rendering-intent") }}</li>
- <li>{{ SVGAttr("xlink:href") }}</li>
-</ul>
-
-<h2 id="Interface_DOM">Interface DOM</h2>
-
-<p>Este elemento implementa a interface do <code><a href="/pt-BR/docs/DOM/SVGColorProfileElement" title="en/DOM/SVGColorProfileElement">SVGColorProfileElement</a></code>.</p>
-
-<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
-
-<p>{{ CompatibilityTable() }}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Recurso</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatUnknown() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Recurso</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-   <td>{{ CompatNo() }}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p>A tabela é baseada <a href="/pt-BR/docs/SVG/Compatibility_sources" title="en/SVG/Compatibility sources">nessas fontes</a>.</p>
author	Peter Bengtsson <mail@peterbe.com>	2021-07-11 09:25:19 -0400
committer	GitHub <noreply@github.com>	2021-07-11 10:25:19 -0300
commit	7053a316d36dc8193eb102d0cba46f4970a05637 (patch)
tree	65e1b5586cb94cfb16300f496c7287d03a7aa251 /files/pt-br/orphaned/web
parent	0cce4493c05cd8f7becf8e1de289259bef488986 (diff)
download	translated-content-7053a316d36dc8193eb102d0cba46f4970a05637.tar.gz translated-content-7053a316d36dc8193eb102d0cba46f4970a05637.tar.bz2 translated-content-7053a316d36dc8193eb102d0cba46f4970a05637.zip