From 5f61e529536a2721cf33a83a868791d57bc79f8e Mon Sep 17 00:00:00 2001
From: Andrea Longo <longoandrea.dev@gmail.com>
Date: Wed, 24 Mar 2021 22:07:36 +0100
Subject: [PATCH 1/7] translated first part

---
 .../03-cross-window-communication/article.md  | 92 +++++++++----------
 1 file changed, 46 insertions(+), 46 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 091a0cecb..4f53c79b9 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -1,65 +1,65 @@
-# Cross-window communication
+# Comuniaczione cross-window
 
-The "Same Origin" (same site) policy limits access of windows and frames to each other.
+La politcia di "Same Origin" ("stessa origine", ovvero stesso sito) limita il reciproco accesso tra finestre ed iframe diversi.
 
-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.
+L'idea è che, se un utente ha deu pagine aperte: una su `john-smith.com`, ed un'altra su `gmail.com`, allora non vorrà che uno script ion esecuzione su `john-smith.com` possa leggere tutte le sue mail dalla finestra di `gmail.com`. Quindi, lo scopo della politica "Same Origin" è quello di proteggere l'utente dal furto di informazioni.
 
 ## Same Origin [#same-origin]
 
-Two URLs are said to have the "same origin" if they have the same protocol, domain and port.
+Due URL vengono definiti come appartenenti alla "stessa origine" solo se possiedono lo stesso protocollo, dominio e porta.
 
-These URLs all share the same origin:
+Ad esempio, questi URL condividono la stessa origine:
 
 - `http://site.com`
 - `http://site.com/`
 - `http://site.com/my/page.html`
 
-These ones do not:
+Questi invece 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> (dominio differente: `www.` è diverso)
+- <code>http://<b>site.org</b></code> (dominio differente: `.org` è diverso)
+- <code><b>https://</b>site.com</code> (protocollo differente: `https`)
+- <code>http://site.com:<b>8080</b></code> (porta differente: `8080`)
 
-The "Same Origin" policy states that:
+La politica di "Same Origin" afferma che:
 
