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

package/docs/de/compat/react-intl.md

@@ -0,0 +1,55 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migration von React Intl zu Intlayer"
+description: "Erfahren Sie, wie Sie Ihre React-Anwendung von react-intl zu Intlayer mithilfe des Compat-Adapters migrieren."
+keywords:
+  - react-intl
+  - formatjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Verlauf initialisiert"
+author: aymericzip
+---
+
+# Migration von React Intl zu Intlayer
+
+Wenn Ihre React-Anwendung `react-intl` (FormatJS) verwendet, ist der Übergang zu Intlayer ein Kinderspiel. Unser Compat-Layer behandelt ICU MessageFormat und alle bestehenden `Formatted*`-Komponenten nahtlos.
+
+## Was zu tun ist
+
+Beginnen Sie mit der Ausführung des Initialisierungsbefehls in Ihrem Projekt:
+
+```bash
+npx intlayer init
+```
+
+Richten Sie dann das Intlayer Vite- oder Next.js-Plugin in Ihrer Konfiguration ein. Dieses Plugin injiziert Build-Zeit-Aliase, um `react-intl`-Imports zu `@intlayer/react-intl` weiterzuleiten.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import reactIntlVitePlugin from "@intlayer/react-intl/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactIntlVitePlugin()],
+});
+```
+
+## Was im Hintergrund geschieht
+
+Das Bundler-Plugin aliasiert `react-intl` zu `@intlayer/react-intl`. Anstatt große JSON-Dateien manuell zu parsen und Ihre Anwendung in einem `IntlProvider` zu umhüllen, extrahiert das Intlayer-Plugin Schlüssel statisch und verwendet Intlayer-Wörterbücher zur Laufzeit.
+
+Im Hintergrund:
+
+- **ICU MessageFormat:** Intlayer verwendet den `resolveMessage(..., 'icu')`-Resolver, der die ICU-Pluralisierung, Auswahl, Datums-/Zahlenformatierung und Rich-Text-Tags vollständig nativ unterstützt.
+- **Methoden- & JSX-Aufrufer:** `intl.formatMessage({ id: 'a.b' })` und `<FormattedMessage id="a.b">` werden durch die Intlayer-Compiler-Plugins (`@intlayer/babel` / `@intlayer/swc`) identifiziert, wobei flache, gepunktete Schlüssel so konvertiert werden, dass das erste Segment korrekt zum Intlayer-Wörterbuchschlüssel aufgelöst wird.
+- **Formatter:** `<FormattedNumber>`, `<FormattedDate>` etc. überbrücken zu den nativen `core/formatters` mithilfe von `Intl`.

package/docs/de/compat/svelte-i18n.md

@@ -0,0 +1,47 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migration von Svelte I18n zu Intlayer"
+description: "Erfahren Sie, wie Sie Ihre Svelte-Anwendung von svelte-i18n zu Intlayer mithilfe des Compat-Adapters migrieren."
+keywords:
+  - svelte-i18n
+  - svelte
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - svelte-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Verlauf initialisiert"
+author: aymericzip
+---
+
+# Migration von Svelte I18n zu Intlayer
+
+Das Verschieben Ihrer Svelte-Anwendung von `svelte-i18n` zu Intlayer dauert mit dem Compat-Adapter nur einen Moment.
+
+## Was zu tun ist
+
+Führen Sie einfach den Initialisierungsbefehl in Ihrem Projekt aus:
+
+```bash
+npx intlayer init
+```
+
+Dadurch wird `intlayer.config.ts` generiert. Stellen Sie sicher, dass Ihre SvelteKit/Vite-Plugins mit Intlayers Alias-Plugin umhüllt sind, um `svelte-i18n` nahtlos auf `@intlayer/svelte-i18n` abzubilden.
+
+## Was im Hintergrund geschieht
+
+Svelte-i18n basiert auf häufig verwendeten Stores (`$_`, `$t`, `$format` etc.) und ICU MessageFormat.
+
+Im Hintergrund:
+
+- **Stores:** Intlayer proxyt die `svelte-i18n`-Stores. `$_` wird zu einem abgeleiteten Store der aktuellen Locale, der einen Intlayer-Resolver zurückgibt.
+- **Schlüssel:** Ihre flachen Schlüssel (z.B. `$_('home.title')`) werden so ausgewertet, dass das erste Pfadsegment das Intlayer-Wörterbuch repräsentiert.
+- **ICU-Syntax:** Vollständig durch den gemeinsamen ICU-Resolver behandelt (äquivalentes `intl-messageformat`-Parsing).
+- **Formatter:** `$date`-, `$time`- und `$number`-Aufrufe leiten sicher zu Intlayers nativen Kern-Formatierern weiter.
+- **Babel/SWC-Analyse:** Der Intlayer-Analyzer liest die Svelte-Store-Aufrufer (`$_`) in Ihren `.svelte`-Quelldateien vor der Kompilierung, um automatisch die relevanten Wörterbuch-Chunks zu erstellen.

package/docs/de/compat/transloco.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migration von Transloco zu Intlayer"
+description: "Erfahren Sie, wie Sie Ihre Angular-Anwendung von Transloco zu Intlayer mithilfe des Compat-Adapters migrieren."
+keywords:
+  - transloco
+  - angular
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - transloco
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Verlauf initialisiert"
+author: aymericzip
+---
+
+# Migration von Transloco zu Intlayer
+
+Wenn Ihre Angular-Anwendung derzeit `@jsverse/transloco` verwendet, können Sie mit unserem Compat-Adapter zu Intlayer migrieren. Dieser Übergang ermöglicht es Ihnen, Ihre bestehende Template-Syntax beizubehalten und gleichzeitig die leistungsstarke Wörterbuchstruktur von Intlayer zu nutzen.
+
+## Was zu tun ist
+
+Führen Sie einfach den Initialisierungsbefehl in Ihrem Projekt aus:
+
+```bash
+npx intlayer init
+```
+
+Dadurch wird die erforderliche `intlayer.config.ts`-Konfiguration generiert. Sie ersetzen dann Ihre Transloco-Imports durch `@intlayer/transloco`-Module oder verlassen sich auf die Build-Aliase.
+
+## Was im Hintergrund geschieht
+
+Transloco verwendet Scopes und einen `TranslocoService` (`translate`, `selectTranslate`) neben strukturellen Direktiven (`*transloco="let t"`) und Pipes (`| transloco`).
+
+Im Hintergrund:
+
+- **Scopes:** Ordnen sich natürlich den Intlayer-Wörterbuchschlüsseln zu und bieten eine hervorragende Bereinigungsgeschichte für die Bundle-Optimierung.
+- **Service & Direktiven:** Der Angular-Adapter von Intlayer ersetzt die Provider nahtlos und ermöglicht es Ihren bestehenden Template-Pipes und -Direktiven, Zeichenketten gegen Intlayer-Wörterbücher aufzulösen.
+- **Build-Zeit-Parsing:** Der TypeScript-Analyzer erkennt `instant/get`-Aufrufe, und Fallback-Bereinigung gewährleistet Korrektheit auch dann, wenn die Template-Nutzung nicht statisch verfolgbar ist.

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

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migration von Vue I18n zu Intlayer"
+description: "Erfahren Sie, wie Sie Ihre Vue-Anwendung von vue-i18n zu Intlayer mithilfe des Compat-Adapters migrieren."
+keywords:
+  - vue-i18n
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - vue-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Verlauf initialisiert"
+author: aymericzip
+---
+
+# Migration von Vue I18n zu Intlayer
+
+Wenn Ihre Vue-Anwendung derzeit `vue-i18n` verwendet, können Sie zu Intlayer migrieren, ohne Ihre Komponenten umzuschreiben oder Hooks zu übersetzen. Intlayer bietet einen Compat-Adapter, der die API von `vue-i18n` perfekt spiegelt und dabei die leistungsstarken Funktionen von Intlayer im Hintergrund nutzt.
+
+## Was zu tun ist
+
+Um zu beginnen, führen Sie einfach den Initialisierungsbefehl in Ihrem Projekt aus:
+
+```bash
+npx intlayer init
+```
+
+Während der Initialisierung richtet Intlayer Ihre Konfigurationsdatei (`intlayer.config.ts`) ein und bereitet Ihr Projekt für die Migration vor. Sie müssen lediglich das Intlayer-Plugin zu Ihrer Vite-Konfiguration hinzufügen, um die `vue-i18n`-Imports automatisch zu aliasieren.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vue(), vueI18nVitePlugin()],
+});
+```
+
+## Was im Hintergrund geschieht
+
+Das `vueI18nVitePlugin` injiziert einen Modul-Alias in Ihren Bundler. Jeder Import von `vue-i18n` in Ihrem Codebase wird transparent zu `@intlayer/vue-i18n` weitergeleitet.
+
+**Im Hintergrund behandelt der Adapter die komplexe `vue-i18n`-Syntax nativ:**
+
+- **Interpolation & Plurale:** Löst `{name}`- und Listen-`{0}`-Interpolationen auf. Pipe-Plurale (`"car | cars"`) werden basierend auf positionaler Semantik in Intlayer-Enumerations-/Plural-Knoten umgewandelt.
+- **Formate:** Funktionen wie `d()` und `n()` umhüllen `Intl` im Hintergrund und berücksichtigen die in Ihren Optionen definierten `datetimeFormats` und `numberFormats`.
+- **Globaler & lokaler Zustand:** `global.locale` wird einem `WritableComputedRef` zugeordnet, das vom Intlayer-Client unterstützt wird, sodass sich die Reaktivität genau wie erwartet verhält (z.B. `locale.value = 'fr'`).
+- **Direktiven:** Die `v-t`-Direktive ist registriert und funktioniert normal.
+
+Ihre Anwendung rendert weiterhin genau wie zuvor, aber der Inhalt wird von Ihren Intlayer-Wörterbüchern bereitgestellt, was Ihnen Typsicherheit, bessere Bundle-Optimierung und nahtlose CMS-Integration bietet.

