diff --git a/8-web-components/5-slots-composition/article.md b/8-web-components/5-slots-composition/article.md
index ada52a06a..0df0e0c91 100644
--- a/8-web-components/5-slots-composition/article.md
+++ b/8-web-components/5-slots-composition/article.md
@@ -1,33 +1,33 @@
 # Shadow DOM slots, composition
 
-Many types of components, such as tabs, menus, image galleries, and so on, need the content to render.
+Molti tipi di components, come tabs, menù, gallerie di immagini ed altri ancora, necessitano di contenuti da visualizzare.
 
-Just like built-in browser `<select>` expects `<option>` items, our `<custom-tabs>` may expect the actual tab content to be passed. And a `<custom-menu>` may expect menu items.
+Proprio come gli elementi built-in del browser, in cui `<select>` si aspetta gli elementi `<option>`, i nostri `<custom-tabs>` potrebbero avere la necessità che gli venga passato il contenuto attuale del tab. Oppure un `<custom-menu>`, ad esempio, si aspetterebbe gli elementi del menù.
 
-The code that makes use of `<custom-menu>` can look like this:
+Il codice che fa uso del `<custom-menu>` potrebbe essere questo:
 
 ```html
 <custom-menu>
-  <title>Candy menu</title>
-  <item>Lollipop</item>
-  <item>Fruit Toast</item>
+  <title>Menù dei dolciumi</title>
+  <item>Lecca-lecca</item>
+  <item>Toast alla frutta</item>
   <item>Cup Cake</item>
 </custom-menu>
 ```
 
-...Then our component should render it properly, as a nice menu with given title and items, handle menu events, etc.
+...Il nostro "component" potrebbe visualizzarsi correttamente in questo modo, come un menù con titolo ed i suoi elementi, la gestione degli eventi e tutto il resto...
 
-How to implement it?
+Come si può implementare?
 
-We could try to analyze the element content and dynamically copy-rearrange DOM nodes. That's possible, but if we're moving elements to shadow DOM, then CSS styles from the document do not apply in there, so the visual styling may be lost. Also that requires some coding.
+Possiamo provare ad analizzare il contenuto dell'elemento, e poi copiare e riarrangiare dinamicamente i nodi DOM. Ciò è sicuramente fattibile, ma se stiamo spostando gli elementi nello shadow DOM, e quindi gli stili CSS del documento non verranno applicati in quella sezione, potremmo incorrere in difetti di visualizzazione degli stili, cosa che richiederebbe un po' di gestione lato codice.
 
-Luckily, we don't have to. Shadow DOM supports `<slot>` elements, that are automatically filled by the content from light DOM.
+Fortunatamente, non è necessario. Lo Shadow DOM supporta gli elementi `<slot>`, che vengono automaticamente riempiti dal contenuto del light DOM.
 
 ## Named slots
 
-Let's see how slots work on a simple example.
+Diamo un'occhiata al funzionamento degli slots con un esempio basilare.
 
-Here, `<user-card>` shadow DOM provides two slots, filled from light DOM:
+Qui, lo shadow DOM `<user-card>` fornisce due slots, riempiti dal light DOM:
 
 ```html run autorun="no-epub" untrusted height=80
 <script>
@@ -56,11 +56,11 @@ customElements.define('user-card', class extends HTMLElement {
 </user-card>
 ```
 
-In the shadow DOM, `<slot name="X">` defines an "insertion point", a place where elements with `slot="X"` are rendered.
+Nello shadow DOM, `<slot name="X">` definisce un "punto di inserimento", cioè una posizione all'interno della quale vengono visualizzati gli elementi con `slot="X"`.
 
-Then the browser performs "composition": it takes elements from the light DOM and renders them in corresponding slots of the shadow DOM. At the end, we have exactly what we want -- a component that can be filled with data.
+Quindi, il browser esegue la "composition": prende gli elementi dal light DOM e ne esegue il rendering all'interno degli slots corrispondenti dello shadow DOM. Ed alla fine del processo, avremo esattamente quello che vogliamo: un componente che può essere riempito con dei dati.
 
