@intlayer/docs 5.5.8

package/it/packages/@intlayer/webpack/index.md

@@ -0,0 +1,35 @@
+# @intlayer/webpack: Pacchetto NPM per utilizzare il plugin Intlayer Webpack nella tua applicazione
+
+**Intlayer** è una suite di pacchetti progettata specificamente per gli sviluppatori JavaScript. È compatibile con framework come React, React e Express.js.
+
+Il pacchetto **`@intlayer/webpack`** viene utilizzato per fornire una configurazione Webpack per facilitare il lavoro con un'applicazione basata su Webpack con Intlayer. Il pacchetto fornisce anche un plugin da aggiungere a un'applicazione Webpack esistente.
+
+## Utilizzo
+
+```ts
+import { IntlayerPlugin } from "@intlayer/webpack";
+
+export default {
+  plugins: [
+    new IntlayerPlugin({
+      // Opzioni
+    }),
+  ],
+};
+```
+
+## Installazione
+
+Installa il pacchetto necessario utilizzando il tuo gestore di pacchetti preferito:
+
+```bash packageManager="npm"
+npm install @intlayer/webpack
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/webpack
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/webpack
+```

package/it/packages/angular-intlayer/index.md

@@ -0,0 +1,3 @@
+this doc will be automatically generated translated from the english doc
+
+see /docs/en/packages/angular-intlayer/index.md

package/it/packages/express-intlayer/index.md

