---
title: Migration von MJML
description: MJML-E-Mail-Templates mit @templatical/import-mjml in das Templatical-Format konvertieren.
---

# Migration von MJML

Diese Anleitung richtet sich an Teams, die E-Mail-Templates bisher in rohem [MJML](https://mjml.io) erstellt haben (mit Editoren wie VS Code, einem internen CLI oder einer selbstgebauten Build-Pipeline) und auf Templaticals visuellen Editor wechseln möchten. **`@templatical/import-mjml`** konvertiert ein MJML-Dokument direkt in Templaticals `TemplateContent`-Format — installieren Sie es, führen Sie es aus, und nutzen Sie die folgenden Abschnitte, um alles nachzuarbeiten, was es nicht automatisch abbilden kann.

## Installation

::: code-group

```bash [npm]
npm install @templatical/import-mjml
```

```bash [pnpm]
pnpm add @templatical/import-mjml
```

```bash [yarn]
yarn add @templatical/import-mjml
```

```bash [bun]
bun add @templatical/import-mjml
```

:::

### Ohne Build-Schritt (CDN)

Sie können es auch von einem CDN laden:

```html
<script type="module">
  import { convertMjmlTemplate } from 'https://cdn.jsdelivr.net/npm/@templatical/import-mjml/+esm';
  // ...dann konvertieren wie im Abschnitt „Verwendung" unten
</script>
```

## Verwendung {#usage}

```ts
import { convertMjmlTemplate } from '@templatical/import-mjml';

// Den rohen MJML-Quelltext einer E-Mail laden
const res = await fetch('/path/to/email.mjml');
const mjml = await res.text();

// In das Templatical-Format konvertieren
const { content, report } = convertMjmlTemplate(mjml);

// Im Editor verwenden
const editor = await init({
  container: '#editor',
  content,
});

// Konvertierungsbericht auf Auffälligkeiten prüfen
console.log(report);
```

[Im Playground öffnen](https://play.templatical.com/scenes/import-mjml)

`convertMjmlTemplate` arbeitet synchron und gibt ein `ImportResult` zurück mit:
- `content` — das konvertierte `TemplateContent`, bereit für den Editor
- `report` — ein Konvertierungsbericht mit dem Status jedes Quellelements (`converted`, `approximated`, `html-fallback` oder `skipped`)

## Optionen {#options}

`convertMjmlTemplate` akzeptiert als zweites Argument `ConvertMjmlOptions`. `defaultLocale?: string` setzt `settings.locale`, wenn die Quelle keine Standardsprache angibt; andernfalls gilt `"en"`. Eine deklarierte Standardsprache hat Vorrang. Sprachcodes werden von `_` nach `-` normalisiert. Eine deklarierte Standardsprache oder ein `defaultLocale`, das danach kein Sprach-Tag ist, etwa ein Platzhalter <code v-pre>{{lang}}</code>, wird mit einem `report.warnings`-Eintrag ignoriert, der den Wert nennt; dann gilt der nächste gültige Wert oder `"en"`.

Die Quelle deklariert ihre Standardsprache mit `<mjml lang>`.

```ts
export interface ConvertMjmlOptions {
  defaultLocale?: string;
}
```

## Den Bericht lesen

Jeder Eintrag in `report.entries` beschreibt ein Quellelement:

| Status | Bedeutung |
|---|---|
| `converted` | Jedes Attribut mit einer Templatical-Entsprechung wurde übernommen. |
| `approximated` | Auf den richtigen Block abgebildet, aber ein Wert musste auf einen begrenzten Wertebereich angepasst werden — `note` nennt den ursprünglichen Wert. |
| `html-fallback` | Keine Block-Entsprechung vorhanden; das ursprüngliche Markup bleibt in einem `HtmlBlock` erhalten. |
| `skipped` | Es wurde nichts erzeugt (`templaticalBlockType: null`). |

```ts
console.log(report.summary);
// { total: 24, converted: 21, approximated: 2, htmlFallback: 1, skipped: 0 }

for (const entry of report.entries) {
  if (entry.status === 'approximated') {
    console.warn(`<${entry.sourceTag}> approximiert:`, entry.note);
  }
}
// <mj-section> approximiert: Column widths 20%, 20%, 20%, 20%, 20% have no exact Templatical layout; resolved to "4". Templatical supports up to four columns.
```

Ein `note` bei einem `approximated`-Eintrag nennt immer den ersetzten Wert — ein Diff von `report.entries` zwischen zwei Durchläufen zeigt so genau, was eine Migration verändert hat.

## Konvertierungsmodell

Diese Migration ist etwas kontraintuitiv. Templaticals Renderer erzeugt *MJML als Ausgabe* — auf den ersten Blick sehen MJML und Templatical identisch aus. Aber:

- **MJML** ist eine Markup-Sprache. Sie schreiben XML-ähnliche Tags (`<mj-section>`, `<mj-column>`, `<mj-text>`) und der MJML-Compiler verwandelt das in tabellenbasiertes HTML.
- **Templatical** speichert Templates als JSON-Baum mit typisierten Blöcken (`SectionBlock`, `ParagraphBlock` usw.) und rendert diesen Baum beim Export zu MJML.

Um ein MJML-Template in Templatical zu bringen, parsen Sie das MJML und bauen einen äquivalenten JSON-Baum auf — einschließlich der Auflösung von MJMLs eigenen Attribut-Vererbungsregeln (`mj-all`, Tag-Defaults, `mj-class`), bevor jedes Element abgebildet wird. Genau das leistet `@templatical/import-mjml`; die Mapping-Tabelle unten zeigt, was es umsetzt.

## Pfad 1 — Visuell mit dem MJML als Referenz neu aufbauen

Bei einer Handvoll Templates ist der Neuaufbau von Hand neben Ihrer MJML-Quelle oft schneller, als ein Paket zu installieren:

1. Öffnen Sie Ihre MJML-Quelle im Editor Ihrer Wahl.
2. Öffnen Sie den Templatical-Editor (oder den [Playground](https://play.templatical.com)) daneben.
3. Kompilieren Sie Ihr MJML einmal zu HTML und sehen Sie es sich an — das ist Ihr visuelles Ziel.
4. Ziehen Sie die entsprechenden Templatical-Blöcke hinein (siehe [Mapping-Tabelle](#mjml-tag-mapping) unten).
5. Kopieren Sie Textinhalte direkt. Bilder über Ihre Medienbibliothek neu hosten.
6. Bilden Sie Styling über Templaticals [Design-Tokens](/de/guide/theming) ab, statt über inline `mj-attributes`.

Die meisten MJML-Templates sind in 10–20 Minuten umgezogen, sobald Sie eines oder zwei gemacht haben. Bei größeren Mengen führen Sie zuerst `@templatical/import-mjml` aus und nutzen diesen Pfad nur, um nachzuarbeiten, was als HTML-Fallback-Block gelandet ist.

## Pfad 2 — Templaticals Renderer zur Verifikation nutzen

Sobald ein Template in Templatical vorliegt — importiert oder von Hand nachgebaut:

```ts
import { renderToMjml } from '@templatical/renderer';

const mjml = await renderToMjml(content);
// Vergleichen Sie dieses MJML mit Ihrem ursprünglichen MJML-Quelltext.
```

Ein Diff zwischen Original und dem von Templatical erzeugten MJML zeigt strukturelle Unterschiede. Eine sinnvolle Sanity-Prüfung vor einer Bulk-Migration.

## MJML-Tag-Mapping {#mjml-tag-mapping}

| MJML-Tag | Templatical-Block | Hinweise |
|---|---|---|
| `mj-section` (mit `mj-column`s) | `SectionBlock` mit `columns` | Eine Breite innerhalb von 2 Prozentpunkten eines Presets behält dieses Preset. Jedes andere Verhältnis von zwei bis vier Spalten wird auf 100 skaliert: Anteile, die einem Preset entsprechen, behalten dieses Preset, alle anderen setzen `columnWidths` auf dem gleichmäßigen Layout dieser Anzahl. Fünf oder mehr Spalten falten sich in `"4"`. Breiten kommen aus MJMLs `width`-Attribut. Eine Spalte ohne Breite erhält die Elternbreite geteilt durch die Spaltenzahl, und eine px-Breite ist ein Anteil der inneren Box der Section. Fehlt jede Breite, sind die Spalten gleich. Ebenso `border-radius` und `border` (siehe [Rahmen und Ecken](#rahmen-und-ecken)). `background-url` mit Größe, Position und Wiederholung wird zu `backgroundImage` (siehe [Hintergrundbilder](#hintergrundbilder)). |
| `mj-column` | Section-Spalte | Eine Spalte hält eine Liste verschachtelter Blöcke. |
| `mj-group` | `SectionBlock.stackOnMobile: false` | Kein eigener Block — markiert, dass die Spalten der Section auf Mobilgeräten nebeneinander bleiben, statt zu stapeln. |
| `mj-text` | `TitleBlock` / `TableBlock` / `MenuBlock` / `ParagraphBlock` | Strukturell aufgelöst: Eine einzelne Überschrift als Wurzelelement wird zu `TitleBlock`, eine einzelne `<table>` zu `TableBlock`, durch `<span>` getrennte Top-Level-Anker ohne Paragraph-Wrapper und ohne Nicht-Whitespace-Textknoten als Geschwister zu `MenuBlock`, ein Satz Fließtext plus ein abschließendes `<a>` zu `ParagraphBlock`, alles andere zu `ParagraphBlock`. `align`, `color` und `font-size` eines Absatzes landen in seinem Markup: `text-align` auf jedem `<p>`, Farbe und Größe auf einem `<span>` darin (`ParagraphBlock` hat dafür keine Felder). Eine Ausrichtung an der Startkante (`left`, in einem RTL-Template `right`) und eine Größe von 14px entfallen. |
| `mj-image` | `ImageBlock` | `src`, `alt`, `href`, `width` (siehe [Bildbreite](#image-width)), Padding, `border-radius`, `border` (siehe [Rahmen und Ecken](#rahmen-und-ecken)). `fluid-on-mobile` bleibt bei einem Bild erhalten, das seine Spalte füllt; bei einem schmaleren ist es `approximated`, weil das Bild [auf dem Smartphone seine Breite behält](/de/guide/images#width-on-phones). |
| `mj-button` | `ButtonBlock` | `href`, `background-color`, `color`, `font-size`, `font-family`, Padding, `width` (siehe [Button-Breite](#button-breite)), `line-height` (siehe [Button-Zeilenhöhe](#button-zeilenhoehe)), `border-radius`, `border` (siehe [Rahmen und Ecken](#rahmen-und-ecken)). |
| `mj-divider` | `DividerBlock` | `border-color`, `border-width`, `width` (siehe [Divider-Breite](#divider-breite)), Padding. |
| `mj-spacer` | `SpacerBlock` | `height`. |
| `mj-social` (mit `mj-social-element`) | `SocialIconsBlock` | Jedes `mj-social-element` → ein `SocialIcon`-Eintrag. Die Plattform kommt aus `name`, dem `src`-Dateinamen (Pack-Suffixe wie `-round-outlined` werden abgetrennt) oder, nur ohne `src`, aus `alt`. Ein unerkanntes Icon mit Bild, auch eines, dessen `alt` ein Netzwerk nennt, wird ein benutzerdefiniertes Icon (eigenes Bild, Link und Alt-Text) im selben Social-Block. Ein von Templatical gerendertes eigenes Icon trägt `css-class="tpl-social-custom"` und bleibt benutzerdefiniert, auch wenn seine Datei nach einem Netzwerk benannt ist. Ohne Bild wird es ein `website`-Icon und als `approximated` gemeldet. |
| `mj-navbar` (mit `mj-navbar-link`) | `MenuBlock` | Jeder Link → `MenuItemData`. |
| `mj-table` | `TableBlock` | Bildet `<tr>`/`<td>`/`<th>`-Zeilen und -Zellen auf Templaticals Tabellen-Daten ab; eine führende `<th>`-Zeile setzt `hasHeaderRow`. |
| `mj-raw` | `HtmlBlock` | Inneres Markup bleibt wortgetreu erhalten. |
| `mj-wrapper` | `SectionBlock.wrapper` | Das äußere Band der Section, **keine eigene Section**. Eine einzelne Section darin fließt in deren `wrapper`; mehrere teilen sich dasselbe Band und werden als `approximated` markiert. `background-color`, `background-url` (mit Größe, Position und Wiederholung), `padding` und `border-radius` werden übernommen; ein `border` wird verworfen und gemeldet. `full-width="full-width"` setzt `wrapper.fullWidth`, sodass das Band bis zum Fensterrand läuft. |
| `mj-hero` | `SectionBlock` mit `hero` | Eine einspaltige Hero-Sektion. `fluid-height` → `height: "image"`, mit `background-width` / `background-height` als `naturalWidth` / `naturalHeight` des Bilds; `fixed-height` → diese `height`; ein `fixed-height`-Hero, der so hoch ist wie sein über die Box des Heros gezeichnetes Bild (so exportiert Templatical **Wie Bild**), wird wieder `height: "image"`. Ein `fluid-height`-Hero ohne `background-width` / `background-height` wird trotzdem als `height: "image"` importiert, mit einer Notiz: Solange sein Bild keine Größe hat, wird er als normale Sektion dargestellt, und die Warnung `structure.hero-not-applied` nennt die Größe als Grund. Ein `fixed-height`-Hero ohne `height` (MJMLs Standard) wird eine normale Sektion mit dem Hintergrundbild. `background-position` wird übernommen; `inner-padding` und `inner-background-color` werden verworfen und gemeldet. In einem `mj-wrapper` erhält der Hero das Band des Wrappers. |
| `mj-carousel`, `mj-accordion` | `HtmlBlock` | Wird in einen HTML-Block mit erhaltenem Original-Markup konvertiert. |
| `mjml` | Template-`settings` | `lang` → `locale`; `dir` → `direction`, nur wenn es von der Schreibrichtung abweicht, die die Sprache vorgibt. |
| `mj-head`-Inhalte | Template-`settings` | `mj-preview` → `preheaderText`; `mj-attributes`/`mj-font`/`mj-style` setzen Schriftart, Textfarbe und Link-Farbe/-Unterstreichung des Dokuments. `mj-title` hat keine Entsprechung in den Settings und wird mit einer Warnung verworfen. |

### Bildbreite {#image-width}

Eine px-`width` wird `"full"`, sobald sie den Platz des Bildes erreicht: seine Spalte abzüglich seines eigenen seitlichen Paddings und Rahmens, wo MJML es begrenzt. Eine schmalere px-Breite bleibt px, und ein Bild ohne `width` ist `"full"`.

### Divider-Breite

| `width` am `mj-divider` | `DividerBlock.width` | Status |
|---|---|---|
| fehlt, oder `100%` | `"full"` | `converted` |
| ein Prozentwert unter `100%`, etwa `50%` | derselbe Prozentwert auf zwei Nachkommastellen, `"50%"` | `converted` |
| unter `0%` oder über `100%` | begrenzt auf `"0%"` bzw. `"full"` | `approximated` |
| px, schmaler als die Linie reichen kann | die px-Zahl | `converted` |
| px, so breit wie die Linie reichen kann oder breiter | `"full"` | `converted` |
| px, unter `0` | begrenzt auf `0` | `approximated` |
| jeder andere Wert | `"full"` | `approximated` |

Die Linie reicht über ihre Spalte abzüglich des seitlichen Paddings der Spalte und ihres eigenen; so zeichnet `mj-divider` `100%`. Die Breite einer Spalte ist ihr Anteil an der `width` von `mj-body`: das Preset oder `columnWidths`, wenn die Sektion sie setzt.

Templatical zentriert jeden Divider. Ein Divider mit Teilbreite, den MJML links oder rechts ausrichtet (`align`), ist `approximated`; seine `note` nennt die Ausrichtung.

### Button-Breite

| `width` am `mj-button` | `ButtonBlock.width` | Status |
|---|---|---|
| fehlt | keine, der Button passt sich seiner Beschriftung an | `converted` |
| `100%` | `"full"` | `converted` |
| px, über `0` | die px-Zahl | `converted` |
| ein Prozentwert über 0 und unter `100%`, etwa `40%` | dieser Prozentwert, auf zwei Nachkommastellen gerundet, nachgestellte Nullen entfallen | `converted` |
| über `100%` | `"full"` | `approximated` |
| ein Prozentwert von `0%` oder darunter | keine, der Button passt sich seiner Beschriftung an | `approximated` |
| px von `0` oder darunter | keine, der Button passt sich seiner Beschriftung an | `approximated` |
| jeder andere Wert | keine, der Button passt sich seiner Beschriftung an | `approximated` |

Ein Prozentwert über 0 und unter 100 wird als dieser Prozentwert gespeichert. MJML rendert ihn an der Inhaltsbox der Spalte, der Spalte abzüglich des seitlichen Paddings des Buttons, daher schrumpft der Button auf dem Smartphone mit seiner Spalte. Ein Prozentwert von `100%` oder mehr ist `"full"`; einer über `100%` trägt eine Notiz, dass er geklemmt wurde. Ein Prozentwert von `0%` oder darunter und eine px-Breite von `0` oder darunter lassen den Button sich seiner Beschriftung anpassen, mit einer Notiz. Eine px-Breite über `0` bleibt px, weil der Renderer `"full"` als `100%` schreibt.

### Button-Zeilenhöhe {#button-zeilenhoehe}

`line-height` wird zu `lineHeight`, einem Vielfachen der Schriftgröße, und gilt für jede Zeile einer umbrochenen Beschriftung. Ein Prozentwert ist diese Zahl geteilt durch 100 (`200%` ist `2`), eine einheitenlose Zahl ist sie selbst, eine px-Länge ist diese Pixelzahl geteilt durch die Schriftgröße (`28px` bei 14px ist `2`; ohne `font-size` durch die 15px des Buttons), und eine `em`-Länge ist die Zahl selbst (`2em` ist `2`), gerundet auf zwei Dezimalstellen. Ein Wert, der 1,2 entspricht, einschließlich `120%` und `1.2em`, oder ein fehlender Wert lässt `lineHeight` ungesetzt, und der Button bleibt konvertiert, sodass ein Button, den der Renderer mit `120%` geschrieben hat, so importiert wird, wie er heute rendert. Jeder andere explizite Wert, der nicht gelesen werden kann (`2rem`, `normal`, `calc(...)`, eine nicht positive Zahl), lässt `lineHeight` ungesetzt und ergänzt die Notiz `Button line-height "<value>" could not be read; imported at 1.2.`, sodass der Eintrag angenähert ist.

### Rahmen und Ecken

`mj-section`, `mj-image` und `mj-button` behalten ihren `border-radius` und ihren Rahmen; `mj-wrapper` behält seinen `border-radius`.

| `border-radius` | Eckenradius | Status |
|---|---|---|
| ein bis vier px-Werte, etwa `8px` oder `8px 8px 0 0` | dieselben Ecken, eine einzelne Zahl, wenn alle vier gleich sind | `converted` |
| jeder andere Wert, etwa `50%`, `1em` oder `8px / 4px` | eckig | `approximated` |

| `border` oder `border-<side>` | Diese Seite | Status |
|---|---|---|
| eine px-Breite, `solid`, `dashed` oder `dotted` und eine Farbe | dieselbe | `converted` |
| Stil `none` oder `hidden`, kein Stil oder Breite `0` | nicht gezeichnet | `converted` |
| Stil `double`, `groove`, `ridge`, `inset` oder `outset` | `solid` gezeichnet | `approximated` |
| eine Breite, die nicht in px angegeben ist, etwa `2em` oder `thin`, oder keine Breite | nicht gezeichnet | `approximated` |

Ein `border-<side>` einer Seite hat wie in MJML Vorrang vor `border`. Eine fehlende Farbe wird als nicht gesetzt importiert und wie in MJML in der geerbten Textfarbe (`currentColor`) gezeichnet; dasselbe gilt für eine Farbe, die der Importer nicht lesen kann. Der Wrapper in Templatical hat keinen Rahmen, daher wird ein `border` an einem `mj-wrapper` verworfen, und die `note` seines Eintrags nennt ihn.

### Hintergrundbilder

`background-url` an einer `mj-section` wird zum `backgroundImage` der Section, an einem `mj-wrapper` zum `wrapper.backgroundImage` des Bands. `background-size`, `background-position` (sowie `-x` / `-y`) und `background-repeat` werden mitgenommen, und ein Attribut, das das Element weglässt, übernimmt MJMLs eigenen Standard (`auto`, `top center`, `repeat`) — das Bild erscheint also dort, wo es war. Eine `mj-section` mit `full-width="full-width"` und eigenem Hintergrund verschiebt diesen auf `section.wrapper` mit `fullWidth: true` und lässt den Section-Hintergrund ungesetzt. Ein Wrapper, der bereits malt, behält seine Farbe, und die Section behält ihren Hintergrund. Eine vollbreite Section in einem Wrapper, der selbst nicht vollbreit ist, behält ihren Hintergrund auf der Section.

Ein Wert ohne exaktes Templatical-Schlüsselwort wird auf das nächstliegende abgebildet, und der Eintrag ist `approximated` mit einer Notiz:

- **Größe** — eine Größe, die eine Seite füllt (`100%`, `100% auto`, `auto 100%` oder eine px-Breite mindestens so groß wie die Section), wird `cover`; jede andere Länge oder Prozentangabe wird `auto`.
- **Position** — eine Prozentangabe rastet auf das nächste von links, Mitte und rechts (oben, Mitte und unten) ein; eine Länge ist ein Versatz vom linken bzw. oberen Rand und wird dort verankert.
- **Wiederholung** — `repeat-x`, `repeat-y`, `round` und `space` werden zu `repeat`.

`mj-column` kennt in MJML kein `background-url`, es gibt also kein Spaltenbild zu importieren. Das Bild eines `mj-hero` wird zum `backgroundImage` der Sektion, als die er importiert wird, immer `cover` und nicht wiederholt, wie mj-hero es malt: einer Hero-Sektion oder, bei einem Hero in der Höhe seines Inhalts, einer normalen Sektion.

## Wo das Mapping verlustbehaftet ist

MJML, das Templaticals eigener Renderer erzeugt hat, durchläuft den Importer ohne Näherungen bei Layout, Styling oder Anzeigebedingungen. Die einzige Lücke betrifft den Blocktyp: Ein `VideoBlock` und ein `HtmlBlock` rendern beide als reines MJML ohne Kennzeichnung ihrer Herkunft, sodass beim erneuten Import jeweils ein anderer Blocktyp entsteht (siehe unten). Handgeschriebenes MJML konvertiert für jedes Tag in der Mapping-Tabelle oben sauber; alles, was die Tabelle nicht abdeckt, landet als `HtmlBlock` mit dem ursprünglichen Markup. Innerhalb dessen, was die Tabelle abdeckt, sind einige Konvertierungen Näherungen statt exakter Treffer:

- **Spalten-Geometrie** — Templatical unterstützt diese Spalten-Layouts (`1`, `2`, `3`, `4`, `2-1`, `1-2`, `3-1`, `1-3`, `1-2-1`). Eine Breitenliste innerhalb von 2 Prozentpunkten eines Presets behält dieses Preset. Eine Spalte ohne `width` erhält die Elternbreite geteilt durch die Spaltenzahl, wie `mj-column`, nicht den Raum, den die angegebenen Breiten übrig lassen; fehlt jede Breite, bleibt das gleichmäßige Preset exakt. Eine px-Breite ist ein Anteil der inneren Box der Section, also des Containers abzüglich des horizontalen Paddings der Section und der gezeichneten Seitenrahmen. In einem 600px-Container mit 50px Seitenpadding sind `100px` neben `80%` 100px neben 400px, also die Anteile 20 / 80. Zwei, drei oder vier Spalten, die auf keines passen, werden auf 100 skaliert. Skalierte Anteile, die einem Preset entsprechen, behalten dieses Preset ohne `columnWidths`; alle anderen behalten das gleichmäßige Layout dieser Anzahl und `columnWidths`. Die Zuordnung ist exakt, wenn die Breiten bereits innerhalb von 0,5 Prozentpunkten 100 ergeben. Andernfalls verändert die Skalierung das Quelllayout, die Section ist `approximated` und die Notiz nennt die Quellbreiten. `30%` neben einer fehlenden Breite ist 30 / 50, skaliert und `approximated`. `30%` / `40%` ist `approximated`. `45%` / `45%` ist `"2"` und `30%` / `60%` ist `"1-2"`, beide `approximated`. `30%` / `70%` ist exakt. `25%` / `25%` / `50%` ist `columns: "3"` und `columnWidths: [25, 25, 50]`. `33.33%` / `66.67%` bleibt `"1-2"`. `49%` / `51%` bleibt `"2"`. Der Inhalt einer fünften oder weiteren Spalte fließt in die vierte Spalte. Die `note` nennt die Obergrenze von vier Spalten nur bei diesem Überlauf: `Column widths 20%, 20%, 20%, 20%, 20% have no exact Templatical layout; resolved to "4". Templatical supports up to four columns.`
- **Social-Icon-Größen** — `SocialIconsBlock` unterstützt drei Größen (24px, 32px, 48px). Eine `icon-size` an einem `mj-social-element` außerhalb dieser drei wird auf die nächstliegende aufgelöst.
- **Überschriften-Ebenen** — ein `<h5>` oder `<h6>` innerhalb von `mj-text` wird auf Überschriften-Ebene 4 begrenzt, die höchste, die ein `TitleBlock` unterstützt.
- **Divider-Breite und -Ausrichtung** — eine `width` an einem `mj-divider` außerhalb von 0–100 % oder unter 0px wird in den gültigen Bereich begrenzt, eine nicht lesbare wird zu `"full"`, und ein links oder rechts ausgerichteter Divider mit Teilbreite wird zentriert. Siehe [Divider-Breite](#divider-breite).
- **Button-Breite** — eine `width` an einem `mj-button` über `100%` wird zu `"full"`, und eine nicht lesbare oder eine von `0` oder darunter lässt den Button sich seiner Beschriftung anpassen. Siehe [Button-Breite](#button-breite).
- **Rahmen und Ecken** — ein `border-radius`, der nicht in px angegeben ist, wird als eckig importiert, ein Rahmenstil außer solid, dashed oder dotted wird solid gezeichnet, eine Rahmenseite ohne px-Breite bleibt ungezeichnet, und ein Rahmen an einem `mj-wrapper` wird verworfen. Siehe [Rahmen und Ecken](#rahmen-und-ecken).
- **Hintergrundbilder** — ein `background-size`, `background-position` oder `background-repeat` ohne exaktes Templatical-Schlüsselwort wird auf das nächstliegende abgebildet. Siehe [Hintergrundbilder](#hintergrundbilder).
- **Video-Blöcke** — ein `VideoBlock` wird genauso gerendert wie ein verlinkter `ImageBlock`, sodass nichts im MJML ihn als Video kennzeichnet. Beim Import daraus entsteht ein `ImageBlock` mit demselben Vorschaubild und Link; der Inhalt bleibt erhalten, der Blocktyp nicht.
- **HTML-Blöcke** — aus demselben Grund rendert der Inhalt eines `HtmlBlock` als reines `mj-text`-Markup ohne jede Kennzeichnung als HTML. Beim Import daraus entsteht ein `ParagraphBlock` mit demselben Markup.
- **Block-IDs** — jeder importierte Block erhält eine neu generierte ID. IDs erscheinen nirgends im gerenderten MJML, daher überlebt nichts, das an einer ID hängt — zum Beispiel ein Kommentarthread mit der Block-ID als Schlüssel — einen Durchlauf durch Export und Re-Import.

## Nicht übertragene Merkmale

- **`mj-include`** — der Importer liest einen einzelnen MJML-String ohne Dateisystemzugriff, daher wird ein nicht auflösbares `<mj-include>` übersprungen (`skipped`), mit einer Warnung, die das `path`-Attribut nennt. Inkludierten Inhalt vor dem Import inlinen.
- **Custom MJML-Components** — ein nicht erkanntes `mj-*`-Tag landet automatisch als `HtmlBlock` mit dem gerenderten Markup. Implementieren Sie es als [Templatical Custom Block](/de/guide/custom-blocks), wenn Sie es stattdessen als nativen Block editierbar haben möchten.

## Wenn diese Anleitung etwas nicht abdeckt

[Eröffnen Sie eine Diskussion](https://github.com/templatical/sdk/discussions) mit einem geschwärzten Ausschnitt Ihres MJMLs und was Sie erreichen wollen. Wir nutzen diese Rückmeldungen, um die Abdeckung von `@templatical/import-mjml` zu verbessern.
