@intlayer/docs 9.0.0-canary.3 → 9.0.0-canary.5

package/docs/it/compat/vue-i18n.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da Vue I18n a Intlayer"
+description: "Scopri come migrare la tua applicazione Vue da vue-i18n a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - vue-i18n
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - vue-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da Vue I18n a Intlayer
+
+Se la tua applicazione Vue attualmente utilizza `vue-i18n`, puoi migrare a Intlayer senza riscrivere i tuoi componenti o tradurre gli hook. Intlayer fornisce un adattatore di compatibilità che rispecchia perfettamente l'API di `vue-i18n` mentre sfrutta le potenti funzionalità di Intlayer dietro le quinte.
+
+## Cosa fare
+
+Per iniziare, esegui semplicemente il comando di inizializzazione nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Durante l'inizializzazione, Intlayer configura il file di configurazione (`intlayer.config.ts`) e prepara il tuo progetto per la migrazione. Dovrai solo aggiungere il plugin Intlayer alla tua configurazione Vite per creare automaticamente alias per gli import `vue-i18n`.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vue(), vueI18nVitePlugin()],
+});
+```
+
+## Cosa fa sotto il cofano
+
+Il `vueI18nVitePlugin` inietta un alias di modulo nel tuo bundler. Qualsiasi import di `vue-i18n` nel tuo codebase verrà reindirizzato in modo trasparente a `@intlayer/vue-i18n`.
+
+**Sotto il cofano, l'adapter gestisce nativamente la complessa sintassi di `vue-i18n`:**
+
+- **Interpolazione e plurali:** Risolve le interpolazioni `{name}` e di lista `{0}`. I plurali con pipe (`"car | cars"`) vengono convertiti in nodi di enumerazione/plurale di Intlayer basati sulla semantica posizionale.
+- **Formati:** Funzioni come `d()` e `n()` avvolgono `Intl` sotto il cofano, rispettando i `datetimeFormats` e `numberFormats` definiti nelle tue opzioni.
+- **Stato globale e locale:** `global.locale` è mappato a un `WritableComputedRef` supportato dal client Intlayer, quindi la reattività si comporta esattamente come previsto (ad esempio `locale.value = 'fr'`).
+- **Direttive:** La direttiva `v-t` è registrata e funziona normalmente.
+
+La tua applicazione continua a renderizzarsi esattamente come prima, ma il contenuto è alimentato dai tuoi dizionari Intlayer, offrendoti type safety, una migliore ottimizzazione del bundle e un'integrazione CMS senza interruzioni.

package/docs/it/compiler.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-09
-updatedAt: 2026-03-12
+updatedAt: 2026-06-23
 title: Compiler Intlayer | Estrazione automatica dei contenuti per i18n
 description: Automatizza il tuo processo di internazionalizzazione con il compilatore Intlayer. Estrai contenuti direttamente dai tuoi componenti per un i18n più veloce ed efficiente in Vite, Next.js e altro.
 keywords:
@@ -60,6 +60,8 @@ Come alternativa, per automatizzare il tuo processo i18n mantenendo il pieno con
 
 ## Utilizzo
 
+> The quickest way to wire the compiler in is the interactive setup: run `npx intlayer init --interactive` and select **Compiler**. On Vite there is nothing to configure — the compiler is plugged in directly through the `intlayerCompiler()` plugin. On Next.js the command scaffolds the `babel.config.js` shown below. The non-interactive `intlayer init` leaves the compiler setup untouched.
+
 <Tabs>
  <Tab value='vite'>
 

package/docs/it/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-06-17
+updatedAt: 2026-06-23
 title: Configurazione
 description: Scopri come configurare Intlayer per la tua applicazione. Comprendi le diverse impostazioni e opzioni disponibili per personalizzare Intlayer secondo le tue necessità.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.0.0
+    date: 2026-06-24
+    changes: "Add `enableProxy` option to the routing configuration"
   - version: 8.10.0
     date: 2026-06-17
     changes: "Aggiunta l'opzione `format` alla configurazione del dizionario"
@@ -885,6 +888,21 @@ Impostazioni per come i contenuti sono gestiti nell'applicazione, inclusi i nomi
 
 ---
 
+### Configurazione del Sistema
+
+Impostazioni relative ai percorsi interni e ai risultati dell'output di Intlayer. Queste impostazioni sono tipicamente interne e non dovrebbero aver bisogno di essere modificate dall'utente.
+
+| Field                     | Description                                                                                                 | Type     | Default                           | Example              | Note                                                              |
+| ------------------------- | ----------------------------------------------------------------------------------------------------------- | -------- | --------------------------------- | -------------------- | ----------------------------------------------------------------- |
+| `baseDir`                 | La directory di base per il progetto.                                                                       | `string` | `process.cwd()`                   | `'/path/to/project'` | Utilizzato per risolvere tutte le directory correlate a Intlayer. |
+| `dictionariesDir`         | Il percorso della directory per archiviare i dizionari di localizzazione.                                   | `string` | `'.intlayer/dictionary'`          |                      |                                                                   |
+| `moduleAugmentationDir`   | Directory per l'augmentazione dei moduli, che consente migliori suggerimenti dell'IDE e controllo dei tipi. | `string` | `'.intlayer/types'`               | `'intlayer-types'`   | Assicurati di includerlo in `tsconfig.json`.                      |
+| `unmergedDictionariesDir` | La directory per l'archiviazione dei dizionari non uniti.                                                   | `string` | `'.intlayer/unmerged_dictionary'` |                      |                                                                   |
+| `typesDir`                | La directory per l'archiviazione dei tipi di dizionario.                                                    | `string` | `'.intlayer/types'`               |                      |                                                                   |
+| `mainDir`                 | La directory in cui vengono archiviati i file dell'applicazione principale.                                 | `string` | `'.intlayer/main'`                |                      |                                                                   |
+| `configDir`               | La directory in cui vengono archiviati i file di configurazione.                                            | `string` | `'.intlayer/config'`              |                      |                                                                   |
+| `cacheDir`                | La directory in cui vengono archiviati i file della cache.                                                  | `string` | `'.intlayer/cache'`               |                      |                                                                   |
+
 ### Configurazione Dizionario (Dictionary)
 
 Parametri che controllano le operazioni del dizionario, inclusi i comportamenti di auto-compilazione e la generazione dei contenuti.
@@ -993,22 +1011,6 @@ Le opzioni di build sono applicate ai plugin `@intlayer/babel` e `@intlayer/swc`
 
 ---
 
-### Configurazione di Sistema (System)
-
-Queste impostazioni sono per utenti esperti e per la configurazione interna di Intlayer.
-
-| Campo                     | Descrizione                                       | Tipo     | Predefinito                       | Esempio | Commenti |
-| ------------------------- | ------------------------------------------------- | -------- | --------------------------------- | ------- | -------- |
-| `dictionariesDir`         | Directory per i dizionari compilati.              | `string` | `'.intlayer/dictionary'`          |         |          |
-| `moduleAugmentationDir`   | Directory per l'aumento del modulo TypeScript.    | `string` | `'.intlayer/types'`               |         |          |
-| `unmergedDictionariesDir` | Directory per memorizzare i dizionari non fusi.   | `string` | `'.intlayer/unmerged_dictionary'` |         |          |
-| `typesDir`                | Directory per i tipi generati.                    | `string` | `'.intlayer/types'`               |         |          |
-| `mainDir`                 | Directory per i file principali di Intlayer.      | `string` | `'.intlayer/main'`                |         |          |
-| `configDir`               | Directory per i file di configurazione compilati. | `string` | `'.intlayer/config'`              |         |          |
-| `cacheDir`                | Directory per i file di cache.                    | `string` | `'.intlayer/cache'`               |         |          |
-
----
-
 ### Configurazione Compilatore (Compiler)
 
 Impostazioni che controllano il compilatore Intlayer, che raccoglie i dizionari direttamente dai tuoi componenti.

package/docs/it/custom_domains.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-04-02
-updatedAt: 2026-04-02
+updatedAt: 2026-06-23
 title: Domini personalizzati
 description: Impara come configurare il routing delle locale basato su dominio in Intlayer per servire diverse locale da hostname dedicati.
 keywords:

package/docs/it/custom_url_rewrites.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-01-26
+updatedAt: 2026-06-23
 title: Riscritture URL personalizzate
 description: Scopri come configurare e utilizzare le riscritture URL personalizzate in Intlayer per definire percorsi specifici per lingua.
 keywords:

package/docs/it/dictionary/content_file.md

@@ -579,6 +579,10 @@ Schema JSON utilizzato per la validazione della struttura del dizionario. Aggiun
 
 Per i dizionari remoti, questo è l'identificatore univoco del dizionario nel server remoto. Utilizzato per il recupero e la gestione dei contenuti remoti.
 
+##### `projectIds` (string[])
+
+Per i dizionari remoti, questo array contiene gli ID dei progetti che possono utilizzare questo dizionario. Un dizionario remoto può essere condiviso tra più progetti.
+
 ##### `localId` (LocalDictionaryId)
 
 Identificatore univoco per i dizionari locali. Generato automaticamente da Intlayer per aiutare a identificare il dizionario e determinare se è locale o remoto, insieme alla sua posizione.
@@ -599,13 +603,6 @@ Per i dizionari remoti, questo array contiene tutte le versioni disponibili del
 
 Indica se il dizionario è stato compilato automaticamente da fonti esterne. In caso di conflitti, i dizionari base sovrascriveranno quelli compilati automaticamente.
 
-##### `location` ('distant' | 'locale')
-
-Indica la posizione del dizionario:
-
-- `'locale'`: Dizionario locale (da file di contenuto)
-- `'distant'`: Dizionario remoto (da fonte esterna)
-
 ## Tipi di Nodi di Contenuto
 
 Intlayer fornisce diversi tipi specializzati di nodi di contenuto che estendono i valori primitivi di base:

package/docs/it/dictionary/enumeration.md

@@ -464,203 +464,6 @@ document.getElementById("ranking")!.textContent = content.ordinal(lastDigit)({
   </Tab>
 </Tabs>
 
-## Risorse Aggiuntive
-
-Per informazioni più dettagliate sulla configurazione e l'uso, fare riferimento alle seguenti risorse:
-
-- [Documentazione CLI di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/cli/index.md)
-- [Documentazione React Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_with_create_react_app.md)
-- [Documentazione Next Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_with_nextjs_15.md)
-
-Queste risorse forniscono ulteriori approfondimenti sull'installazione e l'uso di Intlayer in diversi ambienti e con vari framework.
-
-## Combining Enumeration with Insert for Ordinal Numbers
-
-<Tabs group="framework">
-  <Tab label="React" value="react">
-
-To use enumeration in a React component, you can leverage the `useIntlayer` hook from the `react-intlayer` package. This hook retrieves the correct content based on the specified ID. Here's an example of how to use it:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>
-        {
-          numberOfCar(0) // Output: No cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(6) // Output: Some cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(20) // Output: Many cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(0.01) // Output: Fallback value
-        }
-      </p>
-    </div>
-  );
-};
-```
-
-  </Tab>
-  <Tab label="Next.js" value="nextjs">
-
-To use enumeration in Next.js Client Components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-"use client";
-
-import type { FC } from "react";
-import { useIntlayer } from "next-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Vue" value="vue">
-
-To use enumeration in Vue components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```vue fileName="**/*.vue"
-<script setup lang="ts">
-import { useIntlayer } from "vue-intlayer";
-
-const { numberOfCar } = useIntlayer("car_count");
-</script>
-
-<template>
-  <div>
-    <p>{{ numberOfCar(6) }}</p>
-  </div>
-</template>
-```
-
-  </Tab>
-  <Tab label="Svelte" value="svelte">
-
-To use enumeration in Svelte components, retrieve it via the `useIntlayer` hook. The store is accessed with `$`. Here's an example:
-
-```svelte fileName="**/*.svelte"
-<script lang="ts">
-import { useIntlayer } from "svelte-intlayer";
-
-const content = useIntlayer("car_count");
-</script>
-
-<div>
-  <p>{$content.numberOfCar(6)}</p>
-</div>
-```
-
-  </Tab>
-  <Tab label="Preact" value="preact">
-
-To use enumeration in Preact components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "preact";
-import { useIntlayer } from "preact-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Solid" value="solid">
-
-To use enumeration in SolidJS components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { Component } from "solid-js";
-import { useIntlayer } from "solid-intlayer";
-
-const CarComponent: Component = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Angular" value="angular">
-
-To use enumeration in Angular components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="app.component.ts" codeFormat="typescript"
-import { Component } from "@angular/core";
-import { useIntlayer } from "angular-intlayer";
-
-@Component({
-  selector: "app-car",
-  template: `
-    <div>
-      <p>{{ content().numberOfCar(6) }}</p>
-    </div>
-  `,
-})
-export class CarComponent {
-  content = useIntlayer("car_count");
-}
-```
-
-  </Tab>
-  <Tab label="Vanilla JS" value="vanilla">
-
-To use enumeration with `vanilla-intlayer`, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="**/*.ts" codeFormat={["typescript", "esm"]}
-import { installIntlayer, useIntlayer } from "vanilla-intlayer";
-
-installIntlayer();
-
-const content = useIntlayer("car_count").onChange((newContent) => {
-  document.getElementById("cars")!.textContent = newContent.numberOfCar(6);
-});
-
-// Initial render
-document.getElementById("cars")!.textContent = content.numberOfCar(6);
-```
-
-  </Tab>
-</Tabs>
 ## Additional Resources
 
 For more detailed information on configuration and usage, refer to the following resources:

package/docs/it/dictionary/file.md

@@ -421,6 +421,14 @@ export default myMultilingualContent;
 
 Questa configurazione consente di recuperare dinamicamente il contenuto in base alla preferenza linguistica dell'utente. Quando viene utilizzata nell'Intlayer Visual Editor o nel CMS, il sistema riconosce che il contenuto proviene dai file Markdown specificati e garantisce che rimangano modificabili.
 
+## Diversi tipi di percorsi
+
+Quando si utilizza la funzione `file`, è possibile utilizzare diversi tipi di percorsi per specificare il file da incorporare.
+
+- `file("./path/to/file.txt")` - Percorso relativo al file corrente
+- `file("path/to/file.txt")` - Percorso relativo alla directory radice del progetto
+- `file("/users/username/path/to/file.txt")` - Percorso assoluto
+
 ## Come Intlayer Gestisce il Contenuto dei File
 
 La funzione `file` si basa sul modulo `fs` di Node.js per leggere il contenuto del file specificato e inserirlo nel dizionario. Quando viene utilizzata in combinazione con l'Intlayer Visual Editor o il CMS, Intlayer può tracciare la relazione tra il dizionario e il file. Questo permette a Intlayer di:

package/docs/it/dictionary/nesting.md

@@ -25,6 +25,45 @@ author: aymericzip
 
 In Intlayer, l'annidamento viene realizzato tramite la funzione `nest`, che consente di fare riferimento e riutilizzare contenuti da un altro dizionario. Invece di duplicare i contenuti, è possibile puntare a un modulo di contenuto esistente tramite la sua chiave.
 