@@ -0,0 +1,229 @@
+# express-intlayer: Pacchetto JavaScript per internazionalizzare (i18n) un'applicazione Express.js
+
+**Intlayer** è una suite di pacchetti progettata specificamente per sviluppatori JavaScript. È compatibile con framework come React, Next.js ed Express.js.
+
+**Il pacchetto `express-intlayer`** consente di internazionalizzare la tua applicazione Express.js. Fornisce un middleware per rilevare la lingua preferita dell'utente e restituisce il dizionario appropriato per l'utente.
+
+## Perché internazionalizzare il tuo backend?
+
+Internazionalizzare il tuo backend è essenziale per servire efficacemente un pubblico globale. Permette alla tua applicazione di fornire contenuti e messaggi nella lingua preferita di ogni utente. Questa capacità migliora l'esperienza utente e amplia la portata della tua applicazione rendendola più accessibile e rilevante per persone di diversi background linguistici.
+
+### Casi d'uso pratici
+
+- **Visualizzare errori del backend nella lingua dell'utente**: Quando si verifica un errore, visualizzare i messaggi nella lingua madre dell'utente migliora la comprensione e riduce la frustrazione. Questo è particolarmente utile per messaggi di errore dinamici che potrebbero essere mostrati in componenti front-end come toast o modali.
+
+- **Recuperare contenuti multilingue**: Per applicazioni che estraggono contenuti da un database, l'internazionalizzazione garantisce che tu possa fornire questi contenuti in più lingue. Questo è cruciale per piattaforme come siti di e-commerce o sistemi di gestione dei contenuti che devono mostrare descrizioni di prodotti, articoli e altri contenuti nella lingua preferita dall'utente.
+
+- **Inviare email multilingue**: Che si tratti di email transazionali, campagne di marketing o notifiche, inviare email nella lingua del destinatario può aumentare significativamente il coinvolgimento e l'efficacia.
+
+- **Notifiche push multilingue**: Per applicazioni mobili, inviare notifiche push nella lingua preferita dell'utente può migliorare l'interazione e la fidelizzazione. Questo tocco personale può rendere le notifiche più rilevanti e utili.
+
+- **Altre comunicazioni**: Qualsiasi forma di comunicazione dal backend, come messaggi SMS, avvisi di sistema o aggiornamenti dell'interfaccia utente, beneficia dell'essere nella lingua dell'utente, garantendo chiarezza e migliorando l'esperienza utente complessiva.
+
+Internazionalizzando il backend, la tua applicazione non solo rispetta le differenze culturali, ma si allinea meglio con le esigenze del mercato globale, rendendolo un passaggio chiave per scalare i tuoi servizi a livello mondiale.
+
+## Perché integrare Intlayer?
+
+- **Ambiente Type-Safe**: Sfrutta TypeScript per garantire che tutte le definizioni dei tuoi contenuti siano precise e prive di errori.
+
+## Installazione
+
+Installa il pacchetto necessario utilizzando il tuo gestore di pacchetti preferito:
+
+```bash
+npm install express-intlayer
+```
+
+```bash
+yarn add express-intlayer
+```
+
+```bash
+pnpm add express-intlayer
+```
+
+### Configura Intlayer
+
+Intlayer fornisce un file di configurazione per impostare il tuo progetto. Posiziona questo file nella radice del tuo progetto.
+
+```typescript fileName="intlayer.config.ts" codeFormat="typescript"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.mjs" codeFormat="esm"
+import { Locales } from "intlayer";
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.cjs" codeFormat="commonjs"
+const { Locales } = require("intlayer");
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+module.exports = config;
+```
+
+> Per un elenco completo dei parametri disponibili, consulta la [documentazione di configurazione](https://github.com/aymericzip/intlayer/blob/main/docs/it/configuration.md).
+
+## Esempio di utilizzo
+
+Configura la tua applicazione Express per utilizzare `express-intlayer`:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+import express, { type Express } from "express";
+import { intlayer, t } from "express-intlayer";
+
+const app: Express = express();
+
+// Carica il gestore delle richieste di internazionalizzazione
+app.use(intlayer());
+
+// Rotte
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      "es-ES": "Ejemplo de contenido devuelto en español (España)",
+      "es-MX": "Ejemplo de contenido devuelto en español (México)",
+    })
+  );
+});
+
+// Avvia il server
+app.listen(3000, () => console.log(`Listening on port 3000`));
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+import express from "express";
+import { intlayer, t } from "express-intlayer";
+
+const app = express();
+
+// Carica il gestore delle richieste di internazionalizzazione
+app.use(intlayer());
+
+// Rotte
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      "es-MX": "Ejemplo de contenido devuelto en español (México)",
+      "es-ES": "Ejemplo de contenido devuelto en español (España)",
+    })
+  );
+});
+
+// Avvia il server
+app.listen(3000, () => console.log(`Listening on port 3000`));
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+const express = require("express");
+const { intlayer, t } = require("express-intlayer");
+
+const app = express();
+
+// Carica il gestore delle richieste di internazionalizzazione
+app.use(intlayer());
+
+// Rotte
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      "es-MX": "Ejemplo de contenido devuelto en español (México)",
+      "es-ES": "Ejemplo de contenido devuelto en español (España)",
+    })
+  );
+});
+
+// Avvia il server
+app.listen(3000, () => console.log(`Listening on port 3000`));
+```
+
+### Compatibilità
+
+`express-intlayer` è completamente compatibile con:
+
+- [`react-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/it/packages/react-intlayer/index.md) per applicazioni React
+- [`next-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/it/packages/next-intlayer/index.md) per applicazioni Next.js
+- [`vite-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/it/packages/vite-intlayer/index.md) per applicazioni Vite
+
+Funziona anche perfettamente con qualsiasi soluzione di internazionalizzazione in vari ambienti, inclusi browser e richieste API. Puoi personalizzare il middleware per rilevare la lingua tramite header o cookie:
+
+```typescript fileName="intlayer.config.ts" codeFormat="typescript"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  // ... Altre opzioni di configurazione
+  middleware: {
+    headerName: "my-locale-header",
+    cookieName: "my-locale-cookie",
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.mjs" codeFormat="esm"
+import { Locales } from "intlayer";
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  // ... Altre opzioni di configurazione
+  middleware: {
+    headerName: "my-locale-header",
+    cookieName: "my-locale-cookie",
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.cjs" codeFormat="commonjs"
+const { Locales } = require("intlayer");
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  // ... Altre opzioni di configurazione
+  middleware: {
+    headerName: "my-locale-header",
+    cookieName: "my-locale-cookie",
+  },
+};
+
+module.exports = config;
+```
+
+Per impostazione predefinita, `express-intlayer` interpreterà l'header `Accept-Language` per determinare la lingua preferita del client.
+
+## Funzioni fornite dal pacchetto `express-intlayer`
+
+- [`t()`](https://github.com/aymericzip/intlayer/blob/main/docs/it-IT/packages/express-intlayer/t.md)

package/it/packages/express-intlayer/t.md

@@ -0,0 +1,432 @@
+# Documentazione: Funzione `t` in `express-intlayer`
+
+La funzione `t` nel pacchetto `express-intlayer` è l'utilità principale per fornire risposte localizzate nella tua applicazione Express. Semplifica l'internazionalizzazione (i18n) selezionando dinamicamente il contenuto in base alla lingua preferita dell'utente.
+
+---
+
+## Panoramica
+
+La funzione `t` viene utilizzata per definire e recuperare traduzioni per un determinato set di lingue. Determina automaticamente la lingua appropriata da restituire in base alle impostazioni della richiesta del client, come l'intestazione `Accept-Language`. Se la lingua preferita non è disponibile, passa senza problemi alla lingua predefinita specificata nella configurazione.
+
+---
+
+## Caratteristiche principali
+
+- **Localizzazione dinamica**: seleziona automaticamente la traduzione più appropriata per il client.
+- **Fallback alla lingua predefinita**: passa a una lingua predefinita se la lingua preferita del client non è disponibile, garantendo continuità nell'esperienza utente.
+- **Leggero e veloce**: progettato per applicazioni ad alte prestazioni, garantendo un sovraccarico minimo.
+- **Supporto alla modalità rigorosa**: applica un'aderenza rigorosa alle lingue dichiarate per un comportamento affidabile.
+
+---
+
+## Firma della funzione
+
+```typescript
+t(translations: Record<string, string>): string;
+```
+
+### Parametri
+
+- `translations`: un oggetto in cui le chiavi sono codici di lingua (ad esempio, `en`, `fr`, `es-MX`) e i valori sono le stringhe tradotte corrispondenti.
+
+### Restituisce
+
+- Una stringa che rappresenta il contenuto nella lingua preferita del client.
+
+---
+
+## Caricamento del gestore delle richieste di internazionalizzazione
+
+Per garantire che la funzionalità di internazionalizzazione fornita da `express-intlayer` funzioni correttamente, **devi** caricare il middleware di internazionalizzazione all'inizio della tua applicazione Express. Questo abilita la funzione `t` e garantisce una corretta gestione del rilevamento della lingua e della traduzione.
+
+Posiziona il middleware `app.use(intlayer())` **prima di qualsiasi route** nella tua applicazione per garantire che tutte le route beneficino dell'internazionalizzazione:
+
+```typescript {7} fileName="src/index.ts" codeFormat="typescript"
+import express, { type Express } from "express";
+import { intlayer } from "express-intlayer";
+
+const app: Express = express();
+
+// Carica il gestore delle richieste di internazionalizzazione
+app.use(intlayer());
+
+// Definisci le tue route dopo aver caricato il middleware
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {7} fileName="src/index.mjs" codeFormat="esm"
+import express from "express";
+import { intlayer } from "express-intlayer";
+
+const app = express();
+
+// Carica il gestore delle richieste di internazionalizzazione
+app.use(intlayer());
+
+// Definisci le tue route dopo aver caricato il middleware
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {7} fileName="src/index.cjs" codeFormat="commonjs"
+const express = require("express");
+const { intlayer } = require("express-intlayer");
+
+const app = express();
+
+// Carica il gestore delle richieste di internazionalizzazione
+app.use(intlayer());
+
+// Definisci le tue route dopo aver caricato il middleware
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+### Perché è necessario
+
+- **Rilevamento della lingua**: il middleware `intlayer` elabora le richieste in arrivo per rilevare la lingua preferita dell'utente in base a intestazioni, cookie o altri metodi configurati.
+- **Contesto di traduzione**: imposta il contesto necessario affinché la funzione `t` operi correttamente, garantendo che le traduzioni vengano restituite nella lingua corretta.
+- **Prevenzione degli errori**: senza questo middleware, l'utilizzo della funzione `t` genererà errori di runtime poiché le informazioni sulla lingua non saranno disponibili.
+
+---
+
+## Esempi di utilizzo
+
+### Esempio base
+
+Servire contenuti localizzati in diverse lingue:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+**Richieste del client:**
+
+- Un client con `Accept-Language: fr` riceverà `Bienvenue!`.
+- Un client con `Accept-Language: es` riceverà `¡Bienvenido!`.
+- Un client con `Accept-Language: de` riceverà `Welcome!` (lingua predefinita).
+
+### Gestione degli errori
+
+Fornire messaggi di errore in più lingue:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/error", (_req, res) => {
+  res.status(500).send(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/error", (_req, res) => {
+  res.status(500).send(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/error", (_req, res) => {
+  res.status(500).send(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    })
+  );
+});
+```
+
+---
+
+### Utilizzo di varianti di lingua
+
+Specificare traduzioni per varianti specifiche di lingua:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/greet", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/greet", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/greet", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+---
+
+## Argomenti avanzati
+
+### Meccanismo di fallback
+
+Se una lingua preferita non è disponibile, la funzione `t` passerà alla lingua predefinita definita nella configurazione:
+
+```typescript {5-6} fileName="intlayer.config.ts" codeFormat="typescript"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+} satisfies IntlayerConfig;
+
+export default config;
+```
+
+```javascript {5-6} fileName="intlayer.config.mjs" codeFormat="esm"
+import { Locales } from "intlayer";
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+```javascript {5-6} fileName="intlayer.config.cjs" codeFormat="commonjs"
+const { Locales } = require("intlayer");
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+module.exports = config;
+```
+
+Ad esempio:
+
+- Se `defaultLocale` è `Locales.CHINESE` e un client richiede `Locales.DUTCH`, la traduzione restituita sarà quella di `Locales.CHINESE`.
+- Se `defaultLocale` non è definito, la funzione `t` passerà al valore di `Locales.ENGLISH`.
+
+---
+
+### Applicazione della modalità rigorosa
+
+Configura la funzione `t` per applicare un'aderenza rigorosa alle lingue dichiarate:
+
+| Modalità    | Comportamento                                                                                       |
+| ----------- | --------------------------------------------------------------------------------------------------- |
+| `strict`    | Tutte le lingue dichiarate devono avere traduzioni fornite. Le lingue mancanti generano errori.     |
+| `inclusive` | Le lingue dichiarate devono avere traduzioni. Le lingue mancanti generano avvisi ma sono accettate. |
+| `loose`     | Qualsiasi lingua esistente è accettata, anche se non dichiarata.                                    |
+
+Esempio di configurazione:
+
+```typescript {7} fileName="intlayer.config.ts" codeFormat="typescript"
+import { type IntlayerConfig } from "intlayer";
+
+const config = {
+  // ... La tua configurazione esistente
+  internationalization: {
+    // ... La tua configurazione di internazionalizzazione esistente
+    strictMode: "strict", // Applica la modalità rigorosa
+  },
+} satisfies IntlayerConfig;
+
+export default config;
+```
+
+```javascript {7} fileName="intlayer.config.mjs" codeFormat="esm"
+import { type IntlayerConfig } from "intlayer";
+
+const config = {
+  // ... La tua configurazione esistente
+  internationalization: {
+    // ... La tua configurazione di internazionalizzazione esistente
+    strictMode: "strict", // Applica la modalità rigorosa
+  },
+};
+
+export default config;
+```
+
+```javascript {7} fileName="intlayer.config.cjs" codeFormat="commonjs"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  // ... La tua configurazione esistente
+  internationalization: {
+    // ... La tua configurazione di internazionalizzazione esistente
+    strictMode: "strict", // Applica la modalità rigorosa
+  },
+};
+
+module.exports = config;
+```
+
+---
+
+### Integrazione con TypeScript
+
+La funzione `t` è sicura per i tipi quando utilizzata con TypeScript. Definisci un oggetto di traduzioni sicuro per i tipi:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+import { type LanguageContent } from "express-intlayer";
+
+const translations: LanguageContent<string> = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (_req, res) => {
+  res.send(t(translations));
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+import { type LanguageContent } from "express-intlayer";
+
+/** @type {import('express-intlayer').LanguageContent<string>} */
+const translations = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (_req, res) => {
+  res.send(t(translations));
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+const { type LanguageContent } = require("express-intlayer");
+
+/** @type {import('express-intlayer').LanguageContent<string>} */
+const translations = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (_req, res) => {
+  res.send(t(translations));
+});
+```
+
+---
+
+### Errori comuni e risoluzione dei problemi
+
+| Problema                      | Causa                                             | Soluzione                                                            |
+| ----------------------------- | ------------------------------------------------- | -------------------------------------------------------------------- |
+| Funzione `t` non funzionante  | Middleware non caricato                           | Assicurati che `app.use(intlayer())` sia aggiunto prima delle route. |
+| Errore di traduzioni mancanti | Modalità rigorosa abilitata senza tutte le lingue | Fornisci tutte le traduzioni richieste.                              |
+
+---
+
+## Suggerimenti per un utilizzo efficace
+
+1. **Centralizza le traduzioni**: utilizza un modulo centralizzato o file JSON per gestire le traduzioni e migliorare la manutenibilità.
+2. **Valida le traduzioni**: assicurati che ogni variante di lingua abbia una traduzione corrispondente per evitare fallback non necessari.
+3. **Combina con i18n frontend**: sincronizza con l'internazionalizzazione frontend per un'esperienza utente senza interruzioni in tutta l'app.
+4. **Valuta le prestazioni**: testa i tempi di risposta dell'app quando aggiungi traduzioni per garantire un impatto minimo.
+
+---
+
+## Conclusione
+
+La funzione `t` è uno strumento potente per l'internazionalizzazione backend. Utilizzandola efficacemente, puoi creare un'applicazione più inclusiva e user-friendly per un pubblico globale. Per un utilizzo avanzato e opzioni di configurazione dettagliate, consulta la [documentazione](https://github.com/aymericzip/intlayer/blob/main/docs/it/configuration.md).