From 41565d2bb720fa2360cc4c27d877c8296a956364 Mon Sep 17 00:00:00 2001
From: Homero304 <homeromaring@gmail.com>
Date: Mon, 31 Aug 2020 22:21:26 -0500
Subject: [PATCH 01/11] Cross-window communication

---
 .../03-cross-window-communication/article.md  | 260 +++++++++---------
 .../postmessage.view/iframe.html              |   4 +-
 .../postmessage.view/index.html               |   4 +-
 .../sandbox.view/index.html                   |   2 +-
 .../sandbox.view/sandboxed.html               |   4 +-
 5 files changed, 137 insertions(+), 137 deletions(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index 53f5f55fc..f9d9ce9f6 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -1,88 +1,88 @@
-# Cross-window communication
+# Comunicación entre ventanas
 
-The "Same Origin" (same site) policy limits access of windows and frames to each other.
+La política de "Mismo origen" (mismo sitio) limita el acceso de ventanas y marcos entre sí.
 
-The idea is that if a user has two pages open: one from `john-smith.com`, and another one is `gmail.com`, then they wouldn't want a script from `john-smith.com` to read our mail from `gmail.com`. So, the purpose of the "Same Origin" policy is to protect users from information theft.
+La idea es que si un usuario tiene dos páginas abiertas: una de `john-smith.com`, y otra es` gmail.com`, entonces no querrán que un script de `john-smith.com` lea nuestro correo de `gmail.com`. Por lo tanto, el propósito de la política de "Mismo origen" es proteger a los usuarios del robo de información.
 
-## Same Origin [#same-origin]
+## Mismo origen [#same-origin]
 
-Two URLs are said to have the "same origin" if they have the same protocol, domain and port.
+Se dice que dos URL tienen el "mismo origen" si tienen el mismo protocolo, dominio y puerto.
 
-These URLs all share the same origin:
+Todas estas URL comparten el mismo origen:
 
 - `http://site.com`
 - `http://site.com/`
 - `http://site.com/my/page.html`
 
-These ones do not:
+Estas no:
 
-- <code>http://<b>www.</b>site.com</code> (another domain: `www.` matters)
-- <code>http://<b>site.org</b></code> (another domain: `.org` matters)
-- <code><b>https://</b>site.com</code> (another protocol: `https`)
-- <code>http://site.com:<b>8080</b></code> (another port: `8080`)
+- <code>http://<b>www.</b>site.com</code> (otro dominio: `www.` importa)
+- <code>http://<b>site.org</b></code> (otro dominio: `.org` importa)
+- <code><b>https://</b>site.com</code> (otro protocolo: `https`)
+- <code>http://site.com:<b>8080</b></code> (otro puerto: `8080`)
 
-The "Same Origin" policy states that:
+La política de "Mismo origen" establece que:
 
-- if we have a reference to another window, e.g. a popup created by `window.open` or a window inside `<iframe>`, and that window comes from the same origin, then we have full access to that window.
-- otherwise, if it comes from another origin, then we can't access the content of that window: variables, document, anything. The only exception is `location`: we can change it (thus redirecting the user). But we cannot *read* location (so we can't see where the user is now, no information leak).
+- si tenemos una referencia a otra ventana, por ejemplo, una ventana emergente creada por `window.open` o una ventana dentro de `<iframe>`, y esa ventana viene del mismo origen, entonces tenemos acceso completo a esa ventana.
+- en caso contrario, si viene de otro origen, entonces no podemos acceder al contenido de esa ventana: variables, documento, nada. La única excepción es `location`: podemos cambiarla (redirigiendo así al usuario). Pero no podemos *leer* location (por lo que no podemos ver dónde está el usuario ahora, no hay fuga de información).
 
-### In action: iframe
+### En acción: iframe
 
-An `<iframe>` tag hosts a separate embedded window, with its own separate `document` and `window` objects.
+Una etiqueta `<iframe>` aloja una ventana incrustada por separado, con sus propios objetos `document` y `window` separados.
 
-We can access them using properties:
+Podemos acceder a ellos usando propiedades:
 
-- `iframe.contentWindow` to get the window inside the `<iframe>`.
-- `iframe.contentDocument` to get the document inside the `<iframe>`, shorthand for `iframe.contentWindow.document`.
+- `iframe.contentWindow` para obtener la ventana dentro del `<iframe>`.
+- `iframe.contentDocument` para obtener el documento dentro del `<iframe>`, abreviatura de `iframe.contentWindow.document`.
 
-When we access something inside the embedded window, the browser checks if the iframe has the same origin. If that's not so then the access is denied (writing to `location` is an exception, it's still permitted).
+Cuando accedemos a algo dentro de la ventana incrustada, el navegador comprueba si el iframe tiene el mismo origen. Si no es así, se niega el acceso (escribir en `location` es una excepción, aún está permitido).
 