package/docs/de/compiler.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-09
-updatedAt: 2026-03-12
+updatedAt: 2026-06-23
 title: Intlayer Compiler | Automatisierte Inhaltsextraktion für i18n
 description: Automatisieren Sie Ihren Internationalisierungsprozess mit dem Intlayer Compiler. Extrahieren Sie Inhalte direkt aus Ihren Komponenten für schnellere und effizientere i18n in Vite, Next.js und mehr.
 keywords:
@@ -60,6 +60,8 @@ Als Alternative, um Ihren i18n-Prozess zu automatisieren und gleichzeitig die vo
 
 ## Verwendung
 
+> The quickest way to wire the compiler in is the interactive setup: run `npx intlayer init --interactive` and select **Compiler**. On Vite there is nothing to configure — the compiler is plugged in directly through the `intlayerCompiler()` plugin. On Next.js the command scaffolds the `babel.config.js` shown below. The non-interactive `intlayer init` leaves the compiler setup untouched.
+
 <Tabs>
  <Tab value='vite'>
 

package/docs/de/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-06-17
+updatedAt: 2026-06-23
 title: Konfiguration (Configuration)
 description: Erfahren Sie, wie Sie Intlayer für Ihre Anwendung konfigurieren. Verstehen Sie die verschiedenen Einstellungen und Optionen, um Intlayer an Ihre Bedürfnisse anzupassen.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.0.0
