Resolve conflicts

Author: odsantos

1-js/03-code-quality/02-coding-style/article.md

@@ -329,13 +329,8 @@ Aqui está um exemplo de um ficheiro `.eslintrc`:
   },
   "rules": {
     "no-console": 0,
-<<<<<<< HEAD
-  },
-  "indent": 2
-=======
     "indent": 2
   }
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 }
 ```
 

1-js/03-code-quality/06-polyfills/article.md

@@ -23,12 +23,8 @@ Actually, there are two parts in Babel:
 
 2. Second, the polyfill.
 
-<<<<<<< HEAD
-    The transpiler rewrites the code, so syntax features are covered. But for new functions we need to write a special script that implements them. JavaScript is a highly dynamic language, scripts may not just add new functions, but also modify built-in ones, so that they behave according to the modern standard.
-=======
     New language features may include not only syntax constructs, but also built-in functions.
     The transpiler rewrites the code, transforming syntax constructs into older ones. But as for new built-in functions, we need to implement them. JavaScript is a highly dynamic language, scripts may add/modify any functions, so that they behave according to the modern standard.
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 
     There's a term "polyfill" for scripts that "fill in" the gap and add missing implementations.
 

1-js/08-prototypes/01-prototype-inheritance/article.md

@@ -12,11 +12,7 @@ In JavaScript, objects have a special hidden property `[[Prototype]]` (as named
 
 ![prototype](object-prototype-empty.svg)
 
-<<<<<<< HEAD
-That `[[Prototype]]` has a "magical" meaning. When we want to read a property from `object`, and it's missing, JavaScript automatically takes it from the prototype. In programming, such thing is called "prototypal inheritance". Many cool language features and programming techniques are based on it.
-=======
 When we  read a property from `object`, and it's missing, JavaScript automatically takes it from the prototype. In programming, such thing is called "prototypal inheritance". And soon we'll study many examples of such inheritance, as well as cooler language features built upon it.
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 
 The property `[[Prototype]]` is internal and hidden, but there are many ways to set it.
 
@@ -127,13 +123,9 @@ alert(longEar.jumps); // true (from rabbit)
 
 ![](proto-animal-rabbit-chain.svg)
 
-<<<<<<< HEAD
-There are actually only two limitations:
-=======
 Now if we read something from `longEar`, and it's missing, JavaScript will look for it in `rabbit`, and then in `animal`.
 
 There are only two limitations:
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 
 1. The references can't go in circles. JavaScript will throw an error if we try to assign `__proto__` in a circle.
 2. The value of `__proto__` can be either an object or `null`, other types (like primitives) are ignored.

1-js/11-async/06-promisify/article.md

@@ -46,11 +46,7 @@ let loadScriptPromise = function(src) {
 // loadScriptPromise('path/script.js').then(...)
 ```
 
-<<<<<<< HEAD
-Now `loadScriptPromise` fits well in our promise-based code.
-=======
 As we can see, the new function is a wrapper around the original `loadScript` function. It calls it providing its own callback that translates to promise `resolve/reject`.
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 
 Now `loadScriptPromise` fits well in promise-based code. If we like promises more than callbacks (and soon we'll see more reasons for that), then we will use it instead.
 
@@ -90,14 +86,10 @@ Here, `promisiefy` assumes that the original function expects a callback with ex
 
 But what if the original `f` expects a callback with more arguments `callback(err, res1, res2)`?
 
-<<<<<<< HEAD
-Here's a modification of `promisify` that returns an array of multiple callback results:
-=======
 We can improve our helper. Let's make a more advanced version of `promisify`.
 
 - When called as `promisify(f)` it should work similar to the version above.
 - When called as `promisify(f, true)`, it should return the promise that resolves with the array of callback results. That's exactly for callbacks with many arguments.
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 
 ```js
 // promisify(f, true) to get array of results

1-js/13-modules/02-import-export/article.md

@@ -321,11 +321,7 @@ export {default as User} from './user.js'; // reexporta o default
 
 Por que isso seria necessário? Vamos ver um caso de uso prático.
 
-<<<<<<< HEAD
-Imagine que estamos escrevendo um "pacote": uma pasta com muitos módulos, com algumas funcionalidades exportadas (ferramentas como NPM permitem publicar e distribuir esses pacotes), e muitos módulos são apenas "auxiliares", para uso interno em outro pacote de módulos.
-=======
 Imagine, we're writing a "package": a folder with a lot of modules, with some of the functionality exported outside (tools like NPM allow us to publish and distribute such packages, but we don't have to use them), and many modules are just "helpers", for internal use in other package modules.
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 
 A estrutura de arquivos pode ser assim:
 ```
@@ -382,11 +378,7 @@ export {default as User} from './user.js';
 
 O export default precisa de um tratamento separado ao reexportar.
 
-<<<<<<< HEAD
-Vamos dizer que temos `user.js` com o `export default class User`, e gostaríamos de o reexportar:
-=======
 Let's say we have `user.js` with the `export default class User` and would like to re-export it:
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
 
 ```js
 // 📁 user.js
@@ -395,14 +387,8 @@ export default class User {
 }
 ```
 
-<<<<<<< HEAD
-Podemos encontrar dois problemas:
-=======
 We can come across two problems with it:
 
-1. `export User from './user.js'` won't work. That would lead to a syntax error.
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
-
 1. `export User from './user.js'` não funcionará. Isso levaria a um erro de sintaxe.
 
     Para reexportar o export default, nós temos que escrever `export {default as User}`, como no exemplo acima.
@@ -415,11 +401,7 @@ We can come across two problems with it:
     export {default} from './user.js'; // para reexportar o export default
     ```
 
-<<<<<<< HEAD
-Essas esquisitices de reexportar o export default são um dos motivos pelos quais alguns desenvolvedores não gostam de default exports e preferem os nomeados.
-=======
-Such oddities of re-exporting a default export are one of the reasons why some developers don't like default exports and prefer named ones.
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
+Essas esquisitices de reexportar um default export são um dos motivos pelos quais alguns desenvolvedores não gostam de default exports e preferem os nomeados.
 
 ## Resumo
 

9-regular-expressions/17-regexp-methods/article.md

@@ -19,15 +19,9 @@ Possui 3 modos:
     alert( result[1] );     // Script (primeira captura de grupo)
     alert( result.length ); // 2
 
-<<<<<<< HEAD
     // Informação adicional:
-    alert( result.index );  // 0 (posição da correspondÊncia)
+    alert( result.index );  // 0 (posição da correspondência)
     alert( result.input );  // Eu amo JavaScript (string original)
-=======
-    // Additional information:
-    alert( result.index );  // 7 (match position)
-    alert( result.input );  // I love JavaScript (source string)
->>>>>>> dccca58f268ad6d5a6f2160613a8ea3c5cd53a2d
     ```
 
 2. Se a `regexp` tiver a flag `padrão:g`, ela retornará uma matriz de todas as correspondências como strings, sem capturar grupos e outros detalhes.