-Here's the DOM structure after the script, not taking composition into account:
+Ecco come sarà la struttura dopo lo script, senza il coinvolgimento della composition:
 
 ```html
 <user-card>
@@ -76,20 +76,20 @@ Here's the DOM structure after the script, not taking composition into account:
 </user-card>
 ```
 
-We created the shadow DOM, so here it is, under `#shadow-root`. Now the element has both light and shadow DOM.
+Abbiamo creato lo shadow DOM, ed eccolo dentro `#shadow-root`. Ora contiene sia lo shadow che il light DOM.
 
-For rendering purposes, for each `<slot name="...">` in shadow DOM, the browser looks for `slot="..."` with the same name in the light DOM. These elements are rendered inside the slots:
+Per esigenze di rendering, per ogni `<slot name="...">` dello shadow DOM, il browser cerca uno `slot="..."` con lo stesso nome, all'interno del light DOM. Questi elementi vengono renderizzati dentro gli slots:
 
 ![](shadow-dom-user-card.svg)
 
-The result is called "flattened" DOM:
+Il risultato viene detto "flattened" DOM:
 
 ```html
 <user-card>
   #shadow-root
     <div>Name:
       <slot name="username">
-        <!-- slotted element is inserted into the slot -->
+        <!-- l'elemento slotted viene inserito nello slot -->
         <span slot="username">John Smith</span>
       </slot>
     </div>
@@ -101,35 +101,35 @@ The result is called "flattened" DOM:
 </user-card>
 ```
 
-...But the flattened DOM exists only for rendering and event-handling purposes. It's kind of "virtual". That's how things are shown. But the nodes in the document are actually not moved around!
+...Tuttavia, il flattened DOM esiste puramente per scopi di rendering e gestione degli eventi. È come se fosse "virtuale". Le cose vengono mostrate così come le vediamo, ma i nodi nel documento non vengono spostati!
 
-That can be easily checked if we run `querySelectorAll`: nodes are still at their places.
+Ciò può essere facilmente verificato se eseguiamo`querySelectorAll`: i nodi saranno rimasti al proprio posto.
 
 ```js
-// light DOM <span> nodes are still at the same place, under `<user-card>`
+// i nodi degli <span> del light DOM sono ancora nella stessa posizione, quindi dentro `<user-card>`
 alert( document.querySelectorAll('user-card span').length ); // 2
 ```
 
-So, the flattened DOM is derived from shadow DOM by inserting slots. The browser renders it and uses for style inheritance, event propagation (more about that later). But JavaScript still sees the document "as is", before flattening.
+Quindi, il flattened DOM deriva dallo shadow DOM con l'inserimento degli slots. Il browser ne effettua il rendering e li usa per ereditare gli stili e la propagazione degli eventi (vedremo questi aspetti più avanti). Ciononostante JavaScript vede ancora il documento "per quello che è", cioè come era prima del processo di flattening.
 
-````warn header="Only top-level children may have slot=\"...\" attribute"
-The `slot="..."` attribute is only valid for direct children of the shadow host (in our example, `<user-card>` element). For nested elements it's ignored.
+````warn header="Solo i figli top-level possono avere l'attributo slot=\"...\" "
+L'attributo `slot="..."` è valido solamente per i figli diretti dello shadow host (nel nostro esempio, l'elemento `<user-card>`), gli elementi annidati, invece, vengono ignorati.
 