-For instance, let's try reading and writing to `<iframe>` from another origin:
+Por ejemplo, intentemos leer y escribir en `<iframe>` desde otro origen:
 
 ```html run
 <iframe src="https://example.com" id="iframe"></iframe>
 
 <script>
   iframe.onload = function() {
-    // we can get the reference to the inner window
+    // podemos obtener la referencia a la ventana interior
 *!*
     let iframeWindow = iframe.contentWindow; // OK
 */!*
     try {
-      // ...but not to the document inside it
+      // ...pero no al documento que contiene
 *!*
       let doc = iframe.contentDocument; // ERROR
 */!*
     } catch(e) {
-      alert(e); // Security Error (another origin)
+      alert(e); // Error de seguridad (otro origen)
     }
 
-    // also we can't READ the URL of the page in iframe
+    // tampoco podemos LEER la URL de la página en iframe
     try {
-      // Can't read URL from the Location object
+      // No se puede leer la URL del objeto Location
 *!*
       let href = iframe.contentWindow.location.href; // ERROR
 */!*
     } catch(e) {
-      alert(e); // Security Error
+      alert(e); // Error de seguridad
     }
 
-    // ...we can WRITE into location (and thus load something else into the iframe)!
+    // ...¡podemos ESCRIBIR en location (y así cargar algo más en el iframe)!
 *!*
     iframe.contentWindow.location = '/'; // OK
 */!*
 
-    iframe.onload = null; // clear the handler, not to run it after the location change
+    iframe.onload = null; // borra el controlador para no ejecutarlo después del cambio de ubicación
   };
 </script>
 ```
 
-The code above shows errors for any operations except:
+El código anterior muestra errores para cualquier operación excepto:
 
-- Getting the reference to the inner window `iframe.contentWindow` - that's allowed.
-- Writing to `location`.
+- Obtener la referencia a la ventana interna `iframe.contentWindow` - eso está permitido.
+- Escribir a `location`.
 
-Contrary to that, if the `<iframe>` has the same origin, we can do anything with it:
+Al contrario, si el `<iframe>` tiene el mismo origen, podemos hacer cualquier cosa con él:
 
 ```html run
 <!-- iframe from the same site -->
@@ -90,41 +90,41 @@ Contrary to that, if the `<iframe>` has the same origin, we can do anything with
 
 <script>
   iframe.onload = function() {
-    // just do anything
-    iframe.contentDocument.body.prepend("Hello, world!");
+    // solo haz cualquier cosa
+    iframe.contentDocument.body.prepend("¡Hola, mundo!");
   };
 </script>
 ```
 
 ```smart header="`iframe.onload` vs `iframe.contentWindow.onload`"
-The `iframe.onload` event (on the `<iframe>` tag) is essentially the same as `iframe.contentWindow.onload` (on the embedded window object). It triggers when the embedded window fully loads with all resources.
+El evento `iframe.onload` (en la etiqueta `<iframe>`) es esencialmente el mismo que `iframe.contentWindow.onload` (en el objeto de ventana incrustado). Se activa cuando la ventana incrustada se carga completamente con todos los recursos.
 
-...But we can't access `iframe.contentWindow.onload` for an iframe from another origin, so using `iframe.onload`.
+... Pero no podemos acceder a `iframe.contentWindow.onload` para un iframe de otro origen, así que usamos `iframe.onload`.
 ```
 
-## Windows on subdomains: document.domain
+## Ventanas en subdominios: document.domain
 
-By definition, two URLs with different domains have different origins.
+Por definición, dos URL con diferentes dominios tienen diferentes orígenes.
 
-But if windows share the same second-level domain, for instance `john.site.com`, `peter.site.com` and `site.com` (so that their common second-level domain is `site.com`), we can make the browser ignore that difference, so that they can be treated as coming from the "same origin" for the purposes of cross-window communication.
+Pero si las ventanas comparten el mismo dominio de segundo nivel, por ejemplo, `john.site.com`, `peter.site.com` y `site.com` (de modo que su dominio de segundo nivel común es `site.com`), podemos hacer que el navegador ignore esa diferencia, de modo que puedan tratarse como si vinieran del "mismo origen" para efecto de la comunicación entre ventanas.
 
-To make it work, each such window should run the code:
+Para que funcione, cada una de estas ventanas debe ejecutar el código:
 
 ```js
 document.domain = 'site.com';
 ```
 
-That's all. Now they can interact without limitations. Again, that's only possible for pages with the same second-level domain.
+Eso es todo. Ahora pueden interactuar sin limitaciones. Nuevamente, eso solo es posible para páginas con el mismo dominio de segundo nivel.
 
-## Iframe: wrong document pitfall
+## Iframe: trampa del documento incorrecto
 
-When an iframe comes from the same origin, and we may access its  `document`, there's a pitfall. It's not related to cross-origin things, but important to know.
+Cuando un iframe proviene del mismo origen y podemos acceder a su `documento`, existe una trampa. No está relacionado con cross-origin, pero es importante saberlo.
 
