@intlayer/docs 9.5.6 → 9.5.8

package/docs/de/cli/infra.md

@@ -0,0 +1,162 @@
+---
+createdAt: 2026-09-21
+updatedAt: 2026-09-21
+title: CLI - Init Infra
+description: Erfahren Sie, wie Sie mit dem Intlayer CLI init infra-Befehl die Desktop-App installieren oder das Intlayer CMS mit Docker (All-in-One-Container oder Docker Compose-Stack) selbst hosten.
+keywords:
+  - CLI
+  - Infrastruktur
+  - Self-Hosting
+  - Desktop-App
+  - Docker
+  - Docker Compose
+  - CMS
+  - Intlayer
+slugs:
+  - doc
+  - concept
+  - cli
+  - infra
+history:
+  - version: 9.5.6
+    date: 2026-09-21
+    changes: "Befehl init infra hinzufügen"
+author: aymericzip
+---
+
+# Intlayer CLI Init Infra Befehl
+
+## Beschreibung
+
+Der Befehl `init infra` richtet die Intlayer-Infrastruktur auf Ihrem Computer ein. Er lädt das gehostete Installationsprogramm für Ihre Plattform herunter (`https://intlayer.org/install.sh` unter macOS / Linux, `https://intlayer.org/install.ps1` unter Windows) und führt es im Terminal aus, sodass das Menü und die Fortschrittsausgabe unverändert angezeigt werden.
+
+Das Installationsprogramm fragt, wie Sie Intlayer ausführen möchten:
+
+- **Desktop-App**: Lädt das native Dashboard für Ihr Betriebssystem und Ihre CPU herunter und öffnet oder installiert es. Die Desktop-Version verbindet sich mit dem Intlayer Cloud-Backend.
+- **All-in-One Docker**: Dashboard + API + MongoDB + Redis + MinIO in einem einzigen Container mit einem Volume. Schreibt `./intlayer.env` mit generierten Secrets und lädt das Image `intlayer/cms-all` herunter.
+- **Docker Compose**: Ein Container pro Dienst für skalierbares Self-Hosting. Schreibt `docker-compose.yml` und `.env` nach `./intlayer/` und lädt die Images herunter.
+
+Das gehostete Installationsprogramm ist die zentrale Referenz für den Einrichtungsprozess: Die CLI führt es aus, anstatt die Schritte neu zu implementieren, sodass `npx intlayer init infra` und `curl -fsSL https://intlayer.org/install.sh | sh` genau dasselbe tun.
+
+## Verwendung
+
+```bash packageManager="npm"
+npx intlayer init infra [options]
+```
+
+```bash packageManager="yarn"
+yarn intlayer init infra [options]
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer init infra [options]
+```
+
+```bash packageManager="bun"
+bun x intlayer init infra [options]
+```
+
+Derselbe Schritt wird auch in der Checkliste von `npx intlayer init --interactive` unter **Infrastruktur (Desktop-App / Self-Hosting)** angeboten.
+
+## Optionen
+
+- `-m, --mode <mode>` - Optional. Überspringt das Menü und führt einen Modus direkt aus. Zulässige Werte: `desktop`, `docker` (All-in-One) oder `compose`. Jeder andere Wert wird mit einer Fehlermeldung beendet.
+
+## Beispiele
+
+### Modus interaktiv auswählen
+
+```bash
+npx intlayer init infra
+```
+
+### Desktop-App installieren
+
+```bash
+npx intlayer init infra --mode desktop
+```
+
+### Self-Hosting mit dem All-in-One-Container
+
+```bash
+npx intlayer init infra --mode docker
+```
+
+### Self-Hosting mit Docker Compose
+
+```bash
+npx intlayer init infra --mode compose
+```
+
+## Beispielausgabe
+
+```bash
+npx intlayer init infra --mode compose
+◇  Installer downloaded
+▸ Fetching docker-compose.yml into ./intlayer
+▸ Writing ./intlayer/.env
+▸ Pulling images
+
+  Everything is installed. Two steps left.
+
+  1. Configure a mailer in:
+
+       ./intlayer/.env
+
+     Either RESEND_API_KEY (resend.com) or the MAIL_SMTP_* block — the first
+     account cannot be verified without a working mailer.
+  2. Start the stack:
+
+       cd ./intlayer && docker compose up -d
+
+  Then open http://localhost:3000 — first boot initialises the
+  datastores, so give it a minute. The first account you create becomes the
+  super admin.
+
+    Logs      docker compose logs -f
+    Stop      docker compose down
+    Upgrade   docker compose pull && docker compose up -d
+```
+
+## Installationsprogramm-Einstellungen
+
+Das Installationsprogramm liest einige Umgebungsvariablen, die die CLI unverändert weitergibt. Setzen Sie diese vor dem Ausführen in der Shell:
+
+```bash
+INTLAYER_COMPOSE_DIR=./cms npx intlayer init infra --mode compose
+```
+
+| Variable                  | Standard                  | Gilt für | Beschreibung                                                    |
+| ------------------------- | ------------------------- | -------- | --------------------------------------------------------------- |
+| `INTLAYER_MODE`           | _(gefragt)_               | alle     | `desktop`, `docker` oder `compose`, entspricht `--mode`         |
+| `INTLAYER_DOWNLOAD_DIR`   | `~/Downloads`             | desktop  | Speicherort für das Installationsprogramm der App               |
+| `INTLAYER_IMAGE`          | `intlayer/cms-all:latest` | docker   | All-in-One-Image zum Herunterladen                              |
+| `INTLAYER_ENV_FILE`       | `./intlayer.env`          | docker   | Speicherort für die Umgebungsdatei                              |
+| `INTLAYER_CONTAINER_NAME` | `intlayer`                | docker   | Containername                                                   |
+| `INTLAYER_DATA_VOLUME`    | `intlayer-data`           | docker   | Benanntes Volume gemountet unter `/data`                        |
+| `INTLAYER_APP_PORT`       | `3000`                    | docker   | Host-Port für das Dashboard                                     |
+| `INTLAYER_API_PORT`       | `3100`                    | docker   | Host-Port für die API                                           |
+| `INTLAYER_S3_PORT`        | `9000`                    | docker   | Host-Port für die MinIO S3-API                                  |
+| `INTLAYER_CONSOLE_PORT`   | `9001`                    | docker   | Host-Port für die MinIO-Konsole                                 |
+| `INTLAYER_COMPOSE_DIR`    | `./intlayer`              | compose  | Speicherort für `docker-compose.yml` und `.env`                 |
+| `INTLAYER_SELFHOST_REF`   | `main`                    | beide    | Git-Ref, von der die Compose-Datei und Vorlage abgerufen werden |
+
+> Die Portvariablen ändern nur die **Host**-Seite des Mappings. Die veröffentlichten Images haben `http://localhost:3000`, `http://localhost:3100` und `http://localhost:9000` im Bundle kompiliert. Behalten Sie die Standardwerte bei, es sei denn, Sie erstellen eigene Images: siehe den [Self-Hosting-Leitfaden](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/self_hosting.md#limitations).
+
+## Anforderungen
+
+- **Desktop-App** benötigt [Node.js](https://nodejs.org): Die App bettet den Dashboard-Server ein und startet ihn mit der maschineneigenen `node`-Binärdatei.
+- **Docker-Modi** benötigen [Docker](https://docs.docker.com/get-docker/) (Docker Desktop mit WSL 2-Backend unter Windows). Der Compose-Modus benötigt zusätzlich das `docker compose`-Plugin.
+
+## Hinweise
+
+- Das erneute Ausführen des Befehls ist sicher: Eine vorhandene Umgebungsdatei wird nie überschrieben, was auch als Upgrade-Pfad dient (neue Images werden geladen, Secrets bleiben erhalten).
+- Das Installationsprogramm wird in ein temporäres Verzeichnis heruntergeladen und nach dem Beenden gelöscht.
+- Der Exit-Code des Befehls entspricht dem des Installationsprogramms. Schlägt der Download fehl, gibt die CLI den entsprechenden `curl … | sh` bzw. `irm … | iex`-Befehl aus.
+- Die Docker-Modi benötigen einen Mailer für Anmelde-E-Mails. Konfigurieren Sie nach Abschluss Resend oder SMTP in der erstellten Umgebungsdatei: siehe [Globaler Mailer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/self_hosting.md#global-mailer).
+
+## Verwandt
+
+- [Self-Hosting-Leitfaden](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/self_hosting.md) - Architektur, erste Schritte und Einschränkungen jedes Modus
+- [Intlayer initialisieren](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/init.md) - Der übergeordnete `init`-Befehl und seine interaktive Checkliste
+- [Intlayer CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/intlayer_CMS.md) - Funktionen des installierten Dashboards

package/docs/de/cli/init.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-12-30
-updatedAt: 2025-12-30
+updatedAt: 2026-09-21
 title: Intlayer initialisieren
 description: Erfahren Sie, wie Sie Intlayer in Ihrem Projekt initialisieren.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - cli
   - init
 history:
+  - version: 9.5.6
+    date: 2026-09-21
+    changes: "Unterbefehl init infra hinzufügen"
   - version: 7.5.9
     date: 2025-12-30
     changes: "Init-Befehl hinzugefügt"
@@ -121,6 +124,26 @@ bun x intlayer init --no-gitignore
 
 Dies richtet alle Konfigurationsdateien ein, ohne Ihre `.gitignore` zu ändern.
 
+### Infrastruktur einrichten (Desktop-App oder Self-Hosting):
+
+```bash
+npx intlayer init infra
+```
+
+Lädt das gehostete Installationsprogramm (`https://intlayer.org/install.sh` bzw. `install.ps1` unter Windows) herunter und führt es aus, welches fragt, wie Sie Intlayer ausführen möchten:
+
+- **Desktop-App** - installiert das native Dashboard auf Ihrem Computer, verbunden mit der Intlayer Cloud.
+- **All-in-One Docker** - Dashboard + API + MongoDB + Redis + MinIO in einem einzigen Container.
+- **Docker Compose** - ein Container pro Dienst für skalierbares Self-Hosting.
+
+Überspringen Sie das Menü mit `--mode`:
+
+```bash
+npx intlayer init infra --mode compose
+```
+
+Derselbe Schritt wird auch von `npx intlayer init --interactive` angeboten. Siehe die [`init infra`-Referenz](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/cli/infra.md) für die Einstellungen des Installationsprogramms und den [Self-Hosting-Leitfaden](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/self_hosting.md) für die Details zu jedem Modus.
+
 ## Beispielausgabe:
 
 ```bash

package/docs/de/cli/upgrade.md

@@ -0,0 +1,125 @@
+---
+createdAt: 2026-09-23
+updatedAt: 2026-09-23
+title: CLI - Intlayer-Pakete aktualisieren
+description: Erfahren Sie, wie Sie mit dem Befehl upgrade des Intlayer-CLI alle Intlayer-Pakete Ihres Projekts oder Monorepos auflisten und auf die neueste Version aktualisieren.
+keywords:
+  - CLI
+  - Upgrade
+  - Update
+  - Pakete
+  - Monorepo
+  - Intlayer
+slugs:
+  - doc
+  - concept
+  - cli
+  - upgrade
+history:
+  - version: 9.5.8
+    date: 2026-09-23
+    changes: "Befehl upgrade hinzufügen"
+author: aymericzip
+---
+
+# Intlayer-Pakete aktualisieren
+
+```bash packageManager="npm"
+npx intlayer upgrade
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade
+```
+
+Der Befehl `upgrade` listet die in jeder `package.json` Ihres Projekts deklarierten Intlayer-Pakete auf, einschließlich Monorepo-Workspaces, und aktualisiert sie auf die neueste veröffentlichte Version. Er führt denselben Paketaktualisierungsschritt wie `intlayer init` eigenständig aus.
+
+## Argumente:
+
+- `--project-root [projectRoot]` - Optional. Das Projekt-Stammverzeichnis. Standardmäßig startet der Befehl von der nächstgelegenen `package.json` oberhalb des aktuellen Arbeitsverzeichnisses.
+- `--dry-run` - Optional. Listet die Pakete und ihre Zielversion auf, ohne Dateien zu ändern.
+- `--tag <tag>` - Optional. Das npm-dist-tag, auf das aktualisiert werden soll (zum Beispiel `canary`). Standardmäßig `latest`.
+
+## Funktionsweise:
+
+1. **Listet die Intlayer-Pakete auf** - Durchsucht jede `package.json` des Projekts (ignoriert `node_modules` und Build-Ausgaben) nach Abhängigkeiten und Dev-Abhängigkeiten wie `intlayer`, `@intlayer/*`, `*-intlayer` und `intlayer-*`.
+2. **Ruft die Zielversion ab** - Liest die Version des ausgewählten dist-tags (standardmäßig `latest`) jedes Pakets aus der npm-Registry.
+3. **Schreibt die Versionsbereiche neu** - Aktualisiert jeden veralteten Bereich direkt in der Datei unter Beibehaltung des Operators (`^`, `~` oder keiner) sowie der Dateieinrückung.
+4. **Einmalige Installation** - Führt eine einzelne Installation aus dem Workspace-Root aus (dem nächstgelegenen Verzeichnis mit einer Lock-Datei), unter Verwendung des Paketmanagers, dem die Lock-Datei gehört:
+
+| Lock-Datei                     | Befehl         |
+| ------------------------------ | -------------- |
+| `bun.lock` / `bun.lockb`       | `bun install`  |
+| `pnpm-lock.yaml`               | `pnpm install` |
+| `yarn.lock`                    | `yarn install` |
+| `package-lock.json` oder keine | `npm install`  |
+
+Wenn keine Lock-Datei vorhanden ist, wird das Feld `packageManager` der `package.json` (zum Beispiel `"bun@1.2.0"`) verwendet, bevor auf npm zurückgegriffen wird.
+
+Bereiche, die nicht auf die Registry verweisen, wie `workspace:*`, `file:`, `link:`, `catalog:` oder Git-URLs, werden niemals geändert.
+
+## Beispiele:
+
+### Verfügbare Upgrades auflisten, ohne sie anzuwenden:
+
+```bash packageManager="npm"
+npx intlayer upgrade --dry-run
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade --dry-run
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade --dry-run
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade --dry-run
+```
+
+### Auf das Canary-Release aktualisieren:
+
+```bash packageManager="npm"
+npx intlayer upgrade --tag canary
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade --tag canary
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade --tag canary
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade --tag canary
+```
+
+## Beispielausgabe:
+
+```bash
+npx intlayer upgrade
+Intlayer packages:
+  package.json
+    intlayer ^9.0.0 → ^9.5.7
+  apps/web/package.json
+    next-intlayer ^9.5.7 (latest)
+    vite-intlayer ~9.2.0 → ~9.5.7
+Running bun install...
+✓ Upgraded 2 Intlayer dependencies to latest
+```
+
+## Hinweise:
+
+- Führen Sie den Befehl im Stammverzeichnis Ihres Repositorys aus, um alle Workspaces zu aktualisieren. Führen Sie ihn in einem Workspace aus, um nur diesen Workspace zu aktualisieren.
+- Pakete, deren Version nicht abgerufen werden kann (offline, privates oder unveröffentlichtes Paket), werden aufgelistet und unverändert gelassen.
+- Schlägt die Installation fehl, bleiben die aktualisierten Bereiche in `package.json` erhalten. Führen Sie den Installationsbefehl Ihres Paketmanagers manuell aus.

package/docs/de/dictionary/html.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-01-20
-updatedAt: 2026-03-24
+updatedAt: 2026-09-21
 title: HTML-Inhalte
 description: Erfahren Sie, wie Sie HTML-Inhalte deklarieren und mit benutzerdefinierten Komponenten in Intlayer verwenden. Folgen Sie dieser Dokumentation, um reichhaltige HTML-ähnliche Inhalte mit dynamischem Komponentenersatz in Ihrem internationalisierten Projekt einzubetten.
 keywords:
@@ -13,6 +13,8 @@ keywords:
   - React
   - Vue
   - Svelte
+  - Remix
+  - Astro
 slugs:
   - doc
   - concept
@@ -235,6 +237,83 @@ Wenn Sie auf Inhalte über `useIntlayer` zugreifen, sind HTML-Knoten bereits fü
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    In Remix 3 werden HTML-Knoten zu einem HTML-String aufgelöst. Fügen Sie ihn mit der `innerHTML`-Prop von Remix JSX oder mit `html.raw` in einer `html-template`-Ansicht ein.
+
+    ```tsx fileName="src/views/home.tsx"
+    import { useIntlayer } from "remix-intlayer";
+
+    export const HomePage = () => () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return <div innerHTML={myHtmlContent.value} />;
+    };
+    ```
+
+    ```ts fileName="src/views/home.ts"
+    import { html } from "remix/html-template";
+    import { useIntlayer } from "remix-intlayer";
+
+    export const renderHomePage = () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return html.raw`<div>${myHtmlContent.value}</div>`;
+    };
+    ```
+
+    > Remix maskiert interpolierte Werte standardmäßig. `innerHTML` und `html.raw` sind die beiden Ausnahmen, die ein HTML-String benötigt.
+
+    Verwenden Sie die Methode `.use()`, um Tags zu überschreiben oder benutzerdefinierte Komponenten zuzuordnen. Überschreibungen sind Funktionen, die einen HTML-String zurückgeben:
+
+    ```tsx
+    <div
+      innerHTML={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    In Astro werden HTML-Knoten zu einem HTML-String aufgelöst. Fügen Sie ihn mit der `set:html`-Direktive im Template oder mit `innerHTML` in einem clientseitigen `<script>` ein.
+
+    ```astro fileName="src/pages/index.astro"
+    ---
+    import { useIntlayer } from "astro-intlayer";
+
+    const { myHtmlContent } = useIntlayer("app");
+    ---
+
+    <div set:html={myHtmlContent.value} />
+    ```
+
+    ```astro fileName="src/components/Content.astro"
+    <div id="content"></div>
+
+    <script>
+      import { useIntlayer } from "astro-intlayer";
+
+      const { myHtmlContent } = useIntlayer("app");
+
+      document.querySelector("#content")!.innerHTML = myHtmlContent.value;
+    </script>
+    ```
+
+    > Astro maskiert `{Ausdrücke}` standardmäßig. `set:html` ist die Ausnahme, die ein HTML-String benötigt.
+
+    Verwenden Sie die Methode `.use()`, um Tags zu überschreiben oder benutzerdefinierte Komponenten zuzuordnen. Überschreibungen sind Funktionen, die einen HTML-String zurückgeben:
+
+    ```astro
+    <div
+      set:html={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Globale Konfiguration mit `HTMLProvider`
@@ -470,6 +549,41 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     > Das dynamische Importieren Ihres HTML-Renderers ist eine gute Möglichkeit, die Bundle-Größe Ihrer Anwendung zu reduzieren.
 
   </Tab>
+  <Tab label="Remix" value="remix">
+
+    Remix verfügt über keinen Komponentenbaum, der einen Provider aufnehmen könnte, daher wird die Konfiguration einmalig als Singleton beim Serverstart installiert. Sie konfiguriert den von `useHTMLRenderer()` zurückgegebenen Renderer. Die von `useIntlayer` zurückgegebenen `html`-Knoten werden unverändert gerendert; überschreiben Sie deren Tags pro Knoten mit `.use()`.
+
+    ```typescript fileName="src/router.ts"
+    import { installIntlayerHTML } from "remix-intlayer/html";
+
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+    ```
+
+    > Verwenden Sie `installIntlayerHTMLDynamic(async () => …)`, um den Renderer selbst träge zu laden; der Loader wird nur beim ersten Aufruf ausgeführt.
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+
+    Astro verfügt über keinen Komponentenbaum, der einen Provider aufnehmen könnte, daher wird die Konfiguration einmalig als Singleton in der Middleware (Server) und in einem clientseitigen `<script>` (Browser) installiert. Sie konfiguriert den von `useHTMLRenderer()` zurückgegebenen Renderer. Die von `useIntlayer` zurückgegebenen `html`-Knoten werden unverändert gerendert; überschreiben Sie deren Tags pro Knoten mit `.use()`.
+
+    ```typescript fileName="src/middleware.ts"
+    import { installIntlayerHTML } from "astro-intlayer/html";
+    import { defineMiddleware } from "astro:middleware";
+
+    // Wird einmal beim Serverstart ausgeführt; die Intlayer-Middleware selbst wird
+    // vor dieser Datei durch die Integration registriert.
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+
+    export const onRequest = defineMiddleware((_context, next) => next());
+    ```
+
+    > Verwenden Sie `installIntlayerHTMLDynamic(async () => …)`, um den Renderer selbst träge zu laden; der Loader wird nur beim ersten Aufruf ausgeführt.
+
+  </Tab>
 </Tabs>
 
 ### Manuelles Rendering & Erweiterte Tools
@@ -642,15 +756,69 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    #### `useHTMLRenderer()` Hook
+
+    Holen Sie sich eine von `installIntlayerHTML()` vorkonfigurierte Renderer-Funktion. Sie gibt einen HTML-String zurück.
+
+    ```tsx
+    import { useHTMLRenderer } from "remix-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+
+    return <div innerHTML={renderHTML("<p>Hello <strong>World</strong></p>")} />;
+    ```
+
+    #### `renderHTML()` Utility
+
+    Eigenständiges Dienstprogramm, das die globale Konfiguration ignoriert.
+
+    ```tsx
+    import { renderHTML } from "remix-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    #### `useHTMLRenderer()` Hook
+
+    Holen Sie sich eine von `installIntlayerHTML()` vorkonfigurierte Renderer-Funktion. Sie gibt einen HTML-String zurück.
+
+    ```astro
+    ---
+    import { useHTMLRenderer } from "astro-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+    ---
+
+    <div set:html={renderHTML("<p>Hello <strong>World</strong></p>")} />
+    ```
+
+    #### `renderHTML()` Utility
+
+    Eigenständiges Dienstprogramm, das die globale Konfiguration ignoriert.
+
+    ```astro
+    ---
+    import { renderHTML } from "astro-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ---
+
+    <div set:html={html} />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Optionen-Referenz
 
 Diese Optionen können an `HTMLProvider`, `HTMLRenderer`, `useHTMLRenderer` und `renderHTML` übergeben werden.
 
-| Option       | Typ                   | Standard | Beschreibung                                                                                                                   |
-| :----------- | :-------------------- | :------- | :----------------------------------------------------------------------------------------------------------------------------- |
-| `components` | `Record<string, any>` | `{}`     | Eine Map von HTML-Tags oder benutzerdefinierten Komponentennamen zu Komponenten.                                               |
-| `renderHTML` | `Function`            | `null`   | Eine benutzerdefinierte Rendering-Funktion, um den Standard-HTML-Parser vollständig zu ersetzen (Nur für Vue/Svelte Provider). |
+| Option       | Typ                   | Standard | Beschreibung                                                                                                                             |
+| :----------- | :-------------------- | :------- | :--------------------------------------------------------------------------------------------------------------------------------------- |
+| `components` | `Record<string, any>` | `{}`     | Eine Map von HTML-Tags oder benutzerdefinierten Komponentennamen zu Komponenten.                                                         |
+| `renderHTML` | `Function`            | `null`   | Eine benutzerdefinierte Rendering-Funktion, um den Standard-HTML-Parser vollständig zu ersetzen (Vue, Svelte, Remix und Astro Provider). |
 
 > Hinweis: Für React und Preact werden Standard-HTML-Tags automatisch bereitgestellt. Sie müssen das `components`-Prop nur übergeben, wenn Sie sie überschreiben oder benutzerdefinierte Komponenten hinzufügen möchten.