+    date: 2026-06-24
+    changes: "Add `enableProxy` option to the routing configuration"
   - version: 8.10.0
     date: 2026-06-17
     changes: "Option `format` zur Wörterbuchkonfiguration hinzugefügt"
@@ -885,6 +888,21 @@ Einstellungen für die Inhaltsbehandlung in der Anwendung, einschließlich Verze
 
 ---
 
+### Systemkonfiguration
+
+Einstellungen für interne Pfade und Ausgabeergebnisse von Intlayer. Diese Einstellungen sind typischerweise intern und sollten normalerweise vom Benutzer nicht geändert werden.
+
+| Field                     | Description                                                                               | Type     | Default                           | Example              | Note                                                                 |
+| ------------------------- | ----------------------------------------------------------------------------------------- | -------- | --------------------------------- | -------------------- | -------------------------------------------------------------------- |
+| `baseDir`                 | Das Basisverzeichnis für das Projekt.                                                     | `string` | `process.cwd()`                   | `'/path/to/project'` | Wird verwendet, um alle Intlayer-bezogenen Verzeichnisse aufzulösen. |
+| `dictionariesDir`         | Der Verzeichnispfad zum Speichern von Lokalisierungswörterbüchern.                        | `string` | `'.intlayer/dictionary'`          |                      |                                                                      |
+| `moduleAugmentationDir`   | Verzeichnis für Modul-Augmentation, das bessere IDE-Vorschläge und Typprüfung ermöglicht. | `string` | `'.intlayer/types'`               | `'intlayer-types'`   | Stellen Sie sicher, dass dies in `tsconfig.json` enthalten ist.      |
+| `unmergedDictionariesDir` | Das Verzeichnis zum Speichern von nicht zusammengeführten Wörterbüchern.                  | `string` | `'.intlayer/unmerged_dictionary'` |                      |                                                                      |
+| `typesDir`                | Das Verzeichnis zum Speichern von Wörterbuchtypen.                                        | `string` | `'.intlayer/types'`               |                      |                                                                      |
+| `mainDir`                 | Das Verzeichnis, in dem die Hauptanwendungsdateien gespeichert sind.                      | `string` | `'.intlayer/main'`                |                      |                                                                      |
+| `configDir`               | Das Verzeichnis, in dem Konfigurationsdateien gespeichert sind.                           | `string` | `'.intlayer/config'`              |                      |                                                                      |
+| `cacheDir`                | Das Verzeichnis, in dem Cache-Dateien gespeichert sind.                                   | `string` | `'.intlayer/cache'`               |                      |                                                                      |
+
 ### Wörterbuchkonfiguration
 
 Einstellungen, die Wörterbuchoperationen steuern, einschließlich automatischem Ausfüllverhalten und Inhaltsgenerierung.
