` mais doit être spécifiée autrement.
+
+## Exemples
+
+### Responsive
+
+
+
+```jsx
+import Image from 'next/image'
+import mountains from '../public/mountains.jpg'
+
+export default function Responsive() {
+ return (
+
+
+
+ )
+}
+```
+
+### Remplir le conteneur
+
+
+
+```jsx
+import Image from 'next/image'
+import mountains from '../public/mountains.jpg'
+
+export default function Fill() {
+ return (
+
+
+
+
+ {/* Et plus d'images dans la grille... */}
+
+ )
+}
+```
+
+### Image de fond
+
+
+
+```jsx
+import Image from 'next/image'
+import mountains from '../public/mountains.jpg'
+
+export default function Background() {
+ return (
+
+ )
+}
+```
+
+Pour des exemples du composant Image utilisé avec différents styles, voir la [Démo du composant Image](https://image-component.nextjs.gallery).
+
+## Autres propriétés
+
+[**Voir toutes les propriétés disponibles pour le composant `next/image`.**](/docs/app/api-reference/components/image)
+
+## Configuration
+
+Le composant `next/image` et l'API d'optimisation d'images de Next.js peuvent être configurés dans le fichier [`next.config.js`](/docs/app/api-reference/next-config-js). Ces configurations permettent d'[activer les images distantes](/docs/app/api-reference/components/image#remotepatterns), [définir des points de rupture d'images personnalisés](/docs/app/api-reference/components/image#devicesizes), [modifier le comportement de cache](/docs/app/api-reference/components/image#caching-behavior) et plus encore.
+
+[**Lire la documentation complète sur la configuration des images pour plus d'informations.**](/docs/app/api-reference/components/image#configuration-options)
\ No newline at end of file
diff --git a/apps/docs/content/fr/docs/13/02-app/01-building-your-application/06-optimizing/02-fonts.mdx b/apps/docs/content/fr/docs/13/02-app/01-building-your-application/06-optimizing/02-fonts.mdx
new file mode 100644
index 00000000..4ab75b4a
--- /dev/null
+++ b/apps/docs/content/fr/docs/13/02-app/01-building-your-application/06-optimizing/02-fonts.mdx
@@ -0,0 +1,644 @@
+---
+source-updated-at: 2025-05-16T04:52:11.000Z
+translation-updated-at: 2025-06-06T17:43:26.555Z
+title: Optimisation des polices
+nav_title: Polices
+description: Optimisez les polices web de votre application avec les chargeurs intégrés `next/font`.
+related:
+ title: Référence API
+ description: En savoir plus sur l'API next/font.
+ links:
+ - app/api-reference/components/font
+---
+
+{/* Le contenu de ce document est partagé entre le routeur app et pages. Vous pouvez utiliser le composant `
Contenu` pour ajouter du contenu spécifique au routeur Pages. Tout contenu partagé ne doit pas être encapsulé dans un composant. */}
+
+[**`next/font`**](/docs/app/api-reference/components/font) optimisera automatiquement vos polices (y compris les polices personnalisées) et supprimera les requêtes réseau externes pour améliorer la confidentialité et les performances.
+
+> **🎥 Regarder :** En savoir plus sur l'utilisation de `next/font` → [YouTube (6 minutes)](https://www.youtube.com/watch?v=L8_98i_bMMA).
+
+`next/font` inclut **l'hébergement automatique intégré** pour _n'importe quel_ fichier de police. Cela signifie que vous pouvez charger les polices web de manière optimale sans décalage de mise en page, grâce à la propriété CSS `size-adjust` utilisée en arrière-plan.
+
+Ce nouveau système de polices vous permet également d'utiliser commodément toutes les polices Google en tenant compte des performances et de la confidentialité. Les fichiers CSS et de police sont téléchargés au moment de la construction et hébergés avec le reste de vos ressources statiques. **Aucune requête n'est envoyée à Google par le navigateur.**
+
+## Polices Google
+
+Hébergez automatiquement n'importe quelle police Google. Les polices sont incluses dans le déploiement et servies depuis le même domaine que votre déploiement. **Aucune requête n'est envoyée à Google par le navigateur.**
+
+Commencez par importer la police que vous souhaitez utiliser depuis `next/font/google` en tant que fonction. Nous recommandons d'utiliser des [polices variables](https://fonts.google.com/variablefonts) pour les meilleures performances et flexibilité.
+
+
+
+```tsx filename="app/layout.tsx" switcher
+import { Inter } from 'next/font/google'
+
+// Si vous chargez une police variable, vous n'avez pas besoin de spécifier le poids
+const inter = Inter({
+ subsets: ['latin'],
+ display: 'swap',
+})
+
+export default function RootLayout({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+```jsx filename="app/layout.js" switcher
+import { Inter } from 'next/font/google'
+
+// Si vous chargez une police variable, vous n'avez pas besoin de spécifier le poids
+const inter = Inter({
+ subsets: ['latin'],
+ display: 'swap',
+})
+
+export default function RootLayout({ children }) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+Si vous ne pouvez pas utiliser une police variable, vous **devrez spécifier un poids** :
+
+```tsx filename="app/layout.tsx" switcher
+import { Roboto } from 'next/font/google'
+
+const roboto = Roboto({
+ weight: '400',
+ subsets: ['latin'],
+ display: 'swap',
+})
+
+export default function RootLayout({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+```jsx filename="app/layout.js" switcher
+import { Roboto } from 'next/font/google'
+
+const roboto = Roboto({
+ weight: '400',
+ subsets: ['latin'],
+ display: 'swap',
+})
+
+export default function RootLayout({ children }) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+
+
+
+
+Pour utiliser la police dans toutes vos pages, ajoutez-la au fichier [`_app.js`](/docs/pages/building-your-application/routing/custom-app) sous `/pages` comme indiqué ci-dessous :
+
+```jsx filename="pages/_app.js"
+import { Inter } from 'next/font/google'
+
+// Si vous chargez une police variable, vous n'avez pas besoin de spécifier le poids
+const inter = Inter({ subsets: ['latin'] })
+
+export default function MyApp({ Component, pageProps }) {
+ return (
+
+
+
+ )
+}
+```
+
+Si vous ne pouvez pas utiliser une police variable, vous **devrez spécifier un poids** :
+
+```jsx filename="pages/_app.js"
+import { Roboto } from 'next/font/google'
+
+const roboto = Roboto({
+ weight: '400',
+ subsets: ['latin'],
+})
+
+export default function MyApp({ Component, pageProps }) {
+ return (
+
+
+
+ )
+}
+```
+
+
+
+Vous pouvez spécifier plusieurs poids et/ou styles en utilisant un tableau :
+
+```jsx filename="app/layout.js"
+const roboto = Roboto({
+ weight: ['400', '700'],
+ style: ['normal', 'italic'],
+ subsets: ['latin'],
+ display: 'swap',
+})
+```
+
+> **Bon à savoir :** Utilisez un trait de soulignement (_) pour les noms de polices avec plusieurs mots. Par exemple, `Roboto Mono` doit être importé comme `Roboto_Mono`.
+
+
+
+### Appliquer la police dans ``
+
+Vous pouvez également utiliser la police sans wrapper et `className` en l'injectant dans le `` comme suit :
+
+```jsx filename="pages/_app.js"
+import { Inter } from 'next/font/google'
+
+const inter = Inter({ subsets: ['latin'] })
+
+export default function MyApp({ Component, pageProps }) {
+ return (
+ <>
+
+
+ >
+ )
+}
+```
+
+### Utilisation sur une seule page
+
+Pour utiliser la police sur une seule page, ajoutez-la à la page spécifique comme indiqué ci-dessous :
+
+```jsx filename="pages/index.js"
+import { Inter } from 'next/font/google'
+
+const inter = Inter({ subsets: ['latin'] })
+
+export default function Home() {
+ return (
+
+ )
+}
+```
+
+
+
+### Spécifier un sous-ensemble
+
+Les polices Google sont automatiquement [sous-ensemblées](https://fonts.google.com/knowledge/glossary/subsetting). Cela réduit la taille du fichier de police et améliore les performances. Vous devrez définir quels sous-ensembles vous souhaitez précharger. Ne pas spécifier de sous-ensemble alors que [`preload`](/docs/app/api-reference/components/font#preload) est `true` entraînera un avertissement.
+
+Cela peut être fait en l'ajoutant à l'appel de fonction :
+
+
+
+```tsx filename="app/layout.tsx" switcher
+const inter = Inter({ subsets: ['latin'] })
+```
+
+```jsx filename="app/layout.js" switcher
+const inter = Inter({ subsets: ['latin'] })
+```
+
+
+
+
+
+```jsx filename="pages/_app.js"
+const inter = Inter({ subsets: ['latin'] })
+```
+
+
+
+Consultez la [Référence API des polices](/docs/app/api-reference/components/font) pour plus d'informations.
+
+### Utiliser plusieurs polices
+
+Vous pouvez importer et utiliser plusieurs polices dans votre application. Il existe deux approches possibles.
+
+La première approche consiste à créer une fonction utilitaire qui exporte une police, l'importe et applique sa `className` là où c'est nécessaire. Cela garantit que la police est préchargée uniquement lorsqu'elle est rendue :
+
+```ts filename="app/fonts.ts" switcher
+import { Inter, Roboto_Mono } from 'next/font/google'
+
+export const inter = Inter({
+ subsets: ['latin'],
+ display: 'swap',
+})
+
+export const roboto_mono = Roboto_Mono({
+ subsets: ['latin'],
+ display: 'swap',
+})
+```
+
+```js filename="app/fonts.js" switcher
+import { Inter, Roboto_Mono } from 'next/font/google'
+
+export const inter = Inter({
+ subsets: ['latin'],
+ display: 'swap',
+})
+
+export const roboto_mono = Roboto_Mono({
+ subsets: ['latin'],
+ display: 'swap',
+})
+```
+
+
+
+```tsx filename="app/layout.tsx" switcher
+import { inter } from './fonts'
+
+export default function Layout({ children }: { children: React.ReactNode }) {
+ return (
+
+
+ {children}
+
+
+ )
+}
+```
+
+```jsx filename="app/layout.js" switcher
+import { inter } from './fonts'
+
+export default function Layout({ children }) {
+ return (
+
+
+ {children}
+
+
+ )
+}
+```
+
+```tsx filename="app/page.tsx" switcher
+import { roboto_mono } from './fonts'
+
+export default function Page() {
+ return (
+ <>
+ My page
+ >
+ )
+}
+```
+
+```jsx filename="app/page.js" switcher
+import { roboto_mono } from './fonts'
+
+export default function Page() {
+ return (
+ <>
+ My page
+ >
+ )
+}
+```
+
+
+
+Dans l'exemple ci-dessus, `Inter` sera appliquée globalement, et `Roboto Mono` peut être importée et appliquée selon les besoins.
+
+Alternativement, vous pouvez créer une [variable CSS](/docs/app/api-reference/components/font#variable) et l'utiliser avec votre solution CSS préférée :
+
+
+
+```tsx filename="app/layout.tsx" switcher
+import { Inter, Roboto_Mono } from 'next/font/google'
+import styles from './global.css'
+
+const inter = Inter({
+ subsets: ['latin'],
+ variable: '--font-inter',
+ display: 'swap',
+})
+
+const roboto_mono = Roboto_Mono({
+ subsets: ['latin'],
+ variable: '--font-roboto-mono',
+ display: 'swap',
+})
+
+export default function RootLayout({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ return (
+
+
+ My App
+ {children}
+
+
+ )
+}
+```
+
+```jsx filename="app/layout.js" switcher
+import { Inter, Roboto_Mono } from 'next/font/google'
+
+const inter = Inter({
+ subsets: ['latin'],
+ variable: '--font-inter',
+ display: 'swap',
+})
+
+const roboto_mono = Roboto_Mono({
+ subsets: ['latin'],
+ variable: '--font-roboto-mono',
+ display: 'swap',
+})
+
+export default function RootLayout({ children }) {
+ return (
+
+
+ My App
+ {children}
+
+
+ )
+}
+```
+
+
+
+```css filename="app/global.css"
+html {
+ font-family: var(--font-inter);
+}
+
+h1 {
+ font-family: var(--font-roboto-mono);
+}
+```
+
+Dans l'exemple ci-dessus, `Inter` sera appliquée globalement, et toutes les balises `
` seront stylisées avec `Roboto Mono`.
+
+> **Recommandation :** Utilisez plusieurs polices avec parcimonie car chaque nouvelle police est une ressource supplémentaire que le client doit télécharger.
+
+## Polices locales
+
+Importez `next/font/local` et spécifiez le `src` de votre fichier de police local. Nous recommandons d'utiliser des [polices variables](https://fonts.google.com/variablefonts) pour les meilleures performances et flexibilité.
+
+
+
+```tsx filename="app/layout.tsx" switcher
+import localFont from 'next/font/local'
+
+// Les fichiers de police peuvent être colocalisés dans `app`
+const myFont = localFont({
+ src: './my-font.woff2',
+ display: 'swap',
+})
+
+export default function RootLayout({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+```jsx filename="app/layout.js" switcher
+import localFont from 'next/font/local'
+
+// Les fichiers de police peuvent être colocalisés dans `app`
+const myFont = localFont({
+ src: './my-font.woff2',
+ display: 'swap',
+})
+
+export default function RootLayout({ children }) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+
+
+
+
+```jsx filename="pages/_app.js"
+import localFont from 'next/font/local'
+
+// Les fichiers de police peuvent être colocalisés dans `pages`
+const myFont = localFont({ src: './my-font.woff2' })
+
+export default function MyApp({ Component, pageProps }) {
+ return (
+
+
+
+ )
+}
+```
+
+
+
+Si vous souhaitez utiliser plusieurs fichiers pour une seule famille de polices, `src` peut être un tableau :
+
+```js
+const roboto = localFont({
+ src: [
+ {
+ path: './Roboto-Regular.woff2',
+ weight: '400',
+ style: 'normal',
+ },
+ {
+ path: './Roboto-Italic.woff2',
+ weight: '400',
+ style: 'italic',
+ },
+ {
+ path: './Roboto-Bold.woff2',
+ weight: '700',
+ style: 'normal',
+ },
+ {
+ path: './Roboto-BoldItalic.woff2',
+ weight: '700',
+ style: 'italic',
+ },
+ ],
+})
+```
+
+Consultez la [Référence API des polices](/docs/app/api-reference/components/font) pour plus d'informations.
+
+## Avec Tailwind CSS
+
+`next/font` peut être utilisé avec [Tailwind CSS](https://tailwindcss.com/) via une [variable CSS](/docs/app/api-reference/components/font#css-variables).
+
+Dans l'exemple ci-dessous, nous utilisons la police `Inter` de `next/font/google` (vous pouvez utiliser n'importe quelle police Google ou locale). Chargez votre police avec l'option `variable` pour définir le nom de votre variable CSS et assignez-la à `inter`. Ensuite, utilisez `inter.variable` pour ajouter la variable CSS à votre document HTML.
+
+
+
+```tsx filename="app/layout.tsx" switcher
+import { Inter, Roboto_Mono } from 'next/font/google'
+
+const inter = Inter({
+ subsets: ['latin'],
+ display: 'swap',
+ variable: '--font-inter',
+})
+
+const roboto_mono = Roboto_Mono({
+ subsets: ['latin'],
+ display: 'swap',
+ variable: '--font-roboto-mono',
+})
+
+export default function RootLayout({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+```jsx filename="app/layout.js" switcher
+import { Inter, Roboto_Mono } from 'next/font/google'
+
+const inter = Inter({
+ subsets: ['latin'],
+ display: 'swap',
+ variable: '--font-inter',
+})
+
+const roboto_mono = Roboto_Mono({
+ subsets: ['latin'],
+ display: 'swap',
+ variable: '--font-roboto-mono',
+})
+
+export default function RootLayout({ children }) {
+ return (
+
+ {children}
+
+ )
+}
+```
+
+
+
+
+
+```jsx filename="pages/_app.js"
+import { Inter } from 'next/font/google'
+
+const inter = Inter({
+ subsets: ['latin'],
+ variable: '--font-inter',
+})
+
+export default function MyApp({ Component, pageProps }) {
+ return (
+
+
+
+ )
+}
+```
+
+
+
+Enfin, ajoutez la variable CSS à votre [configuration Tailwind CSS](/docs/app/building-your-application/styling/tailwind-css#configuring-tailwind) :
+
+```js filename="tailwind.config.js"
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+ content: [
+ './pages/**/*.{js,ts,jsx,tsx}',
+ './components/**/*.{js,ts,jsx,tsx}',
+ './app/**/*.{js,ts,jsx,tsx}',
+ ],
+ theme: {
+ extend: {
+ fontFamily: {
+ sans: ['var(--font-inter)'],
+ mono: ['var(--font-roboto-mono)'],
+ },
+ },
+ },
+ plugins: [],
+}
+```
+
+Vous pouvez maintenant utiliser les classes utilitaires `font-sans` et `font-mono` pour appliquer la police à vos éléments.
+
+## Préchargement
+
+
+Lorsqu'une fonction de police est appelée sur une page de votre site, elle n'est pas disponible globalement et préchargée sur toutes les routes. Au lieu de cela, la police est uniquement préchargée sur les routes associées en fonction du type de fichier où elle est utilisée :
+
+- Si c'est une [page unique](/docs/app/building-your-application/routing/pages-and-layouts#pages), elle est préchargée sur la route unique de cette page.
+- Si c'est une [disposition](/docs/app/building-your-application/routing/pages-and-layouts#layouts), elle est préchargée sur toutes les routes englobées par la disposition.
+- Si c'est la [disposition racine](/docs/app/building-your-application/routing/pages-and-layouts#root-layout-required), elle est préchargée sur toutes les routes.
+
+
+
+
+
+Lorsqu'une fonction de police est appelée sur une page de votre site, elle n'est pas disponible globalement et préchargée sur toutes les routes. Au lieu de cela, la police est uniquement préchargée sur la ou les routes associées en fonction du type de fichier où elle est utilisée :
+
+- si c'est une [page unique](/docs/pages/building-your-application/routing/pages-and-layouts), elle est préchargée sur la route unique de cette page
+- si c'est dans l'[App personnalisée](/docs/pages/building-your-application/routing/custom-app), elle est préchargée sur toutes les routes du site sous `/pages`
+
+
+
+## Réutiliser les polices
+
+Chaque fois que vous appelez la fonction `localFont` ou Google font, cette police est hébergée comme une instance dans votre application. Par conséquent, si vous chargez la même fonction de police dans plusieurs fichiers, plusieurs instances de la même police sont hébergées. Dans cette situation, il est recommandé de faire ce qui suit :
+
+- Appeler la fonction de chargement de police dans un fichier partagé
+- L'exporter comme une constante
+- Importer la constante dans chaque fichier où vous souhaitez utiliser cette police
\ No newline at end of file
diff --git a/apps/docs/content/fr/docs/13/02-app/01-building-your-application/06-optimizing/03-scripts.mdx b/apps/docs/content/fr/docs/13/02-app/01-building-your-application/06-optimizing/03-scripts.mdx
new file mode 100644
index 00000000..3574117f
--- /dev/null
+++ b/apps/docs/content/fr/docs/13/02-app/01-building-your-application/06-optimizing/03-scripts.mdx
@@ -0,0 +1,377 @@
+---
+source-updated-at: 2025-05-16T04:52:11.000Z
+translation-updated-at: 2025-06-06T17:42:23.857Z
+title: Optimisation des scripts
+nav_title: Scripts
+description: Optimisez les scripts tiers avec le composant Script intégré.
+related:
+ title: Référence API
+ description: En savoir plus sur l'API next/script.
+ links:
+ - app/api-reference/components/script
+---
+
+{/* Le contenu de ce document est partagé entre le routeur app et pages. Vous pouvez utiliser le composant `Contenu` pour ajouter du contenu spécifique au routeur Pages. Tout contenu partagé ne doit pas être encapsulé dans un composant. */}
+
+
+
+### Scripts de mise en page
+
+Pour charger un script tiers pour plusieurs routes, importez `next/script` et incluez le script directement dans votre composant de mise en page :
+
+```tsx filename="app/dashboard/layout.tsx" switcher
+import Script from 'next/script'
+
+export default function DashboardLayout({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ return (
+ <>
+
+
+ >
+ )
+}
+```
+
+```jsx filename="app/dashboard/layout.js" switcher
+import Script from 'next/script'
+
+export default function DashboardLayout({ children }) {
+ return (
+ <>
+
+
+ >
+ )
+}
+```
+
+Le script tiers est récupéré lorsque la route du dossier (par exemple `dashboard/page.js`) ou toute route imbriquée (par exemple `dashboard/settings/page.js`) est accédée par l'utilisateur. Next.js s'assurera que le script **ne se charge qu'une seule fois**, même si un utilisateur navigue entre plusieurs routes dans la même mise en page.
+
+
+
+### Scripts d'application
+
+
+
+Pour charger un script tiers pour toutes les routes, importez `next/script` et incluez le script directement dans votre mise en page racine :
+
+```tsx filename="app/layout.tsx" switcher
+import Script from 'next/script'
+
+export default function RootLayout({
+ children,
+}: {
+ children: React.ReactNode
+}) {
+ return (
+
+ {children}
+
+
+ )
+}
+```
+
+```jsx filename="app/layout.js" switcher
+import Script from 'next/script'
+
+export default function RootLayout({ children }) {
+ return (
+
+ {children}
+
+
+ )
+}
+```
+
+
+
+
+
+Pour charger un script tiers pour toutes les routes, importez `next/script` et incluez le script directement dans votre `_app` personnalisé :
+
+```jsx filename="pages/_app.js"
+import Script from 'next/script'
+
+export default function MyApp({ Component, pageProps }) {
+ return (
+ <>
+
+
+ >
+ )
+}
+```
+
+
+
+Ce script se chargera et s'exécutera lorsque _n'importe quelle_ route de votre application est accédée. Next.js s'assurera que le script **ne se charge qu'une seule fois**, même si un utilisateur navigue entre plusieurs pages.
+
+> **Recommandation** : Nous recommandons d'inclure les scripts tiers uniquement dans des pages ou mises en page spécifiques afin de minimiser l'impact inutile sur les performances.
+
+### Stratégie
+
+Bien que le comportement par défaut de `next/script` vous permette de charger des scripts tiers dans n'importe quelle page ou mise en page, vous pouvez affiner son comportement de chargement en utilisant la propriété `strategy` :
+
+- `beforeInteractive` : Charge le script avant tout code Next.js et avant toute hydratation de page.
+- `afterInteractive` : (**par défaut**) Charge le script tôt mais après une certaine hydratation de la page.
+- `lazyOnload` : Charge le script plus tard pendant les temps d'inactivité du navigateur.
+- `worker` : (expérimental) Charge le script dans un web worker.
+
+Consultez la documentation de référence de l'API [`next/script`](/docs/app/api-reference/components/script#strategy) pour en savoir plus sur chaque stratégie et leurs cas d'utilisation.
+
+### Délégation des scripts à un web worker (expérimental)
+
+> **Avertissement** : La stratégie `worker` n'est pas encore stable et ne fonctionne pas encore avec le répertoire [`app`](/docs/app/building-your-application/routing/defining-routes). À utiliser avec prudence.
+
+Les scripts qui utilisent la stratégie `worker` sont délégués et exécutés dans un web worker avec [Partytown](https://partytown.builder.io/). Cela peut améliorer les performances de votre site en dédiant le thread principal au reste de votre code d'application.
+
+Cette stratégie est encore expérimentale et ne peut être utilisée que si le drapeau `nextScriptWorkers` est activé dans `next.config.js` :
+
+```js filename="next.config.js"
+module.exports = {
+ experimental: {
+ nextScriptWorkers: true,
+ },
+}
+```
+
+Ensuite, exécutez `next` (normalement `npm run dev` ou `yarn dev`) et Next.js vous guidera à travers l'installation des packages requis pour terminer la configuration :
+
+```bash filename="Terminal"
+npm run dev
+```
+
+Vous verrez des instructions comme celles-ci : Veuillez installer Partytown en exécutant `npm install @builder.io/partytown`
+
+Une fois la configuration terminée, définir `strategy="worker"` instanciera automatiquement Partytown dans votre application et déléguera le script à un web worker.
+
+```tsx filename="pages/home.tsx" switcher
+import Script from 'next/script'
+
+export default function Home() {
+ return (
+ <>
+
+ >
+ )
+}
+```
+
+```jsx filename="pages/home.js" switcher
+import Script from 'next/script'
+
+export default function Home() {
+ return (
+ <>
+
+ >
+ )
+}
+```
+
+Il y a un certain nombre de compromis à considérer lors du chargement d'un script tiers dans un web worker. Veuillez consulter la documentation sur les [compromis](https://partytown.builder.io/trade-offs) de Partytown pour plus d'informations.
+
+### Scripts inline
+
+Les scripts inline, ou scripts non chargés depuis un fichier externe, sont également pris en charge par le composant Script. Ils peuvent être écrits en plaçant le JavaScript entre des accolades :
+
+```jsx
+
+```
+
+Ou en utilisant la propriété `dangerouslySetInnerHTML` :
+
+```jsx
+
+```
+
+> **Avertissement** : Une propriété `id` doit être attribuée pour les scripts inline afin que Next.js puisse suivre et optimiser le script.
+
+### Exécution de code supplémentaire
+
+Des gestionnaires d'événements peuvent être utilisés avec le composant Script pour exécuter du code supplémentaire après qu'un certain événement se produit :
+
+- `onLoad` : Exécute du code après que le script a fini de se charger.
+- `onReady` : Exécute du code après que le script a fini de se charger et à chaque montage du composant.
+- `onError` : Exécute du code si le script échoue à se charger.
+
+
+
+Ces gestionnaires ne fonctionneront que lorsque `next/script` est importé et utilisé dans un [composant client](/docs/app/building-your-application/rendering/client-components) où `"use client"` est défini comme la première ligne de code :
+
+```tsx filename="app/page.tsx" switcher
+'use client'
+
+import Script from 'next/script'
+
+export default function Page() {
+ return (
+ <>
+
+```
+
+Ou en utilisant la propriété `dangerouslySetInnerHTML` :
+
+```jsx
+
+```
+
+> **Avertissement** : Une propriété `id` doit être attribuée pour les scripts inline afin que Next.js puisse suivre et optimiser le script.
+
+### Exécution de code supplémentaire
+
+Des gestionnaires d'événements peuvent être utilisés avec le composant Script pour exécuter du code supplémentaire après qu'un certain événement se produise :
+
+- `onLoad` : Exécute du code après que le script a fini de charger.
+- `onReady` : Exécute du code après que le script a fini de charger et à chaque fois que le composant est monté.
+- `onError` : Exécute du code si le script échoue à charger.
+
+
+
+Ces gestionnaires ne fonctionneront que lorsque `next/script` est importé et utilisé à l'intérieur d'un [composant client](/docs/app/building-your-application/rendering/client-components) où `"use client"` est défini comme la première ligne de code :
+
+```tsx filename="app/page.tsx" switcher
+'use client'
+
+import Script from 'next/script'
+
+export default function Page() {
+ return (
+ <>
+