-For example, the second `<span>` here is ignored (as it's not a top-level child of `<user-card>`):
+Ad esempio, qui il secondo `<span>` viene ignorato (dal momento che non è un figlio top-level di `<user-card>`):
 ```html
 <user-card>
   <span slot="username">John Smith</span>
   <div>
-    <!-- invalid slot, must be direct child of user-card -->
+    <!-- slot non valido, deve essere un figlio diretto di user-card -->
     <span slot="birthday">01.01.2001</span>
   </div>
 </user-card>
 ```
 ````
 
-If there are multiple elements in light DOM with the same slot name, they are appended into the slot, one after another.
+Se ci sono più elementi nel light DOM con lo stesso slot name, questi vengono inseriti nello slot, uno dopo l'altro in successione.
 
-For example, this:
+Come nel seguente esempio:
 ```html
 <user-card>
   <span slot="username">John</span>
@@ -137,7 +137,7 @@ For example, this:
 </user-card>
 ```
 
-Gives this flattened DOM with two elements in `<slot name="username">`:
+Restituisce il flattened DOM con due elementi dentro `<slot name="username">`:
 
 ```html
 <user-card>
@@ -156,9 +156,9 @@ Gives this flattened DOM with two elements in `<slot name="username">`:
 
 ## Slot fallback content
 
-If we put something inside a `<slot>`, it becomes the fallback, "default" content. The browser shows it if there's no corresponding filler in light DOM.
+Se inseriamo qualcosa dentro l'elemento `<slot>`, rappresenterà il contenuto di ripiego, cioè quello "predefinito". Quindi, nel caso in cui non vi fossero contenuti corrispondenti nel light DOM, sarà questo il contenuto che verrà visualizzato dal browser.
 
-For example, in this piece of shadow DOM, `Anonymous` renders if there's no `slot="username"` in light DOM.
+Per esempio, in questo pezzo di shadow DOM, verrà visualizzato `Anonymous` se non ci sono `slot="username"` nel light DOM.
 
 ```html
 <div>Name:
@@ -166,11 +166,11 @@ For example, in this piece of shadow DOM, `Anonymous` renders if there's no `slo
 </div>
 ```
 
-## Default slot: first unnamed
+## Slot "default": il primo senza nome
 
-The first `<slot>` in shadow DOM that doesn't have a name is a "default" slot. It gets all nodes from the light DOM that aren't slotted elsewhere.
+Il primo `<slot>` dello shadow DOM privo di nome è uno slot "default". Esso riceve al suo interno tutti i nodi dal light DOM che non sono stati slottati da nessuna parte.
 
-For example, let's add the default slot to our `<user-card>` that shows all unslotted information about the user:
+Per esempio, aggiungiamo lo slot default al nostro `<user-card>` che mostrerà tutte le informazioni non slottate dell'utente:
 
 ```html run autorun="no-epub" untrusted height=140
 <script>
@@ -197,21 +197,21 @@ customElements.define('user-card', class extends HTMLElement {
 
 <user-card>
 *!*
-  <div>I like to swim.</div>
+  <div>Mi piace nuotare.</div>
 */!*
   <span slot="username">John Smith</span>
   <span slot="birthday">01.01.2001</span>
 *!*
-  <div>...And play volleyball too!</div>
+  <div>...ed anche giocare a pallavolo!</div>
 */!*
 </user-card>
 ```
 
-All the unslotted light DOM content gets into the "Other information" fieldset.
+Tutti i contenuti del light DOM unslotted andranno a finire dentro il fieldset "Other information".
 
-Elements are appended to a slot one after another, so both unslotted pieces of information are in the default slot together.
+Gli elementi vengono accodati su uno slot, uno dopo l'altro, quindi anche i pezzi di informazione unslotted vanno a finire dentro lo slot default, tutti insieme.
 
-The flattened DOM looks like this:
+Il flattened DOM apparirà come questo:
 
 ```html
 <user-card>
@@ -238,24 +238,24 @@ The flattened DOM looks like this:
 </user-card>
 ```
 
-## Menu example
+## Esempio di menù
 
-Now let's back to `<custom-menu>`, mentioned at the beginning of the chapter.
+Torniamo adesso al `<custom-menu>`, citato all'inizio del capitolo.
 
-We can use slots to distribute elements.
+Possiamo usare gli slot per distribuire gli elementi.
 
-Here's the markup for `<custom-menu>`:
+Ecco il markup per il `<custom-menu>`:
 
 ```html
 <custom-menu>
-  <span slot="title">Candy menu</span>
-  <li slot="item">Lollipop</li>
-  <li slot="item">Fruit Toast</li>
+  <span slot="title">Menù dei dolciumi</span>
+  <li slot="item">Lecca-lecca</li>
+  <li slot="item">Toast alla frutta</li>
   <li slot="item">Cup Cake</li>
 </custom-menu>
 ```
 
-The shadow DOM template with proper slots:
+Questo è invece il template dello shadow DOM con gli slot appropriati:
 
 ```html
 <template id="tmpl">
@@ -267,10 +267,10 @@ The shadow DOM template with proper slots:
 </template>
 ```
 
-1. `<span slot="title">` goes into `<slot name="title">`.
-2. There are many `<li slot="item">` in the template, but only one `<slot name="item">` in the template. So all such `<li slot="item">` are appended to `<slot name="item">` one after another, thus forming the list.
+1. `<span slot="title">` verrà inserito dentro `<slot name="title">`.
+2. Ci sono tanti `<li slot="item">`, ma solo uno `<slot name="item">` nel template. Di conseguenza tutti gli elementi `<li slot="item">` verranno inseriti dentro `<slot name="item">` uno dopo l'altro, così da formare la lista.
 
-The flattened DOM becomes:
+Il flattened DOM diventa:
 
 ```html
 <custom-menu>
@@ -278,12 +278,12 @@ The flattened DOM becomes:
     <style> /* menu styles */ </style>
     <div class="menu">
       <slot name="title">
-        <span slot="title">Candy menu</span>
+        <span slot="title">Menù dei dolciumi</span>
       </slot>
       <ul>
         <slot name="item">
-          <li slot="item">Lollipop</li>
-          <li slot="item">Fruit Toast</li>
+          <li slot="item">Lecca-lecca</li>
+          <li slot="item">Toast alla frutta</li>
           <li slot="item">Cup Cake</li>
         </slot>
       </ul>
@@ -291,48 +291,48 @@ The flattened DOM becomes:
 </custom-menu>
 ```
 
-One might notice that, in a valid DOM, `<li>` must be a direct child of `<ul>`. But that's flattened DOM, it describes how the component is rendered, such thing happens naturally here.
+Qualcuno potrebbe notare che, in un DOM valido, un `<li>` dovrebbe essere figlio diretto di `<ul>`. Tuttavia questo è un flattened DOM, che descrive la maniera nella qualre il componente verrà renderizzato, quindi è perfettamente lecito e regolare.
 
-We just need to add a `click` handler to open/close the list, and the `<custom-menu>` is ready:
+Dobbiamo solo aggiungere una gestione per il `click`, per poter aprire e chiudere la lista, ed il `<custom-menu>` sarà pronto:
 
 ```js
 customElements.define('custom-menu', class extends HTMLElement {
   connectedCallback() {
     this.attachShadow({mode: 'open'});
 
-    // tmpl is the shadow DOM template (above)
+    // tmpl e' il template dello shadow DOM (sopra)
     this.shadowRoot.append( tmpl.content.cloneNode(true) );
 
-    // we can't select light DOM nodes, so let's handle clicks on the slot
+    // non possiamo selezionare nodi del light DOM, quindi andiamo a gestire gli eventi nello slot
     this.shadowRoot.querySelector('slot[name="title"]').onclick = () => {
-      // open/close the menu
+      // apre e chiude il menu'
       this.shadowRoot.querySelector('.menu').classList.toggle('closed');
     };
   }
 });
 ```
 
-Here's the full demo:
+Ecco la demo completa:
 
 [iframe src="menu" height=140 edit]
 
-Of course, we can add more functionality to it: events, methods and so on.
+Certamente possiamo andare ad aggiungere più funzionalità: eventi metodi e via dicendo.
 
-## Updating slots
+## Aggiornamento degli slots
 
-What if the outer code wants to add/remove menu items dynamically?
+E se volessimo aggiungere e rimuovere elementi del menù dinamicamente?
 
-**The browser monitors slots and updates the rendering if slotted elements are added/removed.**
+**Il browser monitora gli slots e aggiorna la visualizzazione all'inserimento o rimozione di elementi slotted.**
 
-Also, as light DOM nodes are not copied, but just rendered in slots, the changes inside them immediately become visible.
+Inoltre, dal momento che i nodi del light DOM non vengono copiati, ma solamente visualizzati negli slots, le modifiche al loro interno saranno immediatamente visibili.
 
-So we don't have to do anything to update rendering. But if the component code wants to know about slot changes, then `slotchange` event is available.
+Ne consegue che non dobbiamo fare assolutamente nulla per aggiornare la visualizzazione. Ma se il codice del componente vuole dei dettagli sulla modifica degli slots, allora si potrà usare l'evento `slotchange`.
 
-For example, here the menu item is inserted dynamically after 1 second, and the title changes after 2 seconds:
+Per esempio, qui l'elemento del menù viene inserito dinamicamente dopo un secondo, ed il titolo cambia dopo 2 secondi:
 
 ```html run untrusted height=80
 <custom-menu id="menu">
-  <span slot="title">Candy menu</span>
+  <span slot="title">Menù dei dolciumi</span>
 </custom-menu>
 
 <script>
@@ -344,7 +344,7 @@ customElements.define('custom-menu', class extends HTMLElement {
       <ul><slot name="item"></slot></ul>
     </div>`;
 
-    // shadowRoot can't have event handlers, so using the first child
+    // shadowRoot non puo' gestire l'evento, quindi usiamo il primo nodo figlio
     this.shadowRoot.firstElementChild.addEventListener('slotchange',
       e => alert("slotchange: " + e.target.name)
     );
@@ -352,49 +352,49 @@ customElements.define('custom-menu', class extends HTMLElement {
 });
 
 setTimeout(() => {
-  menu.insertAdjacentHTML('beforeEnd', '<li slot="item">Lollipop</li>')
+  menu.insertAdjacentHTML('beforeEnd', '<li slot="item">Lecca-lecca</li>')
 }, 1000);
 
 setTimeout(() => {
-  menu.querySelector('[slot="title"]').innerHTML = "New menu";
+  menu.querySelector('[slot="title"]').innerHTML = "Nuovo menù";
 }, 2000);
 </script>
 ```
 
-The menu rendering updates each time without our intervention.
+Il rendering del menù, viene aggiornato ogni volta senza la necessità di un nostro intervento.
 
-There are two `slotchange` events here:
+In questo esempio, ci sono due eventi `slotchange`:
 
-1. At initialization:
+1. Nella inizializzazione:
 
-    `slotchange: title` triggers immediately, as the `slot="title"` from the light DOM gets into the corresponding slot.
-2. After 1 second:
+    `slotchange: title` viene scaturito immediatamente, dal momento che `slot="title"` dal light DOM va a finire nello slot corrispondente.
+2. Dopo 1 secondo:
 
-    `slotchange: item` triggers, when a new `<li slot="item">` is added.
+    `slotchange: item` viene scaturito quando viene aggiunto un nuovo `<li slot="item">`.
 
-Please note: there's no `slotchange` event after 2 seconds, when the content of `slot="title"` is modified. That's because there's no slot change. We modify the content inside the slotted element, that's another thing.
+Nota bene: non ci sono eventi `slotchange` dopo 2 secondi, quando viene modificato il contenuto di `slot="title"`. Questo perché non ci sono modifiche slot. Abbiamo modificato il contenuto dentro l'elemento slotted, che è una cosa differente e non collegata.
 
-If we'd like to track internal modifications of light DOM from JavaScript, that's also possible using a more generic mechanism: [MutationObserver](info:mutation-observer).
+Volendo però tenere traccia delle modifiche interne nel light DOM tramite JavaScript, potremmo anche usare un meccanismo più generico come quello dei [MutationObserver](info:mutation-observer).
 
 ## Slot API
 
-Finally, let's mention the slot-related JavaScript methods.
+Infine, citiamo i metodi JavaScript inerenti gli slots.
 
-As we've seen before, JavaScript looks at the "real" DOM, without flattening. But, if the shadow tree has `{mode: 'open'}`, then we can figure out which elements assigned to a slot and, vise-versa, the slot by the element inside it:
+Come già visto, JavaScript tiene d'occhio il DOM "effettivo", privo di flattening. Ma, se lo shadow tree ha il `{mode: 'open'}`, possiamo vedere quali elementi vengono assegnati a uno slot o, viceversa, lo slot con l'elemento al suo interno:
 
-- `node.assignedSlot` -- returns the `<slot>` element that the `node` is assigned to.
-- `slot.assignedNodes({flatten: true/false})` -- DOM nodes, assigned to the slot. The `flatten` option is `false` by default. If explicitly set to `true`, then it looks more deeply into the flattened DOM, returning nested slots in case of nested components and the fallback content if no node assigned.
-- `slot.assignedElements({flatten: true/false})` -- DOM elements, assigned to the slot (same as above, but only element nodes).
+- `node.assignedSlot` -- restituisce l'elemento `<slot>` a cui è assegnato il `node`.
+- `slot.assignedNodes({flatten: true/false})` -- nodi DOM, assegnati allo slot. L'opzione `flatten` è `false` di default. Se impostata esplicitamente a `true`, analizzerà più in profondità all'interno del flattened DOM, restituendo gli slot annidati in caso di componenti annidati o il fallback content, in assenza di nodi assegnati.
+- `slot.assignedElements({flatten: true/false})` -- Elementi DOM, assegnati allo slot (come sopra, ma solo elementi di tipo nodo).
 
-These methods are useful when we need not just show the slotted content, but also track it in JavaScript.
+Questi metodi sono utili quando dobbiamo mostrare, non solo lo slotted content, ma anche tenerne traccia con JavaScript.
 
-For example, if `<custom-menu>` component wants to know, what it shows, then it could track `slotchange` and get the items from `slot.assignedElements`:
+Ad esempio, se il componente `<custom-menu>` vuole sapere cosa sta mostrando, può tracciare `slotchange` ed ottenere gli elementi da `slot.assignedElements`:
 
 ```html run untrusted height=120
 <custom-menu id="menu">
-  <span slot="title">Candy menu</span>
-  <li slot="item">Lollipop</li>
-  <li slot="item">Fruit Toast</li>
+  <span slot="title">Menù dei dolciumi</span>
+  <li slot="item">Lecca-lecca</li>
+  <li slot="item">Toast alla frutta</li>
 </custom-menu>
 
 <script>
@@ -408,7 +408,7 @@ customElements.define('custom-menu', class extends HTMLElement {
       <ul><slot name="item"></slot></ul>
     </div>`;
 
-    // triggers when slot content changes
+    // viene generato quando cambia il contenuto dello slot
 *!*
     this.shadowRoot.firstElementChild.addEventListener('slotchange', e => {
       let slot = e.target;
@@ -421,7 +421,7 @@ customElements.define('custom-menu', class extends HTMLElement {
   }
 });
 
-// items update after 1 second
+// gli elementi vengono aggiornati dopo 1 secondo
 setTimeout(() => {
   menu.insertAdjacentHTML('beforeEnd', '<li slot="item">Cup Cake</li>')
 }, 1000);
@@ -429,29 +429,29 @@ setTimeout(() => {
 ```
 
 
-## Summary
+## Riepilogo
 
-Usually, if an element has shadow DOM, then its light DOM is not displayed. Slots allow to show elements from light DOM in specified places of shadow DOM.
+Generalmente, se un elemento ha lo shadow DOM, il suo light DOM non viene mostrato. Gli slots permettono di mostrare gli elementi del light DOM nei punti contrassegnati dello shadow DOM.
 
-There are two kinds of slots:
+Esistono due tipi di slots:
 
-- Named slots: `<slot name="X">...</slot>` -- gets light children with `slot="X"`.
-- Default slot: the first `<slot>` without a name (subsequent unnamed slots are ignored) -- gets unslotted light children.
-- If there are many elements for the same slot -- they are appended one after another.
-- The content of `<slot>` element is used as a fallback. It's shown if there are no light children for the slot.
+- Named slots: `<slot name="X">...</slot>` -- ottiene i figli light tramite `slot="X"`.
+- Default slot: il primo `<slot>` senza un nome (i successivi elementi privi di nome vengono ignorati) -- ottiene i figli light unslotted.
+- Se ci sono più elementi per uno stesso slot -- vengono accodati uno dopo l'altro.
+- Il contenuto dell'elemento `<slot>` viene usato come un ripiego (fallback). Viene mostrato se non ci sono figli light per un determinato slot.
 
-The process of rendering slotted elements inside their slots is called "composition". The result is called a "flattened DOM".
+Il processo di rendering degli elementi slotted all'interno dei loro slots viene chiamato "composition". Il risultato viene soprannominato "flattened DOM".
 
-Composition does not really move nodes, from JavaScript point of view the DOM is still same.
+La Composition non sposta realmente i nodi, dal punto di vista di JavaScript il DOM rimane immutato.
 
-JavaScript can access slots using methods:
-- `slot.assignedNodes/Elements()` -- returns nodes/elements inside the `slot`.
-- `node.assignedSlot` -- the reverse property, returns slot by a node.
+JavaScript può accedere agli slots tramite:
+- `slot.assignedNodes/Elements()` -- restituisce i nodi o gli elementi dentro lo `slot`.
+- `node.assignedSlot` -- la proprietà inversa, restituisce lo slot partendo dal nodo.
 
-If we'd like to know what we're showing, we can track slot contents using:
-- `slotchange` event -- triggers the first time a slot is filled, and on any add/remove/replace operation of the slotted element, but not its children. The slot is `event.target`.
-- [MutationObserver](info:mutation-observer) to go deeper into slot content, watch changes inside it.
+Se volessimo conoscere cosa stiamo mostrando, possiamo tracciare il contenuto degli slot tramite:
+- `slotchange` evento -- viene generato la prima volta che uno slot viene riempito, e per ogni operazione di aggiunta/rimozione degli elementi slotted, ma non i loro figli. Lo slot sarà `event.target`.
+- [MutationObserver](info:mutation-observer) se vogliamo andare in profondità all'interno dello slot content, e tenere traccia dei cambiamenti all'interno di essi.
 
-Now, as we know how to show elements from light DOM in shadow DOM, let's see how to style them properly. The basic rule is that shadow elements are styled inside, and light elements -- outside, but there are notable exceptions.
+Ora, dal momento che conosciamo come mostrare gli elementi dal light DOM allo shadow DOM, possiamo vedere come stilizzarli in maniera consona. La regola di base è che gli elementi shadow vengono stilizzati dentro, mentre gli elementi light esternamente, ma ci sono delle eccezioni degne di nota.
 
-We'll see the details in the next chapter.
+Lo vedremo in dettaglio nel prossimo capitolo.
diff --git a/8-web-components/5-slots-composition/menu.view/index.html b/8-web-components/5-slots-composition/menu.view/index.html
index 86b31d860..aed102643 100644
--- a/8-web-components/5-slots-composition/menu.view/index.html
+++ b/8-web-components/5-slots-composition/menu.view/index.html
@@ -47,8 +47,8 @@
 </script>
 
 <custom-menu>
-  <span slot="title">Candy menu</span>
-  <li slot="item">Lollipop</li>
-  <li slot="item">Fruit Toast</li>
+  <span slot="title">Menù dei dolciumi</span>
+  <li slot="item">Lecca-lecca</li>
+  <li slot="item">Toast alla frutta</li>
   <li slot="item">Cup Cake</li>
 </custom-menu>