@@ -993,22 +1011,6 @@ Die Build-Optionen gelten für die Plugins `@intlayer/babel` und `@intlayer/swc`
 
 ---
 
-### Systemkonfiguration
-
-Diese Einstellungen sind für fortgeschrittene Anwendungsfälle und die interne Konfiguration von Intlayer gedacht.
-
-| Feld                      | Beschreibung                                         | Typ      | Standard                          | Beispiel | Hinweis |
-| ------------------------- | ---------------------------------------------------- | -------- | --------------------------------- | -------- | ------- |
-| `dictionariesDir`         | Verzeichnis für kompilierte Wörterbücher.            | `string` | `'.intlayer/dictionary'`          |          |         |
-| `moduleAugmentationDir`   | Verzeichnis für die TypeScript-Modul-Augmentierung.  | `string` | `'.intlayer/types'`               |          |         |
-| `unmergedDictionariesDir` | Verzeichnis für nicht zusammengeführte Wörterbücher. | `string` | `'.intlayer/unmerged_dictionary'` |          |         |
-| `typesDir`                | Verzeichnis für generierte Typen.                    | `string` | `'.intlayer/types'`               |          |         |
-| `mainDir`                 | Verzeichnis für die Intlayer-Hauptdatei.             | `string` | `'.intlayer/main'`                |          |         |
-| `configDir`               | Verzeichnis für kompilierte Konfigurationsdateien.   | `string` | `'.intlayer/config'`              |          |         |
-| `cacheDir`                | Verzeichnis für Cache-Dateien.                       | `string` | `'.intlayer/cache'`               |          |         |
-
----
-
 ### Compiler-Konfiguration
 
 Einstellungen, die den Intlayer-Compiler steuern, der Wörterbücher direkt aus Ihren Komponenten extrahiert.

package/docs/de/custom_domains.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-04-02
-updatedAt: 2026-04-02
+updatedAt: 2026-06-23
 title: Eigene Domains
 description: Erfahren Sie, wie Sie das domänenbasierte Locale-Routing in Intlayer konfigurieren, um verschiedene Locales über dedizierte Hostnamen bereitzustellen.
 keywords:

package/docs/de/custom_url_rewrites.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-01-26
+updatedAt: 2026-06-23
 title: Benutzerdefinierte URL Rewrites
 description: Erfahren Sie, wie Sie in Intlayer benutzerdefinierte URL Rewrites konfigurieren und verwenden, um locale-spezifische Pfade zu definieren.
 keywords:

package/docs/de/dictionary/content_file.md

@@ -582,6 +582,10 @@ JSON-Schema zur Validierung der Wörterbuchstruktur. Wird automatisch von Intlay
 
 Für entfernte Wörterbücher ist dies die eindeutige Kennung des Wörterbuchs auf dem entfernten Server. Wird zum Abrufen und Verwalten von entfernten Inhalten verwendet.
 
+##### `projectIds` (string[])
+
+For remote dictionaries, this array contains the IDs of the projects that can use this dictionary. A remote dictionary can be shared between multiple projects.
+
 ##### `localId` (LocalDictionaryId)
 
 Eindeutige Kennung für lokale Wörterbücher. Wird automatisch von Intlayer generiert, um das Wörterbuch zu identifizieren und festzustellen, ob es lokal oder entfernt ist, sowie dessen Standort.

package/docs/de/dictionary/enumeration.md

@@ -452,205 +452,6 @@ document.getElementById("cars")!.textContent = content.numberOfCar(6);
   </Tab>
 </Tabs>
 
-## Zusätzliche Ressourcen
-
-Für detailliertere Informationen zur Konfiguration und Nutzung verweisen wir auf die folgenden Ressourcen:
-
-- [Intlayer CLI Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/index.md)
-- [React Intlayer Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_create_react_app.md)
-- [Next Intlayer Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_with_nextjs_15.md)
-
-Diese Ressourcen bieten weitere Einblicke in die Einrichtung und Nutzung von Intlayer in verschiedenen Umgebungen und mit unterschiedlichen Frameworks.
-
-### Using Ordinal Enumeration
-
-<Tabs group="framework">
-  <Tab label="React" value="react">
-
-To use this in a React component, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const RankingComponent: FC<{ count: number }> = ({ count }) => {
-  const { ordinal } = useIntlayer("ranking_component");
-
-  // Get the last digit to determine the correct suffix
-  const lastDigit = Math.abs(count) % 10;
-
-  return (
-    <div>
-      <p>
-        {
-          ordinal(lastDigit)({ count }) // e.g., "5th place" for count=5
-        }
-      </p>
-    </div>
-  );
-};
-```
-
-  </Tab>
-  <Tab label="Next.js" value="nextjs">
-
-To use this in Next.js Client Components, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-"use client";
-
-import type { FC } from "react";
-import { useIntlayer } from "next-intlayer";
-
-const RankingComponent: FC<{ count: number }> = ({ count }) => {
-  const { ordinal } = useIntlayer("ranking_component");
-  const lastDigit = Math.abs(count) % 10;
-
-  return (
-    <div>
-      <p>{ordinal(lastDigit)({ count })}</p>
-    </div>
-  );
-};
-
-export default RankingComponent;
-```
-
-  </Tab>
-  <Tab label="Vue" value="vue">
-
-To use this in Vue components, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```vue fileName="**/*.vue"
-<script setup lang="ts">
-import { useIntlayer } from "vue-intlayer";
-
-defineProps<{ count: number }>();
-
-const { ordinal } = useIntlayer("ranking_component");
-</script>
-
-<template>
-  <div>
-    <p>{{ ordinal(Math.abs(count) % 10)({ count }) }}</p>
-  </div>
-</template>
-```
-
-  </Tab>
-  <Tab label="Svelte" value="svelte">
-
-To use this in Svelte components, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```svelte fileName="**/*.svelte"
-<script lang="ts">
-import { useIntlayer } from "svelte-intlayer";
-
-export let count: number;
-
-const content = useIntlayer("ranking_component");
-$: lastDigit = Math.abs(count) % 10;
-</script>
-
-<div>
-  <p>{$content.ordinal(lastDigit)({ count })}</p>
-</div>
-```
-
-  </Tab>
-  <Tab label="Preact" value="preact">
-
-To use this in Preact components, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "preact";
-import { useIntlayer } from "preact-intlayer";
-
-const RankingComponent: FC<{ count: number }> = ({ count }) => {
-  const { ordinal } = useIntlayer("ranking_component");
-  const lastDigit = Math.abs(count) % 10;
-
-  return (
-    <div>
-      <p>{ordinal(lastDigit)({ count })}</p>
-    </div>
-  );
-};
-
-export default RankingComponent;
-```
-
-  </Tab>
-  <Tab label="Solid" value="solid">
-
-To use this in SolidJS components, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { Component } from "solid-js";
-import { useIntlayer } from "solid-intlayer";
-
-const RankingComponent: Component<{ count: number }> = (props) => {
-  const { ordinal } = useIntlayer("ranking_component");
-
-  return (
-    <div>
-      <p>{ordinal(Math.abs(props.count) % 10)({ count: props.count })}</p>
-    </div>
-  );
-};
-
-export default RankingComponent;
-```
-
-  </Tab>
-  <Tab label="Angular" value="angular">
-
-To use this in Angular components, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```typescript fileName="app.component.ts" codeFormat="typescript"
-import { Component, Input } from "@angular/core";
-import { useIntlayer } from "angular-intlayer";
-
-@Component({
-  selector: "app-ranking",
-  template: `
-    <div>
-      <p>{{ content().ordinal(lastDigit())({ count }) }}</p>
-    </div>
-  `,
-})
-export class RankingComponent {
-  @Input() count!: number;
-
-  content = useIntlayer("ranking_component");
-
-  lastDigit() {
-    return Math.abs(this.count) % 10;
-  }
-}
-```
-
-  </Tab>
-  <Tab label="Vanilla JS" value="vanilla">
-
-To use this with `vanilla-intlayer`, call the enumeration with the last digit of the number to get the correct suffix, then pass the full count as the insertion value:
-
-```typescript fileName="**/*.ts" codeFormat={["typescript", "esm"]}
-import { installIntlayer, useIntlayer } from "vanilla-intlayer";
-
-installIntlayer();
-
-const content = useIntlayer("ranking_component");
-const lastDigit = Math.abs(5) % 10;
-
-document.getElementById("ranking")!.textContent = content.ordinal(lastDigit)({
-  count: 5,
-});
-```
-
-  </Tab>
-</Tabs>
-
 ## Combining Enumeration with Insert for Ordinal Numbers
 
 A common use case is displaying ordinal numbers (1st, 2nd, 3rd, etc.). You can combine `enu` with `insert` to create dynamic ordinal content:

package/docs/de/dictionary/file.md

@@ -255,6 +255,14 @@ export default myMultilingualContent;
 
 Diese Einrichtung ermöglicht es, den Inhalt dynamisch basierend auf der Sprachpräferenz des Benutzers abzurufen. Wenn sie im Intlayer Visual Editor oder CMS verwendet wird, erkennt das System, dass der Inhalt aus den angegebenen Markdown-Dateien stammt und stellt sicher, dass diese weiterhin bearbeitbar bleiben.
 
+## Verschiedene Arten von Pfaden
+
+Bei Verwendung der `file`-Funktion können Sie verschiedene Arten von Pfaden verwenden, um die einzubettende Datei anzugeben.
+
+- `file("./path/to/file.txt")` - Relativer Pfad zur aktuellen Datei
+- `file("path/to/file.txt")` - Relativer Pfad zum Projektroot-Verzeichnis
+- `file("/users/username/path/to/file.txt")` - Absoluter Pfad
+
 ## Wie Intlayer mit Datei-Inhalten umgeht
 
 Die `file`-Funktion basiert auf dem `fs`-Modul von Node.js, um den Inhalt der angegebenen Datei zu lesen und in das Wörterbuch einzufügen. Wenn sie in Verbindung mit dem Intlayer Visual Editor oder CMS verwendet wird, kann Intlayer die Beziehung zwischen dem Wörterbuch und der Datei verfolgen. Dies ermöglicht Intlayer:

package/docs/de/dictionary/insertion.md