-Upon its creation an iframe immediately has a document. But that document is different from the one that loads into it!
+Tras su creación, un iframe tiene inmediatamente un documento. ¡Pero ese documento es diferente del que se carga en él!
 
-So if we do something with the document immediately, that will probably be lost.
+Entonces, si hacemos algo con el documento de inmediato, probablemente se perderá.
 
-Here, look:
+Aquí, mira:
 
 
 ```html run
@@ -135,20 +135,20 @@ Here, look:
   iframe.onload = function() {
     let newDoc = iframe.contentDocument;
 *!*
-    // the loaded document is not the same as initial!
+    // ¡el documento cargado no es el mismo que el inicial!
     alert(oldDoc == newDoc); // false
 */!*
   };
 </script>
 ```
 
-We shouldn't work with the document of a not-yet-loaded iframe, because that's the *wrong document*. If we set any event handlers on it, they will be ignored.
+No deberíamos trabajar con el documento de un iframe aún no cargado, porque ese es el *documento incorrecto*. Si configuramos algún controlador de eventos en él, se ignorarán.
 
-How to detect the moment when the document is there?
+¿Cómo detectar el momento en que el documento está ahí?
 
-The right document is definitely at place when `iframe.onload`  triggers. But it only triggers when the whole iframe with all resources is loaded.
+El documento correcto definitivamente está en su lugar cuando se activa `iframe.onload`. Pero solo se activa cuando se carga todo el iframe con todos los recursos.
 
-We can try to catch the moment earlier using checks in `setInterval`:
+Podemos intentar capturar el momento anterior usando comprobaciones en `setInterval`:
 
 ```html run
 <iframe src="/" id="iframe"></iframe>
@@ -156,26 +156,26 @@ We can try to catch the moment earlier using checks in `setInterval`:
 <script>
   let oldDoc = iframe.contentDocument;
 
-  // every 100 ms check if the document is the new one
+  // cada 100 ms comprueba si el documento es el nuevo
   let timer = setInterval(() => {
     let newDoc = iframe.contentDocument;
     if (newDoc == oldDoc) return;
 
-    alert("New document is here!");
+    alert("¡El nuevo documento está aquí!");
 
-    clearInterval(timer); // cancel setInterval, don't need it any more
+    clearInterval(timer); // cancelo setInterval, ya no lo necesito
   }, 100);
 </script>
 ```
 
-## Collection: window.frames
+## Colección: window.frames
 
-An alternative way to get a window object for `<iframe>` -- is to get it from the named collection  `window.frames`:
+Una forma alternativa de obtener un objeto de ventana para `<iframe>` -- es obtenerlo de la colección nombrada `window.frames`:
 
-- By number: `window.frames[0]` -- the window object for the first frame in the document.
-- By name: `window.frames.iframeName` -- the window object for the frame with  `name="iframeName"`.
+- Por número: `window.frames[0]` -- el objeto de ventana para el primer marco del documento.
+- Por nombre: `window.frames.iframeName` -- el objeto de ventana para el marco con `name="iframeName"`.
 
-For instance:
+Por ejemplo:
 
 ```html run
 <iframe src="/" style="height:80px" name="win" id="iframe"></iframe>
@@ -186,93 +186,93 @@ For instance:
 </script>
 ```
 
-An iframe may have other iframes inside. The corresponding `window` objects form a hierarchy.
+Un iframe puede tener otros iframes en su interior. Los objetos `window` correspondientes forman una jerarquía.
 
-Navigation links are:
+Los enlaces de navegación son:
 
-- `window.frames` -- the collection of "children" windows (for nested frames).
-- `window.parent` -- the reference to the "parent" (outer) window.
-- `window.top` -- the reference to the topmost parent window.
+- `window.frames` -- la colección de ventanas "hijas" (para marcos anidados).
+- `window.parent` -- la referencia a la ventana "padre" (exterior).
+- `window.top` -- la referencia a la ventana padre superior.
 
-For instance:
+Por ejemplo:
 
 ```js run
 window.frames[0].parent === window; // true
 ```
 
-We can use the `top` property to check if the current document is open inside a frame or not:
+Podemos usar la propiedad `top` para verificar si el documento actual está abierto dentro de un marco o no:
 
 ```js run
 if (window == top) { // current window == window.top?
-  alert('The script is in the topmost window, not in a frame');
+  alert('El script está en la ventana superior, no en un marco.');
 } else {
-  alert('The script runs in a frame!');
+  alert('¡El script se ejecuta en un marco!');
 }
 ```
 
-## The "sandbox" iframe attribute
+## "sandbox", el atributo de iframe
 
