@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.7

package/docs/fr/intlayer_with_vite+react_compiler.md

@@ -213,11 +213,18 @@ Ajoutez le plugin intlayer dans votre configuration.
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react-swc";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [react(), intlayer(), intlayerCompiler()],
+  plugins: [
+    react(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/fr/intlayer_with_vite+solid.md

@@ -596,6 +596,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -605,7 +607,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+svelte.md

@@ -458,14 +458,17 @@ En parallèle, vous pouvez également utiliser le `intlayerProxy` pour ajouter u
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { svelte } from "@sveltejs/vite-plugin-svelte";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
     svelte(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -597,6 +600,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -606,7 +611,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+vanilla.md

@@ -205,7 +205,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -466,12 +472,15 @@ Tout d'abord, ajoutez `intlayerProxy` à votre config Vite :
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // doit être placé en premier
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -603,6 +612,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -612,7 +623,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+vue.md

@@ -620,14 +620,17 @@ Parallèlement, vous pouvez également utiliser le `intlayerProxy` pour ajouter
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
     vue(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -952,6 +955,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -961,7 +966,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/packages/@intlayer_babel/export.md

@@ -0,0 +1,131 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: "Documentation du package @intlayer/babel"
+description: Plugins Babel pour Intlayer afin de gérer l'extraction de contenu, l'optimisation des importations, la purge des champs inutilisés et le masquage des noms de champs lors de la construction.
+keywords:
+  - "@intlayer/babel"
+  - babel
+  - plugin
+  - internationalisation
+  - i18n
+  - compilateur
+  - optimiser
+  - purger
+  - minifier
+slugs:
+  - doc
+  - packages
+  - "@intlayer/babel"
+  - export
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Documentation unifiée de toutes les exportations"
+author: aymericzip
+---
+
+# Package @intlayer/babel
+
+Le package `@intlayer/babel` fournit un ensemble de plugins Babel spécialisés pour Intlayer. Ces plugins couvrent l'ensemble du cycle de construction : extraction des déclarations de contenu, réécriture des appels `useIntlayer` / `getIntlayer` en importations de dictionnaires optimisés, purge des champs inutilisés et minification des noms de champs.
+
+## Installation
+
+```bash
+npm install @intlayer/babel
+```
+
+## Exportations
+
+Importation :
+
+```ts
+import { ... } from "@intlayer/babel";
+```
+
+---
+
+### Plugins
+
+| Fonction / Classe              | Description                                                                                                                                                                                                                  |
+| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `intlayerExtractBabelPlugin`   | Plugin Babel qui extrait le contenu traduisible des fichiers sources et injecte automatiquement les hooks `useIntlayer` / `getIntlayer`. Conçu pour être utilisé avec Next.js et les outils de construction basés sur Babel. |
+| `intlayerOptimizeBabelPlugin`  | Plugin Babel qui transforme les appels `useIntlayer` et `getIntlayer` et réécrit leurs importations en importations de dictionnaires JSON optimisées (statiques, dynamiques ou via fetch).                                   |
+| `intlayerPurgeBabelPlugin`     | Plugin Babel qui analyse les fichiers sources et réécrit les fichiers JSON des dictionnaires compilés pour supprimer les champs inutilisés (`build.purge`) ou les renommer en alias courts (`build.minify`).                 |
+| `intlayerMinifyBabelPlugin`    | Plugin Babel qui réécrit les fichiers sources pour utiliser les alias de champs courts attribués pendant la phase de minification (par exemple, `content.title` ← `content.a`). Dépend de `intlayerPurgeBabelPlugin`.        |
+| `makeFieldRenameBabelPlugin`   | Fonction factory qui produit un plugin Babel pour renommer les accès aux champs de contenu des dictionnaires dans les fichiers sources selon la `dictionaryKeyToFieldRenameMap` renseignée dans le `PruneContext`.           |
+| `makeUsageAnalyzerBabelPlugin` | Fonction factory qui produit un plugin Babel pour analyser l'utilisation de `useIntlayer` / `getIntlayer` dans le code source et regrouper les données d'utilisation des champs dans le `PruneContext` partagé.              |
+| `getSharedPruneContext`        | Fonction utilitaire qui renvoie l'objet `PruneContext` partagé pour le répertoire de base spécifié, ou `null` si le contexte n'a pas encore été initialisé.                                                                  |
+
+---
+
+### Utilitaires de configuration des plugins
+
+| Fonction                   | Description                                                                                                                                                  |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `getExtractPluginOptions`  | Charge la configuration Intlayer et renvoie les `ExtractPluginOptions` prêtes à l'emploi avec `intlayerExtractBabelPlugin`.                                  |
+| `getOptimizePluginOptions` | Charge la configuration Intlayer et les dictionnaires compilés, et renvoie les `OptimizePluginOptions` prêtes à l'emploi avec `intlayerOptimizeBabelPlugin`. |
+| `getPurgePluginOptions`    | Charge la configuration Intlayer et renvoie les `PurgePluginOptions` prêtes à l'emploi avec `intlayerPurgeBabelPlugin`.                                      |
+| `getMinifyPluginOptions`   | Charge la configuration Intlayer et renvoie les `MinifyPluginOptions` prêtes à l'emploi avec `intlayerMinifyBabelPlugin`.                                    |
+
+---
+
+### Types
+
+| Type                    | Description                                                                                                                                |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `CompilerMode`          | Mode du compilateur : `'dev'` pour le développement avec support HMR, ou `'build'` pour les builds de production.                          |
+| `ExtractPluginOptions`  | Options pour `intlayerExtractBabelPlugin` : liste des fichiers, configuration, callback `onExtract`, etc.                                  |
+| `ExtractResult`         | Résultat de l'extraction : clé de dictionnaire, chemin du fichier, contenu et locale.                                                      |
+| `OptimizePluginOptions` | Options pour `intlayerOptimizeBabelPlugin` : chemins des dictionnaires, mode d'importation, carte des modes par dictionnaire, etc.         |
+| `PurgePluginOptions`    | Options pour `intlayerPurgeBabelPlugin` : répertoire de base, drapeaux purge/minify/optimize, liste des fichiers de composants.            |
+| `MinifyPluginOptions`   | Options pour `intlayerMinifyBabelPlugin` : répertoire de base, drapeaux minify/optimize/editorEnabled.                                     |
+| `PruneContext`          | État partagé entre les plugins d'analyse et de purge : cartes d'utilisation des champs, cartes de renommage, etc.                          |
+| `DictionaryFieldUsage`  | Résultat de l'utilisation des champs pour un seul dictionnaire : `Set<string>` ou `'all'` lorsque l'analyse statique n'est pas concluante. |
+| `NestedRenameEntry`     | Nœud dans l'arbre de renommage : le `shortName` et la carte des enfants.                                                                   |
+| `NestedRenameMap`       | Un niveau dans l'arbre de renommage : `Map<string, NestedRenameEntry>`.                                                                    |
+| `CompatCallerConfig`    | Configuration pour un analyseur d'utilisation compatible pour les packages compat-adapter (nom de l'appelant et options de traitement).    |
+| `ScriptBlock`           | Bloc de script extrait d'un fichier SFC (Vue ou Svelte) : contenu, décalage de début et décalage de fin.                                   |
+
+---
+
+### Fonctions utilitaires
+
+| Fonction                          | Description                                                                                                                                                                                       |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `generateShortFieldName`          | Convertit un entier (en commençant par zéro) en un identifiant alphabétique court : `0` → `'a'`, `25` → `'z'`, `26` → `'aa'`, etc.                                                                |
+| `buildNestedRenameMapFromContent` | Construit de manière récursive une `NestedRenameMap` à partir de la valeur du contenu d'un dictionnaire compilé, en respectant les structures de nœuds Intlayer (translation, enumeration, etc.). |
+| `createPruneContext`              | Crée un nouvel objet `PruneContext` vide initialisé avec les valeurs par défaut.                                                                                                                  |
+| `extractScriptBlocks`             | Extrait les blocs `<script>` des fichiers SFC (Vue / Svelte) pour une analyse Babel ultérieure.                                                                                                   |
+| `BABEL_PARSER_OPTIONS`            | Constante représentant les options du parseur Babel couvrant les frameworks pris en charge (React/Vue/Svelte/Angular/...).                                                                        |
+| `INTLAYER_CALLER_NAMES`           | Liste constante des noms d'appelants originaux d'Intlayer : `['useIntlayer', 'getIntlayer']`.                                                                                                     |
+
+---
+
+## Exemple d'utilisation
+
+```js
+// babel.config.js
+const {
+  intlayerExtractBabelPlugin,
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
+  intlayerOptimizeBabelPlugin,
+  getExtractPluginOptions,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+  getOptimizePluginOptions,
+} = require("@intlayer/babel");
+
+module.exports = {
+  presets: ["next/babel"],
+  plugins: [
+    [intlayerExtractBabelPlugin, getExtractPluginOptions()],
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],
+  ],
+};
+```
+
+> **Note :** Le plugin `intlayerPurgeBabelPlugin` doit être déclaré **avant** `intlayerMinifyBabelPlugin`, car ce dernier lit la carte de renommage construite par le premier. De plus, ils doivent tous deux être précédés par `intlayerOptimizeBabelPlugin` afin que celui-ci puisse voir les clés de dictionnaire avant que les appels à `useIntlayer` ne soient réécrits.

package/docs/fr/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentation du plugin Vite intlayerCompiler | vite-intlayer
+description: Plugin Vite qui extrait les déclarations de contenu Intlayer en ligne des fichiers de composants et les écrit dans des fichiers JSON de dictionnaire lors du build ou de la phase de transformation.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compilateur
+  - contenu
+  - dictionnaire
+  - internationalisation
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Intégré dans intlayer() ; initialisation de la doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` est un plugin Vite qui scanne les fichiers sources des composants à la recherche de **déclarations de contenu Intlayer en ligne** — du contenu défini directement à l'intérieur d'un composant plutôt que dans un fichier `.content.ts` séparé — et les écrit dans des fichiers JSON de dictionnaire pendant la phase de transformation.
+
+> **Depuis Intlayer v9**, `intlayerCompiler` est automatiquement inclus dans le plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/vite-intlayer/intlayer.md) lorsque `compiler.enabled` est à `true` et que `compiler.output` est défini dans votre configuration Intlayer. Vous n'avez besoin de l'enregistrer séparément que si vous souhaitez un contrôle total sur la configuration spécifique au compilateur.
+
+## Utilisation
+
+### En tant que partie de `intlayer()` (recommandé, v9+)
+
+Activez le compilateur via votre configuration Intlayer :
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // où les dictionnaires extraits sont écrits
+  },
+});
+```
+
+Ensuite, utilisez le plugin standard sans enregistrement supplémentaire :
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Autonome (si nécessaire)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Options
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Option           | Type                      | Description                                                                                                   |
+| ---------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Surcharges de configuration Intlayer transmises à `getConfiguration()`.                                       |
+| `compilerConfig` | `Partial<CompilerConfig>` | Surcharges pour la section de configuration spécifique au compilateur (ex. `enabled`, `output`, `filesList`). |
+
+### Exemple
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Comment ça fonctionne
+
+### Phase de transformation
+
+Pour chaque fichier source qui correspond à `compiler.filesList`, le plugin du compilateur :
+
+1. Passe le contenu du fichier via `extractContent` de `@intlayer/babel`.
+2. Appelle `onExtract` pour chaque déclaration trouvée, ce qui écrit le JSON du dictionnaire résultant dans `compiler.output`.
+3. Renvoie le code source transformé avec les déclarations en ligne remplacées par des appels standard `useIntlayer('key')` / `getIntlayer('key')`.
+
+Types de fichiers pris en charge : `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Lorsqu'un fichier de composant est enregistré en mode développement, le compilateur :
+
+1. Détecte le changement de fichier via le hook `handleHotUpdate` de Vite.
+2. Extrait à nouveau le contenu du fichier mis à jour.
+3. Écrit le JSON du dictionnaire mis à jour.
+4. Déclenche un rechargement complet de la page (`server.ws.send({ type: 'full-reload' })`).
+
+Un debounce de 500 ms empêche l'écriture du dictionnaire elle-même (qui déclenche également un événement de modification de fichier) de provoquer une boucle d'extraction infinie.
+
+### Dédoublonnage
+
+`intlayerCompiler` utilise le même mécanisme de dédoublonnage `createPrimaryInstanceGuard` que les autres plugins intégrés. Lorsque `intlayer()` (qui intègre le compilateur) et un appel manuel à `intlayerCompiler()` sont tous deux présents, seule la première instance enregistrée s'exécute — aucun dictionnaire n'est écrit deux fois.

package/docs/fr/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentation du plugin Vite intlayerMinify | vite-intlayer
+description: Plugin Vite qui minifie les fichiers JSON de dictionnaire Intlayer compilés et réduit éventuellement la taille du bundle en masquant les noms des champs de contenu.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minifier
+  - taille du bundle
+  - dictionnaire
+  - internationalisation
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Initialisation de la doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+`intlayerMinify` est un plugin Vite qui minifie les fichiers JSON de dictionnaire compilés lors d'un build de production. Il supprime tous les espaces inutiles et, lorsqu'il est combiné avec `intlayerPrune`, renomme éventuellement les noms des champs de contenu en alias alphabétiques courts (`a`, `b`, `c`, …) pour réduire davantage la taille du bundle.
+
+> Le plugin est déjà inclus et configuré automatiquement lorsque vous utilisez [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/vite-intlayer/intlayer.md). Vous n'avez besoin de l'enregistrer manuellement que si vous composez vous-même la pile de plugins.
+
+## Utilisation
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Conditions d'activation
+
+`intlayerMinify` est actif **uniquement** lorsque les trois conditions suivantes sont remplies :
+
+1. La commande Vite est `build` (pas `serve` / dev).
+2. `build.optimize` est à `true` (ou `undefined`, qui vaut par défaut `true` pour les builds).
+3. `build.minify` est à `true` dans votre configuration Intlayer.
+
+Il est automatiquement **désactivé** lorsque `editor.enabled` est à `true` car l'éditeur a besoin du contenu complet et lisible par l'homme du dictionnaire.
+
+## Ce qui est minifié
+
+Le plugin cible deux emplacements de dictionnaire (tels que résolus depuis `intlayer.system`) :
+
+- `dictionariesDir` — dictionnaires statiques toutes langues (ex. `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — dictionnaires dynamiques par langue
+
+> Les dictionnaires en mode fetch (`fetchDictionariesDir`) ne sont **jamais** minifiés car ils sont servis depuis une API distante au moment de l'exécution en utilisant leurs noms de champs d'origine. Renommer les champs créerait un décalage entre la réponse du serveur et les accès aux propriétés côté client.
+
+## Masquage des noms de champs (minification des propriétés)
+
+Lorsque `intlayerPrune` a analysé la codebase et rempli `pruneContext.dictionaryKeyToFieldRenameMap`, `intlayerMinify` renomme également les noms de champs de contenu en alias courts. Par exemple :
+
+```json
+// avant
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// après (avec masquage)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Les accès aux propriétés correspondants dans les fichiers sources sont renommés par la passe Babel dans `intlayerOptimize`, le comportement au runtime reste donc inchangé.
+
+Les champs internes d'Intlayer (`nodeType`, `translation`, etc.) ne sont jamais renommés.
+
+## Dictionnaires de cas limites (Edge-cases)
+
+Les dictionnaires signalés dans `pruneContext.dictionariesWithEdgeCases` (anomalies structurelles détectées lors de la phase de prune) sont entièrement ignorés — ni minifiés ni masqués — pour éviter de livrer des données corrompues.
+
+## Groupes qualifiés (collections / variantes / enregistrements méta)
+
+Pour les dictionnaires avec un tableau `qualifierTypes` (collections, variantes et enregistrements méta), le plugin préserve le tableau `qualifierTypes` et la table de correspondance `meta` textuellement. Seules les entrées de `content` ont leurs noms de champs masqués. Les clés composites (utilisées pour la correspondance des sélecteurs au runtime) ne sont jamais touchées.