@intlayer/docs 8.4.10 → 8.5.1

package/docs/de/compiler.md

@@ -208,7 +208,10 @@ const config: IntlayerConfig = {
 
     /**
      * Gibt an, ob die Komponenten nach der Transformation gespeichert werden sollen.
-     * Auf diese Weise kann der Compiler nur einmal ausgeführt werden, um die App zu transformieren, und dann entfernt werden.
+     *
+     * - Wenn `true`, schreibt der Compiler die Komponentendatei auf die Festplatte um. Die Transformation ist also dauerhaft und der Compiler überspringt die Transformation für den nächsten Prozess. Auf diese Weise kann der Compiler die App transformieren und anschließend entfernt werden.
+     *
+     * - Wenn `false`, fügt der Compiler den `useIntlayer()` Funktionsaufruf nur in den Code der Build-Ausgabe ein und lässt die Basis-Code-Basis intakt. Die Transformation erfolgt nur im Speicher.
      */
     saveComponents: false,
 
@@ -287,6 +290,8 @@ Die folgenden Eigenschaften können im Block `compiler` Ihrer Datei `intlayer.co
   - _Typ_: `boolean`
   - _Standard_: `false`
   - _Beschreibung_: Gibt an, ob die Komponenten nach der Transformation gespeichert werden sollen.
+    - Wenn `true`, schreibt der Compiler die Komponentendatei auf die Festplatte um. Die Transformation ist dauerhaft und der Compiler kann anschließend entfernt werden.
+    - Wenn `false`, fügt der Compiler den `useIntlayer()` Funktionsaufruf nur in den Code der Build-Ausgabe ein und lässt die Basis-Code-Basis intakt. Die Transformation erfolgt nur im Speicher.
 
 ### Fehlende Übersetzungen ausfüllen
 

package/docs/de/configuration.md

@@ -518,7 +518,10 @@ const config: IntlayerConfig = {
 
     /**
      * Gibt an, ob die Komponenten nach der Transformation gespeichert werden sollen.
-     * Auf diese Weise kann der Compiler nur einmal ausgeführt werden, um die App zu transformieren, und dann entfernt werden.
+     *
+     * - Wenn `true`, schreibt der Compiler die Komponentendatei auf die Festplatte um. Die Transformation ist also dauerhaft und der Compiler überspringt die Transformation für den nächsten Prozess. Auf diese Weise kann der Compiler die App transformieren und anschließend entfernt werden.
+     *
+     * - Wenn `false`, fügt der Compiler den `useIntlayer()` Funktionsaufruf nur in den Code der Build-Ausgabe ein und lässt die Basis-Code-Basis intakt. Die Transformation erfolgt nur im Speicher.
      */
     saveComponents: false,
 
@@ -932,14 +935,14 @@ Diese Einstellungen sind für fortgeschrittene Anwendungsfälle und die interne
 
 Einstellungen, die den Intlayer-Compiler steuern, der Wörterbücher direkt aus Ihren Komponenten extrahiert.
 
-| Feld                  | Beschreibung                                                                                                                                                                                                                                                                                                          | Typ                                                                                                             | Standard    | Beispiel                                                                                                                                                 | Hinweis                                                                                                                                                                                                           |
-| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `enabled`             | Gibt an, ob der Compiler für die Extraktion von Wörterbüchern aktiviert sein soll.                                                                                                                                                                                                                                    | `boolean` &#124; <br/> `'build-only'`                                                                           | `true`      | `'build-only'`                                                                                                                                           | `'build-only'` überspringt den Compiler während der Entwicklung, um Builds zu beschleunigen; wird nur bei Build-Befehlen ausgeführt.                                                                              |
-| `dictionaryKeyPrefix` | Präfix für extrahierte Wörterbuch-Schlüssel.                                                                                                                                                                                                                                                                          | `string`                                                                                                        | `''`        | `'mein-präfix-'`                                                                                                                                         | Wird dem generierten Schlüssel (basierend auf dem Dateinamen) vorangestellt, um Konflikte zu vermeiden.                                                                                                           |
-| `saveComponents`      | Gibt an, ob Komponenten nach der Transformation gespeichert werden sollen.                                                                                                                                                                                                                                            | `boolean`                                                                                                       | `false`     |                                                                                                                                                          | • Wenn `true`, werden Originaldateien durch transformierte Versionen ersetzt.<br/>• Der Compiler kann nach einem Durchlauf entfernt werden.                                                                       |
-| `output`              | Definiert den Pfad für Ausgabedateien. Ersetzt `outputDir`. Unterstützt Template-Variablen: `{{fileName}}`, <br/> `{{key}}`, <br/> `{{locale}}`, <br/> `{{extension}}`, <br/> `{{componentFileName}}`, <br/> `{{componentExtension}}`, <br/> `{{format}}`, <br/> `{{componentFormat}}`, <br/> `{{componentDirPath}}`. | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `undefined` | `'./{{fileName}}{{extension}}'` <br/> `'/locales/{{locale}}/{{key}}.json'` <br/> `{ en: ({ key }) => './locales/en/${key}.json', fr: '...', es: false }` | • `./` Pfade werden relativ zum Komponentenverzeichnis aufgelöst.<br/>• `/` Pfade relativ zum Stamm.<br/>• `{{locale}}` löst die Pro-Sprache-Generierung aus.<br/>• Unterstützt objektweise Notation pro Sprache. |
-| `noMetadata`          | Wenn `true`, lässt der Compiler die Metadaten des Wörterbuchs (Schlüssel, Inhalts-Wrapper) in der Ausgabe weg.                                                                                                                                                                                                        | `boolean`                                                                                                       | `false`     | `false` → `{"key":"mein-schlüssel","content":{"key":"wert"}}` <br/> `true` → `{"key":"wert"}`                                                            | • Nützlich für i18next oder ICU MessageFormat JSON-Ausgaben.<br/>• Funktioniert gut mit dem `loadJSON` Plugin.                                                                                                    |
-| `dictionaryKeyPrefix` | Wörterbuch-Schlüsselpräfix                                                                                                                                                                                                                                                                                            | `string`                                                                                                        | `''`        |                                                                                                                                                          | Fügen Sie ein optionales Präfix für die extrahierten Wörterbuchschlüssel hinzu                                                                                                                                    |
+| Feld                  | Beschreibung                                                                                                                                                                                                                                                                                                          | Typ                                                                                                             | Standard    | Beispiel                                                                                                                                                 | Hinweis                                                                                                                                                                                                                                                                                                                      |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `enabled`             | Gibt an, ob der Compiler für die Extraktion von Wörterbüchern aktiviert sein soll.                                                                                                                                                                                                                                    | `boolean` &#124; <br/> `'build-only'`                                                                           | `true`      | `'build-only'`                                                                                                                                           | `'build-only'` überspringt den Compiler während der Entwicklung, um Builds zu beschleunigen; wird nur bei Build-Befehlen ausgeführt.                                                                                                                                                                                         |
+| `dictionaryKeyPrefix` | Präfix für extrahierte Wörterbuch-Schlüssel.                                                                                                                                                                                                                                                                          | `string`                                                                                                        | `''`        | `'mein-präfix-'`                                                                                                                                         | Wird dem generierten Schlüssel (basierend auf dem Dateinamen) vorangestellt, um Konflikte zu vermeiden.                                                                                                                                                                                                                      |
+| `saveComponents`      | Gibt an, ob die Komponenten nach der Transformation gespeichert werden sollen.                                                                                                                                                                                                                                        | `boolean`                                                                                                       | `false`     |                                                                                                                                                          | • Wenn `true`, schreibt der Compiler die Komponentendatei auf die Festplatte um. Die Transformation ist dauerhaft und der Compiler kann anschließend entfernt werden.<br/>• Wenn `false`, fügt der Compiler den `useIntlayer()` Funktionsaufruf nur in den Code der Build-Ausgabe ein und lässt die Basis-Code-Basis intakt. |
+| `output`              | Definiert den Pfad für Ausgabedateien. Ersetzt `outputDir`. Unterstützt Template-Variablen: `{{fileName}}`, <br/> `{{key}}`, <br/> `{{locale}}`, <br/> `{{extension}}`, <br/> `{{componentFileName}}`, <br/> `{{componentExtension}}`, <br/> `{{format}}`, <br/> `{{componentFormat}}`, <br/> `{{componentDirPath}}`. | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `undefined` | `'./{{fileName}}{{extension}}'` <br/> `'/locales/{{locale}}/{{key}}.json'` <br/> `{ en: ({ key }) => './locales/en/${key}.json', fr: '...', es: false }` | • `./` Pfade werden relativ zum Komponentenverzeichnis aufgelöst.<br/>• `/` Pfade relativ zum Stamm.<br/>• `{{locale}}` löst die Pro-Sprache-Generierung aus.<br/>• Unterstützt objektweise Notation pro Sprache.                                                                                                            |
+| `noMetadata`          | Wenn `true`, lässt der Compiler die Metadaten des Wörterbuchs (Schlüssel, Inhalts-Wrapper) in der Ausgabe weg.                                                                                                                                                                                                        | `boolean`                                                                                                       | `false`     | `false` → `{"key":"mein-schlüssel","content":{"key":"wert"}}` <br/> `true` → `{"key":"wert"}`                                                            | • Nützlich für i18next oder ICU MessageFormat JSON-Ausgaben.<br/>• Funktioniert gut mit dem `loadJSON` Plugin.                                                                                                                                                                                                               |
+| `dictionaryKeyPrefix` | Wörterbuch-Schlüsselpräfix                                                                                                                                                                                                                                                                                            | `string`                                                                                                        | `''`        |                                                                                                                                                          | Fügen Sie ein optionales Präfix für die extrahierten Wörterbuchschlüssel hinzu                                                                                                                                                                                                                                               |
 
 ---
 

package/docs/de/dictionary/html.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-01-20
-updatedAt: 2026-01-22
+updatedAt: 2026-03-24
 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:
@@ -19,6 +19,12 @@ slugs:
   - content
   - html
 history:
+  - version: 8.5.0
+    date: 2026-03-24
+    changes: "Add `intlayerHTML` plugin object; use `app.use(intlayerHTML)` instead of `app.use(installIntlayerHTML)`"
+  - version: 8.5.0
+    date: 2026-03-24
+    changes: "Import von {{framework}}-intlayer nach {{framework}}-intlayer/html verschieben"
   - version: 8.0.0
     date: 2026-01-22
     changes: "Hinzufügen von HTMLRenderer / useHTMLRenderer / renderHTML Utility"
@@ -240,7 +246,7 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
   <Tab label="React / Next.js" value="react">
   
     ```tsx fileName="AppProvider.tsx"
-    import { HTMLProvider } from "react-intlayer";
+    import { HTMLProvider } from "react-intlayer/html";
 
     export const AppProvider = ({ children }) => (
       <HTMLProvider
@@ -254,18 +260,38 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     );
     ```
 
+    Sie können auch Ihren eigenen HTML-Renderer verwenden:
+
+    ```tsx fileName="AppProvider.tsx"
+    import { HTMLProvider } from "react-intlayer/html";
+
+    export const AppProvider = ({ children }) => (
+      <HTMLProvider
+        renderHTML={async (html) => {
+          const { renderHTML } = await import('react-intlayer/html');
+          return renderHTML(html);
+        }}
+      >
+        {children}
+      </HTMLProvider>
+    );
+    ```
+
+    > Das dynamische Importieren Ihres HTML-Renderers ist eine gute Möglichkeit, die Bundle-Größe Ihrer Anwendung zu reduzieren.
+
   </Tab>
   <Tab label="Vue" value="vue">
   
     ```typescript fileName="main.ts"
     import { createApp, h } from "vue";
-    import { installIntlayer, installIntlayerHTML } from "vue-intlayer";
+    import { intlayer } from "vue-intlayer";
+    import { intlayerHTML } from "vue-intlayer/html";
     import App from "./App.vue";
 
     const app = createApp(App);
 
-    app.use(installIntlayer);
-    app.use(installIntlayerHTML, {
+    app.use(intlayer);
+    app.use(intlayerHTML, {
       components: {
         p: (props, { slots }) => h("p", { class: "prose", ...props }, slots.default?.()),
         CustomLink: (props, { slots }) => h("a", { href: "/details", ...props }, slots.default?.()),
@@ -275,12 +301,35 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     app.mount("#app");
     ```
 
+    Sie können auch Ihren eigenen HTML-Renderer verwenden:
+
+    ```typescript fileName="main.ts"
+    import { createApp, h } from "vue";
+    import { intlayer } from "vue-intlayer";
+    import { intlayerHTML } from "vue-intlayer/html";
+    import App from "./App.vue";
+
+    const app = createApp(App);
+
+    app.use(intlayer);
+    app.use(intlayerHTML, {
+      renderHTML: async (html) => {
+        const { renderHTML } = await import('vue-intlayer/html');
+        return renderHTML(html);
+      },
+    });
+
+    app.mount("#app");
+    ```
+
+    > Das dynamische Importieren Ihres HTML-Renderers ist eine gute Möglichkeit, die Bundle-Größe Ihrer Anwendung zu reduzieren.
+
   </Tab>
   <Tab label="Svelte" value="svelte">
    
     ```svelte fileName="App.svelte"
     <script lang="ts">
-      import { HTMLProvider } from "svelte-intlayer";
+      import { HTMLProvider } from "svelte-intlayer/html";
       import MyCustomP from "./MyCustomP.svelte";
     </script>
 
@@ -293,11 +342,30 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     </HTMLProvider>
     ```
 
+    Sie können auch Ihren eigenen HTML-Renderer verwenden:
+
+    ```svelte fileName="App.svelte"
+    <script lang="ts">
+      import { HTMLProvider } from "svelte-intlayer/html";
+    </script>
+
+    <HTMLProvider
+      renderHTML={async (html) => {
+        const { renderHTML } = await import('svelte-intlayer/html');
+        return renderHTML(html);
+      }}
+    >
+      <slot />
+    </HTMLProvider>
+    ```
+
+    > Das dynamische Importieren Ihres HTML-Renderers ist eine gute Möglichkeit, die Bundle-Größe Ihrer Anwendung zu reduzieren.
+
   </Tab>
   <Tab label="Preact" value="preact">
    
     ```tsx fileName="AppProvider.tsx"
-    import { HTMLProvider } from "preact-intlayer";
+    import { HTMLProvider } from "preact-intlayer/html";
 
     export const AppProvider = ({ children }) => (
       <HTMLProvider
@@ -310,11 +378,30 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     );
     ```
 
+    Sie können auch Ihren eigenen HTML-Renderer verwenden:
+
+    ```tsx fileName="AppProvider.tsx"
+    import { HTMLProvider } from "preact-intlayer/html";
+
+    export const AppProvider = ({ children }) => (
+      <HTMLProvider
+        renderHTML={async (html) => {
+          const { renderHTML } = await import('preact-intlayer/html');
+          return renderHTML(html);
+        }}
+      >
+        {children}
+      </HTMLProvider>
+    );
+    ```
+
+    > Das dynamische Importieren Ihres HTML-Renderers ist eine gute Möglichkeit, die Bundle-Größe Ihrer Anwendung zu reduzieren.
+
   </Tab>
   <Tab label="Solid" value="solid">
    
     ```tsx fileName="AppProvider.tsx"
-    import { HTMLProvider } from "solid-intlayer";
+    import { HTMLProvider } from "solid-intlayer/html";
 
     export const AppProvider = (props) => (
       <HTMLProvider
@@ -327,15 +414,34 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     );
     ```
 
+    Sie können auch Ihren eigenen HTML-Renderer verwenden:
+
+    ```tsx fileName="AppProvider.tsx"
+    import { HTMLProvider } from "solid-intlayer/html";
+
+    export const AppProvider = (props) => (
+      <HTMLProvider
+        renderHTML={async (html) => {
+          const { renderHTML } = await import('solid-intlayer/html');
+          return renderHTML(html);
+        }}
+      >
+        {props.children}
+      </HTMLProvider>
+    );
+    ```
+
+    > Das dynamische Importieren Ihres HTML-Renderers ist eine gute Möglichkeit, die Bundle-Größe Ihrer Anwendung zu reduzieren.
+
   </Tab>
   <Tab label="Angular" value="angular">
 
     ```typescript fileName="app.config.ts"
-    import { createIntlayerMarkdownProvider } from "angular-intlayer";
+    import { createIntlayerHTMLProvider } from "angular-intlayer/html";
 
     export const appConfig: ApplicationConfig = {
       providers: [
-        createIntlayerMarkdownProvider({
+        createIntlayerHTMLProvider({
           components: {
             p: { class: "prose" },
             CustomLink: { href: "/details" },
@@ -345,6 +451,25 @@ Sie können das HTML-Rendering global für Ihre gesamte Anwendung konfigurieren.
     };
     ```
 
+    Sie können auch Ihren eigenen HTML-Renderer verwenden:
+
+    ```typescript fileName="app.config.ts"
+    import { createIntlayerHTMLProvider } from "angular-intlayer/html";
+
+    export const appConfig: ApplicationConfig = {
+      providers: [
+        createIntlayerHTMLProvider({
+          renderMarkdown: async (html) => {
+            const { renderMarkdown } = await import('angular-intlayer/html');
+            return renderMarkdown(html);
+          },
+        }),
+      ],
+    };
+    ```
+
+    > Das dynamische Importieren Ihres HTML-Renderers ist eine gute Möglichkeit, die Bundle-Größe Ihrer Anwendung zu reduzieren.
+
   </Tab>
 </Tabs>
 
@@ -360,7 +485,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     Rendern Sie einen HTML-String mit spezifischen Komponenten.
 
     ```tsx
-    import { HTMLRenderer } from "react-intlayer";
+    import { HTMLRenderer } from "react-intlayer/html";
 
     <HTMLRenderer components={{ p: MyCustomP }}>
       {"<p>Hello World</p>"}
@@ -372,7 +497,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     Holen Sie sich eine vorkonfigurierte Renderer-Funktion.
 
     ```tsx
-    import { useHTMLRenderer } from "react-intlayer";
+    import { useHTMLRenderer } from "react-intlayer/html";
 
     const renderHTML = useHTMLRenderer({
       components: { strong: (props) => <strong {...props} className="text-red-500" /> }
@@ -386,7 +511,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     Eigenständiges Utility zum Rendern außerhalb von Komponenten.
 
     ```tsx
-    import { renderHTML } from "react-intlayer";
+    import { renderHTML } from "react-intlayer/html";
 
     const jsx = renderHTML("<p>Hello</p>", { components: { p: 'div' } });
     ```
@@ -398,7 +523,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
    
     ```vue
     <script setup>
-    import { HTMLRenderer } from "vue-intlayer";
+    import { HTMLRenderer } from "vue-intlayer/html";
     </script>
 
     <template>
@@ -413,7 +538,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
    
     ```svelte
     <script lang="ts">
-    import { HTMLRenderer } from "svelte-intlayer";
+    import { HTMLRenderer } from "svelte-intlayer/html";
     </script>
 
     <HTMLRenderer value="<p>Hello World</p>" />
@@ -423,7 +548,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
 
     ```svelte
     <script lang="ts">
-    import { useHTMLRenderer } from "svelte-intlayer";
+    import { useHTMLRenderer } from "svelte-intlayer/html";
     const render = useHTMLRenderer();
     </script>
 
@@ -434,7 +559,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
 
     ```svelte
     <script lang="ts">
-    import { renderHTML } from "svelte-intlayer";
+    import { renderHTML } from "svelte-intlayer/html";
     </script>
 
     {@html renderHTML("<p>Hello World</p>")}
@@ -446,7 +571,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     #### `<HTMLRenderer />` Komponente
    
     ```tsx
-    import { HTMLRenderer } from "preact-intlayer";
+    import { HTMLRenderer } from "preact-intlayer/html";
 
     <HTMLRenderer>
       {"<p>Hello World</p>"}
@@ -456,7 +581,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     #### `useHTMLRenderer()` Hook
 
     ```tsx
-    import { useHTMLRenderer } from "preact-intlayer";
+    import { useHTMLRenderer } from "preact-intlayer/html";
 
     const render = useHTMLRenderer();
 
@@ -466,7 +591,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     #### `renderHTML()` Utility
 
     ```tsx
-    import { renderHTML } from "preact-intlayer";
+    import { renderHTML } from "preact-intlayer/html";
 
     return <div>{renderHTML("<p>Hello World</p>")}</div>;
     ```
@@ -477,7 +602,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     #### `<HTMLRenderer />` Komponente
    
     ```tsx
-    import { HTMLRenderer } from "solid-intlayer";
+    import { HTMLRenderer } from "solid-intlayer/html";
 
     <HTMLRenderer>
       {"<p>Hello World</p>"}
@@ -487,7 +612,7 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     #### `useHTMLRenderer()` Hook
 
     ```tsx
-    import { useHTMLRenderer } from "solid-intlayer";
+    import { useHTMLRenderer } from "solid-intlayer/html";
 
     const render = useHTMLRenderer();
 
@@ -497,21 +622,21 @@ Wenn Sie rohe HTML-Strings rendern müssen oder mehr Kontrolle über die Kompone
     #### `renderHTML()` Utility
 
     ```tsx
-    import { renderHTML } from "solid-intlayer";
+    import { renderHTML } from "solid-intlayer/html";
 
     return <div>{renderHTML("<p>Hello World</p>")}</div>;
     ```
 
   </Tab>
   <Tab label="Angular" value="angular">
-    #### `IntlayerMarkdownService` Service
+    #### `IntlayerHTMLService` Service
     Rendern Sie einen HTML-String mit dem Service.
 
     ```typescript
-    import { IntlayerMarkdownService } from "angular-intlayer";
+    import { IntlayerHTMLService } from "angular-intlayer";
 
     export class MyComponent {
-      constructor(private markdownService: IntlayerMarkdownService) {}
+      constructor(private markdownService: IntlayerHTMLService) {}
 
       renderHTML(html: string) {
         return this.markdownService.renderMarkdown(html);