-The `sandbox` attribute allows for the exclusion of certain actions inside an `<iframe>` in order to prevent it executing untrusted code. It "sandboxes" the iframe by treating it as coming from another origin and/or applying other limitations.
+El atributo `sandbox` permite la exclusión de ciertas acciones dentro de un `<iframe>` para evitar que ejecute código no confiable. Realiza una "caja de arena" del iframe tratándolo como si procediera de otro origen y/o aplicando otras limitaciones.
 
-There's a "default set" of restrictions applied for `<iframe sandbox src="...">`. But it can be relaxed if we provide a space-separated list of restrictions that should not be applied as a value of the attribute, like this: `<iframe sandbox="allow-forms allow-popups">`.
+Hay un "conjunto predeterminado" de restricciones aplicadas para `<iframe sandbox src="...">`. Pero se puede relajar si proporcionamos una lista de restricciones separadas por espacios que no deben aplicarse como un valor del atributo, así: `<iframe sandbox="allow-forms allow-popups">`.
 
-In other words, an empty `"sandbox"` attribute puts the strictest limitations possible, but we can put a space-delimited list of those that we want to lift.
+En otras palabras, un atributo "sandbox" vacío pone las limitaciones más estrictas posibles, pero podemos poner una lista delimitada por espacios de aquellas que queremos levantar.
 
-Here's a list of limitations:
+Aquí hay una lista de limitaciones:
 
 `allow-same-origin`
-: By default `"sandbox"` forces the "different origin" policy for the iframe. In other words, it makes the browser to treat the `iframe` as coming from another origin, even if its `src` points to the same site. With all implied restrictions for scripts. This option removes that feature.
+: Por defecto, "sandbox" fuerza la política de "origen diferente" para el iframe. En otras palabras, hace que el navegador trate el `iframe` como si viniera de otro origen, incluso si su `src` apunta al mismo sitio. Con todas las restricciones implícitas para los scripts. Esta opción elimina esa característica.
 
 `allow-top-navigation`
-: Allows the `iframe` to change `parent.location`.
+: Permite que el `iframe` cambie `parent.location`.
 
 `allow-forms`
-: Allows to submit forms from `iframe`.
+: Permite enviar formularios desde "iframe".
 
 `allow-scripts`
-: Allows to run scripts from the `iframe`.
+: Permite ejecutar scripts desde el `iframe`.
 
 `allow-popups`
-: Allows to `window.open` popups from the `iframe`
+: Permite `window.open` popups desde el `iframe`
 
-See [the manual](mdn:/HTML/Element/iframe) for more.
+Consulta [el manual](mdn:/HTML/Element/iframe) para obtener más información.
 
-The example below demonstrates a sandboxed iframe with the default set of restrictions: `<iframe sandbox src="...">`. It has some JavaScript and a form.
+El siguiente ejemplo muestra un iframe de espacio aislado con el conjunto de restricciones predeterminado: `<iframe sandbox src="...">`. Tiene algo de JavaScript y un formulario.
 
-Please note that nothing works. So the default set is really harsh:
+Tenga en cuenta que nada funciona. Entonces, el conjunto predeterminado es realmente duro:
 
 [codetabs src="sandbox" height=140]
 
 
 ```smart
-The purpose of the `"sandbox"` attribute is only to *add more* restrictions. It cannot remove them. In particular, it can't relax same-origin restrictions if the iframe comes from another origin.
+El propósito del atributo `"sandbox"` es solo *agregar más* restricciones. No puede eliminarlas. En particular, no puede relajar las restricciones del mismo origen si el iframe proviene de otro origen.
 ```
 
-## Cross-window messaging
+## Mensajería entre ventanas
 
-The `postMessage` interface allows windows to talk to each other no matter which origin they are from.
+La interfaz `postMessage` permite que las ventanas se comuniquen entre sí sin importar de qué origen sean.
 
-So, it's a way around the "Same Origin" policy. It allows a window from `john-smith.com` to talk to `gmail.com` and exchange information, but only if they both agree and call corresponding JavaScript functions. That makes it safe for users.
+Por lo tanto, es una forma de evitar la política del "mismo origen". Permite a una ventana de `john-smith.com` hablar con `gmail.com` e intercambiar información, pero solo si ambos están de acuerdo y llaman a las funciones de JavaScript correspondientes. Eso lo hace seguro para los usuarios.
 
-The interface has two parts.
+La interfaz tiene dos partes.
 
 ### postMessage
 
-The window that wants to send a message calls [postMessage](mdn:api/Window.postMessage) method of the receiving window. In other words, if we want to send the message to `win`, we should call  `win.postMessage(data, targetOrigin)`.
+La ventana que quiere enviar un mensaje llama al método [postMessage](mdn:api/Window.postMessage) de la ventana receptora. En otras palabras, si queremos enviar el mensaje a `win`, debemos llamar a `win.postMessage(data, targetOrigin)`.
 
-Arguments:
+Argumentos:
 
 `data`