@@ -114,10 +114,6 @@ Um Einfügeinhalt in Ihrem Intlayer-Projekt einzurichten, erstellen Sie ein Inha
 }
 ```
 
-## Verwendung von Insertion Content mit React Intlayer
-
-markdown
-
 ## Verwendung von Einfügeinhalten mit React Intlayer
 
 Um Einfügeinhalte innerhalb einer React-Komponente zu verwenden, importieren Sie den `useIntlayer`-Hook aus dem `react-intlayer`-Paket und verwenden ihn. Dieser Hook ruft den Inhalt für den angegebenen Schlüssel ab und ermöglicht es Ihnen, ein Objekt zu übergeben, das jeden Platzhalter in Ihrem Inhalt auf den Wert abbildet, den Sie anzeigen möchten.

package/docs/de/dictionary/nesting.md

@@ -25,6 +25,45 @@ author: aymericzip
 
 In Intlayer wird die Verschachtelung durch die Funktion `nest` erreicht, die es Ihnen ermöglicht, Inhalte aus einem anderen Wörterbuch zu referenzieren und wiederzuverwenden. Anstatt Inhalte zu duplizieren, können Sie auf ein bestehendes Inhaltsmodul mit seinem Schlüssel verweisen.
 
+## Nesting einrichten
+
+Um Nesting in Ihrem Intlayer-Projekt einzurichten, definieren Sie zunächst den Basisinhalt, den Sie wiederverwenden möchten. Dann verwenden Sie in einem separaten Content-Modul die Funktion `nest`, um diesen Inhalt zu importieren.
+
+### Basis-Dictionary
+
+Nachfolgend ist ein Beispiel eines Basis-Dictionary zum Verschachteln in einem anderen Dictionary:
+
+```typescript fileName="firstDictionary.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { type Dictionary } from "intlayer";
+
+const firstDictionary = {
+  key: "key_of_my_first_dictionary",
+  content: {
+    content: "content",
+    subContent: {
+      contentNumber: 0,
+      contentString: "string",
+    },
+  },
+} satisfies Dictionary;
+
+export default firstDictionary;
+```
+
+```json fileName="firstDictionary.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "key_of_my_first_dictionary",
+  "content": {
+    "content": "content",
+    "subContent": {
+      "contentNumber": 0,
+      "contentString": "string"
+    }
+  }
+}
+```
+
 ## Einrichtung der Verschachtelung
 
 <Tabs group="framework">

package/docs/de/dictionary/translation.md

@@ -259,64 +259,3 @@ document.getElementById("welcome-message")!.textContent = String(
 
   </Tab>
 </Tabs>
-
-## Benutzerdefinierte Inhaltsobjekte
-
-`intlayer` unterstützt benutzerdefinierte Inhaltsobjekte für Übersetzungen, die es Ihnen ermöglichen, komplexere Strukturen zu definieren und dabei die Typensicherheit zu gewährleisten. Hier ist ein Beispiel mit einem benutzerdefinierten Objekt:
-
-```typescript fileName="**/*.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
-import { t, type Dictionary } from "intlayer";
-
-interface ICustomContent {
-  title: string;
-  content: string;
-}
-
-const customContent = {
-  key: "custom_content",
-  content: {
-    profileText: t<ICustomContent>({
-      en: {
-        title: "Seitentitel",
-        content: "Seiteninhalt",
-      },
-      fr: {
-        title: "Titre de la Page",
-        content: "Contenu de la Page",
-      },
-      es: {
-        title: "Título de la Página",
-        content: "Contenido de la Página",
-      },
-    }),
-  },
-} satisfies Dictionary;
-
-export default customContent;
-```
-
-```json fileName="**/*.content.json" contentDeclarationFormat="json"
-{
-  "$schema": "https://intlayer.org/schema.json",
-  "key": "custom_content",
-  "content": {
-    "profileText": {
-      "nodeType": "translation",
-      "translation": {
-        "en": {
-          "title": "Seitentitel",
-          "content": "Seiteninhalt"
-        },
-        "fr": {
-          "title": "Seitentitel",
-          "content": "Seiteninhalt"
-        },
-        "es": {
-          "title": "Seitentitel",
-          "content": "Seiteninhalt"
-        }
-      }
-    }
-  }
-}
-```