@intlayer/docs 5.5.9 → 5.5.11

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

@@ -1,35 +0,0 @@
-# @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

@@ -1,3 +0,0 @@
-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

@@ -1,229 +0,0 @@
-# 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

@@ -1,432 +0,0 @@
-# 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).