-: The data to send. Can be any object, the data is cloned using the "structured cloning algorithm". IE supports only strings, so we should `JSON.stringify` complex objects to support that browser.
+: Los datos a enviar. Puede ser cualquier objeto, los datos se clonan mediante el "algoritmo de clonación estructurada". IE solo admite cadenas, por lo que debemos usar `JSON.stringify` en objetos complejos para admitir ese navegador.
 
 `targetOrigin`
-: Specifies the origin for the target window, so that only a window from the given origin will get the message.
+: Especifica el origen de la ventana de destino, de modo que solo una ventana del origen dado recibirá el mensaje.
 
-The `targetOrigin` is a safety measure. Remember, if the target window comes from another origin, we can't read it's `location` in the sender window. So we can't be sure which site is open in the intended window right now: the user could navigate away, and the sender window has no idea about it.
+El argumento "targetOrigin" es una medida de seguridad. Recuerde, si la ventana de destino proviene de otro origen, no podemos leer su `location` en la ventana del remitente. Por lo tanto, no podemos estar seguros de qué sitio está abierto en la ventana deseada en este momento: el usuario podría navegar fuera y la ventana del remitente no tiene idea de ello.
 
-Specifying `targetOrigin` ensures that the window only receives the data if it's still at the right site. Important when the data is sensitive.
+Especificar `targetOrigin` asegura que la ventana solo reciba los datos si todavía está en el sitio correcto. Importante cuando los datos son sensibles.
 
-For instance, here `win` will only receive the message if it has a document from the origin `http://example.com`:
+Por ejemplo, aquí `win` solo recibirá el mensaje si tiene un documento del origen `http://example.com`:
 
 ```html no-beautify
 <iframe src="http://example.com" name="example">
@@ -284,7 +284,7 @@ For instance, here `win` will only receive the message if it has a document from
 </script>
 ```
 
-If we don't want that check, we can set `targetOrigin` to `*`.
+Si no queremos esa comprobación, podemos establecer `targetOrigin` en `*`.
 
 ```html no-beautify
 <iframe src="http://example.com" name="example">
@@ -301,70 +301,70 @@ If we don't want that check, we can set `targetOrigin` to `*`.
 
 ### onmessage
 
-To receive a message, the target window should have a handler on the `message` event. It triggers when `postMessage` is called (and `targetOrigin` check is successful).
+Para recibir un mensaje, la ventana destino debe tener un controlador en el evento `message`. Se activa cuando se llama a `postMessage` (y la comprobación de `targetOrigin` es correcta).
 
-The event object has special properties:
+El objeto de evento tiene propiedades especiales:
 
 `data`
-: The data from `postMessage`.
+: Los datos de `postMessage`.
 
 `origin`
-: The origin of the sender, for instance `http://javascript.info`.
+: El origen del remitente, por ejemplo, `http://javascript.info`.
 
 `source`
-: The reference to the sender window. We can immediately `source.postMessage(...)` back if we want.
+: La referencia a la ventana del remitente. Podemos llamar inmediatamente `source.postMessage(...)` de regreso si queremos.
 
-To assign that handler, we should use `addEventListener`, a short syntax `window.onmessage` does not work.
+Para asignar ese controlador, debemos usar `addEventListener`, una sintaxis corta `window.onmessage` no funciona.
 
-Here's an example:
+He aquí un ejemplo:
 
 ```js
 window.addEventListener("message", function(event) {
   if (event.origin != 'http://javascript.info') {
-    // something from an unknown domain, let's ignore it
+    // algo de un dominio desconocido, ignorémoslo
     return;
   }
 
-  alert( "received: " + event.data );
+  alert( "Recibí: " + event.data );
 
-  // can message back using event.source.postMessage(...)
+  // puedes enviar un mensaje usando event.source.postMessage(...)
 });
 ```
 
-The full example:
+El ejemplo completo:
 
 [codetabs src="postmessage" height=120]
 
-## Summary
+## Resumen
 
-To call methods and access the content of another window, we should first have a reference to it.
+Para llamar a métodos y acceder al contenido de otra ventana, primero debemos tener una referencia a ella.
 
-For popups we have these references:
-- From the opener window: `window.open` -- opens a new window and returns a reference to it,
-- From the popup: `window.opener` -- is a reference to the opener window from a popup.
+Para las ventanas emergentes tenemos estas referencias:
+- Desde la ventana de apertura: `window.open` -- abre una nueva ventana y devuelve una referencia a ella,
+- Desde la ventana emergente: `window.opener` -- es una referencia a la ventana de apertura desde una ventana emergente.
 
-For iframes, we can access parent/children windows using:
-- `window.frames` -- a collection of nested window objects,
-- `window.parent`, `window.top` are the references to parent and top windows,
-- `iframe.contentWindow` is the window inside an `<iframe>` tag.
+Para iframes, podemos acceder a las ventanas padres o hijas usando:
+- `window.frames` -- una colección de objetos de ventana anidados,
+- `window.parent`, `window.top` son las referencias a las ventanas principales y superiores,
+- `iframe.contentWindow` es la ventana dentro de una etiqueta `<iframe>`.
 
