Resolve conflicts

Author: odsantos

1-js/02-first-steps/05-types/article.md

@@ -46,23 +46,15 @@ Além dos números regulares, existem os chamados "valores numéricos especiais"
     alert( "not a number" / 2 ); // NaN, tal divisão é errônea
     ```
 
-<<<<<<< HEAD
-    `NaN` é pegajoso. Qualquer outra operação em `NaN` retorna `NaN`:
-=======
-    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
->>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
+    `NaN` é pegajoso. Qualquer outra operação matemática com `NaN` retorna `NaN`:
 
     ```js run
     alert( NaN + 1 ); // NaN
     alert( 3 * NaN ); // NaN
     alert( "not a number" / 2 - 1 ); // NaN
     ```
 
-<<<<<<< HEAD
-     Então, se há um `NaN` em algum lugar em uma expressão matemática, ele se propaga para o resultado inteiro.
-=======
-    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
->>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
+     Então, se há um `NaN` em algum lugar em uma expressão matemática, ele se propaga para o resultado inteiro (existe apenas uma exceção nisto: `NaN ** 0` é `1`).
 
 ```smart header="As operações matemáticas são seguras"
 Fazer matemática é "seguro" em JavaScript. Podemos fazer qualquer coisa: dividir por zero, tratar strings não-numéricas como números, etc.

1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -33,11 +33,7 @@ let sum = function(a, b) {
 alert( sum(1, 2) ); // 3
 ```
 
-<<<<<<< HEAD
 Como pode ver, `(a, b) => a + b` significa uma função que aceita dois argumentos, nomeadamente `a` e `b`. No momento da execução, esta avalia a expressão `a + b` e retorna o resultado.
-=======
-As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
->>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 - Se tivermos apenas um argumento, então os parênteses à sua volta podem ser omitidos, tornando ela ainda mais curta.
 
@@ -90,11 +86,7 @@ Desta forma:
 let sum = (a, b) => {  // a chaveta abre uma função multi-linha
   let result = a + b;
 *!*
-<<<<<<< HEAD
   return result; // se usarmos chavetas, então precisamos de um "return" explícito
-=======
-  return result; // if we use curly braces, then we need an explicit "return"
->>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 */!*
 };
 

1-js/11-async/03-promise-chaining/article.md

@@ -120,11 +120,7 @@ new Promise(function(resolve, reject) {
 });
 ```
 
-<<<<<<< HEAD
-Aqui o primeiro `.then` exibe `1` e retorna `new Promise(…)` na linha `(*)`. Após 1 segundo ele é resolvido, e o resultado (o argumento de `resolve`, no caso é `result * 2`) é passado ao tratador do segundo `.then`. O tratador está na linha `(**)`, ele exibe `2` e faz a mesma coisa.
-=======
-Here the first `.then` shows `1` and returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result * 2`) is passed on to the handler of the second `.then`. That handler is in the line `(**)`, it shows `2` and does the same thing.
->>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
+Aqui o primeiro `.then` exibe `1` e retorna `new Promise(…)` na linha `(*)`. Após 1 segundo ela é resolvida, e o resultado (o argumento de `resolve`, aqui é `result * 2`) é passado ao tratador do segundo `.then`. O tratador está na linha `(**)`, ele exibe `2` e faz a mesma coisa.
 
 Então a saída é a mesma que no exemplo anterior: 1 -> 2 -> 4, mas agora com 1 segundo de atraso entre as chamadas `alert`.