-- 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).
+- se abbiamo un riferimento ad un'altra finestra, ad esempio un popup creato tramite `window.open` oppure una finestra all'interno di un `<iframe>`, e queste finestre appartengono alla stessa origine, allora avremo pieno accesso ad esse.
+- altrimenti, se queste provengono da origini differenti, allora non potremo accedere al cotenuto della finestra: variables, il suo document, e qualsiasi altra informazione. L'unica eccezione è sulla proprietà `location`: possiamo modificarla (reindirizzando l'utente). Ma non possiamo *leggerne* il contenuto (quindi non possiamo sapere in quale sito si trova l'utente in un dato momento, nessuna infromazione viene trapelata).
 
-### In action: iframe
+### In azione: iframe
 
-An `<iframe>` tag hosts a separate embedded window, with its own separate `document` and `window` objects.
+Un tag di `<iframe>` permette di incorporare una finestra separata, la quale avrà i suoi oggetti `document` e `window` separati.
 
-We can access them using properties:
+Possiamo accedervi utilizzando le proprietà:
 
-- `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` per ottenere il riferiemnto alla finestra all'interno di `<iframe>`.
+- `iframe.contentDocument` per ottenere il riferimento al document all'interno di `<iframe>`, abbreviazione per `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).
+Quando accediamo a qualche proprietà della finestra incorporata, il browser verificherà se l'iframe appartiene alla stessa origine. Se cosi non è, allora l'accesso verrà negatp (rimane l'eccezione sulla scrittura di `location`, che è comunque permessa).
 
-For instance, let's try reading and writing to `<iframe>` from another origin:
+Ad esempio, proviamo a leggere e scrivere su un `<iframe>` da un'altra origine:
 
 ```html run
 <iframe src="https://example.com" id="iframe"></iframe>
 
 <script>
   iframe.onload = function() {
-    // we can get the reference to the inner window
+    // possiamo ottenere il riferiemento alla finestra integrata
 *!*
     let iframeWindow = iframe.contentWindow; // OK
 */!*
     try {
-      // ...but not to the document inside it
+      // ...ma non al suo document
 *!*
       let doc = iframe.contentDocument; // ERROR
 */!*
     } catch(e) {
-      alert(e); // Security Error (another origin)
+      alert(e); // Security Error (origine diversa)
     }
 
-    // also we can't READ the URL of the page in iframe
+    // non possiamo nemmeno LEGGERE l'URL di un iframe
     try {
-      // Can't read URL from the Location object
+      // Non possiamo leggere l'URL dall'oggetto Location
 *!*
       let href = iframe.contentWindow.location.href; // ERROR
 */!*
@@ -67,64 +67,64 @@ For instance, let's try reading and writing to `<iframe>` from another origin:
       alert(e); // Security Error
     }
 
-    // ...we can WRITE into location (and thus load something else into the iframe)!
+    // ...possiamo però SCRIVERE sulla proprietà location (e questo caricherà un'altra pagina nell'iframe)!
 *!*
     iframe.contentWindow.location = '/'; // OK
 */!*
 
-    iframe.onload = null; // clear the handler, not to run it after the location change
+    iframe.onload = null; // ripuliamo l'handler, per evitare che venga eseguito dopo il cambio di location
   };
 </script>
 ```
 
-The code above shows errors for any operations except:
+Il codice sopra genera errori in tutti i casi ad eccezione di:
 
-- Getting the reference to the inner window `iframe.contentWindow` - that's allowed.
-- Writing to `location`.
+- Lettura del riferimento alla finestra interna `iframe.contentWindow`, la quale è permessa.
+- Scrittura su `location`.
 
-Contrary to that, if the `<iframe>` has the same origin, we can do anything with it:
+Contrariamente a questo, se l'`<iframe>` proviene dalla stessa origine, possiamo farci qualsiasi cosa:
 
 ```html run
-<!-- iframe from the same site -->
+<!-- iframe dallo stesso sito -->
 <iframe src="/" id="iframe"></iframe>
 
 <script>
   iframe.onload = function() {
-    // just do anything
+    // qualsiasi operazione
     iframe.contentDocument.body.prepend("Hello, world!");
   };
 </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.
+L'evento di `iframe.onload` (nel tag `<iframe>`) equivale a `iframe.contentWindow.onload` (nell'oggetto della finestra incorporata). Si innesca quando la finestra integrata completaa il caricamento con tutte le risorse.
 
-...But we can't access `iframe.contentWindow.onload` for an iframe from another origin, so using `iframe.onload`.
+...Ma non possiamo accedere a `iframe.contentWindow.onload` per un iframe che appartiene ad un'altra origine, utilizzando `iframe.onload`.
 ```
 
-## Windows on subdomains: document.domain
+## Finestre di sotto-domini: document.domain
 
-By definition, two URLs with different domains have different origins.
+Per definizione, due URL con domini differenti appartengono ad origini differenti.
 
-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.
+Ma se le due finestre condividono lo stesso dominio di secondo livello, ad esempio `john.site.com`, `peter.site.com` e `site.com` (il loro dominio di secondo livello comunue è `site.com`), possiamo far si che il browser ignori la differenza, in questo modo verrannop trattate come se provenissero dalla "stessa origine", per gli scopi della comunicazione tra finestre.
 
-To make it work, each such window should run the code:
+Per far si che questo funzioni, ogni finestra dovrà eseguire il seguente codice:
 
 ```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.
+Questo è tutto. Da questo momento in poi potranno interagire senza limitazioni. Nuovamente, questo è possibile solamente per pagine che possiedono lo stesso dominio di secondo livello.
 
-## Iframe: wrong document pitfall
+## Iframe: il tranello del document errato
 
-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.
+Quando un iframe appartine alla stessa origine, con la possibilità quindi di accere al suo `document`, c'è un piccolo tranello a cui prestare attenzione. Non è strettamente legato al cross-origin, ma è comunque importante esserne a consocenza.
 
-Upon its creation an iframe immediately has a document. But that document is different from the one that loads into it!
+Al momento della creazione, un iframe genera immediatamente un docuement. Ma quest utlimo è diverso da quello che verrà caricato internamente!
 
-So if we do something with the document immediately, that will probably be lost.
+Quindi, se qualsiasi operazione effettuata sul document negli istanti dopo al creazione, andrà probabilmente persa.
 
-Here, look:
+Vediamo un esempio di quanto affermato:
 
 
 ```html run
@@ -135,7 +135,7 @@ Here, look:
   iframe.onload = function() {
     let newDoc = iframe.contentDocument;
 *!*
-    // the loaded document is not the same as initial!
+    // il document caricato non equivale a quello iniziale!
     alert(oldDoc == newDoc); // false
 */!*
   };

From d81574aa24148d1885c5edc4a7188e818f549398 Mon Sep 17 00:00:00 2001
From: Andrea Longo <longoandrea.dev@gmail.com>
Date: Wed, 24 Mar 2021 22:20:12 +0100
Subject: [PATCH 2/7] translated second part

---
 .../03-cross-window-communication/article.md  | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 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 4f53c79b9..fc04dde45 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -142,13 +142,13 @@ Vediamo un esempio di quanto affermato:
 </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.
+Dovremmo evitare di effettuare operazioni sul document di un iframe non ancora completamente caricato, poiché questo è il *document sbagliato*. Qualsiasi gestore di evento ad esso collegato, verrà ignorato.
 
-How to detect the moment when the document is there?
+Come possiamo assicurarci che il document sia quello corretto?
 
-The right document is definitely at place when `iframe.onload`  triggers. But it only triggers when the whole iframe with all resources is loaded.
+Per essere sicuri di lavorare con il document corretto, dovremmo attendere fin quando verrà emesso l'evento `iframe.onload`. Il quale verrà innescato solemente una volta che l'iframe avrà caricato tutte le risorse.
 
-We can try to catch the moment earlier using checks in `setInterval`:
+Possiamo provare ad intercettarlo anticipatamente effettuando controlli all'interno di un `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
+  // ogni 100ms verifichiamo se è stato generato il nuovo document
   let timer = setInterval(() => {
     let newDoc = iframe.contentDocument;
     if (newDoc == oldDoc) return;
 
     alert("New document is here!");
 
-    clearInterval(timer); // cancel setInterval, don't need it any more
+    clearInterval(timer); // cancelliamo il setInterval, non ne abbiamo più bisogno
   }, 100);
 </script>
 ```
 
 ## Collection: window.frames
 
-An alternative way to get a window object for `<iframe>` -- is to get it from the named collection  `window.frames`:
+Un modo alternativo per ottenere l'oggetto realtivo ad una finestra di `<iframe>`, è quello di accedervi tramite la collection `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"`.
+- Tramite indice: `window.frames[0]`: l'oggetto relativo alla prima finestra di iframe nel document.
+- By name: `window.frames.iframeName`: l'oggetto realtivo all'iframew con `name="iframeName"`.
 
-For instance:
+Ad esempio:
 
 ```html run
 <iframe src="/" style="height:80px" name="win" id="iframe"></iframe>
@@ -186,31 +186,31 @@ For instance:
 </script>
 ```
 
-An iframe may have other iframes inside. The corresponding `window` objects form a hierarchy.
+Un iframe potrebbe possedere a sua volta degli iframe. I rispettivi oggetti `window` formeranno una gerarchia.
 
-Navigation links are:
+E' possibile navigare tra le finestre della gerarchia utilizzando:
 
-- `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 collezione delle finestre "figlie" (per iframe annidati).
+- `window.parent`: il riferimento alla finestra "padre" (quella esterna).
+- `window.top`: il riferiemento alla finestra in cima alla gerarchia.
 
-For instance:
+Ad esempio:
 
 ```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:
+Possiamo utilizzare la proprietà `top` per verificare se il document corrente è aperto all'interno di un iframe o no:
 
 ```js run
-if (window == top) { // current window == window.top?
+if (window == top) { // window == window.top?
   alert('The script is in the topmost window, not in a frame');
 } else {
   alert('The script runs in a frame!');
 }
 ```
 
-## The "sandbox" iframe attribute
+## L'attributo "sandbox" per 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.
 

From 63fb73585abb7693e295eaedb36e557cf1f1dc03 Mon Sep 17 00:00:00 2001
From: Andrea <longoandrea.dev@gmail.com>
Date: Thu, 25 Mar 2021 21:50:28 +0100
Subject: [PATCH 3/7] translated full article

---
 .../03-cross-window-communication/article.md  | 120 +++++++++---------
 1 file changed, 61 insertions(+), 59 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 fc04dde45..a55a7a9be 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -212,67 +212,67 @@ if (window == top) { // window == window.top?
 
 ## L'attributo "sandbox" per 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.
+L'attributo `sandbox` permette l'esclusione di determinate azioni all'interno di un `<iframe>`, in modo da prevenire l'esecuzione di codice non affidabile. Consente di "isolare" ("sandbox") l'iframe, facendo si che venga trattato come se appartenesse ad un origine diversa e/o applicando altre limitazioni.
 
-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">`.
+Ci sono una serie di restriozioni "applicate di default" per un `<iframe sandbox src="...">`. Ma possono essere disattivate esplicitamente fornendo, come valore dell'attributo, la lista delle restrizioni da non applicare separate da un carettere di spazio, in questo modo: `<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.
+In altre parole, un attributo `"sandbox"` vuoto, applica tutte le restrizioni, ma possiamo fornirgli la lista di quelle che vogliamo disattivare, separandole con uno spazio.
 
-Here's a list of limitations:
+Di seguito la lista delle limitazioni:
 
 `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.
+: Di default l'attributo `"sandbox"` forza la politica di "diversa origine" per un iframe. In altre parole, fa si che il browser trati l'`iframe` come se appartenesse ad un origine diversa, anche se in realtà il suo `src` sta puntando allo stesso sito. Con tutte le relative implicazioni viste prima. Questa opzione, disabilita la restrizione.
 
 `allow-top-navigation`
-: Allows the `iframe` to change `parent.location`.
+: Permette all'iframe` di cambiare `parent.location`.
 
 `allow-forms`
-: Allows to submit forms from `iframe`.
+: Permette l'invio di forms dall'`iframe`.
 
 `allow-scripts`
-: Allows to run scripts from the `iframe`.
+: Permette l'esecuzione di script dall'`iframe`.
 
 `allow-popups`
-: Allows to `window.open` popups from the `iframe`
+: Permette all'`iframe` l'apertura di finestre di poopup tramite `window.open`
 
-See [the manual](mdn:/HTML/Element/iframe) for more.
+Consulta [il manuale](mdn:/HTML/Element/iframe) per maggiori informazioni.
 
-The example below demonstrates a sandboxed iframe with the default set of restrictions: `<iframe sandbox src="...">`. It has some JavaScript and a form.
+L'esempio sotto dimostra un iframe "isolato" con le restrizioni di default attivate: `<iframe sandbox src="...">`. Contiene del codice JavaScript ed un form.
 
-Please note that nothing works. So the default set is really harsh:
+Avrete notato che nulla di ciò che è presente funziona. Quindi le restrizioni di default sono piuttosto restrittive:
 
 [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.
+Lo scopo dell'attributo `"sandbox"` è solamente quello di *aggiungere più* restrizioni. Non di diminuirle. In particolare, non può essere utilizzato per disabilitare la restrizione di "Same Origin" per iframe appartengono ad origini differenti.
 ```
 
-## Cross-window messaging
+## Messaggi Cross-window
 
-The `postMessage` interface allows windows to talk to each other no matter which origin they are from.
+L'interfaccia `postMessage` permette alle finestre di comunicare indistintamente dall'origine di appartenenza.
 
-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.
+Quindi, è di fatto un modo per aggirare la politica di "Same Origin". Consente infatti ad una finestra proveniente da `john-smith.com` di comunicare con `gmail.com` e scambiarsi informazioni, ma solamente nel caso in cui entrambe acconsentono questo comportamento ed invocano le rispettive funzoni JavaScript. Questo rende il meccaniscmo di comunicazione tra finestre sicuro per l'utente.
 
-The interface has two parts.
+L'interfaccia è composta da due parti.
 
 ### 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 finestra che vuole inviare un messaggio invoca il metodo [postMessage](mdn:api/Window.postMessage) della finestra destinataria. In altre parole, se volessimo inviare un messaggio a `win`, dovremmo invocare `win.postMessage(data, targetOrigin)`.
 
-Arguments:
+Argomenti:
 
 `data`
-: The data to send. Can be any object, the data is cloned using the "structured serialization algorithm". IE supports only strings, so we should `JSON.stringify` complex objects to support that browser.
+: I dati da inviare. Possono essere un qualsiasi oggetto, che verrà poi duplicato utilizzando "l'algorito di serializzazione strutturato". IE supporta solamente stringhe, quindi dovremo utilizzare `JSON.stringify` per supportarlo.
 
 `targetOrigin`
-: Specifies the origin for the target window, so that only a window from the given origin will get the message.
+: Specifica l'origine per al finestra target, in questo modo il messaggio verrà ricevuto solamente dalla giusta finestra.
 
-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.
+Il parametro `targetOrigin` è una misura di sicurezza. Ricordate, se una finestra target appartiene ad una diversa origine, non possiamo leggere la sua `location` nella finestra mittente. Quindi non possiamo essere certi di quale sito sia aperto nella finestra a cui vogliamo inviare il messaggio: l'utente potrebbe aver cambiato sito, senza che la finestra mittente ne sia al corrente.
 
-Specifying `targetOrigin` ensures that the window only receives the data if it's still at the right site. Important when the data is sensitive.
+Specificando la proprietà `targetOrigin` ci assicuriamo che la finestra riceva i dati solamente se si trova nel sito che ci aspettiamo li riceva. Questa caratteristica è molto importante, specialmente per dati sensibili.
 
-For instance, here `win` will only receive the message if it has a document from the origin `http://example.com`:
+Ad esempio, in questo caso `win` riceverà il messaggio solamente se si trova nel sito `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 `*`.
+Se non abbiamo intenzione di effettuare tale verifica, possiamo impostare `targetOrigin` a `*`.
 
 ```html no-beautify
 <iframe src="http://example.com" name="example">
@@ -301,70 +301,72 @@ 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).
+Per poter ricevere un messaggio, la finestra target deve aver definito un handler per gestire l'evento `message`. Questo verrà innescato al momento dell'invocazione di `postMessage` (se la verifica del `targetOrigin` avrà successo).
 
-The event object has special properties:
+L'oggetto innescato dall'evento possiede le seguenti proprietà:
 
 `data`
-: The data from `postMessage`.
+: I dati inviati da `postMessage`.
 
 `origin`
-: The origin of the sender, for instance `http://javascript.info`.
+: L'origine del mittente, ad esempio `http://javascript.info`.
 
 `source`
-: The reference to the sender window. We can immediately `source.postMessage(...)` back if we want.
+: Il riferimento alla finestra mittente. Potremmo quindi rispondere immediatamente utilizzando `source.postMessage(...)`, se è ciò che vogliamo fare.
 
-To assign that handler, we should use `addEventListener`, a short syntax `window.onmessage` does not work.
+Per assegnare il gestore, dovremo utilizzare `addEventListener`. Non abbiamo a disposizione la sintassi abbreviata `window.onmessage`,
 
-Here's an example:
+Vediamo un esempio:
 
 ```js
 window.addEventListener("message", function(event) {
   if (event.origin != 'http://javascript.info') {
-    // something from an unknown domain, let's ignore it
+    // qualcosa da un dominio sconosciuto, lo ignoriamo
     return;
   }
 
   alert( "received: " + event.data );
 
-  // can message back using event.source.postMessage(...)
+  // rispondiamo al messaggio utilizzando event.source.postMessage(...)
 });
 ```
 
-The full example:
+Ecco l'esempio completo:
 
 [codetabs src="postmessage" height=120]
 
-## Summary
+## Riepilogo
 
-To call methods and access the content of another window, we should first have a reference to it.
+Per poter invocare metodi ed accedere al contenuto di un'altra finestra, dobbiamo come prima cosa ottenere un riferimeto ad essa.
 
-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.
+Per le finestre di popup abbiamo i seguenti riferimenti:
+- Dalla finestra che innesca l'apertura: `window.open`, consente di aprire una nuova finestra e ne ritorna il riferimento,
+- Dalla finestra di popup: `window.opener`, è il riferimento alla finestra che ha innescato l'apertura.
 
-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.
+Per gli iframe, possiamo accedere alle finestre padre/figlie utilizzando:
+- `window.frames`, una collection di oggetti relativi alle finestre annidate,
+- `window.parent`, `window.top` sono i riferimenti alle finestre padre e alla figlia,
+- `iframe.contentWindow` è la finestra all'interno di un tag `<iframe>`.
 
-If windows share the same origin (host, port, protocol), then windows can do whatever they want with each other.
+Se le finestre condividono la stessa origine (host, porta e protocollo), allora queste potranno accedere liberamente alle proprietà.
 
-Otherwise, only possible actions are:
-- Change the `location` of another window (write-only access).
-- Post a message to it.
+Altrimenti, le uniche azioni possibili saranno:
+- Cambio di `location` di un'altra finestra (accesso in scrittura).
+- Inviare un messaggio.
 
-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.
+Le uniche eccezioni sono:
+- Finestere che condividono lo stesso dominio di secondo livello: `a.site.com` e `b.site.com`. E che abbiamo entrambe impostato: `document.domain='site.com'`. In questo caso verranno intepretate come appartenenti alla stessa origine.
+- Se un iframe possiede l'attributo `sandbox`, allora questo verrà forzato ad uno stato di "origine differente", a meno che non venga esplicitamente disattivato passando come valore dell'attributo `allow-same-origin`. In questo caso verrà permessa l'esecuzione di codice esterno all'interno dell'iframe (se appartengono alla stessa origine).
 
-The `postMessage` interface allows two windows with any origins to talk:
+L'interfaccia `postMessage` consente a due finestre, qualsiasi sia la loro origine, di comunicare:
+
+1. Il mittente invocherà `targetWin.postMessage(data, targetOrigin)`.
+2. Se `targetOrigin` non è impostato a `'*'`, allora il browser verificherà se la finestra `targetWin` appartiene all'origine `targetOrigin`.
+3. Se questo è il caso, allora `targetWin` innescherà l'evento `message`, il quale possiede le seguenti proprietà:
+    - `origin`: l'origine della finestra mittente (ad esempio `http://my.site.com`)
+    - `source`: il riferimento alla finestra mittente.
+    - `data`: i dati inviati, sono supportati tutti i tipi di oggetto, ad eccezione di IE che accetta solamente stringhe.
+
+    Dobbiamo utilizzare `addEventListener` all'interno delle finestra targer, per impostare il gestore dell'evento.
 
-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.
 
-    We should use `addEventListener` to set the handler for this event inside the target window.

From 58c3bca924a85619a16b95f556247221885dd03a Mon Sep 17 00:00:00 2001
From: Andrea Longo <longoandreadev@gmail.com>
Date: Thu, 25 Mar 2021 22:00:04 +0100
Subject: [PATCH 4/7] fix typos

---
 .../03-cross-window-communication/article.md  | 42 +++++++++----------
 1 file changed, 21 insertions(+), 21 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 a55a7a9be..cad0a28d7 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -1,8 +1,8 @@
 # Comuniaczione cross-window
 
-La politcia di "Same Origin" ("stessa origine", ovvero stesso sito) limita il reciproco accesso tra finestre ed iframe diversi.
+La politica di "Same Origin" ("stessa origine", ovvero stesso sito) limita il reciproco accesso tra finestre ed iframe diversi.
 
-L'idea è che, se un utente ha deu pagine aperte: una su `john-smith.com`, ed un'altra su `gmail.com`, allora non vorrà che uno script ion esecuzione su `john-smith.com` possa leggere tutte le sue mail dalla finestra di `gmail.com`. Quindi, lo scopo della politica "Same Origin" è quello di proteggere l'utente dal furto di informazioni.
+L'idea è che, se un utente ha due pagine aperte: una su `john-smith.com`, ed un'altra su `gmail.com`, allora non vorrà che uno script in esecuzione su `john-smith.com` possa leggere tutte le sue mail dalla finestra di `gmail.com`. Quindi, lo scopo della politica "Same Origin" è quello di proteggere l'utente dal furto di informazioni.
 
 ## Same Origin [#same-origin]
 
@@ -24,7 +24,7 @@ Questi invece no:
 La politica di "Same Origin" afferma che:
 
 - se abbiamo un riferimento ad un'altra finestra, ad esempio un popup creato tramite `window.open` oppure una finestra all'interno di un `<iframe>`, e queste finestre appartengono alla stessa origine, allora avremo pieno accesso ad esse.
-- altrimenti, se queste provengono da origini differenti, allora non potremo accedere al cotenuto della finestra: variables, il suo document, e qualsiasi altra informazione. L'unica eccezione è sulla proprietà `location`: possiamo modificarla (reindirizzando l'utente). Ma non possiamo *leggerne* il contenuto (quindi non possiamo sapere in quale sito si trova l'utente in un dato momento, nessuna infromazione viene trapelata).
+- altrimenti, se queste provengono da origini differenti, allora non potremo accedere al contenuto della finestra: variabili, il suo document, e qualsiasi altra informazione. L'unica eccezione è sulla proprietà `location`: possiamo modificarla (reindirizzando l'utente). Ma non possiamo *leggerne* il contenuto (quindi non possiamo sapere in quale sito si trova l'utente in un dato momento, nessuna infromazione viene trapelata).
 
 ### In azione: iframe
 
@@ -32,10 +32,10 @@ Un tag di `<iframe>` permette di incorporare una finestra separata, la quale avr
 
 Possiamo accedervi utilizzando le proprietà:
 
-- `iframe.contentWindow` per ottenere il riferiemnto alla finestra all'interno di `<iframe>`.
+- `iframe.contentWindow` per ottenere il riferimento alla finestra all'interno di `<iframe>`.
 - `iframe.contentDocument` per ottenere il riferimento al document all'interno di `<iframe>`, abbreviazione per `iframe.contentWindow.document`.
 
-Quando accediamo a qualche proprietà della finestra incorporata, il browser verificherà se l'iframe appartiene alla stessa origine. Se cosi non è, allora l'accesso verrà negatp (rimane l'eccezione sulla scrittura di `location`, che è comunque permessa).
+Quando accediamo a qualche proprietà della finestra incorporata, il browser verificherà se l'iframe appartiene alla stessa origine. Se cosi non è, allora l'accesso verrà negato (rimane l'eccezione sulla scrittura di `location`, che è comunque permessa).
 
 Ad esempio, proviamo a leggere e scrivere su un `<iframe>` da un'altra origine:
 
@@ -44,7 +44,7 @@ Ad esempio, proviamo a leggere e scrivere su un `<iframe>` da un'altra origine:
 
 <script>
   iframe.onload = function() {
-    // possiamo ottenere il riferiemento alla finestra integrata
+    // possiamo ottenere il riferimento alla finestra integrata
 *!*
     let iframeWindow = iframe.contentWindow; // OK
 */!*
@@ -106,7 +106,7 @@ L'evento di `iframe.onload` (nel tag `<iframe>`) equivale a `iframe.contentWindo
 
 Per definizione, due URL con domini differenti appartengono ad origini differenti.
 
-Ma se le due finestre condividono lo stesso dominio di secondo livello, ad esempio `john.site.com`, `peter.site.com` e `site.com` (il loro dominio di secondo livello comunue è `site.com`), possiamo far si che il browser ignori la differenza, in questo modo verrannop trattate come se provenissero dalla "stessa origine", per gli scopi della comunicazione tra finestre.
+Ma se le due finestre condividono lo stesso dominio di secondo livello, ad esempio `john.site.com`, `peter.site.com` e `site.com` (il loro dominio di secondo livello comune è `site.com`), possiamo far si che il browser ignori la differenza, in questo modo verranno trattate come se provenissero dalla "stessa origine", per gli scopi della comunicazione tra finestre.
 
 Per far si che questo funzioni, ogni finestra dovrà eseguire il seguente codice:
 
@@ -118,9 +118,9 @@ Questo è tutto. Da questo momento in poi potranno interagire senza limitazioni.
 
 ## Iframe: il tranello del document errato
 
-Quando un iframe appartine alla stessa origine, con la possibilità quindi di accere al suo `document`, c'è un piccolo tranello a cui prestare attenzione. Non è strettamente legato al cross-origin, ma è comunque importante esserne a consocenza.
+Quando un iframe appartiene alla stessa origine, con la possibilità quindi di accedere al suo `document`, c'è un piccolo tranello a cui prestare attenzione. Non è strettamente legato al cross-origin, ma è comunque importante esserne a conoscenza.
 
-Al momento della creazione, un iframe genera immediatamente un docuement. Ma quest utlimo è diverso da quello che verrà caricato internamente!
+Al momento della creazione, un iframe genera immediatamente un document. Ma quest ultimo è diverso da quello che verrà caricato internamente!
 
 Quindi, se qualsiasi operazione effettuata sul document negli istanti dopo al creazione, andrà probabilmente persa.
 
@@ -146,7 +146,7 @@ Dovremmo evitare di effettuare operazioni sul document di un iframe non ancora c
 
 Come possiamo assicurarci che il document sia quello corretto?
 
-Per essere sicuri di lavorare con il document corretto, dovremmo attendere fin quando verrà emesso l'evento `iframe.onload`. Il quale verrà innescato solemente una volta che l'iframe avrà caricato tutte le risorse.
+Per essere sicuri di lavorare con il document corretto, dovremmo attendere fin quando verrà emesso l'evento `iframe.onload`. Il quale verrà innescato solamente una volta che l'iframe avrà caricato tutte le risorse.
 
 Possiamo provare ad intercettarlo anticipatamente effettuando controlli all'interno di un `setInterval`:
 
@@ -170,10 +170,10 @@ Possiamo provare ad intercettarlo anticipatamente effettuando controlli all'inte
 
 ## Collection: window.frames
 
-Un modo alternativo per ottenere l'oggetto realtivo ad una finestra di `<iframe>`, è quello di accedervi tramite la collection `window.frames`:
+Un modo alternativo per ottenere l'oggetto relativo ad una finestra di `<iframe>`, è quello di accedervi tramite la collection `window.frames`:
 
 - Tramite indice: `window.frames[0]`: l'oggetto relativo alla prima finestra di iframe nel document.
-- By name: `window.frames.iframeName`: l'oggetto realtivo all'iframew con `name="iframeName"`.
+- By name: `window.frames.iframeName`: l'oggetto relativo all'iframew con `name="iframeName"`.
 
 Ad esempio:
 
@@ -192,7 +192,7 @@ E' possibile navigare tra le finestre della gerarchia utilizzando:
 
 - `window.frames`: la collezione delle finestre "figlie" (per iframe annidati).
 - `window.parent`: il riferimento alla finestra "padre" (quella esterna).
-- `window.top`: il riferiemento alla finestra in cima alla gerarchia.
+- `window.top`: il riferimento alla finestra in cima alla gerarchia.
 
 Ad esempio:
 
@@ -214,14 +214,14 @@ if (window == top) { // window == window.top?
 
 L'attributo `sandbox` permette l'esclusione di determinate azioni all'interno di un `<iframe>`, in modo da prevenire l'esecuzione di codice non affidabile. Consente di "isolare" ("sandbox") l'iframe, facendo si che venga trattato come se appartenesse ad un origine diversa e/o applicando altre limitazioni.
 
-Ci sono una serie di restriozioni "applicate di default" per un `<iframe sandbox src="...">`. Ma possono essere disattivate esplicitamente fornendo, come valore dell'attributo, la lista delle restrizioni da non applicare separate da un carettere di spazio, in questo modo: `<iframe sandbox="allow-forms allow-popups">`.
+Ci sono una serie di restrizioni "applicate di default" per un `<iframe sandbox src="...">`. Ma possono essere disattivate esplicitamente fornendo, come valore dell'attributo, la lista delle restrizioni da non applicare separate da un carattere di spazio, in questo modo: `<iframe sandbox="allow-forms allow-popups">`.
 
 In altre parole, un attributo `"sandbox"` vuoto, applica tutte le restrizioni, ma possiamo fornirgli la lista di quelle che vogliamo disattivare, separandole con uno spazio.
 
 Di seguito la lista delle limitazioni:
 
 `allow-same-origin`
-: Di default l'attributo `"sandbox"` forza la politica di "diversa origine" per un iframe. In altre parole, fa si che il browser trati l'`iframe` come se appartenesse ad un origine diversa, anche se in realtà il suo `src` sta puntando allo stesso sito. Con tutte le relative implicazioni viste prima. Questa opzione, disabilita la restrizione.
+: Di default l'attributo `"sandbox"` forza la politica di "diversa origine" per un iframe. In altre parole, fa si che il browser tratti l'`iframe` come se appartenesse ad un origine diversa, anche se in realtà il suo `src` sta puntando allo stesso sito. Con tutte le relative implicazioni viste prima. Questa opzione, disabilita la restrizione.
 
 `allow-top-navigation`
 : Permette all'iframe` di cambiare `parent.location`.
@@ -233,7 +233,7 @@ Di seguito la lista delle limitazioni:
 : Permette l'esecuzione di script dall'`iframe`.
 
 `allow-popups`
-: Permette all'`iframe` l'apertura di finestre di poopup tramite `window.open`
+: Permette all'`iframe` l'apertura di finestre di popup tramite `window.open`
 
 Consulta [il manuale](mdn:/HTML/Element/iframe) per maggiori informazioni.
 
@@ -252,7 +252,7 @@ Lo scopo dell'attributo `"sandbox"` è solamente quello di *aggiungere più* res
 
 L'interfaccia `postMessage` permette alle finestre di comunicare indistintamente dall'origine di appartenenza.
 
-Quindi, è di fatto un modo per aggirare la politica di "Same Origin". Consente infatti ad una finestra proveniente da `john-smith.com` di comunicare con `gmail.com` e scambiarsi informazioni, ma solamente nel caso in cui entrambe acconsentono questo comportamento ed invocano le rispettive funzoni JavaScript. Questo rende il meccaniscmo di comunicazione tra finestre sicuro per l'utente.
+Quindi, è di fatto un modo per aggirare la politica di "Same Origin". Consente infatti ad una finestra proveniente da `john-smith.com` di comunicare con `gmail.com` e scambiarsi informazioni, ma solamente nel caso in cui entrambe acconsentono questo comportamento ed invocano le rispettive funzioni JavaScript. Questo rende il meccaniscmo di comunicazione tra finestre sicuro per l'utente.
 
 L'interfaccia è composta da due parti.
 
@@ -263,7 +263,7 @@ La finestra che vuole inviare un messaggio invoca il metodo [postMessage](mdn:ap
 Argomenti:
 
 `data`
-: I dati da inviare. Possono essere un qualsiasi oggetto, che verrà poi duplicato utilizzando "l'algorito di serializzazione strutturato". IE supporta solamente stringhe, quindi dovremo utilizzare `JSON.stringify` per supportarlo.
+: I dati da inviare. Possono essere un qualsiasi oggetto, che verrà poi duplicato utilizzando "l'algoritmo di serializzazione strutturato". IE supporta solamente stringhe, quindi dovremo utilizzare `JSON.stringify` per supportarlo.
 
 `targetOrigin`
 : Specifica l'origine per al finestra target, in questo modo il messaggio verrà ricevuto solamente dalla giusta finestra.
@@ -337,7 +337,7 @@ Ecco l'esempio completo:
 
 ## Riepilogo
 
-Per poter invocare metodi ed accedere al contenuto di un'altra finestra, dobbiamo come prima cosa ottenere un riferimeto ad essa.
+Per poter invocare metodi ed accedere al contenuto di un'altra finestra, dobbiamo come prima cosa ottenere un riferimento ad essa.
 
 Per le finestre di popup abbiamo i seguenti riferimenti:
 - Dalla finestra che innesca l'apertura: `window.open`, consente di aprire una nuova finestra e ne ritorna il riferimento,
@@ -355,7 +355,7 @@ Altrimenti, le uniche azioni possibili saranno:
 - Inviare un messaggio.
 
 Le uniche eccezioni sono:
-- Finestere che condividono lo stesso dominio di secondo livello: `a.site.com` e `b.site.com`. E che abbiamo entrambe impostato: `document.domain='site.com'`. In questo caso verranno intepretate come appartenenti alla stessa origine.
+- Finestre che condividono lo stesso dominio di secondo livello: `a.site.com` e `b.site.com`. E che abbiamo entrambe impostato: `document.domain='site.com'`. In questo caso verranno interpretate come appartenenti alla stessa origine.
 - Se un iframe possiede l'attributo `sandbox`, allora questo verrà forzato ad uno stato di "origine differente", a meno che non venga esplicitamente disattivato passando come valore dell'attributo `allow-same-origin`. In questo caso verrà permessa l'esecuzione di codice esterno all'interno dell'iframe (se appartengono alla stessa origine).
 
 L'interfaccia `postMessage` consente a due finestre, qualsiasi sia la loro origine, di comunicare:
@@ -367,6 +367,6 @@ L'interfaccia `postMessage` consente a due finestre, qualsiasi sia la loro origi
     - `source`: il riferimento alla finestra mittente.
     - `data`: i dati inviati, sono supportati tutti i tipi di oggetto, ad eccezione di IE che accetta solamente stringhe.
 
-    Dobbiamo utilizzare `addEventListener` all'interno delle finestra targer, per impostare il gestore dell'evento.
+    Dobbiamo utilizzare `addEventListener` all'interno delle finestra target, per impostare il gestore dell'evento.
 
 

From d7a823f4526541f8a0967cfc0131a3c5b5cfb4cc Mon Sep 17 00:00:00 2001
From: Andrea Longo <longoandreadev@gmail.com>
Date: Thu, 25 Mar 2021 22:01:10 +0100
Subject: [PATCH 5/7] fix typo

---
 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 cad0a28d7..ea00eed15 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -1,4 +1,4 @@
-# Comuniaczione cross-window
+# Comunicazione cross-window
 
 La politica di "Same Origin" ("stessa origine", ovvero stesso sito) limita il reciproco accesso tra finestre ed iframe diversi.
 

From 003415ab330c19087d4cec8796dfb7246de7de47 Mon Sep 17 00:00:00 2001
From: Andrea <45577511+longo-andrea@users.noreply.github.com>
Date: Sat, 3 Apr 2021 10:10:57 +0200
Subject: [PATCH 6/7] Apply suggestions from code review

Co-authored-by: Dorin David <70648503+Dorin-David@users.noreply.github.com>
---
 .../03-cross-window-communication/article.md    | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 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 ea00eed15..a5a695a4f 100644
--- a/3-frames-and-windows/03-cross-window-communication/article.md
+++ b/3-frames-and-windows/03-cross-window-communication/article.md
@@ -24,7 +24,7 @@ Questi invece no:
 La politica di "Same Origin" afferma che:
 
 - se abbiamo un riferimento ad un'altra finestra, ad esempio un popup creato tramite `window.open` oppure una finestra all'interno di un `<iframe>`, e queste finestre appartengono alla stessa origine, allora avremo pieno accesso ad esse.
-- altrimenti, se queste provengono da origini differenti, allora non potremo accedere al contenuto della finestra: variabili, il suo document, e qualsiasi altra informazione. L'unica eccezione è sulla proprietà `location`: possiamo modificarla (reindirizzando l'utente). Ma non possiamo *leggerne* il contenuto (quindi non possiamo sapere in quale sito si trova l'utente in un dato momento, nessuna infromazione viene trapelata).
+- altrimenti, se queste provengono da origini differenti, allora non potremo accedere al contenuto della finestra: alle variabili, il suo document, e qualsiasi altra informazione. L'unica eccezione è sulla proprietà `location`: possiamo modificarla (reindirizzando l'utente). Ma non possiamo *leggerne* il contenuto (quindi non possiamo sapere in quale sito si trova l'utente in un dato momento, nessuna infromazione viene trapelata).
 
 ### In azione: iframe
 
@@ -120,9 +120,9 @@ Questo è tutto. Da questo momento in poi potranno interagire senza limitazioni.
 
 Quando un iframe appartiene alla stessa origine, con la possibilità quindi di accedere al suo `document`, c'è un piccolo tranello a cui prestare attenzione. Non è strettamente legato al cross-origin, ma è comunque importante esserne a conoscenza.
 
-Al momento della creazione, un iframe genera immediatamente un document. Ma quest ultimo è diverso da quello che verrà caricato internamente!
+Al momento della creazione, un iframe genera immediatamente un document. Ma quest'ultimo è diverso da quello che verrà caricato internamente!
 
-Quindi, se qualsiasi operazione effettuata sul document negli istanti dopo al creazione, andrà probabilmente persa.
+Quindi, qualsiasi operazione effettuata sul document negli istanti dopo al creazione, andrà probabilmente persa.
 
 Vediamo un esempio di quanto affermato:
 
@@ -191,7 +191,7 @@ Un iframe potrebbe possedere a sua volta degli iframe. I rispettivi oggetti `win
 E' possibile navigare tra le finestre della gerarchia utilizzando:
 
 - `window.frames`: la collezione delle finestre "figlie" (per iframe annidati).
-- `window.parent`: il riferimento alla finestra "padre" (quella esterna).
+- `window.parent`: il riferimento alla finestra "genitore" (quella esterna).
 - `window.top`: il riferimento alla finestra in cima alla gerarchia.
 
 Ad esempio:
@@ -221,7 +221,7 @@ In altre parole, un attributo `"sandbox"` vuoto, applica tutte le restrizioni, m
 Di seguito la lista delle limitazioni:
 
 `allow-same-origin`
-: Di default l'attributo `"sandbox"` forza la politica di "diversa origine" per un iframe. In altre parole, fa si che il browser tratti l'`iframe` come se appartenesse ad un origine diversa, anche se in realtà il suo `src` sta puntando allo stesso sito. Con tutte le relative implicazioni viste prima. Questa opzione, disabilita la restrizione.
+: Di default l'attributo `"sandbox"` forza la politica di "diversa origine" per un iframe. In altre parole, fa sì che il browser tratti l'`iframe` come se appartenesse ad un origine diversa, anche se in realtà il suo `src` sta puntando allo stesso sito. Con tutte le relative implicazioni viste prima. Questa opzione disabilita la restrizione.
 
 `allow-top-navigation`
 : Permette all'iframe` di cambiare `parent.location`.
@@ -343,9 +343,9 @@ Per le finestre di popup abbiamo i seguenti riferimenti:
 - Dalla finestra che innesca l'apertura: `window.open`, consente di aprire una nuova finestra e ne ritorna il riferimento,
 - Dalla finestra di popup: `window.opener`, è il riferimento alla finestra che ha innescato l'apertura.
 
-Per gli iframe, possiamo accedere alle finestre padre/figlie utilizzando:
+Per gli iframe, possiamo accedere alle finestre genitrici/figlie utilizzando:
 - `window.frames`, una collection di oggetti relativi alle finestre annidate,
-- `window.parent`, `window.top` sono i riferimenti alle finestre padre e alla figlia,
+- `window.parent`, `window.top` sono i riferimenti alle finestre genitrici e figlia,
 - `iframe.contentWindow` è la finestra all'interno di un tag `<iframe>`.
 
 Se le finestre condividono la stessa origine (host, porta e protocollo), allora queste potranno accedere liberamente alle proprietà.
@@ -367,6 +367,5 @@ L'interfaccia `postMessage` consente a due finestre, qualsiasi sia la loro origi
     - `source`: il riferimento alla finestra mittente.
     - `data`: i dati inviati, sono supportati tutti i tipi di oggetto, ad eccezione di IE che accetta solamente stringhe.
 
-    Dobbiamo utilizzare `addEventListener` all'interno delle finestra target, per impostare il gestore dell'evento.
-
+    Dobbiamo utilizzare `addEventListener` all'interno delle finestra target per impostare il gestore dell'evento.
 

From eab7f57b1a31c21f5bf45ec529c5d63ba1237003 Mon Sep 17 00:00:00 2001
From: Andrea <45577511+longo-andrea@users.noreply.github.com>
Date: Mon, 5 Apr 2021 21:44:03 +0200
Subject: [PATCH 7/7] Apply suggestions from code review

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>
---
 .../03-cross-window-communication/article.md  | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 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 a5a695a4f..334c07f76 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 politica di "Same Origin" ("stessa origine", ovvero stesso sito) limita il reciproco accesso tra finestre ed iframe diversi.
 
-L'idea è che, se un utente ha due pagine aperte: una su `john-smith.com`, ed un'altra su `gmail.com`, allora non vorrà che uno script in esecuzione su `john-smith.com` possa leggere tutte le sue mail dalla finestra di `gmail.com`. Quindi, lo scopo della politica "Same Origin" è quello di proteggere l'utente dal furto di informazioni.
+L'idea è che, se un utente ha due pagine aperte: una su `john-smith.com`, ed un'altra su `gmail.com`, allora non si vorrà che uno script in esecuzione su `john-smith.com` possa leggere tutte le email dalla finestra di `gmail.com`. Quindi, lo scopo della politica "Same Origin" è quello di proteggere l'utente dal furto di informazioni.
 
 ## Same Origin [#same-origin]
 
@@ -24,11 +24,11 @@ Questi invece no:
 La politica di "Same Origin" afferma che:
 
 - se abbiamo un riferimento ad un'altra finestra, ad esempio un popup creato tramite `window.open` oppure una finestra all'interno di un `<iframe>`, e queste finestre appartengono alla stessa origine, allora avremo pieno accesso ad esse.
-- altrimenti, se queste provengono da origini differenti, allora non potremo accedere al contenuto della finestra: alle variabili, il suo document, e qualsiasi altra informazione. L'unica eccezione è sulla proprietà `location`: possiamo modificarla (reindirizzando l'utente). Ma non possiamo *leggerne* il contenuto (quindi non possiamo sapere in quale sito si trova l'utente in un dato momento, nessuna infromazione viene trapelata).
+- altrimenti, se queste provengono da origini differenti, allora non potremo accedere al contenuto della finestra: alle variabili, il suo document, e qualsiasi altra informazione. L'unica eccezione è sulla proprietà `location`: possiamo modificarla (reindirizzando l'utente). Ma non possiamo *leggerne* il contenuto (quindi non possiamo sapere in quale sito si trova l'utente in un dato momento, nessuna informazione viene esposta).
 
 ### In azione: iframe
 
-Un tag di `<iframe>` permette di incorporare una finestra separata, la quale avrà i suoi oggetti `document` e `window` separati.
+Un tag `<iframe>` permette di incorporare una finestra separata, con i propri oggetti `document` e `window`.
 
 Possiamo accedervi utilizzando le proprietà:
 
@@ -82,7 +82,7 @@ Il codice sopra genera errori in tutti i casi ad eccezione di:
 - Lettura del riferimento alla finestra interna `iframe.contentWindow`, la quale è permessa.
 - Scrittura su `location`.
 
-Contrariamente a questo, se l'`<iframe>` proviene dalla stessa origine, possiamo farci qualsiasi cosa:
+Al contrario, se l'`<iframe>` proviene dalla stessa origine, possiamo eseguire qualsiasi operazione:
 
 ```html run
 <!-- iframe dallo stesso sito -->
@@ -114,7 +114,7 @@ Per far si che questo funzioni, ogni finestra dovrà eseguire il seguente codice
 document.domain = 'site.com';
 ```
 
-Questo è tutto. Da questo momento in poi potranno interagire senza limitazioni. Nuovamente, questo è possibile solamente per pagine che possiedono lo stesso dominio di secondo livello.
+Questo è tutto. Da questo momento in poi potranno interagire senza limitazioni. Nuovamente, questo è possibile solamente per pagine che appartengono allo stesso dominio di secondo livello.
 
 ## Iframe: il tranello del document errato
 
@@ -173,7 +173,7 @@ Possiamo provare ad intercettarlo anticipatamente effettuando controlli all'inte
 Un modo alternativo per ottenere l'oggetto relativo ad una finestra di `<iframe>`, è quello di accedervi tramite la collection `window.frames`:
 
 - Tramite indice: `window.frames[0]`: l'oggetto relativo alla prima finestra di iframe nel document.
-- By name: `window.frames.iframeName`: l'oggetto relativo all'iframew con `name="iframeName"`.
+- By name: `window.frames.iframeName`: l'oggetto relativo all'iframe con `name="iframeName"`.
 
 Ad esempio:
 
@@ -245,7 +245,7 @@ Avrete notato che nulla di ciò che è presente funziona. Quindi le restrizioni
 
 
 ```smart
-Lo scopo dell'attributo `"sandbox"` è solamente quello di *aggiungere più* restrizioni. Non di diminuirle. In particolare, non può essere utilizzato per disabilitare la restrizione di "Same Origin" per iframe appartengono ad origini differenti.
+Lo scopo dell'attributo `"sandbox"` è solamente quello di *aggiungere più* restrizioni, non di rimuoverle. In particolare, non può essere utilizzato per disabilitare la restrizione di "Same Origin" per iframe appartenenti ad origini differenti.
 ```
 
 ## Messaggi Cross-window
@@ -266,7 +266,7 @@ Argomenti:
 : I dati da inviare. Possono essere un qualsiasi oggetto, che verrà poi duplicato utilizzando "l'algoritmo di serializzazione strutturato". IE supporta solamente stringhe, quindi dovremo utilizzare `JSON.stringify` per supportarlo.
 
 `targetOrigin`
-: Specifica l'origine per al finestra target, in questo modo il messaggio verrà ricevuto solamente dalla giusta finestra.
+: Specifica l'origine per la finestra target, in questo modo il messaggio verrà ricevuto solamente dalla giusta finestra.
 
 Il parametro `targetOrigin` è una misura di sicurezza. Ricordate, se una finestra target appartiene ad una diversa origine, non possiamo leggere la sua `location` nella finestra mittente. Quindi non possiamo essere certi di quale sito sia aperto nella finestra a cui vogliamo inviare il messaggio: l'utente potrebbe aver cambiato sito, senza che la finestra mittente ne sia al corrente.
 
@@ -348,14 +348,14 @@ Per gli iframe, possiamo accedere alle finestre genitrici/figlie utilizzando:
 - `window.parent`, `window.top` sono i riferimenti alle finestre genitrici e figlia,
 - `iframe.contentWindow` è la finestra all'interno di un tag `<iframe>`.
 
-Se le finestre condividono la stessa origine (host, porta e protocollo), allora queste potranno accedere liberamente alle proprietà.
+Se le finestre condividono la stessa origine (host, porta e protocollo), allora queste potranno accedere reciprocamente alle proprietà.
 
 Altrimenti, le uniche azioni possibili saranno:
 - Cambio di `location` di un'altra finestra (accesso in scrittura).
 - Inviare un messaggio.
 
 Le uniche eccezioni sono:
-- Finestre che condividono lo stesso dominio di secondo livello: `a.site.com` e `b.site.com`. E che abbiamo entrambe impostato: `document.domain='site.com'`. In questo caso verranno interpretate come appartenenti alla stessa origine.
+- Finestre che condividono lo stesso dominio di secondo livello: `a.site.com` e `b.site.com`. E che abbiano entrambe impostato: `document.domain='site.com'`. In questo caso verranno interpretate come appartenenti alla stessa origine.
 - Se un iframe possiede l'attributo `sandbox`, allora questo verrà forzato ad uno stato di "origine differente", a meno che non venga esplicitamente disattivato passando come valore dell'attributo `allow-same-origin`. In questo caso verrà permessa l'esecuzione di codice esterno all'interno dell'iframe (se appartengono alla stessa origine).
 
 L'interfaccia `postMessage` consente a due finestre, qualsiasi sia la loro origine, di comunicare:
@@ -368,4 +368,3 @@ L'interfaccia `postMessage` consente a due finestre, qualsiasi sia la loro origi
     - `data`: i dati inviati, sono supportati tutti i tipi di oggetto, ad eccezione di IE che accetta solamente stringhe.
 
     Dobbiamo utilizzare `addEventListener` all'interno delle finestra target per impostare il gestore dell'evento.
-