-If windows share the same origin (host, port, protocol), then windows can do whatever they want with each other.
+Si las ventanas comparten el mismo origen (host, puerto, protocolo), las ventanas pueden hacer lo que quieran entre sí.
 
-Otherwise, only possible actions are:
-- Change the `location` of another window (write-only access).
-- Post a message to it.
+En caso contrario, las únicas acciones posibles son:
+- Cambiar `location` en otra ventana (acceso de solo escritura).
+- Enviarle un mensaje.
 
-Exceptions are:
-- Windows that share the same second-level domain: `a.site.com` and `b.site.com`. Then setting `document.domain='site.com'` in both of them puts them into the "same origin" state.
-- If an iframe has a `sandbox` attribute, it is forcefully put into the "different origin" state, unless the `allow-same-origin` is specified in the attribute value. That can be used to run untrusted code in iframes from the same site.
+Las excepciones son:
+- Ventanas que comparten el mismo dominio de segundo nivel: `a.site.com` y `b.site.com`. Luego, configurar `document.domain='site.com'` en ambos, los coloca en el estado de "mismo origen".
+- Si un iframe tiene un atributo `sandbox`, se coloca forzosamente en el estado de "origen diferente", a menos que se especifique `allow-same-origin` en el valor del atributo. Eso se puede usar para ejecutar código que no es de confianza en iframes desde el mismo sitio.
 
-The `postMessage` interface allows two windows with any origins to talk:
+La interfaz `postMessage` permite que dos ventanas con cualquier origen hablen:
 
-1. The sender calls `targetWin.postMessage(data, targetOrigin)`.
-2. If `targetOrigin` is not `'*'`, then the browser checks if window `targetWin` has the origin `targetOrigin`.
-3. If it is so, then `targetWin` triggers the `message` event with special properties:
-    - `origin` -- the origin of the sender window (like `http://my.site.com`)
-    - `source` -- the reference to the sender window.
-    - `data` -- the data, any object in everywhere except IE that supports only strings.
+1. El remitente llama a `targetWin.postMessage(data, targetOrigin)`.
+2. Si `targetOrigin` no es `'*'`, entonces el navegador comprueba si la ventana `targetWin` tiene el origen `targetOrigin`.
+3. Si es así, entonces `targetWin` activa el evento `message` con propiedades especiales:
+    - `origin` -- el origen de la ventana del remitente (como` http://my.site.com`)
+    - `source` -- la referencia a la ventana del remitente.
+    - `data` -- los datos, cualquier objeto en todas partes excepto IE que solo admite cadenas.
 
-    We should use `addEventListener` to set the handler for this event inside the target window.
+    Deberíamos usar `addEventListener` para configurar el controlador para este evento dentro de la ventana de destino.
diff --git a/3-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html b/3-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html
index 88e098b7b..767cf9de3 100644
--- a/3-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html
+++ b/3-frames-and-windows/03-cross-window-communication/postmessage.view/iframe.html
@@ -7,10 +7,10 @@
 
 <body>
 
-  Receiving iframe.
+  Recibiendo iframe.
   <script>
     window.addEventListener('message', function(event) {
-      alert(`Received ${event.data} from ${event.origin}`);
+      alert(`Recibí ${event.data} de ${event.origin}`);
     });
   </script>
 
diff --git a/3-frames-and-windows/03-cross-window-communication/postmessage.view/index.html b/3-frames-and-windows/03-cross-window-communication/postmessage.view/index.html
index abcb065c6..b36b5256e 100644
--- a/3-frames-and-windows/03-cross-window-communication/postmessage.view/index.html
+++ b/3-frames-and-windows/03-cross-window-communication/postmessage.view/index.html
@@ -8,8 +8,8 @@
 <body>
 
   <form id="form">
-    <input type="text" placeholder="Enter message" name="message">
-    <input type="submit" value="Click to send">
+    <input type="text" placeholder="Ingresa mensaje" name="message">
+    <input type="submit" value="Haz clic para enviar">
   </form>
 
   <iframe src="iframe.html" id="iframe" style="display:block;height:60px"></iframe>
diff --git a/3-frames-and-windows/03-cross-window-communication/sandbox.view/index.html b/3-frames-and-windows/03-cross-window-communication/sandbox.view/index.html
index 46dd7b5cc..e87a6fed0 100644
--- a/3-frames-and-windows/03-cross-window-communication/sandbox.view/index.html
+++ b/3-frames-and-windows/03-cross-window-communication/sandbox.view/index.html
@@ -7,7 +7,7 @@
 
 <body>
 
-  <div>The iframe below has the <code>sandbox</code> attribute.</div>
+  <div>El siguiente iframe tiene el atributo <code> sandbox </code>.</div>
 
   <iframe sandbox src="sandboxed.html" style="height:60px;width:90%"></iframe>
 
