fix(pt-br): remove duplicate headings (#17667)

files/pt-br/learn/javascript/asynchronous/introducing/index.md

@@ -258,7 +258,7 @@ document.querySelector("#reload").addEventListener("click", () => {
 
 Isso é exatamente como os [manipuladores de eventos que encontramos em um módulo anterior](/pt-BR/docs/Learn/JavaScript/Building_blocks/Events), exceto que, em vez de o evento ser uma ação do usuário, como o usuário clicar um botão, o evento é uma mudança no estado de algum objeto.
 
-## Manipuladores de eventos
+## Callback
 
 Um manipulador de eventos é um tipo específico de callback. Um callback é apenas uma função que é passada para outra função, com a expectativa de que o callback seja chamado no momento apropriado. Como acabamos de ver, os retornos de chamada costumavam ser a principal forma de implementação de funções assíncronas em JavaScript.
 

files/pt-br/web/api/filereader/index.md

@@ -83,76 +83,3 @@ Ouça esses eventos usando {{domxref("EventTarget/addEventListener", "addEventLi
 - {{domxref("File")}}
 - {{domxref("Blob")}}
 - {{domxref("FileReaderSync")}}{ APIRef("File API")}}
-
-## Resumo
-
-O objeto `FileReader` permite aplicações web ler assincronamente o conteúdo dos arquivos (ou buffers de dados puros) do computador do usuário, utilizando o objeto {{ domxref("File") }} ou {{ domxref("Blob") }} para especificar o arquivo ou os dados a serem lidos.
-
-Objetos File podem ser obtidos a partir de um objeto {{ domxref("FileList") }} retornado como resultado da seleção de um usuário utilizando um elemento {{ HTMLElement("input") }}, a partir de uma operação de drag and drop [`DataTransfer`](/En/DragDrop/DataTransfer), ou a partir de um `mozGetAsFile()` da api {{ domxref("HTMLCanvasElement") }}.
-
-## Construtor
-
-```
-FileReader FileReader();
-```
-
-Veja [Using files from web applications](/pt-BR/Using_files_from_web_applications) para detalhes e exemplos.
-
-## Propriedades
-
-- {{domxref("FileReader.error")}} {{readonlyinline}}
-  - : Um {{domxref("DOMError")}} representa o erro que ocorreu durante a leitura do arquivo.
-- {{domxref("FileReader.readyState")}} {{readonlyinline}}
-  - : Um número indicando o estado do `FileReader`. Este poderá ser um dos seguintes estados [State constants](#state_constants).
-- {{domxref("FileReader.result")}} {{readonlyinline}}
-  - : O conteúdo do arquivo. Esta propriedade é válida apenas após a operação de leitura estar completa, e o formato dos dados dependem de qual método foi usado para iniciar a operação de leitura.
-
-### Manipuladores de eventos
-
-- {{domxref("FileReader.onabort")}}
-  - : Um manipulador para o evento {{event("abort")}}. Este evento é chamado cada vez que a operação de leitura é abortada.
-- {{domxref("FileReader.onerror")}}
-  - : Um manipulador para o evento {{event("error")}}. Este evento é chamado cada vez que a operação de leitura encontra um erro.
-- {{domxref("FileReader.onload")}}
-  - : Um manipulador para o evento {{event("load")}}. Este evento é chamado cada vez que a operação de leitura é completada com sucesso.
-- {{domxref("FileReader.onloadstart")}}
-  - : Um manipulador para o evento {{event("loadstart")}}. Este evento é chamado cada vez que a leitura começa.
-- {{domxref("FileReader.onloadend")}}
-  - : Um manipulador para o evento {{event("loadend")}}. Este evento é chamado cada vez que a operação de leitura é completada (tanto em caso de sucesso quanto de erro).
-- {{domxref("FileReader.onprogress")}}
-  - : Um manipulador para o evento {{event("progress")}}. Este evento é chamado durante a leitura do conteúdo de {{domxref("Blob")}}.
-
-> **Nota:** Nota: O `FileReader` herda de {{domxref("EventTarget")}}, todos estes eventos podem ser listados usando o método {{domxref("EventTarget.addEventListener()","addEventListener")}}.
-
-### Constantes de estado
-
-- `EMPTY`: `0` : Nenhum dado foi carregado ainda.
-- `LOADING`: `1` : Os dados estão sendo carregados.
-- `DONE`: `2` : Toda a requisição de leitura foi completada.
-
-## Métodos
-
-- {{domxref("FileReader.abort()")}}
-  - : Aborta a operação de leitura. O retorno, no `readyState` será `DONE`.
-- {{domxref("FileReader.readAsArrayBuffer()")}}
-  - : Inicia a leitura do conteúdo do {{ domxref("Blob") }} espeficado, uma vez finalizado, o atributo `result` conterá um {{domxref("ArrayBuffer")}} representando os dados do arquivo.
-- {{domxref("FileReader.readAsBinaryString()")}}
-  - : Inicia a leitura do conteúdo do {{ domxref("Blob") }} especificado, uma vez finalizado, o atributo `result` conterá os dados raw binários do arquivo como string.
-- {{domxref("FileReader.readAsDataURL()")}}
-  - : Inicia a leitura do conteúdo do {{ domxref("Blob") }} especificado, uma vez finalizado, o atributo `result` conterá um `data:` URL representando os dados do arquivo.
-- {{domxref("FileReader.readAsText()")}}
-  - : Inicia a leitura do conteúdo do {{ domxref("Blob") }} especificado, uma vez finalizado, o atributo `result` conterá o conteúdo do arquivo como string de texto.
-
-## Especificações
-
-{{Specifications}}
-
-## Compatibilidade com navegadores
-
-{{Compat}}
-
-## Veja também
-
-- [Using files from web applications](/pt-BR/Using_files_from_web_applications)
-- {{ domxref("File") }}
-- {{ domxref("Blob") }}

files/pt-br/web/api/web_audio_api/simple_synth/index.md

@@ -526,7 +526,7 @@ Então conseguimos o tipo de forma de onda para usar ao checar o valor do contro
 
 A frequência do oscilador é colocada no valor especificado no paramêtro `freq` ao colocar o valor dos objetos {{domxref("Oscillator.frequency")}} {{domxref("AudioParam")}} . Então, enfim, o oscilador é iniciado e começa a produzir sons ao chamar o método {{domxref("AudioScheduledSourceNode.start()")}} .
 
-#### Tocando um tom
+#### Tocando uma nota
 
 Quando o evento {{event("mousedown")}} ou {{domxref("mouseover")}} ocorre em uma tecla, queremos que toque a nota correspondente. A função `notePressed()` é usada como o modificador de eventos para esses eventos.
 

files/pt-br/web/api/webgl_api/tutorial/adding_2d_content_to_a_webgl_context/index.md

@@ -164,7 +164,7 @@ This routine is pretty simplistic given the basic nature of the scene in this ex
 
 Once that's done, we create a JavaScript array containing the coordinates for each vertex of the square. This is then converted into an array of WebGL floats and passed into the `gl` object's `bufferData()` method to establish the vertices for the object.
 
-## Desenhando a cena
+## Renderizando a cena
 
 Once the shaders are established and the object constructed, we can actually render the scene. Since we're not animating anything in this example, our `drawScene()` function is very simple. It uses a few utility routines we'll cover shortly.
 

files/pt-br/web/api/xmlhttprequest/index.md

@@ -17,22 +17,6 @@ var myRequest = new XMLHttpRequest();
 
 Para obter detalhes sobre como usar XMLHttpRequest , consulte [Usando XMLHttpRequest](/pt-BR/DOM/XMLHttpRequest/Using_XMLHttpRequest).
 
-## Métodos
-
-| `XMLHttpRequest(JSObject objParameters);`                                                                                                                   |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `void abort();`                                                                                                                                             |
-| `DOMString getAllResponseHeaders();`                                                                                                                        |
-| `DOMString? getResponseHeader(DOMString header);`                                                                                                           |
-| `void open(DOMString method, DOMString url, optional boolean async, optional DOMString? user, optional DOMString? password);`                               |
-| `void overrideMimeType(DOMString mime);`                                                                                                                    |
-| `void send();` `void send(ArrayBuffer data);` `void send(Blob data);` `void send(Document data);` `void send(DOMString? data);` `void send(FormData data);` |
-| `void setRequestHeader(DOMString header, DOMString value);`                                                                                                 |
-| Métodos não-padrão                                                                                                                                          |
-| `[noscript] void init(in nsIPrincipal principal, in nsIScriptContext scriptContext, in nsPIDOMWindow ownerWindow);`                                         |
-| `[noscript] void openRequest(in AUTF8String method, in AUTF8String url, in boolean async, in AString user, in AString password);`                           |
-| `void sendAsBinary(in DOMString body);`                                                                                                                     |
-
 ## Propriedades
 
 <table class="standard-table">

files/pt-br/web/css/block-size/index.md

@@ -36,15 +36,15 @@ block-size: unset;
 
 Se o modo de escrita está orientado verticalmente, o valor do `block-size` refere-se à largura do elemento; senão, refere-se à altura do elemento. Uma propriedade relacionada é {{cssxref("inline-size")}}, que define as outras dimensões do elemento.
 
-{{cssinfo}}
-
-## Sintaxe
-
 ### Valores
 
 A propriedade `block-size` leva os mesmos valores que as propriedades {{cssxref("width")}} e {{cssxref("height")}}.
 
-### Sintaxe formal
+## Definição formal
+
+{{cssinfo}}
+
+## Sintaxe formal
 
 {{csssyntax}}
 

files/pt-br/web/html/element/button/index.md

@@ -98,7 +98,7 @@ Note que esse botão possui CSS aplicado.
 
 {{Compat}}
 
-## Notas
+### Notas
 
 Elementos `<button>` são muito mais fáceis estilizá-los do que elementos {{HTMLElement("input")}}. Você pode adicionar dentro do conteúdo do HTML (imagine em `<em>`, `<strong>` ou mesmo `<img>`), e fazer uso do pseudo-elemento {{Cssxref(":after")}} e {{Cssxref(":before")}} para realizar renderizações complexas enquanto {{HTMLElement("input")}} apenas aceita um atributo com valor textual.
 

files/pt-br/web/html/element/input/range/index.md

@@ -7,11 +7,7 @@ slug: Web/HTML/Element/input/range
 
 {{HTMLElement("input")}} elementos do tipo **`"range"`** deixam o usuário especificar um valor numérico que não deve ser inferior a um determinado valor, e não mais do que um valor máximo especificado. O valor preciso, no entanto, não é considerado importante. Este geralmente é representado por um controle deslizante ou o mesmo tipo de controle de "number" input. Como este tipo de elemento é impreciso, não deve ser usado a menos que o valor exato do controle não seja importante.
 
-```html
-<input type="range" />
-```
-
-{{EmbedLiveSample("summary_sample1", 600, 40)}}
+{{EmbedInteractiveExample("pages/tabbed/input-range.html", "tabbed-standard")}}
 
 Se o navegador do usuário não suportar o tipo `"range"`, este será tratado como um input do tipo [`"text"`](/pt-BR/docs/Web/HTML/Element/input/text).
 
@@ -94,25 +90,29 @@ Por exemplo, para pedir ao usuário um valor entre -10 e 10, você pode usar:
 <input type="range" min="-10" max="10" />
 ```
 
-{{EmbedLiveSample("Specifying_the_minimum_and_maximum", 600, 40)}}
+{{EmbedLiveSample("Especificando o mínimo e o máximo", 600, 40)}}
 
 ### Definindo a escala entre valores
 
 Por padrão, a escala entre o mínimo e o máximo é 1, significando que este sempre é um valor inteiro. você pode alterar o atributo [`step`](/pt-BR/docs/Web/HTML/Global_attributes#step) para controlar esta escala. Por exemplo, se você precisa de um valor de duas casas decimais entre os valores 5 e 10, voce deve definir o valor de `step` para 0.01:
 
+### Configurando o atributo step
+
 ```html
 <input type="range" min="5" max="10" step="0.01" />
 ```
 
-{{EmbedLiveSample("Granularity_sample1", 600, 40)}}
+{{EmbedLiveSample("Configurando o atributo step", 600, 40)}}
+
+### Configurando step como `any`
 
 Se você deseja aceitar um valor independente das casas decimais, voce pode especificar o valor `"any"` para o atributo [`step`](/pt-BR/docs/Web/HTML/Element/input#step):
 
 ```html
 <input type="range" min="0" max="3.14" step="any" />
 ```
 
-{{EmbedLiveSample("Granularity_sample2", 600, 40)}}
+{{EmbedLiveSample("Configurando step como any", 600, 40)}}
 
 Este exemplo permite ao usuário selecionar qualquer valor entre 0 e π sem qualquer restrição na parte fracionada do valor selecionado.
 
@@ -235,42 +235,45 @@ Você pode adicionar rótulos para seu controle usando o atributo [`label`](/pt-
 
 > **Nota:** Atualmente nenhum navegador suporta estes recursos totalmente. Firefox não suporta pontos e rótulos, por exemplo, enquanto o Chrome suporta as marcações de pontos, porém não suporta as etiquetas.
 
-### Change the orientation
+### Criando controles de intervalo vertical
+
+#### Controle de range horizontal
 
 Considerando este controle:
 
 ```html
 <input type="range" id="volume" min="0" max="11" value="7" step="1" />
 ```
 
-{{EmbedLiveSample("Orientation_sample1", 200, 200, "orientation_sample1.png")}}
+{{EmbedLiveSample("Controle de range horizontal", 200, 200)}}
 
-Esse controle é horizontal (pelo menos na maioria, senão em todos os principais navegadores, outros podem variar). Fazê-lo vertical é tão simples como adicionar CSS para alterar as dimensões do controle para que ele seja mais alto que o largo, como este:
+Esse controle é horizontal (pelo menos na maioria, senão em todos os principais navegadores, outros podem variar).
 
-#### CSS
+#### Usando a propriedade appearance
 
-```css
-#volume {
-  height: 150px;
-  width: 50px;
-}
-```
+A propriedade {{cssxref('appearance')}} tem um valor não padrão de `slider-vertical` que, bem, torna os controles deslizantes verticais.
 
-#### HTML
+Usamos o mesmo HTML dos exemplos anteriores:
 
 ```html
-<input type="range" id="volume" min="0" max="11" value="7" step="1" />
+<input type="range" min="0" max="11" value="7" step="1" />
 ```
 
-#### Resultado
+Visamos apenas as entradas com um tipo de range:
+
+```css
+input[type="range"] {
+  appearance: slider-vertical;
+}
+```
 
-{{EmbedLiveSample("Orientation_sample2", 200, 200, "orientation_sample2.png")}}
+{{EmbedLiveSample("Usando a propriedade appearance", 200, 200)}}
 
-**Atualmente, nenhum dos principais navegadores suporta a criação de entradas de alcance vertical usando o CSS desta maneira, mesmo que seja a maneira como a especificação recomenda que eles o façam.**
+#### Controle de range vertical
 
 As especificações HTML recomenda que os navegadores mudem automaticamente para um controle vertical quando a largura for menor que à altura. Infortuniamente nenhum dos principais navegadores atualmente oferece tal suporte. No entanto você pode cria-lo pelo seu lado. A maneira mais fácil para isto é usar o CSS: aplicando um: {{cssxref("transform")}} para rotacionar o elemento tornando-o vertical. Vamos dar uma olhada:
 
-#### HTML
+##### HTML
 
 No HTML o elemento {{HTMLElement("input")}} precisa ser envolto em uma {{HTMLElement("div")}} para nos permitir corrigir o layout após a transformação ser executada, (uma vez que as transformações não afetam automaticamente o layout da página):
 
@@ -280,7 +283,7 @@ No HTML o elemento {{HTMLElement("input")}} precisa ser envolto em uma {{HTMLEle
 </div>
 ```
 
-#### CSS
+##### CSS
 
 Agora precisamos de algum CSS. Primeiro é o CSS para o próprio wrapper; isso especifica o modo de exibição e o tamanho que queremos para que a página seja definida corretamente; em essência, está reservando uma área da página para que o controle deslizante gire e se encaixe no espaço reservado sem bagunçar outros elementos.
 
@@ -309,7 +312,7 @@ O tamanho do controle está configurado para ter 150 pixels de comprimento por 2
 
 #### Result
 
-{{EmbedLiveSample("Orientation_sample3", 200, 200, "orientation_sample3.png")}}
+{{EmbedLiveSample("Controle de range vertical", 200, 200)}}
 
 ## Validação
 

files/pt-br/web/html/element/title/index.md

@@ -42,8 +42,6 @@ Uma técnica comum de navegação para usuários de tecnologias assistivas é le
 
 Para ajudar o usuário, atualize o valor do `title` para refletir mudanças significativas no estado da página (como problemas de validação em formulários).
 
-#### Exemplo
-
 ```
 <title>2 erros - Seu pedido - Casa Azul Comida Chinesa - FoodYum: Faça seu pedido online!</title>
 ```

files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.md

@@ -77,41 +77,6 @@ function fixedCharCodeAt(str, idx) {
 }
 ```
 
-### Corrigindo o `charCodeAt()` para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida
-
-```js
-function knownCharCodeAt(str, idx) {
-  str += "";
-  var code,
-    end = str.length;
-
-  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-  while (surrogatePairs.exec(str) != null) {
-    var li = surrogatePairs.lastIndex;
-    if (li - 2 < idx) {
-      idx++;
-    } else {
-      break;
-    }
-  }
-
-  if (idx >= end || idx < 0) {
-    return NaN;
-  }
-
-  code = str.charCodeAt(idx);
-
-  var hi, low;
-  if (0xd800 <= code && code <= 0xdbff) {
-    hi = code;
-    low = str.charCodeAt(idx + 1);
-    // Vá um adiante, já que um dos "characters" é parte de um par substituto
-    return (hi - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
-  }
-  return code;
-}
-```
-
 ## Especificações
 
 {{Specifications}}