Sync with upstream @ ff804bc1

1-js/02-first-steps/04-variables/article.md

@@ -172,7 +172,11 @@ let userName;
 let test123;
 ```
 
+<<<<<<< HEAD
 Cuando el nombre contiene varias palabras, se suele usar el estilo [camelCase](https://es.wikipedia.org/wiki/Camel_case) (capitalización en camello), donde las palabras van pegadas una detrás de otra, con cada inicial en mayúscula: `miNombreMuyLargo`.
+=======
+When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, with each word except the first starting with a capital letter: `myVeryLongName`.
+>>>>>>> ff804bc19351b72bc5df7766f4b9eb8249a3cb11
 
 Es interesante notar que el símbolo del dólar `'$'` y el guion bajo `'_'` también se utilizan en nombres. Son símbolos comunes, tal como las letras, sin ningún significado especial.
 

1-js/02-first-steps/08-operators/article.md

@@ -266,7 +266,11 @@ alert( c ); // 4
 
 Las asignaciones encadenadas evalúan de derecha a izquierda. Primero, se evalúa la expresión más a la derecha `2 + 2` y luego se asigna a las variables de la izquierda: `c`, `b` y `a`. Al final, todas las variables comparten un solo valor.
 
+<<<<<<< HEAD
 Una vez más, con el propósito de la legibilidad es mejor separa tal código en unas pocas líneas:
+=======
+Once again, for the purposes of readability it's better to split such code into a few lines:
+>>>>>>> ff804bc19351b72bc5df7766f4b9eb8249a3cb11
 
 ```js
 c = 2 + 2;

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

@@ -2,6 +2,7 @@
 Podrías notar lo siguiente:
 
 ```js no-beautify
+<<<<<<< HEAD
 function pow(x,n)  // <- sin espacio entre argumentos
 {  // <- llave en una línea separada
   let result=1;   // <- sin espacios antes o después de =
@@ -15,6 +16,21 @@ let x=prompt("x?",''), n=prompt("n?",'') // <-- técnicamente posible,
 if (n<0)  // <- sin espacios dentro (n < 0), y debe haber una línea extra por encima
 {   // <- llave en una línea separada
   // debajo - las líneas largas se pueden dividir en varias líneas para mejorar la legibilidad
+=======
+function pow(x,n)  // <- no space between arguments
+{  // <- curly brace on a separate line
+  let result=1;   // <- no spaces before or after =
+  for(let i=0;i<n;i++) {result*=x;}   // <- no spaces
+  // the contents of { ... } should be on a new line
+  return result;
+}
+
+let x=prompt("x?",''), n=prompt("n?",'') // <-- technically possible,
+// but better make it 2 lines, also there's no spaces and missing ;
+if (n<=0)  // <- no spaces inside (n <= 0), and should be extra line above it
+{   // <- curly brace on a separate line
+  // below - long lines can be split into multiple lines for improved readability
+>>>>>>> ff804bc19351b72bc5df7766f4b9eb8249a3cb11
   alert(`Power ${n} is not supported, please enter an integer number greater than zero`);
 }
 else // <- podría escribirlo en una sola línea como "} else {"

1-js/04-object-basics/01-object/article.md

@@ -5,7 +5,11 @@ Como aprendimos en el capítulo <info:types>, hay ocho tipos de datos en JavaScr
 
 En contraste, los objetos son usados para almacenar colecciones de varios datos y entidades más complejas asociados con un nombre clave. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. 
 
+<<<<<<< HEAD
 Podemos crear un objeto usando las llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key:value", donde `key` es un string (también llamado "nombre clave"), y `value` puede ser cualquier cosa. P.D. Para fines prácticos de la lección, nos referiremos a este par de conceptos como "clave:valor".
+=======
+An object can be created with curly braces `{…}` with an optional list of *properties*. A property is a "key: value" pair, where `key` is a string (also called a "property name"), and `value` can be anything.
+>>>>>>> ff804bc19351b72bc5df7766f4b9eb8249a3cb11
 
 Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de datos es almacenada en su archivo por la clave. Es fácil encontrar un archivo por su nombre o agregar/eliminar un archivo.
 
@@ -20,7 +24,11 @@ let user = {};  // sintaxis de "objeto literal"
 
 ![](object-user-empty.svg)
 
+<<<<<<< HEAD
 Normalmente se utilizan las llaves `{...}`. Esa declaración se llama *objeto literal*.
+=======
+Usually, the curly braces `{...}` are used. That declaration is called an *object literal*.
+>>>>>>> ff804bc19351b72bc5df7766f4b9eb8249a3cb11
 
 ## Literales y propiedades
 

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -80,8 +80,13 @@ Esto funciona, porque internamente una desestructuración trabaja iterando sobre
 ````
 
 
+<<<<<<< HEAD
 ````smart header="Asignar a cualquier cosa en el lado izquierdo"
 Podemos usar cualquier "asignable" en el lado izquierdo.
+=======
+````smart header="Assign to anything on the left-side"
+We can use any "assignables" on the left side.
+>>>>>>> ff804bc19351b72bc5df7766f4b9eb8249a3cb11
 
 Por ejemplo, una propiedad de objeto:
 ```js run

1-js/06-advanced-functions/08-settimeout-setinterval/article.md

@@ -218,7 +218,11 @@ Y aquí está la imagen para el `setTimeout` anidado:
 
 ![](settimeout-interval.svg)
 
+<<<<<<< HEAD
 **El `setTimeout` anidado garantiza el retraso fijo (aquí 100ms).**
+=======
+**The nested `setTimeout` ensures a minimum delay (100ms here) between the end of one call and the beginning of the subsequent one.**
+>>>>>>> ff804bc19351b72bc5df7766f4b9eb8249a3cb11
 
 Esto se debe a que se planea una nueva llamada al final de la anterior.