diff --git a/3-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html b/3-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html
index c10273255..8db29b86b 100644
--- a/3-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html
+++ b/3-frames-and-windows/03-cross-window-communication/sandbox.view/sandboxed.html
@@ -7,11 +7,11 @@
 
 <body>
 
-  <button onclick="alert(123)">Click to run a script (doesn't work)</button>
+  <button onclick="alert(123)">Haz clic para ejecutar un script (no funciona)</button>
 
   <form action="http://google.com">
     <input type="text">
-    <input type="submit" value="Submit (doesn't work)">
+    <input type="submit" value="Enviar (no funciona)">
   </form>
 
 </body>

From f15ce6d55564bea4661051bdd96e0433804c038a Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 01:44:24 -0500
Subject: [PATCH 02/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index f9d9ce9f6..266907350 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -2,7 +2,7 @@
 
 La política de "Mismo origen" (mismo sitio) limita el acceso de ventanas y marcos entre sí.
 
-La idea es que si un usuario tiene dos páginas abiertas: una de `john-smith.com`, y otra es` gmail.com`, entonces no querrán que un script de `john-smith.com` lea nuestro correo de `gmail.com`. Por lo tanto, el propósito de la política de "Mismo origen" es proteger a los usuarios del robo de información.
+La idea es que si un usuario tiene dos páginas abiertas: una de `john-smith.com`, y otra es `gmail.com`, entonces no querrán que un script de `john-smith.com` lea nuestro correo de `gmail.com`. Por lo tanto, el propósito de la política de "Mismo origen" es proteger a los usuarios del robo de información.
 
 ## Mismo origen [#same-origin]
 

From ff63369a2e65275953ce2d854df9e1125fcac23a Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 01:44:56 -0500
Subject: [PATCH 03/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index 266907350..fd52cf5d0 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -82,7 +82,7 @@ El código anterior muestra errores para cualquier operación excepto:
 - Obtener la referencia a la ventana interna `iframe.contentWindow` - eso está permitido.
 - Escribir a `location`.
 
-Al contrario, si el `<iframe>` tiene el mismo origen, podemos hacer cualquier cosa con él:
+Por el contrario, si el `<iframe>` tiene el mismo origen, podemos hacer cualquier cosa con él:
 
 ```html run
 <!-- iframe from the same site -->

From 270a4884385afe9302bafd474615d501e6d0bc05 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 01:45:18 -0500
Subject: [PATCH 04/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index fd52cf5d0..a9c5ac514 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -118,7 +118,7 @@ Eso es todo. Ahora pueden interactuar sin limitaciones. Nuevamente, eso solo es
 
 ## Iframe: trampa del documento incorrecto
 
-Cuando un iframe proviene del mismo origen y podemos acceder a su `documento`, existe una trampa. No está relacionado con cross-origin, pero es importante saberlo.
+Cuando un iframe proviene del mismo origen y podemos acceder a su `document`, existe una trampa. No está relacionado con cross-origin, pero es importante saberlo.
 
 Tras su creación, un iframe tiene inmediatamente un documento. ¡Pero ese documento es diferente del que se carga en él!
 

From 220f440c210095e1097c4da90309f64c8c6af2e4 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 01:45:40 -0500
Subject: [PATCH 05/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: joaquinelio <joaquinelio@gmail.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index a9c5ac514..5d00a6943 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -210,7 +210,7 @@ if (window == top) { // current window == window.top?
 }
 ```
 
-## "sandbox", el atributo de iframe
+## El atributo de iframe "sandbox"
 
 El atributo `sandbox` permite la exclusión de ciertas acciones dentro de un `<iframe>` para evitar que ejecute código no confiable. Realiza una "caja de arena" del iframe tratándolo como si procediera de otro origen y/o aplicando otras limitaciones.
 

From f7adb65b6ff69c57c79239621eda867c2297066c Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 09:35:12 -0500
Subject: [PATCH 06/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: Ezequiel Castellanos <51804994+EzequielCaste@users.noreply.github.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index 5d00a6943..ba89aeecf 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -21,7 +21,7 @@ Estas no:
 - <code><b>https://</b>site.com</code> (otro protocolo: `https`)
 - <code>http://site.com:<b>8080</b></code> (otro puerto: `8080`)
 
-La política de "Mismo origen" establece que:
+La política "Mismo Origen" establece que:
 
 - si tenemos una referencia a otra ventana, por ejemplo, una ventana emergente creada por `window.open` o una ventana dentro de `<iframe>`, y esa ventana viene del mismo origen, entonces tenemos acceso completo a esa ventana.
 - en caso contrario, si viene de otro origen, entonces no podemos acceder al contenido de esa ventana: variables, documento, nada. La única excepción es `location`: podemos cambiarla (redirigiendo así al usuario). Pero no podemos *leer* location (por lo que no podemos ver dónde está el usuario ahora, no hay fuga de información).

From 0682c4f2e7aa3e7d1846088ff7730f252d3fa6c6 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 09:35:41 -0500
Subject: [PATCH 07/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: Ezequiel Castellanos <51804994+EzequielCaste@users.noreply.github.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index ba89aeecf..88d227b09 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -210,7 +210,7 @@ if (window == top) { // current window == window.top?
 }
 ```
 
-## El atributo de iframe "sandbox"
+## El atributo "sandbox" de iframe
 
 El atributo `sandbox` permite la exclusión de ciertas acciones dentro de un `<iframe>` para evitar que ejecute código no confiable. Realiza una "caja de arena" del iframe tratándolo como si procediera de otro origen y/o aplicando otras limitaciones.
 

From a276b4b94ad4d6b0719a45af49a12309477aba5d Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 09:36:07 -0500
Subject: [PATCH 08/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: Ezequiel Castellanos <51804994+EzequielCaste@users.noreply.github.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index 88d227b09..fdda42108 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -212,7 +212,7 @@ if (window == top) { // current window == window.top?
 
 ## El atributo "sandbox" de iframe
 
-El atributo `sandbox` permite la exclusión de ciertas acciones dentro de un `<iframe>` para evitar que ejecute código no confiable. Realiza una "caja de arena" del iframe tratándolo como si procediera de otro origen y/o aplicando otras limitaciones.
+El atributo `sandbox` permite la exclusión de ciertas acciones dentro de un `<iframe>` para evitar que ejecute código no confiable. Separa el iframe en un "sandbox" tratándolo como si procediera de otro origen y/o aplicando otras limitaciones.
 
 Hay un "conjunto predeterminado" de restricciones aplicadas para `<iframe sandbox src="...">`. Pero se puede relajar si proporcionamos una lista de restricciones separadas por espacios que no deben aplicarse como un valor del atributo, así: `<iframe sandbox="allow-forms allow-popups">`.
 

From fd63b842867bd831b313a4e877b63aedc8e6bd0f Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 09:36:21 -0500
Subject: [PATCH 09/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: Ezequiel Castellanos <51804994+EzequielCaste@users.noreply.github.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index fdda42108..5ad3ae574 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -227,7 +227,7 @@ Aquí hay una lista de limitaciones:
 : Permite que el `iframe` cambie `parent.location`.
 
 `allow-forms`
-: Permite enviar formularios desde "iframe".
+: Permite enviar formularios desde `iframe`.
 
 `allow-scripts`
 : Permite ejecutar scripts desde el `iframe`.

From 7701bdcb8888f4a1a5b665aad3a04cc404c15e82 Mon Sep 17 00:00:00 2001
From: Homero Enrique Marin Galindo <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 09:36:40 -0500
Subject: [PATCH 10/11] Update
 3-frames-and-windows/03-cross-window-communication/article.md

Co-authored-by: Ezequiel Castellanos <51804994+EzequielCaste@users.noreply.github.com>
---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index 5ad3ae574..4df6d916e 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -237,7 +237,7 @@ Aquí hay una lista de limitaciones:
 
 Consulta [el manual](mdn:/HTML/Element/iframe) para obtener más información.
 
-El siguiente ejemplo muestra un iframe de espacio aislado con el conjunto de restricciones predeterminado: `<iframe sandbox src="...">`. Tiene algo de JavaScript y un formulario.
+El siguiente ejemplo muestra un iframe dentro de un entorno controlado con el conjunto de restricciones predeterminado: `<iframe sandbox src="...">`. Tiene algo de JavaScript y un formulario.
 
 Tenga en cuenta que nada funciona. Entonces, el conjunto predeterminado es realmente duro:
 

From 0726d44d062941172cf002df673c4cb79cf7637f Mon Sep 17 00:00:00 2001
From: Homero304 <homeromaring@gmail.com>
Date: Tue, 1 Sep 2020 09:39:11 -0500
Subject: [PATCH 11/11] line:266 cadenas->strings

---
 3-frames-and-windows/03-cross-window-communication/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3-frames-and-windows/03-cross-window-communication/article.md b/3-frames-and-windows/03-cross-window-communication/article.md
index 4df6d916e..368e88578 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -263,7 +263,7 @@ La ventana que quiere enviar un mensaje llama al método [postMessage](mdn:api/W
 Argumentos:
 
 `data`
-: Los datos a enviar. Puede ser cualquier objeto, los datos se clonan mediante el "algoritmo de clonación estructurada". IE solo admite cadenas, por lo que debemos usar `JSON.stringify` en objetos complejos para admitir ese navegador.
+: Los datos a enviar. Puede ser cualquier objeto, los datos se clonan mediante el "algoritmo de clonación estructurada". IE solo admite strings, por lo que debemos usar `JSON.stringify` en objetos complejos para admitir ese navegador.
 
 `targetOrigin`
 : Especifica el origen de la ventana de destino, de modo que solo una ventana del origen dado recibirá el mensaje.