From 2ba85f446d59f664f66ca402489f58b2deffef47 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Fri, 1 Feb 2019 11:55:51 -0400
Subject: [PATCH 01/12] Translating top elements for react.DOM such as:
 overview and browser support

---
 content/docs/reference-react-dom.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index 4060a6c0e..c4b0bdd4e 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -6,11 +6,11 @@ category: Reference
 permalink: docs/react-dom.html
 ---
 
-If you load React from a `<script>` tag, these top-level APIs are available on the `ReactDOM` global. If you use ES6 with npm, you can write `import ReactDOM from 'react-dom'`. If you use ES5 with npm, you can write `var ReactDOM = require('react-dom')`.
+Si cargas React desde una etiqueta `<script>`, estas APIs de alto nivel estaran disponibles en la variable global `ReactDOM`. Si usas ES6 con npm, puedes escribir `import ReactDOM from 'react-dom'`. Si usas ES5 con npm, puedes escribir `var ReactDOM = require('react-dom')`.
 
-## Overview
+## Resumen
 
-The `react-dom` package provides DOM-specific methods that can be used at the top level of your app and as an escape hatch to get outside of the React model if you need to. Most of your components should not need to use this module.
+El paquete `react-dom` proporciona metodos especificos del DOM que pueden ser utilizados en el nivel mas alto de tu aplicacion como una escotilla de escape para salir del modelo de React si asi lo necesitas. La mayoria de tus componentes no deberian necesitar usar este modulo.
 
 - [`render()`](#render)
 - [`hydrate()`](#hydrate)
@@ -18,9 +18,9 @@ The `react-dom` package provides DOM-specific methods that can be used at the to
 - [`findDOMNode()`](#finddomnode)
 - [`createPortal()`](#createportal)
 
-### Browser Support
+### Soporte de Navegadores
 
-React supports all popular browsers, including Internet Explorer 9 and above, although [some polyfills are required](/docs/javascript-environment-requirements.html) for older browsers such as IE 9 and IE 10.
+React soporta todos los navegadores populares, incluyendo Internet Explorer 9 y versiones posteriores, aunque [algunos polyfills son requeridos](/docs/javascript-environment-requirements.html) para navegadores mas viejos como IE 9 e IE 10.
 
 > Note
 >

From 9d514471efdd62950707359340c4a93902e98cae Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Fri, 1 Feb 2019 12:00:58 -0400
Subject: [PATCH 02/12] Translating support note

---
 content/docs/reference-react-dom.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index c4b0bdd4e..a7c6067d3 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -22,9 +22,9 @@ El paquete `react-dom` proporciona metodos especificos del DOM que pueden ser ut
 
 React soporta todos los navegadores populares, incluyendo Internet Explorer 9 y versiones posteriores, aunque [algunos polyfills son requeridos](/docs/javascript-environment-requirements.html) para navegadores mas viejos como IE 9 e IE 10.
 
-> Note
+> Nota
 >
-> We don't support older browsers that don't support ES5 methods, but you may find that your apps do work in older browsers if polyfills such as [es5-shim and es5-sham](https://github.com/es-shims/es5-shim) are included in the page. You're on your own if you choose to take this path.
+> No soportamos navegadores viejos que no soporten metodos ES5, pero puede que te des cuenta de que tus aplicaciones funcionan en navegadores viejos si polyfills como [es5-shim y es5-sham](https://github.com/es-shims/es5-shim) estan incluidas en la pagina. Estas por tu cuenta si decides tomar este camino.
 
 * * *
 

From ada9c13363bb41714a17d6fbf7d241482c03214e Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Fri, 1 Feb 2019 16:28:56 -0400
Subject: [PATCH 03/12] Translating big note about ReactDOM.render

---
 content/docs/reference-react-dom.md | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index a7c6067d3..201e0dd3c 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -28,19 +28,31 @@ React soporta todos los navegadores populares, incluyendo Internet Explorer 9 y
 
 * * *
 
-## Reference
+## Referencia
 
 ### `render()`
 
 ```javascript
-ReactDOM.render(element, container[, callback])
+ReactDOM.render(elemento, contenedor[, callback])
 ```
 
-Render a React element into the DOM in the supplied `container` and return a [reference](/docs/more-about-refs.html) to the component (or returns `null` for [stateless components](/docs/components-and-props.html#functional-and-class-components)).
+Renderiza un elemento React al DOM en el `contenedor` suministrado y retorna una [referencia](/docs/more-about-refs.html) al componente (o devuelve `null` para [componentes sin estado](/docs/components-and-props.html#functional-and-class-components)).
 
-If the React element was previously rendered into `container`, this will perform an update on it and only mutate the DOM as necessary to reflect the latest React element.
+Si el elemento React fue previamente renderizado al `contenedor`, esto ejecutara una actualizacion en el, y solo mutara el DOM de ser necesario para reflejar el mas reciente elemento React.
 
-If the optional callback is provided, it will be executed after the component is rendered or updated.
+Si el callback opcional es suministrado, sera ejecutado despues de que el componente es renderizado o actualizado.
+
+> Nota:
+>
+> `ReactDOM.render()` controla el contenido del nodo contenedor que pasas. Cualquier elemento del DOM adentro de este son reemplazados cuando es llamado por primera vez. Las llamadas posteriores utilizan el algoritmo de diferenciado de React DOM para actualizaciones eficientes.
+>
+> `ReactDOM.render()` no modifica el nodo contenedor (solo modifica los hijos del contenedor). Puede ser posible insertar un componente en un nodo existente del DOM sin sobreescribir los hijos existentes.
+>
+> `ReactDOM.render()` currently returns a reference to the root `ReactComponent` instance. However, using this return value is legacy
+> and should be avoided because future versions of React may render components asynchronously in some cases. If you need a reference to the root `ReactComponent` instance, the preferred solution is to attach a
+> [callback ref](/docs/more-about-refs.html#the-ref-callback-attribute) to the root element.
+>
+> Using `ReactDOM.render()` to hydrate a server-rendered container is deprecated and will be removed in React 17. Use [`hydrate()`](#hydrate) instead.
 
 > Note:
 >

From 5e479bc43178d9c5992350fff5d9519e4f1e88a8 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Fri, 1 Feb 2019 16:58:47 -0400
Subject: [PATCH 04/12] Finishing translate on note about render usage, and
 also starting to add accents

---
 .vscode/settings.json               |  3 +++
 content/docs/reference-react-dom.md | 30 +++++++++--------------------
 2 files changed, 12 insertions(+), 21 deletions(-)
 create mode 100644 .vscode/settings.json

diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 000000000..74fc39c1b
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "cSpell.language": ",es"
+}
\ No newline at end of file
diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index 201e0dd3c..80a110f0f 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -10,7 +10,7 @@ Si cargas React desde una etiqueta `<script>`, estas APIs de alto nivel estaran
 
 ## Resumen
 
-El paquete `react-dom` proporciona metodos especificos del DOM que pueden ser utilizados en el nivel mas alto de tu aplicacion como una escotilla de escape para salir del modelo de React si asi lo necesitas. La mayoria de tus componentes no deberian necesitar usar este modulo.
+El paquete `react-dom` proporciona métodos específicos del DOM que pueden ser utilizados en el nivel mas alto de tu aplicación como una escotilla de escape para salir del modelo de React si asi lo necesitas. La mayoría de tus componentes no deberían necesitar usar este modulo.
 
 - [`render()`](#render)
 - [`hydrate()`](#hydrate)
@@ -38,33 +38,21 @@ ReactDOM.render(elemento, contenedor[, callback])
 
 Renderiza un elemento React al DOM en el `contenedor` suministrado y retorna una [referencia](/docs/more-about-refs.html) al componente (o devuelve `null` para [componentes sin estado](/docs/components-and-props.html#functional-and-class-components)).
 
-Si el elemento React fue previamente renderizado al `contenedor`, esto ejecutara una actualizacion en el, y solo mutara el DOM de ser necesario para reflejar el mas reciente elemento React.
+Si el elemento React fue previamente renderizado al `contenedor`, esto ejecutara una actualización en el, y solo mutara el DOM de ser necesario para reflejar el mas reciente elemento React.
 
-Si el callback opcional es suministrado, sera ejecutado despues de que el componente es renderizado o actualizado.
+Si el callback opcional es suministrado, sera ejecutado después de que el componente es renderizado o actualizado.
 
 > Nota:
 >
-> `ReactDOM.render()` controla el contenido del nodo contenedor que pasas. Cualquier elemento del DOM adentro de este son reemplazados cuando es llamado por primera vez. Las llamadas posteriores utilizan el algoritmo de diferenciado de React DOM para actualizaciones eficientes.
+> `ReactDOM.render()` controla el contenido del nodo contenedor que suministras. Cualquiera de los elementos DOM adentro de este son reemplazados cuando es llamado por primera vez. Las llamadas posteriores utilizan el algoritmo de diferenciado de React DOM para actualizaciones eficientes.
 >
-> `ReactDOM.render()` no modifica el nodo contenedor (solo modifica los hijos del contenedor). Puede ser posible insertar un componente en un nodo existente del DOM sin sobreescribir los hijos existentes.
+> `ReactDOM.render()` no modifica el nodo contenedor (solo modifica los hijos del contenedor). Puede ser posible insertar un componente en un nodo existente del DOM sin sobrescribir los hijos existentes.
 >
-> `ReactDOM.render()` currently returns a reference to the root `ReactComponent` instance. However, using this return value is legacy
-> and should be avoided because future versions of React may render components asynchronously in some cases. If you need a reference to the root `ReactComponent` instance, the preferred solution is to attach a
-> [callback ref](/docs/more-about-refs.html#the-ref-callback-attribute) to the root element.
+> `ReactDOM.render()` actualmente retorna una referencia a la instancia `ReactComponent` raíz. Sin embargo, utilizar este valor retornado es una practica vieja,
+> y debe ser evitada debido a que en futuras versiones de React puede que los componentes se renderizen de manera asíncrona en algunos casos. Si deseas obtener una referencia a la instancia `ReactComponent` raíz,
+> la solución preferida es agregar una [referencia mediante callback](/docs/more-about-refs.html#the-ref-callback-attribute) al elemento raíz.
 >
-> Using `ReactDOM.render()` to hydrate a server-rendered container is deprecated and will be removed in React 17. Use [`hydrate()`](#hydrate) instead.
-
-> Note:
->
-> `ReactDOM.render()` controls the contents of the container node you pass in. Any existing DOM elements inside are replaced when first called. Later calls use React’s DOM diffing algorithm for efficient updates.
->
-> `ReactDOM.render()` does not modify the container node (only modifies the children of the container). It may be possible to insert a component to an existing DOM node without overwriting the existing children.
->
-> `ReactDOM.render()` currently returns a reference to the root `ReactComponent` instance. However, using this return value is legacy
-> and should be avoided because future versions of React may render components asynchronously in some cases. If you need a reference to the root `ReactComponent` instance, the preferred solution is to attach a
-> [callback ref](/docs/more-about-refs.html#the-ref-callback-attribute) to the root element.
->
-> Using `ReactDOM.render()` to hydrate a server-rendered container is deprecated and will be removed in React 17. Use [`hydrate()`](#hydrate) instead.
+> Usar `ReactDOM.render()` para refrescar un contenedor renderizado por servidor es una practica vieja, y sera deprecada en la version 17 de React. Usa [`hydrate()`](#hydrate) en su lugar.
 
 * * *
 

From ec11c947a4e38ab7bfe29ff8568c06797b8f3378 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Fri, 1 Feb 2019 17:35:26 -0400
Subject: [PATCH 05/12] Finishing translation on hydrate part

---
 content/docs/reference-react-dom.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index 80a110f0f..eb1d038c4 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -59,18 +59,18 @@ Si el callback opcional es suministrado, sera ejecutado después de que el compo
 ### `hydrate()`
 
 ```javascript
-ReactDOM.hydrate(element, container[, callback])
+ReactDOM.hydrate(elemento, contenedor[, callback])
 ```
 
-Same as [`render()`](#render), but is used to hydrate a container whose HTML contents were rendered by [`ReactDOMServer`](/docs/react-dom-server.html). React will attempt to attach event listeners to the existing markup.
+Es igual a [`render()`](#render), pero es utilizado para refrescar un contenedor cuyo contenido HTML fur renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratara de agregar detectores de eventos al marcado existente.
 
-React expects that the rendered content is identical between the server and the client. It can patch up differences in text content, but you should treat mismatches as bugs and fix them. In development mode, React warns about mismatches during hydration. There are no guarantees that attribute differences will be patched up in case of mismatches. This is important for performance reasons because in most apps, mismatches are rare, and so validating all markup would be prohibitively expensive.
+React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede ser capaz de arreglar las diferencias en el contexto de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante el refrescamiento. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
 
-If a single element's attribute or text content is unavoidably different between the server and the client (for example, a timestamp), you may silence the warning by adding `suppressHydrationWarning={true}` to the element. It only works one level deep, and is intended to be an escape hatch. Don't overuse it. Unless it's text content, React still won't attempt to patch it up, so it may remain inconsistent until future updates.
+Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de el. A menos que sea contenido de texto, React aun no intentara arreglarlo, asi que es posible que continué inconsistente hasta próximas actualizaciones.
 
-If you intentionally need to render something different on the server and the client, you can do a two-pass rendering. Components that render something different on the client can read a state variable like `this.state.isClient`, which you can set to `true` in `componentDidMount()`. This way the initial render pass will render the same content as the server, avoiding mismatches, but an additional pass will happen synchronously right after hydration. Note that this approach will make your components slower because they have to render twice, so use it with caution.
+Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el pase de renderizado inicial renderizara el mismo contenido que el servidor, evitando desajustes, pero un pase adicional pasara sincronamente justo después de la actualización. Recuerda que este enfoque hará que tus componentes sean mas lentos debido a que se deben renderizar 2 veces, asi que usa esto con precaución.
 
-Remember to be mindful of user experience on slow connections. The JavaScript code may load significantly later than the initial HTML render, so if you render something different in the client-only pass, the transition can be jarring. However, if executed well, it may be beneficial to render a "shell" of the application on the server, and only show some of the extra widgets on the client. To learn how to do this without getting the markup mismatch issues, refer to the explanation in the previous paragraph.
+Recuerda estar consciente d la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una "capa" de la aplicación en el servidor, y solo mostrar unos widgets extra en el cliente. Para aprender como hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
 
 * * *
 

From 95cdb49f7fb301f0b59938b36069aa54200a5b52 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Fri, 1 Feb 2019 17:36:38 -0400
Subject: [PATCH 06/12] Changing hydrate translation for a more consistent one

---
 content/docs/reference-react-dom.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index eb1d038c4..11323ef52 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -52,7 +52,7 @@ Si el callback opcional es suministrado, sera ejecutado después de que el compo
 > y debe ser evitada debido a que en futuras versiones de React puede que los componentes se renderizen de manera asíncrona en algunos casos. Si deseas obtener una referencia a la instancia `ReactComponent` raíz,
 > la solución preferida es agregar una [referencia mediante callback](/docs/more-about-refs.html#the-ref-callback-attribute) al elemento raíz.
 >
-> Usar `ReactDOM.render()` para refrescar un contenedor renderizado por servidor es una practica vieja, y sera deprecada en la version 17 de React. Usa [`hydrate()`](#hydrate) en su lugar.
+> Usar `ReactDOM.render()` para actualizar un contenedor renderizado por servidor es una practica vieja, y sera deprecada en la version 17 de React. Usa [`hydrate()`](#hydrate) en su lugar.
 
 * * *
 
@@ -62,9 +62,9 @@ Si el callback opcional es suministrado, sera ejecutado después de que el compo
 ReactDOM.hydrate(elemento, contenedor[, callback])
 ```
 
-Es igual a [`render()`](#render), pero es utilizado para refrescar un contenedor cuyo contenido HTML fur renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratara de agregar detectores de eventos al marcado existente.
+Es igual a [`render()`](#render), pero es utilizado para actualizar un contenedor cuyo contenido HTML fur renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratara de agregar detectores de eventos al marcado existente.
 
-React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede ser capaz de arreglar las diferencias en el contexto de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante el refrescamiento. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
+React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede ser capaz de arreglar las diferencias en el contexto de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante la actualización. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
 
 Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de el. A menos que sea contenido de texto, React aun no intentara arreglarlo, asi que es posible que continué inconsistente hasta próximas actualizaciones.
 

From ecba1e527c5be5c9cdc7e9795d4ed9ab0c9bed92 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Fri, 1 Feb 2019 18:34:09 -0400
Subject: [PATCH 07/12] Finishing translaiton on last 4 items of ReactDOM, and
 with this, finishing first draft of translation

---
 content/docs/reference-react-dom.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index 11323ef52..281710d2a 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -64,51 +64,51 @@ ReactDOM.hydrate(elemento, contenedor[, callback])
 
 Es igual a [`render()`](#render), pero es utilizado para actualizar un contenedor cuyo contenido HTML fur renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratara de agregar detectores de eventos al marcado existente.
 
-React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede ser capaz de arreglar las diferencias en el contexto de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante la actualización. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
+React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede arreglar las diferencias del contenido de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante la actualización. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
 
 Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de el. A menos que sea contenido de texto, React aun no intentara arreglarlo, asi que es posible que continué inconsistente hasta próximas actualizaciones.
 
 Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el pase de renderizado inicial renderizara el mismo contenido que el servidor, evitando desajustes, pero un pase adicional pasara sincronamente justo después de la actualización. Recuerda que este enfoque hará que tus componentes sean mas lentos debido a que se deben renderizar 2 veces, asi que usa esto con precaución.
 
-Recuerda estar consciente d la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una "capa" de la aplicación en el servidor, y solo mostrar unos widgets extra en el cliente. Para aprender como hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
+Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una "capa" de la aplicación en el servidor, y solo mostrar unos widgets extra en el cliente. Para aprender como hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
 
 * * *
 
 ### `unmountComponentAtNode()`
 
 ```javascript
-ReactDOM.unmountComponentAtNode(container)
+ReactDOM.unmountComponentAtNode(contenedor)
 ```
 
-Remove a mounted React component from the DOM and clean up its event handlers and state. If no component was mounted in the container, calling this function does nothing. Returns `true` if a component was unmounted and `false` if there was no component to unmount.
+Remueve un componente React ya montado en el DOM, y limpia sus manejadores de eventos y estado. Si ningún componente fue montado en el contenedor, llamar a esta función no hará nada. Retorna `true` si un componente fue desmontado, y `false` si no hay algún componente para desmontar.
 
 * * *
 
 ### `findDOMNode()`
 
-> Note:
+> Nota:
 >
-> `findDOMNode` is an escape hatch used to access the underlying DOM node. In most cases, use of this escape hatch is discouraged because it pierces the component abstraction. [It has been deprecated in `StrictMode`.](/docs/strict-mode.html#warning-about-deprecated-finddomnode-usage)
+> `findDOMNode` es una escotilla de escape para acceder al componente DOM subyacente. En la mayoría de los casos, usar esta escotilla de escape no es recomendado debido a que atraviesa la abstracción del componente. [Esto ha sido deprecado en modo estricto: `StrictMode`.](/docs/strict-mode.html#warning-about-deprecated-finddomnode-usage)
 
 ```javascript
-ReactDOM.findDOMNode(component)
+ReactDOM.findDOMNode(componente)
 ```
-If this component has been mounted into the DOM, this returns the corresponding native browser DOM element. This method is useful for reading values out of the DOM, such as form field values and performing DOM measurements. **In most cases, you can attach a ref to the DOM node and avoid using `findDOMNode` at all.**
+Si este componente ha sido montado al DOM, este método retorna el elemento DOM nativo correspondiente. Este método es util para leer valores fuera del DOM, como por ejemplo valores de formularios, o realizar mediciones del DOM. **En la mayoría de casos, puedes agregar una referencia al nodo del DOM, y evitar el uso de `findDOMNode` por completo**
 
-When a component renders to `null` or `false`, `findDOMNode` returns `null`. When a component renders to a string, `findDOMNode` returns a text DOM node containing that value. As of React 16, a component may return a fragment with multiple children, in which case `findDOMNode` will return the DOM node corresponding to the first non-empty child.
+Cuando un componente es renderizado a `null` o `false`, `findDOMNode` retorna `null`. Cuando un componente es renderizado a una cadena de texto, `findDOMNode` retorna un nodo DOM de texto que contiene ese valor. En React 16, un componente puede retornar un fragmento con múltiples hijos, en este caso `findDOMNode` retornara el nodo del DOM correspondiente al primer hijo no vació.
 
-> Note:
+> Nota:
 >
-> `findDOMNode` only works on mounted components (that is, components that have been placed in the DOM). If you try to call this on a component that has not been mounted yet (like calling `findDOMNode()` in `render()` on a component that has yet to be created) an exception will be thrown.
+> `findDOMNode` solo funciona con componentes montados (esto significa, componentes que han sido puestos en el DOM). Si tratas de llamar este método con un componente que aun no ha sido montado (por ejemplo, llamar `findDOMNode()` en `render()` con un componente que aun no ha sido creado) generara una excepción.
 >
-> `findDOMNode` cannot be used on function components.
+> `findDOMNode` no puede ser utilizado con componentes de tipo función.
 
 * * *
 
 ### `createPortal()`
 
 ```javascript
-ReactDOM.createPortal(child, container)
+ReactDOM.createPortal(hijo, contenedor)
 ```
 
-Creates a portal. Portals provide a way to [render children into a DOM node that exists outside the hierarchy of the DOM component](/docs/portals.html).
+Crea un portal. Los portales proveen una forma para [renderizar hijos a un nodo del DOM que existe fuera de la jerarquía del componente DOM](/docs/portals.html).
\ No newline at end of file

From 466ce6541261bf359a82cdb9ff99e93415388d23 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Sat, 2 Feb 2019 13:02:00 -0400
Subject: [PATCH 08/12] Finishing checking on orthography

---
 .vscode/settings.json               | 16 ++++++++++++++-
 content/docs/reference-react-dom.md | 30 ++++++++++++++---------------
 2 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 74fc39c1b..21d1c89ea 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,17 @@
 {
-    "cSpell.language": ",es"
+    "cSpell.language": ",es",
+    "cSpell.words": [
+        "at",
+        "callback",
+        "component",
+        "create",
+        "dom",
+        "find",
+        "from",
+        "hydrate",
+        "node",
+        "polyfills",
+        "portal",
+        "unmount"
+    ]
 }
\ No newline at end of file
diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index 281710d2a..d76bfb4aa 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -6,11 +6,11 @@ category: Reference
 permalink: docs/react-dom.html
 ---
 
-Si cargas React desde una etiqueta `<script>`, estas APIs de alto nivel estaran disponibles en la variable global `ReactDOM`. Si usas ES6 con npm, puedes escribir `import ReactDOM from 'react-dom'`. Si usas ES5 con npm, puedes escribir `var ReactDOM = require('react-dom')`.
+Si cargas React desde una etiqueta `<script>`, estas APIs de alto nivel estarán disponibles en la variable global `ReactDOM`. Si usas ES6 con npm, puedes escribir `import ReactDOM from 'react-dom'`. Si usas ES5 con npm, puedes escribir `var ReactDOM = require('react-dom')`.
 
 ## Resumen
 
-El paquete `react-dom` proporciona métodos específicos del DOM que pueden ser utilizados en el nivel mas alto de tu aplicación como una escotilla de escape para salir del modelo de React si asi lo necesitas. La mayoría de tus componentes no deberían necesitar usar este modulo.
+El paquete `react-dom` proporciona métodos específicos del DOM que pueden ser utilizados en el nivel más alto de tu aplicación como una escotilla de escape para salir del modelo de React si así lo necesitas. La mayoría de tus componentes no deberían necesitar usar este módulo.
 
 - [`render()`](#render)
 - [`hydrate()`](#hydrate)
@@ -20,11 +20,11 @@ El paquete `react-dom` proporciona métodos específicos del DOM que pueden ser
 
 ### Soporte de Navegadores
 
-React soporta todos los navegadores populares, incluyendo Internet Explorer 9 y versiones posteriores, aunque [algunos polyfills son requeridos](/docs/javascript-environment-requirements.html) para navegadores mas viejos como IE 9 e IE 10.
+React soporta todos los navegadores populares, incluyendo Internet Explorer 9 y versiones posteriores, aunque [algunos polyfills son requeridos](/docs/javascript-environment-requirements.html) para navegadores más viejos como IE 9 e IE 10.
 
 > Nota
 >
-> No soportamos navegadores viejos que no soporten metodos ES5, pero puede que te des cuenta de que tus aplicaciones funcionan en navegadores viejos si polyfills como [es5-shim y es5-sham](https://github.com/es-shims/es5-shim) estan incluidas en la pagina. Estas por tu cuenta si decides tomar este camino.
+> No soportamos navegadores viejos que no soporten métodos ES5, pero puede que te des cuenta de que tus aplicaciones funcionan en navegadores viejos si polyfills como [es5-shim y es5-sham](https://github.com/es-shims/es5-shim) están incluidas en la pagina. Estás por tu cuenta si decides tomar este camino.
 
 * * *
 
@@ -38,9 +38,9 @@ ReactDOM.render(elemento, contenedor[, callback])
 
 Renderiza un elemento React al DOM en el `contenedor` suministrado y retorna una [referencia](/docs/more-about-refs.html) al componente (o devuelve `null` para [componentes sin estado](/docs/components-and-props.html#functional-and-class-components)).
 
-Si el elemento React fue previamente renderizado al `contenedor`, esto ejecutara una actualización en el, y solo mutara el DOM de ser necesario para reflejar el mas reciente elemento React.
+Si el elemento React fue previamente renderizado al `contenedor`, esto ejecutará una actualización en él, y solo mutará el DOM de ser necesario para reflejar el más reciente elemento React.
 
-Si el callback opcional es suministrado, sera ejecutado después de que el componente es renderizado o actualizado.
+Si el callback opcional es suministrado, será ejecutado después de que el componente es renderizado o actualizado.
 
 > Nota:
 >
@@ -48,11 +48,11 @@ Si el callback opcional es suministrado, sera ejecutado después de que el compo
 >
 > `ReactDOM.render()` no modifica el nodo contenedor (solo modifica los hijos del contenedor). Puede ser posible insertar un componente en un nodo existente del DOM sin sobrescribir los hijos existentes.
 >
-> `ReactDOM.render()` actualmente retorna una referencia a la instancia `ReactComponent` raíz. Sin embargo, utilizar este valor retornado es una practica vieja,
-> y debe ser evitada debido a que en futuras versiones de React puede que los componentes se renderizen de manera asíncrona en algunos casos. Si deseas obtener una referencia a la instancia `ReactComponent` raíz,
+> `ReactDOM.render()` actualmente retorna una referencia a la instancia `ReactComponent` raíz. Sin embargo, utilizar este valor retornado es una práctica vieja,
+> y debe ser evitada debido a que en futuras versiones de React puede que los componentes se rendericen de manera asíncrona en algunos casos. Si deseas obtener una referencia a la instancia `ReactComponent` raíz,
 > la solución preferida es agregar una [referencia mediante callback](/docs/more-about-refs.html#the-ref-callback-attribute) al elemento raíz.
 >
-> Usar `ReactDOM.render()` para actualizar un contenedor renderizado por servidor es una practica vieja, y sera deprecada en la version 17 de React. Usa [`hydrate()`](#hydrate) en su lugar.
+> Usar `ReactDOM.render()` para actualizar un contenedor renderizado por servidor es una práctica vieja, y será deprecada en la versión 17 de React. Usa [`hydrate()`](#hydrate) en su lugar.
 
 * * *
 
@@ -62,15 +62,15 @@ Si el callback opcional es suministrado, sera ejecutado después de que el compo
 ReactDOM.hydrate(elemento, contenedor[, callback])
 ```
 
-Es igual a [`render()`](#render), pero es utilizado para actualizar un contenedor cuyo contenido HTML fur renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratara de agregar detectores de eventos al marcado existente.
+Es igual a [`render()`](#render), pero es utilizado para actualizar un contenedor cuyo contenido HTML fue renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratara de agregar detectores de eventos al marcado existente.
 
 React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede arreglar las diferencias del contenido de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante la actualización. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
 
-Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de el. A menos que sea contenido de texto, React aun no intentara arreglarlo, asi que es posible que continué inconsistente hasta próximas actualizaciones.
+Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de él. A menos que sea contenido de texto, React aun no intentara arreglarlo, así que es posible que continué inconsistente hasta próximas actualizaciones.
 
-Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el pase de renderizado inicial renderizara el mismo contenido que el servidor, evitando desajustes, pero un pase adicional pasara sincronamente justo después de la actualización. Recuerda que este enfoque hará que tus componentes sean mas lentos debido a que se deben renderizar 2 veces, asi que usa esto con precaución.
+Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el pase de renderizado inicial renderizará el mismo contenido que el servidor, evitando desajustes, pero un pase adicional pasará síncronamente justo después de la actualización. Recuerda que este enfoque hará que tus componentes sean más lentos debido a que se deben renderizar 2 veces, asi que usa esto con precaución.
 
-Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una "capa" de la aplicación en el servidor, y solo mostrar unos widgets extra en el cliente. Para aprender como hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
+Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una "capa" de la aplicación en el servidor, y solo mostrar unos widgets extra en el cliente. Para aprender cómo hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
 
 * * *
 
@@ -93,13 +93,13 @@ Remueve un componente React ya montado en el DOM, y limpia sus manejadores de ev
 ```javascript
 ReactDOM.findDOMNode(componente)
 ```
-Si este componente ha sido montado al DOM, este método retorna el elemento DOM nativo correspondiente. Este método es util para leer valores fuera del DOM, como por ejemplo valores de formularios, o realizar mediciones del DOM. **En la mayoría de casos, puedes agregar una referencia al nodo del DOM, y evitar el uso de `findDOMNode` por completo**
+Si este componente ha sido montado al DOM, este método retorna el elemento DOM nativo correspondiente. Este método es útil para leer valores fuera del DOM, como por ejemplo valores de formularios, o realizar mediciones del DOM. **En la mayoría de casos, puedes agregar una referencia al nodo del DOM, y evitar el uso de `findDOMNode` por completo**
 
 Cuando un componente es renderizado a `null` o `false`, `findDOMNode` retorna `null`. Cuando un componente es renderizado a una cadena de texto, `findDOMNode` retorna un nodo DOM de texto que contiene ese valor. En React 16, un componente puede retornar un fragmento con múltiples hijos, en este caso `findDOMNode` retornara el nodo del DOM correspondiente al primer hijo no vació.
 
 > Nota:
 >
-> `findDOMNode` solo funciona con componentes montados (esto significa, componentes que han sido puestos en el DOM). Si tratas de llamar este método con un componente que aun no ha sido montado (por ejemplo, llamar `findDOMNode()` en `render()` con un componente que aun no ha sido creado) generara una excepción.
+> `findDOMNode` solo funciona con componentes montados (esto significa, componentes que han sido puestos en el DOM). Si tratas de llamar este método con un componente que aún no ha sido montado (por ejemplo, llamar `findDOMNode()` en `render()` con un componente que aún no ha sido creado) generará una excepción.
 >
 > `findDOMNode` no puede ser utilizado con componentes de tipo función.
 

From 52c2902e1f03a7f6a829c74b85d7f1be162f11d7 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Sat, 2 Feb 2019 13:17:21 -0400
Subject: [PATCH 09/12] Checking some accents left, and translation in general

---
 content/docs/reference-react-dom.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index d76bfb4aa..8d558b5aa 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -62,11 +62,11 @@ Si el callback opcional es suministrado, será ejecutado después de que el comp
 ReactDOM.hydrate(elemento, contenedor[, callback])
 ```
 
-Es igual a [`render()`](#render), pero es utilizado para actualizar un contenedor cuyo contenido HTML fue renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratara de agregar detectores de eventos al marcado existente.
+Es igual a [`render()`](#render), pero es utilizado para actualizar un contenedor cuyo contenido HTML fue renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratará de agregar detectores de eventos al marcado existente.
 
 React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede arreglar las diferencias del contenido de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante la actualización. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
 
-Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de él. A menos que sea contenido de texto, React aun no intentara arreglarlo, así que es posible que continué inconsistente hasta próximas actualizaciones.
+Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de él. A menos que sea contenido de texto, React aun no intentará arreglarlo, así que es posible que continue inconsistente hasta próximas actualizaciones.
 
 Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el pase de renderizado inicial renderizará el mismo contenido que el servidor, evitando desajustes, pero un pase adicional pasará síncronamente justo después de la actualización. Recuerda que este enfoque hará que tus componentes sean más lentos debido a que se deben renderizar 2 veces, asi que usa esto con precaución.
 
@@ -93,9 +93,9 @@ Remueve un componente React ya montado en el DOM, y limpia sus manejadores de ev
 ```javascript
 ReactDOM.findDOMNode(componente)
 ```
-Si este componente ha sido montado al DOM, este método retorna el elemento DOM nativo correspondiente. Este método es útil para leer valores fuera del DOM, como por ejemplo valores de formularios, o realizar mediciones del DOM. **En la mayoría de casos, puedes agregar una referencia al nodo del DOM, y evitar el uso de `findDOMNode` por completo**
+Si este componente ha sido montado al DOM, este método retorna el elemento DOM nativo correspondiente. Este método es útil para leer valores fuera del DOM, como por ejemplo valores de formularios, o realizar mediciones del DOM. **En la mayoría de casos, puedes agregar una referencia al nodo del DOM, y evitar el uso de `findDOMNode` por completo**.
 
-Cuando un componente es renderizado a `null` o `false`, `findDOMNode` retorna `null`. Cuando un componente es renderizado a una cadena de texto, `findDOMNode` retorna un nodo DOM de texto que contiene ese valor. En React 16, un componente puede retornar un fragmento con múltiples hijos, en este caso `findDOMNode` retornara el nodo del DOM correspondiente al primer hijo no vació.
+Cuando un componente es renderizado a `null` o `false`, `findDOMNode` retorna `null`. Cuando un componente es renderizado a una cadena de texto, `findDOMNode` retorna un nodo DOM de texto que contiene ese valor. En React 16, un componente puede retornar un fragmento con múltiples hijos, en este caso `findDOMNode` retornará el nodo del DOM correspondiente al primer hijo no vació.
 
 > Nota:
 >

From 850a79bb76073bdff4d88579722fc21a83d1398d Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Sat, 2 Feb 2019 21:58:59 -0400
Subject: [PATCH 10/12] Adding @carburo feedback

---
 content/docs/reference-react-dom.md | 30 ++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index 8d558b5aa..5fe4559d5 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -10,7 +10,7 @@ Si cargas React desde una etiqueta `<script>`, estas APIs de alto nivel estarán
 
 ## Resumen
 
-El paquete `react-dom` proporciona métodos específicos del DOM que pueden ser utilizados en el nivel más alto de tu aplicación como una escotilla de escape para salir del modelo de React si así lo necesitas. La mayoría de tus componentes no deberían necesitar usar este módulo.
+El paquete `react-dom` proporciona métodos específicos del DOM que pueden ser utilizados en el nivel más alto de tu aplicación como una vía de escape del modelo de React si así lo necesitas. La mayoría de tus componentes no deberían necesitar usar este módulo.
 
 - [`render()`](#render)
 - [`hydrate()`](#hydrate)
@@ -20,11 +20,11 @@ El paquete `react-dom` proporciona métodos específicos del DOM que pueden ser
 
 ### Soporte de Navegadores
 
-React soporta todos los navegadores populares, incluyendo Internet Explorer 9 y versiones posteriores, aunque [algunos polyfills son requeridos](/docs/javascript-environment-requirements.html) para navegadores más viejos como IE 9 e IE 10.
+React es compatible con todos los navegadores populares, incluyendo Internet Explorer 9 y versiones posteriores, aunque [se necesitan algunos *polyfills*](/docs/javascript-environment-requirements.html) para navegadores más antiguos como IE 9 e IE 10.
 
 > Nota
 >
-> No soportamos navegadores viejos que no soporten métodos ES5, pero puede que te des cuenta de que tus aplicaciones funcionan en navegadores viejos si polyfills como [es5-shim y es5-sham](https://github.com/es-shims/es5-shim) están incluidas en la pagina. Estás por tu cuenta si decides tomar este camino.
+> No aseguramos la compatibilidad con los navegadores más antiguos que no incluyen métodos ES5, pero quizá encuentres que tus aplicaciones funcionan en estos navegadores si *polyfills* como [es5-shim y es5-sham](https://github.com/es-shims/es5-shim) están incluidos en la página. Estás por tu cuenta si decides tomar este camino.
 
 * * *
 
@@ -40,11 +40,11 @@ Renderiza un elemento React al DOM en el `contenedor` suministrado y retorna una
 
 Si el elemento React fue previamente renderizado al `contenedor`, esto ejecutará una actualización en él, y solo mutará el DOM de ser necesario para reflejar el más reciente elemento React.
 
-Si el callback opcional es suministrado, será ejecutado después de que el componente es renderizado o actualizado.
+Si se suministra el *callback* opcional, será ejecutado después de que el componente es renderizado o actualizado.
 
 > Nota:
 >
-> `ReactDOM.render()` controla el contenido del nodo contenedor que suministras. Cualquiera de los elementos DOM adentro de este son reemplazados cuando es llamado por primera vez. Las llamadas posteriores utilizan el algoritmo de diferenciado de React DOM para actualizaciones eficientes.
+> `ReactDOM.render()` controla el contenido del nodo contenedor que suministras. Cualquiera de los elementos DOM dentro de este son reemplazados cuando se llama por primera vez. Las llamadas posteriores utilizan el algoritmo de diferenciado de React DOM para actualizaciones eficientes.
 >
 > `ReactDOM.render()` no modifica el nodo contenedor (solo modifica los hijos del contenedor). Puede ser posible insertar un componente en un nodo existente del DOM sin sobrescribir los hijos existentes.
 >
@@ -52,7 +52,7 @@ Si el callback opcional es suministrado, será ejecutado después de que el comp
 > y debe ser evitada debido a que en futuras versiones de React puede que los componentes se rendericen de manera asíncrona en algunos casos. Si deseas obtener una referencia a la instancia `ReactComponent` raíz,
 > la solución preferida es agregar una [referencia mediante callback](/docs/more-about-refs.html#the-ref-callback-attribute) al elemento raíz.
 >
-> Usar `ReactDOM.render()` para actualizar un contenedor renderizado por servidor es una práctica vieja, y será deprecada en la versión 17 de React. Usa [`hydrate()`](#hydrate) en su lugar.
+> El uso de `ReactDOM.render()` para hidratar un contenedor renderizado por servidor esta despreciado, y será eliminado en la versión 17 de React. Usa en su lugar [`hydrate()`](#hydrate).
 
 * * *
 
@@ -62,15 +62,15 @@ Si el callback opcional es suministrado, será ejecutado después de que el comp
 ReactDOM.hydrate(elemento, contenedor[, callback])
 ```
 
-Es igual a [`render()`](#render), pero es utilizado para actualizar un contenedor cuyo contenido HTML fue renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratará de agregar detectores de eventos al marcado existente.
+Es igual a [`render()`](#render), pero es utilizado para hidratar un contenedor cuyo contenido HTML fue renderizado por [`ReactDOMServer`](/docs/react-dom-server.html). React tratará de agregar detectores de eventos al marcado existente.
 
-React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede arreglar las diferencias del contenido de texto, pero deberías tratar los desajustes como errores, y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante la actualización. No hay garantías de que las diferencias de atributos serán arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros, por esto validar todo el marcado seria prohibitivamente costoso.
+React espera que el contenido renderizado sea idéntico entre el servidor y el cliente. Puede arreglar las diferencias del contenido de texto, pero deberías tratar los desajustes como errores y arreglarlos. En modo de desarrollo, React alerta sobre desajustes durante la hidratación. No hay garantías de que las diferencias de atributos sean arregladas en caso de desajustes. Esto es importante por razones de rendimiento, porque en la mayoría de las aplicaciones los desajustes son raros y validar todo el marcado sería demasiado costoso.
 
-Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y es pensado para ser una escotilla de escape. No abuses de él. A menos que sea contenido de texto, React aun no intentará arreglarlo, así que es posible que continue inconsistente hasta próximas actualizaciones.
+Si el atributo de un elemento o contenido de texto es inevitablemente diferente entre el servidor y el cliente (por ejemplo, una marca de tiempo), puedes silenciar la alerta agregando `suppressHydrationWarning={true}` al elemento. Esto solo funciona a 1 nivel de profundidad, y está pensado como una vía de escape. No abuses de él. A menos que sea contenido de texto, React aun no intentará arreglarlo, así que es posible que continue inconsistente hasta próximas actualizaciones.
 
-Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el pase de renderizado inicial renderizará el mismo contenido que el servidor, evitando desajustes, pero un pase adicional pasará síncronamente justo después de la actualización. Recuerda que este enfoque hará que tus componentes sean más lentos debido a que se deben renderizar 2 veces, asi que usa esto con precaución.
+Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el paso de renderizado inicial renderizará el mismo contenido que el servidor, evitando desajustes, pero un paso adicional ocurrirá síncronamente justo después de la hidratación. Recuerda que este enfoque hará que tus componentes sean más lentos debido a que se deben renderizar dos veces, así que utilízalo con precaución.
 
-Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una "capa" de la aplicación en el servidor, y solo mostrar unos widgets extra en el cliente. Para aprender cómo hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
+Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una «capa» de la aplicación en el servidor, y solo mostrar unos *widgets* extra en el cliente. Para aprender cómo hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
 
 * * *
 
@@ -80,7 +80,7 @@ Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El
 ReactDOM.unmountComponentAtNode(contenedor)
 ```
 
-Remueve un componente React ya montado en el DOM, y limpia sus manejadores de eventos y estado. Si ningún componente fue montado en el contenedor, llamar a esta función no hará nada. Retorna `true` si un componente fue desmontado, y `false` si no hay algún componente para desmontar.
+Elimina un componente React ya montado en el DOM, y limpia sus manejadores de eventos y estado. Si ningún componente fue montado en el contenedor, llamar a esta función no hará nada. Retorna `true` si un componente fue desmontado, y `false` si no hay algún componente para desmontar.
 
 * * *
 
@@ -88,20 +88,20 @@ Remueve un componente React ya montado en el DOM, y limpia sus manejadores de ev
 
 > Nota:
 >
-> `findDOMNode` es una escotilla de escape para acceder al componente DOM subyacente. En la mayoría de los casos, usar esta escotilla de escape no es recomendado debido a que atraviesa la abstracción del componente. [Esto ha sido deprecado en modo estricto: `StrictMode`.](/docs/strict-mode.html#warning-about-deprecated-finddomnode-usage)
+> `findDOMNode` es una vía de escape para acceder al componente DOM subyacente. En la mayoría de los casos no se recomienda, debido a que rompe la abstracción del componente. [Su uso esta censurado en el modo estricto (StrictMode).](/docs/strict-mode.html#warning-about-deprecated-finddomnode-usage)
 
 ```javascript
 ReactDOM.findDOMNode(componente)
 ```
 Si este componente ha sido montado al DOM, este método retorna el elemento DOM nativo correspondiente. Este método es útil para leer valores fuera del DOM, como por ejemplo valores de formularios, o realizar mediciones del DOM. **En la mayoría de casos, puedes agregar una referencia al nodo del DOM, y evitar el uso de `findDOMNode` por completo**.
 
-Cuando un componente es renderizado a `null` o `false`, `findDOMNode` retorna `null`. Cuando un componente es renderizado a una cadena de texto, `findDOMNode` retorna un nodo DOM de texto que contiene ese valor. En React 16, un componente puede retornar un fragmento con múltiples hijos, en este caso `findDOMNode` retornará el nodo del DOM correspondiente al primer hijo no vació.
+Cuando un componente es renderizado a `null` o `false`, `findDOMNode` retorna `null`. Cuando un componente es renderizado a una cadena de texto, `findDOMNode` retorna un nodo DOM de texto que contiene ese valor. En React 16, un componente puede retornar un fragmento con múltiples hijos, en este caso `findDOMNode` retornará el nodo del DOM correspondiente al primer hijo no vacío.
 
 > Nota:
 >
 > `findDOMNode` solo funciona con componentes montados (esto significa, componentes que han sido puestos en el DOM). Si tratas de llamar este método con un componente que aún no ha sido montado (por ejemplo, llamar `findDOMNode()` en `render()` con un componente que aún no ha sido creado) generará una excepción.
 >
-> `findDOMNode` no puede ser utilizado con componentes de tipo función.
+> `findDOMNode` no puede ser utilizado en componentes de función.
 
 * * *
 

From 01dd6296e551a3e4169f2e9431ed57663325356f Mon Sep 17 00:00:00 2001
From: Miguel Alejandro Bolivar Portilla <MBolivar360@gmail.com>
Date: Sat, 2 Feb 2019 22:13:07 -0400
Subject: [PATCH 11/12] Delete .vscode/settings.json from file

Deleting file
---
 .vscode/settings.json | 17 -----------------
 1 file changed, 17 deletions(-)
 delete mode 100644 .vscode/settings.json

diff --git a/.vscode/settings.json b/.vscode/settings.json
deleted file mode 100644
index 21d1c89ea..000000000
--- a/.vscode/settings.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-    "cSpell.language": ",es",
-    "cSpell.words": [
-        "at",
-        "callback",
-        "component",
-        "create",
-        "dom",
-        "find",
-        "from",
-        "hydrate",
-        "node",
-        "polyfills",
-        "portal",
-        "unmount"
-    ]
-}
\ No newline at end of file

From f94a6c6d1859f61ae9737ed929491a84cea34d91 Mon Sep 17 00:00:00 2001
From: Miguel Bolivar <MBolivar360@gmail.com>
Date: Sat, 2 Feb 2019 22:34:13 -0400
Subject: [PATCH 12/12] Changing typo in word for 'pase'

---
 content/docs/reference-react-dom.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index 5fe4559d5..b77c0382e 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -70,7 +70,7 @@ Si el atributo de un elemento o contenido de texto es inevitablemente diferente
 
 Si necesitas renderizar algo diferente de manera intencional en el servidor y en el cliente, puedes realizar un renderizado en 2 pasos. Los componentes que renderizan contenido diferente al cliente, pueden leer una variable de estado como `this.state.isClient`, la cual puedes cambiar a `true` en `componentDidMount()`. De esta manera, el paso de renderizado inicial renderizará el mismo contenido que el servidor, evitando desajustes, pero un paso adicional ocurrirá síncronamente justo después de la hidratación. Recuerda que este enfoque hará que tus componentes sean más lentos debido a que se deben renderizar dos veces, así que utilízalo con precaución.
 
-Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el pase exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una «capa» de la aplicación en el servidor, y solo mostrar unos *widgets* extra en el cliente. Para aprender cómo hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
+Recuerda estar consciente de la experiencia de usuario en conexiones lentas. El código Javascript puede ser cargado significativamente después de que el HTML inicial sea renderizado, entonces, si renderizas algo diferente en el paso exclusivo por el cliente, la transición puede ser discorde. Sin embargo, si se ejecuta bien, puede ser beneficioso para renderizar una «capa» de la aplicación en el servidor, y solo mostrar unos *widgets* extra en el cliente. Para aprender cómo hacer esto sin tener desajustes en el marcado, consulta la explicación en el párrafo anterior.
 
 * * *