+## Configurazione del Nesting
+
+Per configurare il nesting nel tuo progetto Intlayer, prima definisci il contenuto di base che desideri riutilizzare. Quindi, in un modulo di contenuto separato, utilizzi la funzione `nest` per importare quel contenuto.
+
+### Dizionario di base
+
+Di seguito è riportato un esempio di un dizionario di base da annidare in un altro dizionario:
+
+```typescript fileName="firstDictionary.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { type Dictionary } from "intlayer";
+
+const firstDictionary = {
+  key: "key_of_my_first_dictionary",
+  content: {
+    content: "content",
+    subContent: {
+      contentNumber: 0,
+      contentString: "string",
+    },
+  },
+} satisfies Dictionary;
+
+export default firstDictionary;
+```
+
+```json fileName="firstDictionary.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "key_of_my_first_dictionary",
+  "content": {
+    "content": "content",
+    "subContent": {
+      "contentNumber": 0,
+      "contentString": "string"
+    }
+  }
+}
+```
+
 ## Configurazione dell'Annidamento
 
 <Tabs group="framework">

package/docs/it/dictionary/translation.md

@@ -259,64 +259,3 @@ document.getElementById("welcome-message")!.textContent = String(
 
   </Tab>
 </Tabs>
-
-## Oggetti di Contenuto Personalizzati
-
-`intlayer` supporta oggetti di contenuto personalizzati per la traduzione, permettendoti di definire strutture più complesse garantendo al contempo la sicurezza dei tipi. Ecco un esempio con un oggetto personalizzato:
-
-```typescript fileName="**/*.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
-import { t, type Dictionary } from "intlayer";
-
-interface ICustomContent {
-  title: string;
-  content: string;
-}
-
-const customContent = {
-  key: "custom_content",
-  content: {
-    profileText: t<ICustomContent>({
-      en: {
-        title: "Page Title",
-        content: "Page Content",
-      },
-      fr: {
-        title: "Titre de la Page",
-        content: "Contenu de la Page",
-      },
-      es: {
-        title: "Título de la Página",
-        content: "Contenido de la Página",
-      },
-    }),
-  },
-} satisfies Dictionary;
-
-export default customContent;
-```
-
-```json fileName="**/*.content.json" contentDeclarationFormat="json"
-{
-  "$schema": "https://intlayer.org/schema.json",
-  "key": "custom_content",
-  "content": {
-    "profileText": {
-      "nodeType": "translation",
-      "translation": {
-        "en": {
-          "title": "Page Title",
-          "content": "Contenuto della Pagina"
-        },
-        "fr": {
-          "title": "Titre de la Page",
-          "content": "Contenu de la Page"
-        },
-        "es": {
-          "title": "Título de la Página",
-          "content": "Contenido de la Página"
-        }
-      }
-    }
-  }
-}
-```

package/docs/it/formatters.md

@@ -176,6 +176,61 @@ getLocaleName("de", "es"); // "alemán"
 - **displayLocale**: La localizzazione di cui ottenere il nome
 - **targetLocale**: La localizzazione in cui visualizzare il nome (predefinita a displayLocale)
 
+### Composables Disponibili
+
+Tutti i composables restituiscono computed refs che utilizzano automaticamente la locale dalla `IntlayerProvider` iniettata.
+
+| Composable          | Descrizione                                  | Esempio di Output             |
+| ------------------- | -------------------------------------------- | ----------------------------- |
+| `useNumber()`       | Formatta numeri con raggruppamento           | `"123,456.789"`               |
+| `useCurrency()`     | Formatta valori di valuta                    | `"€1,234.50"`                 |
+| `usePercentage()`   | Formatta percentuali                         | `"25%"`                       |
+| `useDate()`         | Formatta date e ore                          | `"Aug 2, 2025"`               |
+| `useRelativeTime()` | Formatta tempo relativo                      | `"in 3 days"`                 |
+| `useUnit()`         | Formatta valori con unità                    | `"5 kilometers"`              |
+| `useCompact()`      | Formatta numeri in notazione compatta        | `"1.2K"`                      |
+| `useList()`         | Formatta array come liste                    | `"apple, banana, and orange"` |
+| `useIntl()`         | Ottieni oggetto `Intl` associato alla locale | Accesso completo API `Intl`   |
+
+### Esempio Completo
+
+```vue
+<script setup>
+import {
+  useNumber,
+  useCurrency,
+  useDate,
+  usePercentage,
+  useCompact,
+  useList,
+  useRelativeTime,
+  useUnit,
+} from "vue-intlayer/format";
+
+const number = useNumber();
+const currency = useCurrency();
+const date = useDate();
+const percentage = usePercentage();
+const compact = useCompact();
+const list = useList();
+const relativeTime = useRelativeTime();
+const unit = useUnit();
+</script>
+
+<template>
+  <div>
+    <p>{{ number.value(123456.789) }}</p>
+    <p>{{ currency.value(1234.5, { currency: "EUR" }) }}</p>
+    <p>{{ date.value(new Date(), "short") }}</p>
+    <p>{{ percentage.value(0.25) }}</p>
+    <p>{{ compact.value(1200) }}</p>
+    <p>{{ list.value(["apple", "banana", "orange"]) }}</p>
+    <p>{{ relativeTime.value(new Date(), new Date(Date.now() + 86400000)) }}</p>
+    <p>{{ unit.value(5, { unit: "kilometer" }) }}</p>
+  </div>
+</template>
+```
+
 ### `getLocaleLang(locale?)`
 
 Estrae il codice della lingua da una stringa di localizzazione:
@@ -190,6 +245,10 @@ getLocaleLang("de"); // "de"
 
 - **locale**: La localizzazione da cui estrarre la lingua (predefinita alla localizzazione corrente)
 
+## Vanilla JS / Node.js Formatters
+
+Per contesti non-framework, importa i formatter direttamente da `intlayer`. Nota che devi passare il locale manualmente.
+
 ### `getLocaleFromPath(inputUrl)`
 
 Estrae il segmento di localizzazione da un URL o pathname:
@@ -206,6 +265,8 @@ getLocaleFromPath("https://example.com/es/about"); // "es"
 - **inputUrl**: La stringa URL completa o il percorso da elaborare
 - **returns**: La localizzazione rilevata o la localizzazione predefinita se non viene trovata alcuna localizzazione
 
+### Funzioni Formatter
+
 ### `getPathWithoutLocale(inputUrl, locales?)`
 
 Rimuove il segmento di localizzazione da un URL o percorso:
@@ -330,6 +391,8 @@ const content = await getIntlayerAsync("common", "fr");
 
 Tutti gli helper seguenti sono esportati da `intlayer`.
 
+### Funzionalità Intl Aggiuntive
+
 ### `number(value, options?)`
 
 Formatta un valore numerico utilizzando la separazione delle migliaia e i decimali in base alla localizzazione.
@@ -366,6 +429,23 @@ percentage(25); // "25%"
 percentage(0.237, { minimumFractionDigits: 1 }); // "23.7%"
 ```
 
+#### `Intl.PluralRules`
+
+Per determinare le forme plurali in diverse lingue:
+
+```ts
+import { Intl } from "intlayer";
+
+const pluralRules = new Intl.PluralRules("ar");
+pluralRules.select(0); // "zero"
+pluralRules.select(1); // "one"
+pluralRules.select(2); // "two"
+pluralRules.select(3); // "few"
+pluralRules.select(11); // "many"
+```
+
+## Locale Utilities
+
 ### `currency(value, options?)`
 
 Formatta un valore come valuta localizzata. Il valore predefinito è `USD` con due cifre decimali.
@@ -476,6 +556,8 @@ list(["red", "green", "blue"], { locale: "fr", type: "disjunction" }); // "rouge
 list([1, 2, 3], { type: "unit" }); // "1, 2, 3"
 ```
 
+## Utility di Gestione dei Contenuti
+
 ## Note
 
 - Tutti gli helper accettano input di tipo `string`; internamente vengono convertiti in numeri o date.

package/docs/it/how_works_intlayer.md

@@ -22,6 +22,10 @@ author: aymericzip
 
 # Come funziona Intlayer
 
+## Indice
+
+<TOC/>
+
 ## Panoramica
 
 L'idea principale dietro Intlayer è adottare una gestione dei contenuti per componente. Quindi l'idea è permetterti di dichiarare i tuoi contenuti ovunque nel tuo codice, ad esempio nella stessa directory del tuo componente.
@@ -138,8 +142,6 @@ Il pacchetto `vue-intlayer` è utilizzato per interpretare i dizionari di Intlay
 
 ### nuxt-intlayer
 
-### nuxt-intlayer
-
 Il pacchetto `nuxt-intlayer` è un modulo Nuxt per rendere utilizzabili i dizionari Intlayer nelle applicazioni Nuxt. Integra funzionalità essenziali per far funzionare Intlayer in un ambiente Nuxt, come il middleware per la traduzione, il routing e la configurazione del file `nuxt.config.js`.
 
 ### svelte-intlayer
@@ -156,8 +158,6 @@ Il pacchetto `preact-intlayer` è utilizzato per interpretare i dizionari di Int
 
 ### angular-intlayer (WIP)
 
-### angular-intlayer (WIP)
-
 Il pacchetto `angular-intlayer` è utilizzato per interpretare i dizionari di Intlayer e renderli utilizzabili nelle applicazioni Angular.
 
 ### express-intlayer

package/docs/it/intlayer_CMS.md

@@ -40,6 +40,12 @@ Per questo, Intlayer introduce il concetto di 'dizionari remoti'.
 
 ![Interfaccia CMS di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/assets/CMS.png)
 
+## Indice dei contenuti
+
+<TOC/>
+
+---
+
 ## Comprendere i dizionari remoti
 
 Intlayer distingue tra dizionari 'locali' e 'remoti'.