From e30e6b0e4bd09cc4b92d4840b8d208f0085b6bf4 Mon Sep 17 00:00:00 2001
From: mdn-bot <108879845+mdn-bot@users.noreply.github.com>
Date: Thu, 30 Jan 2025 06:27:42 +0000
Subject: [PATCH] chore(de): translate diff [38b5682c11]
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Machine translation from English using gpt-4o-2024-08-06.

Source: https://github.com/mdn/content/commit/38b5682c1170760bb5f696ab675690ca6054f634

System prompt:

```md
You are tasked with translating MDN Web Docs content from English to German.

Ensure that the translation is accurate, preserves technical terminology, and follows the rules provided below.

# Rules for Translation

1. Format:

   - The input is a Markdown file.
   - The output should be a Markdown file.
   - Return the raw output, without wrapping it in a Markdown code block.
   - Keep GFM alert syntax untranslated, such as `> [!NOTE]`, `> [!WARNING]`, and `> [!CALLOUT]`.
   - If the input contains HTML tags wrapped in backticks (e.g. `<video>`), make sure they are wrapped in the output.
   - If the input contains HTML tags escaped with a slash (e.g. `\<length>`), make sure they are escaped in the output.

2. Language:

   - Prefer formal language ("Sie") over informal language ("du").

3. Code blocks:

   - Do not translate code blocks.
   - Do not translate terms wrapped in backticks.

4. Macro calls:

   - MDN uses macros for dynamic content insertion. These macros must remain **unchanged** and not translated.
   - Macro calls start with `{{`, followed by the macro name, optional parameters, and end with `}}`.
   - Avoid invalid macro calls by ensuring curly braces, parentheses, and quotes are closed properly.

5. Technical terms and code snippets in text:

   - Keep technical terms like element names, attributes, and method names in **English**. Only translate the surrounding descriptive text.

6. Links and References:

   - Translate link descriptions, but keep the URLs and their structure intact.
   - Do not change the locale in URLs.

7. Glossary:

   - "Browser compatibility" => "Browser-Kompatibilität"
   - "Guide" => "Leitfaden"
   - "How to" => "Anleitung"

# Translation Scope

Translate the following Markdown content from **English** to **German** while adhering to the rules above.
```
---
 .../de/mozilla/firefox/releases/135/index.md  | 64 ++++++++-----
 .../dommatrix/rotateaxisangleself/index.md    | 77 ++++++++++++++++
 .../dommatrix/rotatefromvectorself/index.md   | 63 +++++++++++++
 .../de/web/api/dommatrix/scale3dself/index.md | 81 +++++++++++++++++
 .../web/api/dommatrixreadonly/rotate/index.md | 70 +++++++++++++++
 .../rotateaxisangle/index.md                  | 78 ++++++++++++++++
 .../rotatefromvector/index.md                 | 71 +++++++++++++++
 .../api/dommatrixreadonly/scale3d/index.md    | 78 ++++++++++++++++
 .../web/api/dommatrixreadonly/skewx/index.md  | 60 +++++++++++++
 .../web/api/dommatrixreadonly/skewy/index.md  | 60 +++++++++++++
 .../api/shadowroot/elementfrompoint/index.md  | 16 ++--
 .../api/shadowroot/elementsfrompoint/index.md | 12 +--
 .../web/api/svgfeblendelement/height/index.md | 41 +++++++++
 .../web/api/svgfeblendelement/result/index.md | 45 ++++++++++
 .../web/api/svgfeblendelement/width/index.md  | 41 +++++++++
 files/de/web/api/svgfeblendelement/x/index.md | 41 +++++++++
 files/de/web/api/svgfeblendelement/y/index.md | 41 +++++++++
 .../svgfecolormatrixelement/height/index.md   | 44 +++++++++
 .../svgfecolormatrixelement/result/index.md   | 45 ++++++++++
 .../svgfecolormatrixelement/width/index.md    | 42 +++++++++
 .../api/svgfecolormatrixelement/x/index.md    | 42 +++++++++
 .../api/svgfecolormatrixelement/y/index.md    | 42 +++++++++
 .../height/index.md                           | 40 +++++++++
 .../result/index.md                           | 43 +++++++++
 .../width/index.md                            | 38 ++++++++
 .../svgfecomponenttransferelement/x/index.md  | 38 ++++++++
 .../svgfecomponenttransferelement/y/index.md  | 38 ++++++++
 .../api/svgfecompositeelement/height/index.md | 39 ++++++++
 .../api/svgfecompositeelement/result/index.md | 42 +++++++++
 .../api/svgfecompositeelement/width/index.md  | 39 ++++++++
 .../web/api/svgfecompositeelement/x/index.md  | 39 ++++++++
 .../web/api/svgfecompositeelement/y/index.md  | 39 ++++++++
 .../height/index.md                           | 40 +++++++++
 .../result/index.md                           | 45 ++++++++++
 .../svgfeconvolvematrixelement/width/index.md | 40 +++++++++
 .../api/svgfeconvolvematrixelement/x/index.md | 40 +++++++++
 .../api/svgfeconvolvematrixelement/y/index.md | 42 +++++++++
 .../height/index.md                           | 41 +++++++++
 .../result/index.md                           | 44 +++++++++
 .../width/index.md                            | 41 +++++++++
 .../svgfedisplacementmapelement/x/index.md    | 41 +++++++++
 .../svgfedisplacementmapelement/y/index.md    | 41 +++++++++
 .../api/window/requestanimationframe/index.md | 44 +++++----
 files/de/web/css/_colon_open/index.md         |  6 +-
 .../html/element/heading_elements/index.md    | 89 ++++++++++---------
 45 files changed, 2001 insertions(+), 102 deletions(-)
 create mode 100644 files/de/web/api/dommatrix/rotateaxisangleself/index.md
 create mode 100644 files/de/web/api/dommatrix/rotatefromvectorself/index.md
 create mode 100644 files/de/web/api/dommatrix/scale3dself/index.md
 create mode 100644 files/de/web/api/dommatrixreadonly/rotate/index.md
 create mode 100644 files/de/web/api/dommatrixreadonly/rotateaxisangle/index.md
 create mode 100644 files/de/web/api/dommatrixreadonly/rotatefromvector/index.md
 create mode 100644 files/de/web/api/dommatrixreadonly/scale3d/index.md
 create mode 100644 files/de/web/api/dommatrixreadonly/skewx/index.md
 create mode 100644 files/de/web/api/dommatrixreadonly/skewy/index.md
 create mode 100644 files/de/web/api/svgfeblendelement/height/index.md
 create mode 100644 files/de/web/api/svgfeblendelement/result/index.md
 create mode 100644 files/de/web/api/svgfeblendelement/width/index.md
 create mode 100644 files/de/web/api/svgfeblendelement/x/index.md
 create mode 100644 files/de/web/api/svgfeblendelement/y/index.md
 create mode 100644 files/de/web/api/svgfecolormatrixelement/height/index.md
 create mode 100644 files/de/web/api/svgfecolormatrixelement/result/index.md
 create mode 100644 files/de/web/api/svgfecolormatrixelement/width/index.md
 create mode 100644 files/de/web/api/svgfecolormatrixelement/x/index.md
 create mode 100644 files/de/web/api/svgfecolormatrixelement/y/index.md
 create mode 100644 files/de/web/api/svgfecomponenttransferelement/height/index.md
 create mode 100644 files/de/web/api/svgfecomponenttransferelement/result/index.md
 create mode 100644 files/de/web/api/svgfecomponenttransferelement/width/index.md
 create mode 100644 files/de/web/api/svgfecomponenttransferelement/x/index.md
 create mode 100644 files/de/web/api/svgfecomponenttransferelement/y/index.md
 create mode 100644 files/de/web/api/svgfecompositeelement/height/index.md
 create mode 100644 files/de/web/api/svgfecompositeelement/result/index.md
 create mode 100644 files/de/web/api/svgfecompositeelement/width/index.md
 create mode 100644 files/de/web/api/svgfecompositeelement/x/index.md
 create mode 100644 files/de/web/api/svgfecompositeelement/y/index.md
 create mode 100644 files/de/web/api/svgfeconvolvematrixelement/height/index.md
 create mode 100644 files/de/web/api/svgfeconvolvematrixelement/result/index.md
 create mode 100644 files/de/web/api/svgfeconvolvematrixelement/width/index.md
 create mode 100644 files/de/web/api/svgfeconvolvematrixelement/x/index.md
 create mode 100644 files/de/web/api/svgfeconvolvematrixelement/y/index.md
 create mode 100644 files/de/web/api/svgfedisplacementmapelement/height/index.md
 create mode 100644 files/de/web/api/svgfedisplacementmapelement/result/index.md
 create mode 100644 files/de/web/api/svgfedisplacementmapelement/width/index.md
 create mode 100644 files/de/web/api/svgfedisplacementmapelement/x/index.md
 create mode 100644 files/de/web/api/svgfedisplacementmapelement/y/index.md

diff --git a/files/de/mozilla/firefox/releases/135/index.md b/files/de/mozilla/firefox/releases/135/index.md
index 9ca80003a..dd3cad720 100644
--- a/files/de/mozilla/firefox/releases/135/index.md
+++ b/files/de/mozilla/firefox/releases/135/index.md
@@ -2,7 +2,7 @@
 title: Firefox 135 für Entwickler
 slug: Mozilla/Firefox/Releases/135
 l10n:
-  sourceCommit: 3c5a0fcfbea7ac79e875b1050986d9eea44e3a7c
+  sourceCommit: 38b5682c1170760bb5f696ab675690ca6054f634
 ---
 
 {{FirefoxSidebar}}
@@ -15,75 +15,91 @@ Dieser Artikel bietet Informationen über die Änderungen in Firefox 135, die En
 
 ### HTML
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### CSS
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### JavaScript
 
-- Der [Vorschlag "JSON parse with source"](https://github.com/tc39/proposal-json-parse-with-source) wird jetzt unterstützt. Dieser zielt darauf ab, Funktionen bereitzustellen, um Probleme im Zusammenhang mit dem Verlust von Präzision zu mildern, wenn Werte wie große Fließkommazahlen und Datumswerte zwischen JavaScript-Werten und JSON-Text konvertiert werden ([Firefox-Bug 1934622](https://bugzil.la/1934622)). Insbesondere sind jetzt die folgenden Funktionen verfügbar:
-  - Das `JSON.parse()` [`reviver` Parameter `context` Argument](/de/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#the_reviver_parameter): Bietet Zugriff auf den ursprünglichen JSON-Quelltext, der analysiert wurde.
-  - [`JSON.isRawJSON()`](/de/docs/Web/JavaScript/Reference/Global_Objects/JSON/isRawJSON): Überprüft, ob ein Wert ein Objekt ist, das von `JSON.rawJSON()` zurückgegeben wird.
-  - [`JSON.rawJSON()`](/de/docs/Web/JavaScript/Reference/Global_Objects/JSON/rawJSON): Erstellt ein "rohes JSON"-Objekt, das ein Stück JSON-Text enthält und in ein Objekt eingefügt werden kann, um den angegebenen Wert zu erhalten, wenn dieses Objekt in einen String umgewandelt wird.
+- Der [JSON parse with source proposal](https://github.com/tc39/proposal-json-parse-with-source) wird jetzt unterstützt. Dieses Feature zielt darauf ab, Probleme bzgl. Präzisionsverlust bei der Umwandlung von Werten wie großen Fließkommazahlen und Datumswerten zwischen JavaScript-Werten und JSON-Texten zu mildern ([Firefox-Bug 1934622](https://bugzil.la/1934622)). Konkret sind die folgenden Features jetzt verfügbar:
+  - Das `JSON.parse()` [`reviver`-Parameter `context`-Argument](/de/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#the_reviver_parameter): Bietet Zugriff auf den ursprünglichen JSON-Quelltext, der geparst wurde.
+  - [`JSON.isRawJSON()`](/de/docs/Web/JavaScript/Reference/Global_Objects/JSON/isRawJSON): Testet, ob ein Wert ein Objekt ist, das von `JSON.rawJSON()` zurückgegeben wird.
+  - [`JSON.rawJSON()`](/de/docs/Web/JavaScript/Reference/Global_Objects/JSON/rawJSON): Erstellt ein "rohes JSON"-Objekt, das ein Stück JSON-Text enthält, welches dann in ein Objekt eingebunden werden kann, um den angegebenen Wert zu bewahren, wenn dieses Objekt zu Text umgewandelt wird.
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### SVG
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### HTTP
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### Sicherheit
 
-- [Zertifikat-Transparenz](/de/docs/Web/Security/Certificate_Transparency) ist ein Standard, der sicherstellt, dass Zertifikate öffentlich offengelegt werden, bevor Webbrowser ihnen vertrauen. Firefox unterstützt diese Funktion jetzt auf Desktop-Versionen (aber nicht auf Android).
-  Dies betrifft nur Server, die Zertifikate verwenden, die von einer Zertifizierungsstelle im Mozilla-Root-CA-Programm ausgestellt wurden.
+- [Certificate Transparency](/de/docs/Web/Security/Certificate_Transparency) ist ein Standard, der sicherstellt, dass Zertifikate öffentlich bekannt gemacht werden, bevor Webbrowser ihnen vertrauen. Firefox unterstützt dieses Feature jetzt in Desktop-Versionen (aber nicht auf Android).
+  Dies betrifft nur Server, die Zertifikate verwenden, die von einer Zertifizierungsstelle im Mozilla Root CA Program ausgestellt wurden.
   ([Firefox-Bug 1938242](https://bugzil.la/1938242)).
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### APIs
 
-- Die statische Methode [`PublicKeyCredential.getClientCapabilities()`](/de/docs/Web/API/PublicKeyCredential/getClientCapabilities_static) wird unterstützt. Sie ermöglicht es einer Web-App zu überprüfen, ob ein Browser bestimmte [WebAuthn](/de/docs/Web/API/Web_Authentication_API) Funktionen und [Erweiterungen](/de/docs/Web/API/Web_Authentication_API/WebAuthn_extensions) aktiviert, ohne auf User-Agent-Sniffing zurückgreifen zu müssen.
+- Die statische Methode [`PublicKeyCredential.getClientCapabilities()`](/de/docs/Web/API/PublicKeyCredential/getClientCapabilities_static) wird unterstützt. Sie ermöglicht es einer Web-App zu prüfen, ob ein Browser bestimmte [WebAuthn](/de/docs/Web/API/Web_Authentication_API)-Fähigkeiten und [Erweiterungen](/de/docs/Web/API/Web_Authentication_API/WebAuthn_extensions) aktiviert hat, ohne auf User-Agent-Sniffing zurückgreifen zu müssen.
   ([Firefox-Bug 1884466](https://bugzil.la/1884466)).
 
 #### DOM
 
 #### Medien, WebRTC und Web Audio
 
-- Die Eigenschaften [`mid`](/de/docs/Web/API/RTCOutboundRtpStreamStats/mid) und [`rid`](/de/docs/Web/API/RTCOutboundRtpStreamStats/rid) des [`RTCOutboundRtpStreamStats`](/de/docs/Web/API/RTCOutboundRtpStreamStats) Interfaces und die [`mid`](/de/docs/Web/API/RTCOutboundRtpStreamStats/mid) Eigenschaft des [`RTCInboundRtpStreamStats`](/de/docs/Web/API/RTCInboundRtpStreamStats) Interfaces werden jetzt unterstützt. ([Firefox-Bug 1643001](https://bugzil.la/1643001)).
+- Die Eigenschaften [`mid`](/de/docs/Web/API/RTCOutboundRtpStreamStats/mid) und [`rid`](/de/docs/Web/API/RTCOutboundRtpStreamStats/rid) des [`RTCOutboundRtpStreamStats`](/de/docs/Web/API/RTCOutboundRtpStreamStats)-Interfaces sowie die[`mid`](/de/docs/Web/API/RTCOutboundRtpStreamStats/mid)-Eigenschaft des [`RTCInboundRtpStreamStats`](/de/docs/Web/API/RTCInboundRtpStreamStats)-Interfaces werden nun unterstützt. ([Firefox-Bug 1643001](https://bugzil.la/1643001)).
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### WebAssembly
 
-#### Entfernungen
+#### Entfernte Elemente
 
 ### WebDriver-Konformität (WebDriver BiDi, Marionette)
 
 #### Allgemein
 
+- Um Benutzereingaben realistischer zu gestalten und echte Benutzerinteraktionen im Browser besser zu simulieren, haben wir die Aktionssequenz-Verarbeitung der `Perform Actions`-Befehle sowohl in Marionette als auch in WebDriver BiDi vom Inhaltsprozess in den Hauptprozess verschoben. Während Ereignisse immer noch synchron vom Inhaltsprozess gesendet werden, werden sie jetzt asynchron über IPC-Aufrufe ausgelöst, die vom Hauptprozess ausgehen ([Firefox-Bug 1922077](https://bugzilla.mozilla.org/show_bug.cgi?id=1922077)).
+
+  Aufgrund dieser signifikanten Änderung können einige Regressionen weiterhin bestehen. Wenn Sie auf Probleme stoßen, melden Sie bitte einen [Fehler für den Remote Agent](https://bugzilla.mozilla.org/enter_bug.cgi?product=Remote%20Protocol&component=Remote%20Agent). Sollten die Regressionen die Testausführung blockieren, können Sie vorübergehend zum vorherigen Verhalten zurückkehren, indem Sie die Firefox-Präferenz `remote.events.async.enabled` auf `false` setzen.
+
+- Mit der Verarbeitung von Aktionen jetzt im Hauptprozess wurden auch folgende Probleme behoben:
+
+  - Wir unterstützen jetzt das ordnungsgemäße Einreihen von Aktionssequenzen ohne Race-Conditions. Dies ist besonders wichtig für den Befehl `input.performActions` von WebDriver BiDi, der mehrfach parallel aufgerufen werden kann und die eingereihten Aktionen nacheinander ausführen muss ([Firefox-Bug 1915798](https://bugzilla.mozilla.org/show_bug.cgi?id=1915798)).
+
+  - Beim Senden von Aktionen wird die `input cancel list` nun korrekt erst dann aktualisiert, wenn die Aktion erfolgreich gesendet wurde. Vorher konnte, wenn eine Aktion nicht ausgeführt werden konnte, eine Rückwärtsaktion stehen bleiben, was zu unerwarteten Nebeneffekten beim Zurücksetzen des Zustands der `input source` führen konnte ([Firefox-Bug 1930845](https://bugzilla.mozilla.org/show_bug.cgi?id=1930845)).
+
+  - Bei der Ausführung von Aktionen werden einzelne Aktionen nun während des Sendens erneut versucht, insbesondere in Situationen, in denen eine einzelne Aktion eine Navigation auslöst, die den aktuellen Browsing-Kontext ersetzt ([Firefox-Bug 1930530](https://bugzilla.mozilla.org/show_bug.cgi?id=1930530), [Firefox-Bug 1930090](https://bugzilla.mozilla.org/show_bug.cgi?id=1930090)).
+
+  - Bei der Ausführung von Aktionen trat ein Fehler `TypeError: can't access property "getActor", browsingContext.currentWindowGlobal is null` auf, wenn eine Aktion (nicht die letzte) in der Aktionskette das Fenster schloss und die verbleibenden Aktionen noch gesendet wurden ([Firefox-Bug 1932916](https://bugzilla.mozilla.org/show_bug.cgi?id=1932916)).
+
+- Einige Marionette- und WebDriver BiDi-Befehle, die intern darauf angewiesen sind, dass ein `requestAnimationFrame` gesendet wird, bevor sie zurückgeben, würden hängen bleiben, wenn der aktuelle Browsing-Kontext während ihrer Ausführung navigiert wurde ([Firefox-Bug 1937118](https://bugzilla.mozilla.org/show_bug.cgi?id=1937118)).
+
 #### WebDriver BiDi
 
-#### Marionette
+- Unterstützung für das `format`-Feld im Befehl `browsingContext.captureScreenshot` hinzugefügt, mit dem Clients verschiedene Dateiformate angeben können (`image/png` und `image/jpg` werden derzeit unterstützt) und die Kompressionsqualität für Screenshots definieren können ([Firefox-Bug 1861737](https://bugzilla.mozilla.org/show_bug.cgi?id=1861737)).
 
 ## Änderungen für Add-on-Entwickler
 
-### Entfernungen
+### Entfernte Elemente
 
 ### Sonstiges
 
-## Experimentelle Web-Features
+## Experimentelle Webfeatures
 
-Diese Funktionen sind neu in Firefox 135 verfügbar, aber standardmäßig deaktiviert. Um mit ihnen zu experimentieren, suchen Sie die entsprechende Einstellung auf der `about:config` Seite und setzen Sie sie auf `true`. Weitere solche Funktionen finden Sie auf der Seite [Experimentelle Features](/de/docs/Mozilla/Firefox/Experimental_features).
+Diese Features sind neu in Firefox 135 verfügbar, aber standardmäßig deaktiviert. Um mit ihnen zu experimentieren, suchen Sie auf der Seite `about:config` nach der entsprechenden Präferenz und setzen Sie diese auf `true`. Weitere solche Features finden Sie auf der Seite [Experimentelle Features](/de/docs/Mozilla/Firefox/Experimental_features).
 
-- **Priiorisierte Task-Planungs-API**: <code>dom.enable_web_task_scheduling</code>.
-  Die [Priiorisierte Task-Planungs-API](/de/docs/Web/API/Prioritized_Task_Scheduling_API) bietet einen standardisierten Weg, um alle Aufgaben einer Anwendung zu priorisieren, unabhängig davon, ob sie im Code eines Websiteentwicklers oder in Drittanbieter-Bibliotheken und Frameworks definiert sind.
-  Diese wurde vorübergehend in Nightly-Builds deaktiviert, um [Fehler in freier Wildbahn](https://bugzil.la/1937232) zu vermeiden.
+- **Priorisiertes Task Scheduling API**: <code>dom.enable_web_task_scheduling</code>.
+  Die [Priorisierte Task Scheduling API](/de/docs/Web/API/Prioritized_Task_Scheduling_API) bietet eine standardisierte Möglichkeit, alle Aufgaben, die zu einer Anwendung gehören, zu priorisieren, egal ob sie im Code eines Website-Entwicklers oder in Drittanbieter-Bibliotheken und -Frameworks definiert sind.
+  Dies wurde vorübergehend in Nightly-Builds deaktiviert, um [Fehler im Natursystem](https://bugzil.la/1937232) zu vermeiden.
   ([Firefox-Bug 1938242](https://bugzil.la/1938242)).
 
 ## Ältere Versionen
diff --git a/files/de/web/api/dommatrix/rotateaxisangleself/index.md b/files/de/web/api/dommatrix/rotateaxisangleself/index.md
new file mode 100644
index 000000000..b8aeb0ba8
--- /dev/null
+++ b/files/de/web/api/dommatrix/rotateaxisangleself/index.md
@@ -0,0 +1,77 @@
+---
+title: "DOMMatrix: rotateAxisAngleSelf() Methode"
+short-title: rotateAxisAngleSelf()
+slug: Web/API/DOMMatrix/rotateAxisAngleSelf
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die `rotateAxisAngleSelf()`-Methode des [`DOMMatrix`](/de/docs/Web/API/DOMMatrix)-Interfaces ist eine Transformationsmethode, die die Quellmatrix um den gegebenen Vektor und Winkel dreht und die veränderte Matrix zurückgibt.
+
+Um eine Matrix zu drehen, ohne sie zu verändern, siehe [`DOMMatrixReadOnly.rotateAxisAngle()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateAxisAngle), welche eine neue gedrehte Matrix erzeugt und die ursprüngliche unverändert lässt.
+
+## Syntax
+
+```js-nolint
+DOMMatrix.rotateAxisAngleSelf()
+DOMMatrix.rotateAxisAngleSelf(rotX)
+DOMMatrix.rotateAxisAngleSelf(rotX, rotY)
+DOMMatrix.rotateAxisAngleSelf(rotX, rotY, rotZ)
+DOMMatrix.rotateAxisAngleSelf(rotX, rotY, rotZ, angle)
+```
+
+### Parameter
+
+- `rotX`
+  - : Eine Zahl; die x-Koordinate des Vektors, der die Rotationsachse bezeichnet. Wenn ungleich null, ist [`is2D`](/de/docs/Web/API/DOMMatrix/is2d) false.
+- `rotY` {{optional_inline}}
+  - : Eine Zahl; die y-Koordinate des Vektors, der die Rotationsachse bezeichnet. Wenn nicht definiert, wird der `rotX`-Wert verwendet. Wenn ungleich null, ist [`is2D`](/de/docs/Web/API/DOMMatrix/is2d) false.
+- `rotZ` {{optional_inline}}
+  - : Eine Zahl; die z-Koordinate des Vektors, der die Rotationsachse bezeichnet. Wenn nicht definiert, wird der `rotX`-Wert verwendet.
+- `angle` {{optional_inline}}
+  - : Eine Zahl; der Drehwinkel um den Achsenvektor, in Grad.
+
+Falls `rotY` und `rotZ` beide fehlen, wird `rotZ` auf den Wert von `rotX` gesetzt und sowohl `rotX` als auch `rotY` sind `0`.
+
+### Rückgabewert
+
+Eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix(); // create a matrix
+console.log(matrix.rotateAxisAngleSelf(10, 20, 30, 45).toString());
+/* "matrix3d(
+    0.728, 0.609, -0.315, 0, 
+    -0.525, 0.791, 0.315, 0, 
+    0.441, -0.063, 0.895, 
+    0, 0, 0, 0, 1)" */
+console.log(matrix.toString());
+/* "matrix3d(
+    0.728, 0.609, -0.315, 0, 
+    -0.525, 0.791, 0.315, 0, 
+    0.441, -0.063, 0.895, 0, 
+    0, 0, 0, 1)" */
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrixReadOnly.rotateAxisAngle()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateAxisAngle)
+- [`DOMMatrix.rotateSelf()`](/de/docs/Web/API/DOMMatrix/rotateSelf)
+- [`DOMMatrix.rotateFromVectorSelf()`](/de/docs/Web/API/DOMMatrix/rotateFromVectorSelf)
+- CSS {{cssxref("transform")}} Eigenschaft und {{cssxref("transform-function/rotate3d", "rotate3d()")}} Funktion
+- CSS {{cssxref("rotate")}} Eigenschaft
+- [CSS Transforms](/de/docs/Web/CSS/CSS_transforms) Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D) Interface und die [`rotate()`](/de/docs/Web/API/CanvasRenderingContext2D/rotate) Methode
diff --git a/files/de/web/api/dommatrix/rotatefromvectorself/index.md b/files/de/web/api/dommatrix/rotatefromvectorself/index.md
new file mode 100644
index 000000000..32cd0074d
--- /dev/null
+++ b/files/de/web/api/dommatrix/rotatefromvectorself/index.md
@@ -0,0 +1,63 @@
+---
+title: "DOMMatrix: rotateFromVectorSelf() Methode"
+short-title: rotateFromVectorSelf()
+slug: Web/API/DOMMatrix/rotateFromVectorSelf
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die `rotateFromVectorSelf()` Methode der [`DOMMatrix`](/de/docs/Web/API/DOMMatrix)-Schnittstelle ist eine veränderbare Transformationsmethode, die eine Matrix verändert, indem sie die Matrix um den Winkel zwischen dem angegebenen Vektor und `(1, 0)` dreht. Der Rotationswinkel wird durch den Winkel zwischen dem Vektor `(1,0)T` und `(x,y)T` im Uhrzeigersinn bestimmt, oder `(+/-)arctan(y/x)`. Wenn `x` und `y` beide `0` sind, wird der Winkel als `0` festgelegt und die Matrix nicht verändert.
+
+Um eine Matrix ohne Veränderung durch einen Vektor zu rotieren, siehe [`DOMMatrixReadOnly.rotateFromVector()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateFromVector), welche eine neue rotierte Matrix erstellt, während die ursprüngliche unverändert bleibt.
+
+## Syntax
+
+```js-nolint
+DOMMatrix.rotateFromVectorSelf()
+DOMMatrix.rotateFromVectorSelf(rotX)
+DOMMatrix.rotateFromVectorSelf(rotX, rotY)
+```
+
+### Parameter
+
+- `rotX` {{optional_inline}}
+  - : Eine Zahl; Die x-Koordinate des x,y Vektors, der den Rotationswinkel bestimmt. Wenn nicht definiert, wird `0` verwendet.
+- `rotY` {{optional_inline}}
+  - : Eine Zahl; Die y-Koordinate des x,y Vektors, der den Rotationswinkel bestimmt. Wenn nicht definiert, wird `0` verwendet.
+
+### Rückgabewert
+
+Gibt sich selbst zurück; die aktualisierte [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix(); // create a matrix
+console.log(matrix.rotateFromVectorSelf().toString());
+// output: matrix(1, 0, 0, 1, 0, 0) (no rotation applied)
+console.log(matrix.rotateFromVectorSelf(10, 20).toString());
+// output: matrix(0.447, 0.894, -0.894, 0.447, 0, 0)
+console.log(matrix.toString());
+// output: matrix(0.447, 0.894, -0.894, 0.447, 0, 0) (same as above)
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrixReadOnly.rotateFromVector()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateFromVector)
+- [`DOMMatrixRead.rotateSelf()`](/de/docs/Web/API/DOMMatrixRead/rotateSelf)
+- [`DOMMatrixRead.rotateAxisAngleSelf()`](/de/docs/Web/API/DOMMatrixRead/rotateAxisAngleSelf)
+- CSS {{cssxref("transform")}} Eigenschaft und {{cssxref("transform-function/rotate3d", "rotate3d()")}} Funktion
+- CSS {{cssxref("rotate")}} Eigenschaft
+- [CSS-Transformationen](/de/docs/Web/CSS/CSS_transforms) Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D) Schnittstelle und [`rotate()`](/de/docs/Web/API/CanvasRenderingContext2D/rotate) Methode
diff --git a/files/de/web/api/dommatrix/scale3dself/index.md b/files/de/web/api/dommatrix/scale3dself/index.md
new file mode 100644
index 000000000..e7f57e112
--- /dev/null
+++ b/files/de/web/api/dommatrix/scale3dself/index.md
@@ -0,0 +1,81 @@
+---
+title: "DOMMatrix: scale3dSelf() Methode"
+short-title: scale3dSelf()
+slug: Web/API/DOMMatrix/scale3dSelf
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die **`scale3dSelf()`**-Methode der [`DOMMatrix`](/de/docs/Web/API/DOMMatrix)-Schnittstelle ist eine veränderbare Transformationsmethode, die eine Matrix modifiziert, indem sie einen angegebenen Skalierungsfaktor auf alle drei Achsen anwendet, zentriert auf den angegebenen Ursprung, mit einem Standardursprung von `(0, 0, 0)`, und die 3D-scalierte Matrix zurückgibt.
+
+Um eine Matrix in 3D zu skalieren, ohne sie zu verändern, siehe [`DOMMatrixReadOnly.scale3d()`](/de/docs/Web/API/DOMMatrixReadOnly/scale3d), die eine neue skalierte Matrix erstellt, während die ursprüngliche unverändert bleibt.
+
+## Syntax
+
+Die `scale3dSelf()`-Methode kann mit null bis vier Werten angegeben werden.
+
+```js
+DOMMatrix.scale3dSelf();
+DOMMatrix.scale3dSelf(scale);
+DOMMatrix.scale3dSelf(scale, originX);
+DOMMatrix.scale3dSelf(scale, originX, originY);
+DOMMatrix.scale3dSelf(scale, originX, originY, originZ);
+```
+
+### Parameter
+
+- `scale`
+  - : Ein Multiplikator; der Skalierungswert. Wenn keine Skalierung angegeben wird, ist der Standardwert `1`. Wenn die Skalierung nicht 1 ist, wird die [`is2D`](/de/docs/Web/API/DOMMatrixReadOnly/is2D) Eigenschaft der aktuellen Matrix auf `false` gesetzt.
+- `originX` {{optional_inline}}
+  - : Eine x-Koordinate für den Ursprung der Transformation. Wenn kein Ursprung angegeben wird, ist der Standardwert `0`.
+- `originY` {{optional_inline}}
+  - : Eine y-Koordinate für den Ursprung der Transformation. Wenn kein Ursprung angegeben wird, ist der Standardwert `0`.
+- `originZ` {{optional_inline}}
+  - : Eine z-Koordinate für den Ursprung der Transformation. Wenn kein Ursprung angegeben wird, ist der Standardwert `0`.
+
+### Rückgabewert
+
+Gibt sich selbst zurück; eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix();
+console.log(matrix.scale3dSelf(2).toString());
+/* matrix3d(
+    2, 0, 0, 0, 
+    0, 2, 0, 0, 
+    0, 0, 2, 0, 
+    0, 0, 0, 1) */
+console.log(matrix.scale3dSelf(3.1, 25, 25, 1.25).toString());
+/* matrix3d(
+    6.2, 0, 0, 0,
+    0, 6.2, 0, 0, 
+    0, 0, 6.2, 0, 
+    -105, -105, -5.25, 1) */
+console.log(matrix.toString());
+/* matrix3d(
+    6.2, 0, 0, 0, 
+    0, 6.2, 0, 0, 
+    0, 0, 6.2, 0, 
+    -105, -105, -5.25, 1) (same as above) */
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrixReadOnly.scale3d()`](/de/docs/Web/API/DOMMatrixReadOnly/scale3d)
+- [`DOMMatrix.scaleSelf()`](/de/docs/Web/API/DOMMatrix/scaleSelf)
+- CSS {{cssxref("transform")}} Eigenschaft und die {{cssxref("transform-function/scale", "scale3d()")}} und {{cssxref("transform-function/matrix3d", "matrix3d()")}} Funktionen
+- [CSS-Transformationen](/de/docs/Web/CSS/CSS_transforms)-Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D) Schnittstelle [`transform()`](/de/docs/Web/API/CanvasRenderingContext2D/transform) Methode
diff --git a/files/de/web/api/dommatrixreadonly/rotate/index.md b/files/de/web/api/dommatrixreadonly/rotate/index.md
new file mode 100644
index 000000000..28ad902a0
--- /dev/null
+++ b/files/de/web/api/dommatrixreadonly/rotate/index.md
@@ -0,0 +1,70 @@
+---
+title: "DOMMatrixReadOnly: rotate()-Methode"
+short-title: rotate()
+slug: Web/API/DOMMatrixReadOnly/rotate
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die `rotate()`-Methode des [`DOMMatrixReadOnly`](/de/docs/Web/API/DOMMatrixReadOnly)-Interfaces gibt eine neue [`DOMMatrix`](/de/docs/Web/API/DOMMatrix) zurück, die durch das Drehen der Ausgangsmatrix um jede ihrer Achsen um die angegebene Anzahl von Grad erstellt wird. Die ursprüngliche Matrix wird nicht verändert.
+
+Um die Matrix während der Drehung zu ändern, siehe [`DOMMatrix.rotateSelf()`](/de/docs/Web/API/DOMMatrix/rotateSelf).
+
+## Syntax
+
+```js-nolint
+DOMMatrixReadOnly.rotate()
+DOMMatrixReadOnly.rotate(rotX)
+DOMMatrixReadOnly.rotate(rotX, rotY)
+DOMMatrixReadOnly.rotate(rotX, rotY, rotZ)
+```
+
+### Parameter
+
+- `rotX`
+  - : Eine Zahl; die x-Koordinate des Vektors, der die Drehachse angibt. Wenn ungleich null, ist [`is2D`](/de/docs/Web/API/DOMMatrix#is2d) false.
+- `rotY` {{optional_inline}}
+  - : Eine Zahl; die y-Koordinate des Vektors, der die Drehachse angibt. Wenn ungleich null, ist [`is2D`](/de/docs/Web/API/DOMMatrix#is2d) false.
+- `rotZ` {{optional_inline}}
+  - : Eine Zahl; die z-Koordinate des Vektors, der die Drehachse angibt.
+
+Wenn nur `rotX` übergeben wird, dann wird `rotX` als Wert für die z-Koordinate verwendet und die x- und y-Koordinaten werden beide auf null gesetzt.
+
+### Rückgabewert
+
+Eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix(); // create a matrix
+console.log(matrix.toString());
+// output: "matrix(1, 0, 0, 1, 0, 0)"
+
+const rotated = matrix.rotate(30); // rotation and assignment
+console.log(matrix.toString()); // original matrix is unchanged
+// output: "matrix(1, 0, 0, 1, 0, 0)"
+console.log(rotated.toString());
+// output: "matrix(0.866, 0.5, -0.5, 0.866, 0, 0)"
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrix.rotateSelf()`](/de/docs/Web/API/DOMMatrix/rotateSelf)
+- [`DOMMatrixReadOnly.rotateAxisAngle()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateAxisAngle)
+- [`DOMMatrixReadOnly.rotateFromVector()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateFromVector)
+- CSS {{cssxref("transform")}}-Eigenschaft und {{cssxref("transform-function/rotate3d", "rotate3d()")}}-Funktion
+- CSS {{cssxref("rotate")}}-Eigenschaft
+- Modul [CSS transforms](/de/docs/Web/CSS/CSS_transforms)
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform)-Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D)-Interface und [`rotate()`](/de/docs/Web/API/CanvasRenderingContext2D/rotate)-Methode
diff --git a/files/de/web/api/dommatrixreadonly/rotateaxisangle/index.md b/files/de/web/api/dommatrixreadonly/rotateaxisangle/index.md
new file mode 100644
index 000000000..b90317680
--- /dev/null
+++ b/files/de/web/api/dommatrixreadonly/rotateaxisangle/index.md
@@ -0,0 +1,78 @@
+---
+title: "DOMMatrixReadOnly: rotateAxisAngle() Methode"
+short-title: rotateAxisAngle()
+slug: Web/API/DOMMatrixReadOnly/rotateAxisAngle
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die `rotateAxisAngle()` Methode des [`DOMMatrixReadOnly`](/de/docs/Web/API/DOMMatrixReadOnly) Interfaces gibt eine neue [`DOMMatrix`](/de/docs/Web/API/DOMMatrix) zurück, die durch Rotation der Ursprungsmatrix um den gegebenen Vektor und Winkel erstellt wird. Die Originalmatrix wird nicht verändert.
+
+Um die Matrix während der Rotation zu ändern, siehe [`DOMMatrix.rotateAxisAngleSelf()`](/de/docs/Web/API/DOMMatrix/rotateAxisAngleSelf).
+
+## Syntax
+
+```js-nolint
+DOMMatrixReadOnly.rotateAxisAngle()
+DOMMatrixReadOnly.rotateAxisAngle(rotX)
+DOMMatrixReadOnly.rotateAxisAngle(rotX, rotY)
+DOMMatrixReadOnly.rotateAxisAngle(rotX, rotY, rotZ)
+DOMMatrixReadOnly.rotateAxisAngle(rotX, rotY, rotZ, angle)
+```
+
+### Parameter
+
+- `rotX`
+  - : Eine Zahl; die x-Koordinate des Vektors, der die Rotationsachse angibt. Wenn ungleich null, ist [`is2D`](/de/docs/Web/API/DOMMatrixReadOnly/is2D) falsch.
+- `rotY` {{optional_inline}}
+  - : Eine Zahl; die y-Koordinate des Vektors, der die Rotationsachse angibt. Wenn undefiniert, wird der `rotX` Wert verwendet. Wenn ungleich null, ist [`is2D`](/de/docs/Web/API/DOMMatrixReadOnly/is2D) falsch.
+- `rotZ` {{optional_inline}}
+  - : Eine Zahl; die z-Koordinate des Vektors, der die Rotationsachse angibt. Wenn undefiniert, wird der `rotX` Wert verwendet.
+- `angle` {{optional_inline}}
+  - : Eine Zahl; der Winkel der Rotation um den Achsenvektor, in Grad.
+
+### Rückgabewert
+
+Eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix(); // create a matrix
+console.log(matrix.rotateAxisAngle().toString()); // matrix(1, 0, 0, 1, 0, 0)
+console.log(matrix.rotateAxisAngle(10, 20, 30).toString()); // matrix(1, 0, 0, 1, 0, 0)
+console.log(matrix.rotateAxisAngle(10, 20, 30, 45).toString());
+/* matrix3d(
+    0.728, 0.609, -0.315, 0, 
+    -0.525, 0.791, 0.315, 0, 
+    0.441, -0.063, 0.895, 
+    0, 0, 0, 0, 1) */
+console.log(matrix.rotateAxisAngle(5, 5, 5, -45).toString());
+/* matrix3d(
+    0.805, -0.311, 0.506, 0, 
+    0.506, 0.805, -0.311, 0, 
+    -0.311, 0.506, 0.805, 0, 
+    0, 0, 0, 1) */
+console.log(matrix.toString()); // output: "matrix(1, 0, 0, 1, 0, 0)" (unchanged)
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrix.rotateAxisAngleSelf()`](/de/docs/Web/API/DOMMatrix/rotateAxisAngleSelf)
+- [`DOMMatrixReadOnly.rotate()`](/de/docs/Web/API/DOMMatrixReadOnly/rotate)
+- [`DOMMatrixReadOnly.rotateFromVector()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateFromVector)
+- CSS {{cssxref("transform")}} Eigenschaft und {{cssxref("transform-function/rotate3d", "rotate3d()")}} Funktion
+- CSS {{cssxref("rotate")}} Eigenschaft
+- [CSS Transforms](/de/docs/Web/CSS/CSS_transforms) Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D) Schnittstelle und [`rotate()`](/de/docs/Web/API/CanvasRenderingContext2D/rotate) Methode
diff --git a/files/de/web/api/dommatrixreadonly/rotatefromvector/index.md b/files/de/web/api/dommatrixreadonly/rotatefromvector/index.md
new file mode 100644
index 000000000..2ae716b75
--- /dev/null
+++ b/files/de/web/api/dommatrixreadonly/rotatefromvector/index.md
@@ -0,0 +1,71 @@
+---
+title: "DOMMatrixReadOnly: Methode rotateFromVector()"
+short-title: rotateFromVector()
+slug: Web/API/DOMMatrixReadOnly/rotateFromVector
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die `rotateFromVector()`-Methode der [`DOMMatrixReadOnly`](/de/docs/Web/API/DOMMatrixReadOnly)-Schnittstelle gibt eine neue [`DOMMatrix`](/de/docs/Web/API/DOMMatrix) zurück, die durch Drehen der Ausgangsmatrix um den Winkel zwischen dem angegebenen Vektor und `(1, 0)` erstellt wurde. Der Rotationswinkel wird durch den Winkel zwischen dem Vektor `(1,0)T` und `(x,y)T` im Uhrzeigersinn bestimmt, oder durch `(+/-)arctan(y/x)`. Wenn `x` und `y` beide `0` sind, wird der Winkel als `0` angegeben. Die ursprüngliche Matrix wird nicht verändert.
+
+Um die Matrix zu ändern, während Sie sie um den Winkel zwischen dem angegebenen Vektor und `(1, 0)` drehen, siehe [`DOMMatrix.rotateFromVectorSelf()`](/de/docs/Web/API/DOMMatrix/rotateFromVectorSelf).
+
+## Syntax
+
+```js-nolint
+DOMMatrixReadOnly.rotateFromVector()
+DOMMatrixReadOnly.rotateFromVector(rotX)
+DOMMatrixReadOnly.rotateFromVector(rotX, rotY)
+```
+
+### Parameter
+
+- `rotX` {{optional_inline}}
+  - : Eine Zahl; Die x-Koordinate des x,y-Vektors, der den Rotationswinkel bestimmt. Wenn nicht definiert, wird `0` verwendet.
+- `rotY` {{optional_inline}}
+  - : Eine Zahl; Die y-Koordinate des x,y-Vektors, der den Rotationswinkel bestimmt. Wenn nicht definiert, wird `0` verwendet.
+
+### Rückgabewert
+
+Eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix(); // create a matrix
+console.log(matrix.toString()); // original value
+// output: "matrix(1, 0, 0, 1, 0, 0)"
+
+console.log(matrix.rotateFromVector().toString()); // defaults to `0`
+// output: matrix(1, 0, 0, 1, 0, 0)
+
+console.log(matrix.rotateFromVector(10, 20).toString());
+// matrix(0.447, 0.894, -0.894, 0.447, 0, 0)
+
+console.log(matrix.rotateFromVector(-5, 5).toString());
+// matrix(-0.707, 0.707, -0.707, -0.707, 0, 0)
+
+console.log(matrix.toString()); // matrix remains unchanged
+// output: "matrix(1, 0, 0, 1, 0, 0)"
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrix.rotateFromVectorSelf()`](/de/docs/Web/API/DOMMatrix/rotateFromVectorSelf)
+- [`DOMMatrixReadOnly.rotate()`](/de/docs/Web/API/DOMMatrixReadOnly/rotate)
+- [`DOMMatrixReadOnly.rotateAxisAngle()`](/de/docs/Web/API/DOMMatrixReadOnly/rotateAxisAngle)
+- CSS {{cssxref("transform")}} Eigenschaft und {{cssxref("transform-function/rotate3d", "rotate3d()")}} Funktion
+- CSS {{cssxref("rotate")}} Eigenschaft
+- [CSS-Transformationen](/de/docs/Web/CSS/CSS_transforms) Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D)-Schnittstelle und [`rotate()`](/de/docs/Web/API/CanvasRenderingContext2D/rotate) Methode
diff --git a/files/de/web/api/dommatrixreadonly/scale3d/index.md b/files/de/web/api/dommatrixreadonly/scale3d/index.md
new file mode 100644
index 000000000..01587fb45
--- /dev/null
+++ b/files/de/web/api/dommatrixreadonly/scale3d/index.md
@@ -0,0 +1,78 @@
+---
+title: "DOMMatrixReadOnly: scale3d()-Methode"
+short-title: scale3d()
+slug: Web/API/DOMMatrixReadOnly/scale3d
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die **`scale3d()`**-Methode der [`DOMMatrixReadOnly`](/de/docs/Web/API/DOMMatrixReadOnly)-Schnittstelle erstellt eine neue Matrix, die das Ergebnis einer 3D-Skalierungstransformation ist, die auf die Matrix angewendet wird. Sie gibt eine neue [`DOMMatrix`](/de/docs/Web/API/DOMMatrix) zurück, die erstellt wird, indem die Quell-3D-Matrix anhand des angegebenen Skalierungsfaktors skaliert wird, zentriert auf den Ursprungspunkt, der durch die Ursprungsparameter angegeben wird, wobei der Standardursprung `(0, 0, 0)` ist. Die Originalmatrix wird nicht verändert.
+
+Um die Matrix zu ändern, während Sie sie 3D-skalieren, siehe [`DOMMatrix.scale3dSelf()`](/de/docs/Web/API/DOMMatrix/scale3dSelf).
+
+## Syntax
+
+```js
+DOMMatrixReadOnly.scale3d();
+DOMMatrixReadOnly.scale3d(scale);
+DOMMatrixReadOnly.scale3d(scale, originX);
+DOMMatrixReadOnly.scale3d(scale, originX, originY);
+DOMMatrixReadOnly.scale3d(scale, originX, originY, originZ);
+```
+
+### Parameter
+
+- `scale`
+  - : Ein Multiplikator; der Skalierungswert. Wenn keine Skala angegeben wird, ist der Standardwert `1`.
+- `originX` {{optional_inline}}
+  - : Eine x-Koordinate für den Ursprung der Transformation. Wenn kein Ursprung angegeben wird, ist der Standardwert `0`.
+- `originY` {{optional_inline}}
+  - : Eine y-Koordinate für den Ursprung der Transformation. Wenn kein Ursprung angegeben wird, ist der Standardwert `0`.
+- `originZ` {{optional_inline}}
+  - : Eine z-Koordinate für den Ursprung der Transformation. Wenn dieser Wert `0` ist, was der Standardwert ist, wenn nichts angegeben wird, könnte die resultierende Matrix nicht 3D sein.
+
+### Rückgabewert
+
+Eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix();
+console.log(matrix.toString()); // no transforms applied
+// matrix(1, 0, 0, 1, 0, 0)
+
+console.log(matrix.scale3d(2).toString());
+/* matrix3d(
+    2, 0, 0, 0, 
+    0, 2, 0, 0, 
+    0, 0, 2, 0, 
+    0, 0, 0, 1) */
+console.log(matrix.scale3d(0.5, 25, 25, 1.25).toString());
+/* matrix3d(
+    0.5, 0, 0, 0, 
+    0, 0.5, 0, 0, 
+    0, 0, 0.5, 0, 1
+    2.5, 12.5, 0.625, 1) */
+console.log(matrix.toString()); // original matrix is unchanged
+// matrix(1, 0, 0, 1, 0, 0)
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrix.scale3dSelf()`](/de/docs/Web/API/DOMMatrix/scale3dSelf)
+- [`DOMMatrixReadOnly.scale()`](/de/docs/Web/API/DOMMatrixReadOnly/scale)
+- CSS {{cssxref("transform")}}-Eigenschaft und {{cssxref("transform-function/scale3d", "scale3d()")}}- und {{cssxref("transform-function/matrix3d", "matrix3d()")}}-Funktionen
+- [CSS transforms](/de/docs/Web/CSS/CSS_transforms) Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D)-Schnittstelle mit der Methode [`CanvasRenderingContext2D.transform()`](/de/docs/Web/API/CanvasRenderingContext2D/transform)
diff --git a/files/de/web/api/dommatrixreadonly/skewx/index.md b/files/de/web/api/dommatrixreadonly/skewx/index.md
new file mode 100644
index 000000000..ab485bdba
--- /dev/null
+++ b/files/de/web/api/dommatrixreadonly/skewx/index.md
@@ -0,0 +1,60 @@
+---
+title: "DOMMatrixReadOnly: skewX() Methode"
+short-title: skewX()
+slug: Web/API/DOMMatrixReadOnly/skewX
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die `skewX()` Methode des [`DOMMatrixReadOnly`](/de/docs/Web/API/DOMMatrixReadOnly) Interfaces gibt eine neue [`DOMMatrix`](/de/docs/Web/API/DOMMatrix) zurück, die durch Anwenden der angegebenen Schrägtransformation an der Quellmatrix entlang ihrer x-Achse erstellt wird. Die ursprüngliche Matrix wird nicht verändert.
+
+Um die Matrix beim Schrägen entlang der x-Achse zu verändern, siehe [`DOMMatrix.skewXSelf()`](/de/docs/Web/API/DOMMatrix/skewXSelf).
+
+## Syntax
+
+```js-nolint
+DOMMatrixReadOnly.skewX()
+DOMMatrixReadOnly.skewX(sX)
+```
+
+### Parameter
+
+- `sX`
+  - : Eine Zahl; der Winkel in Grad, um den die Matrix entlang der x-Achse schräg gestellt wird.
+
+### Rückgabewert
+
+Eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix(); // create a matrix
+console.log(matrix.toString()); // no transform applied
+// "matrix(1, 0, 0, 1, 0, 0)"
+
+console.log(matrix.skewX(14).toString());
+//"matrix(1, 0, 0.25, 1, 0, 0)"
+
+console.log(matrix.toString()); // original is unchanged
+// "matrix(1, 0, 0, 1, 0, 0)"
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrixReadOnly.skewY()`](/de/docs/Web/API/DOMMatrixReadOnly/skewY)
+- [`DOMMatrix.skewX()`](/de/docs/Web/API/DOMMatrix/skewX)
+- CSS {{cssxref("transform")}} Eigenschaft und die {{cssxref("transform-function/skew", "skew()")}}, {{cssxref("transform-function/skewX", "skewX()")}}, und {{cssxref("transform-function/matrix", "matrix()")}} Funktionen
+- [CSS Transformationen](/de/docs/Web/CSS/CSS_transforms) Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D) Schnittstelle's [`transform()`](/de/docs/Web/API/CanvasRenderingContext2D/transform) Methode
diff --git a/files/de/web/api/dommatrixreadonly/skewy/index.md b/files/de/web/api/dommatrixreadonly/skewy/index.md
new file mode 100644
index 000000000..47567f678
--- /dev/null
+++ b/files/de/web/api/dommatrixreadonly/skewy/index.md
@@ -0,0 +1,60 @@
+---
+title: "DOMMatrixReadOnly: skewY()-Methode"
+short-title: skewY()
+slug: Web/API/DOMMatrixReadOnly/skewY
+l10n:
+  sourceCommit: e65acfebb0c59023677e0bab3cc56159d2a22ed5
+---
+
+{{APIRef("Geometry Interfaces")}}{{AvailableInWorkers}}
+
+Die `skewY()`-Methode der [`DOMMatrixReadOnly`](/de/docs/Web/API/DOMMatrixReadOnly)-Schnittstelle gibt eine neue [`DOMMatrix`](/de/docs/Web/API/DOMMatrix) zurück, die durch Anwenden der angegebenen Schertransformation auf die Quellmatrix entlang ihrer y-Achse erstellt wurde. Die ursprüngliche Matrix wird nicht verändert.
+
+Um die Matrix während des Scherens entlang der y-Achse zu ändern, siehe [`DOMMatrix.skewYSelf()`](/de/docs/Web/API/DOMMatrix/skewYSelf).
+
+## Syntax
+
+```js-nolint
+DOMMatrixReadOnly.skewY()
+DOMMatrixReadOnly.skewY(sY)
+```
+
+### Parameter
+
+- `sY`
+  - : Eine Zahl; der Winkel in Grad, um den die Matrix entlang der y-Achse geschert wird.
+
+### Rückgabewert
+
+Eine [`DOMMatrix`](/de/docs/Web/API/DOMMatrix).
+
+## Beispiele
+
+```js
+const matrix = new DOMMatrix(); // create a matrix
+console.log(matrix.toString()); // original value
+// "matrix(1, 0, 0, 1, 0, 0)"
+
+console.log(matrix.skewY(14).toString()); // skew along y-axis
+// "matrix(1, -0.25, 0, 1, 0, 0)"
+
+console.log(matrix.toString()); // original unchanged
+// "matrix(1, 0, 0, 1, 0, 0)"
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMMatrix.skewY()`](/de/docs/Web/API/DOMMatrix/skewY)
+- [`DOMMatrixReadOnly.skewX()`](/de/docs/Web/API/DOMMatrixReadOnly/skewX)
+- CSS {{cssxref("transform")}}-Eigenschaft und die {{cssxref("transform-function/skew", "skew()")}}, {{cssxref("transform-function/skewY", "skewY()")}} und {{cssxref("transform-function/matrix", "matrix()")}} Funktionen
+- [CSS-Transformationen](/de/docs/Web/CSS/CSS_transforms) Modul
+- SVG [`transform`](/de/docs/Web/SVG/Attribute/transform) Attribut
+- [`CanvasRenderingContext2D`](/de/docs/Web/API/CanvasRenderingContext2D)-Schnittstelle mit der [`transform()`](/de/docs/Web/API/CanvasRenderingContext2D/transform)-Methode
diff --git a/files/de/web/api/shadowroot/elementfrompoint/index.md b/files/de/web/api/shadowroot/elementfrompoint/index.md
index 64c10e660..28bbb7eb7 100644
--- a/files/de/web/api/shadowroot/elementfrompoint/index.md
+++ b/files/de/web/api/shadowroot/elementfrompoint/index.md
@@ -1,16 +1,16 @@
 ---
-title: "ShadowRoot: elementFromPoint()-Methode"
+title: "ShadowRoot: elementFromPoint() Methode"
 short-title: elementFromPoint()
 slug: Web/API/ShadowRoot/elementFromPoint
 l10n:
-  sourceCommit: a359b3bc073e23d88a582c4bf77b88b24705e7f5
+  sourceCommit: 62a6f2dbd99b39212f4c4c12aa2a6d499e447f46
 ---
 
 {{APIRef("DOM")}}{{Non-standard_Header}}
 
-Die **`elementFromPoint()`**-Methode, verfügbar auf dem [`ShadowRoot`](/de/docs/Web/API/ShadowRoot)-Objekt, gibt das Element auf der obersten Schattenwurzel-Ebene an den angegebenen Koordinaten relativ zum Ansichtsfenster zurück (die Schattenwurzel, die in der Anzeige Z-Ordnung am höchsten liegt und in der Lage ist, Zeigerereignisse zu empfangen). Schattenwurzel-Elemente, bei denen {{cssxref("pointer-events")}} auf `none` gesetzt ist, werden ignoriert.
+Die **`elementFromPoint()`**-Methode, die auf dem [`ShadowRoot`](/de/docs/Web/API/ShadowRoot)-Objekt verfügbar ist, gibt das Element zurück, das sich in der obersten Schicht des Shadow-DOM an den angegebenen Koordinaten relativ zum Ansichtsfenster (dem Shadow-DOM-Element auf der höchsten Ebene der Anzeige-Z-Reihenfolge, das Zeigerereignisse empfangen kann) befindet. Shadow-DOM-Elemente, die {{cssxref("pointer-events")}} auf `none` gesetzt haben, werden ignoriert.
 
-Befindet sich der angegebene Punkt außerhalb der Begrenzungen der Schattenwurzel, ist das Ergebnis `undefined`.
+Wenn der angegebene Punkt außerhalb der Grenzen des Shadow-DOM liegt, ist das Ergebnis `undefined`.
 
 ## Syntax
 
@@ -21,17 +21,17 @@ elementFromPoint(x, y)
 ### Parameter
 
 - `x`
-  - : Die horizontale Koordinate eines Punktes, relativ zur linken Kante des aktuellen {{Glossary("viewport", "Ansichtsfensters")}}.
+  - : Die horizontale Koordinate eines Punktes, relativ zum linken Rand des aktuellen {{Glossary("viewport", "Ansichtsfensters")}}.
 - `y`
-  - : Die vertikale Koordinate eines Punktes, relativ zur oberen Kante des aktuellen Ansichtsfensters.
+  - : Die vertikale Koordinate eines Punktes, relativ zum oberen Rand des aktuellen Ansichtsfensters.
 
 ### Rückgabewert
 
-Ein [`Element`](/de/docs/Web/API/Element); das oberste Schattenwurzel-Element, das sich an den angegebenen Koordinaten befindet, falls vorhanden.
+Ein [`Element`](/de/docs/Web/API/Element); das oberste Shadow-DOM-Element, das an den angegebenen Koordinaten gefunden wird, falls vorhanden.
 
 ## Beispiele
 
-In diesem Beispiel, unter der Annahme, dass ein {{htmlelement("template")}} im HTML existiert, definieren wir ein `<my-custom-element>`. Wenn das hinzugefügte benutzerdefinierte Element die obere linke Ecke des Ansichtsfensters berührt oder irgendein Teil davon diese Ecke überlappt, wird das Element, das die oberste Schicht an diesem Punkt im benutzerdefinierten Element ist, einen dünnen, gestrichelten roten Rand haben.
+In diesem Beispiel definieren wir, vorausgesetzt, dass ein {{htmlelement("template")}} im HTML vorhanden ist, ein `<my-custom-element>`. Wenn das hinzugefügte benutzerdefinierte Element die obere linke Ecke des Ansichtsfensters berührt oder ein Teil davon diese Ecke überlappt, erhält das Element, das an diesem Punkt die oberste Schicht in dem benutzerdefinierten Element ist, einen dünnen, gestrichelten roten Rahmen.
 
 ```js
 customElements.define(
diff --git a/files/de/web/api/shadowroot/elementsfrompoint/index.md b/files/de/web/api/shadowroot/elementsfrompoint/index.md
index 63aceb45c..11ac804af 100644
--- a/files/de/web/api/shadowroot/elementsfrompoint/index.md
+++ b/files/de/web/api/shadowroot/elementsfrompoint/index.md
@@ -3,14 +3,14 @@ title: "ShadowRoot: elementsFromPoint()-Methode"
 short-title: elementsFromPoint()
 slug: Web/API/ShadowRoot/elementsFromPoint
 l10n:
-  sourceCommit: a359b3bc073e23d88a582c4bf77b88b24705e7f5
+  sourceCommit: 62a6f2dbd99b39212f4c4c12aa2a6d499e447f46
 ---
 
 {{APIRef("DOM")}}{{Non-standard_Header}}
 
-Die **`elementsFromPoint()`**-Methode der [`ShadowRoot`](/de/docs/Web/API/ShadowRoot)-Schnittstelle gibt ein Array aller im Schatten-Root befindlichen Elemente an den angegebenen Koordinaten (relativ zum Viewport) zurück. Die Elemente sind geordnet von dem obersten Element (höchste in der Darstellungs-Z-Reihenfolge) bis zu dem untersten Element.
+Die **`elementsFromPoint()`**-Methode des [`ShadowRoot`](/de/docs/Web/API/ShadowRoot)-Interfaces gibt ein Array aller Shadow-Root-Elemente an den angegebenen Koordinaten (relativ zum Viewport) zurück. Die Elemente sind geordnet vom obersten Element (höchste in der Anzeige z-Ordnung) bis zum untersten Element.
 
-Sie funktioniert ähnlich wie die [`ShadowRoot.elementFromPoint`](/de/docs/Web/API/ShadowRoot/elementFromPoint)-Methode. Einige Browser geben nur die im Schatten-Root vorhandenen Elemente an dieser Position zurück. Andere Browser schließen Elemente außerhalb des [Shadow DOM](/de/docs/Web/API/Web_components/Using_shadow_DOM) ein, vom Schatten-DOM-Element in der obersten Ebene bis zum Dokument-Root-Knoten, wie das {{htmlelement("html")}}- oder {{SVGElement("svg")}}-Root-Element. In diesen Browsern funktioniert sie ähnlich wie die [`Document.elementsFromPoint`](/de/docs/Web/API/Document/elementsFromPoint)-Methode, jedoch mit der Fähigkeit, die {{Glossary("Shadow_tree", "Schatten-Grenze")}} zu überschreiten.
+Sie funktioniert ähnlich wie die [`ShadowRoot.elementFromPoint`](/de/docs/Web/API/ShadowRoot/elementFromPoint)-Methode. Einige Browser geben nur die Shadow-Root-Elemente zurück, die an diesem Ort vorhanden sind. Andere Browser enthalten Elemente außerhalb des [Shadow DOM](/de/docs/Web/API/Web_components/Using_shadow_DOM), vom Shadow-DOM-Element in der obersten Schicht bis zum Dokument-Wurzelknoten, wie das {{htmlelement("html")}}- oder das {{SVGElement("svg")}}-Wurzelelement. In diesen Browsern funktioniert sie ähnlich wie die [`Document.elementsFromPoint`](/de/docs/Web/API/Document/elementsFromPoint)-Methode, jedoch mit der Fähigkeit, die {{Glossary("Shadow_tree", "Schatten-Grenze")}} zu überschreiten.
 
 ## Syntax
 
@@ -21,9 +21,9 @@ elementsFromPoint(x, y)
 ### Parameter
 
 - `x`
-  - : Die horizontale Koordinate eines Punktes, relativ zum linken Rand des aktuellen {{Glossary("viewport", "Viewports")}}.
+  - : Die horizontale Koordinate eines Punktes, relativ zur linken Kante des aktuellen {{Glossary("viewport", "Viewports")}}.
 - `y`
-  - : Die vertikale Koordinate eines Punktes, relativ zum oberen Rand des aktuellen Viewports.
+  - : Die vertikale Koordinate eines Punktes, relativ zur oberen Kante des aktuellen Viewports.
 
 ### Rückgabewert
 
@@ -43,7 +43,7 @@ if (msg) {
 }
 ```
 
-Falls `<my-custom-element>` nahe der oberen linken Ecke des Viewports ist und ein einzelnes `<div>` enthält, kann das obige je nach Browser-Implementierung eines der folgenden zurückgeben:
+Wenn `<my-custom-element>` nahe der oberen linken Ecke des Viewports ist und ein einziges `<div>` enthält, kann das oben Genannte je nach Browser-Implementierung eines der folgenden zurückgeben:
 
 ```plain
 div
diff --git a/files/de/web/api/svgfeblendelement/height/index.md b/files/de/web/api/svgfeblendelement/height/index.md
new file mode 100644
index 000000000..8581992cf
--- /dev/null
+++ b/files/de/web/api/svgfeblendelement/height/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEBlendElement: height-Eigenschaft"
+short-title: height
+slug: Web/API/SVGFEBlendElement/height
+l10n:
+  sourceCommit: ebf665a2679f308eb8e4dc7330864b4661bcdb9c
+---
+
+{{APIRef("SVG")}}
+
+Die **`height`** schreibgeschützte Eigenschaft der Schnittstelle [`SVGFEBlendElement`](/de/docs/Web/API/SVGFEBlendElement) beschreibt die vertikale Größe einer SVG-Filter-Primitiven als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feBlend")}}-Element Attribut {{SVGAttr("height")}} der Filter-Primitiven wider. Das Attribut ist entweder ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`\<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Höhe der Filterregion. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Einheiten des Benutzerkoordinatensystems.
+
+Das `<feBlend>` SVG-Filterelement vermischt zwei Eingabebilder unter Verwendung von allgemein gebräuchlichen Bildbearbeitungs-Software-{{cssxref("blend-mode", "Blending-Modi")}}.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feBlend = document.querySelector("feBlend");
+const verticalSize = feBlend.height;
+console.log(verticalSize.baseVal.value); // the `height` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEBlendElement.width`](/de/docs/Web/API/SVGFEBlendElement/width)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfeblendelement/result/index.md b/files/de/web/api/svgfeblendelement/result/index.md
new file mode 100644
index 000000000..f334f296e
--- /dev/null
+++ b/files/de/web/api/svgfeblendelement/result/index.md
@@ -0,0 +1,45 @@
+---
+title: "SVGFEBlendElement: result Eigenschaft"
+short-title: result
+slug: Web/API/SVGFEBlendElement/result
+l10n:
+  sourceCommit: ebf665a2679f308eb8e4dc7330864b4661bcdb9c
+---
+
+{{APIRef("SVG")}}
+
+Die **`result`** schreibgeschützte Eigenschaft der [`SVGFEBlendElement`](/de/docs/Web/API/SVGFEBlendElement) Schnittstelle beschreibt den zugewiesenen Namen eines SVG-Filterprimitivs als [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+Sie spiegelt das {{SVGElement("feBlend")}} Elementattribut {{SVGAttr("result")}} wider.
+Das `<feBlend>` SVG-Filterelement kombiniert zwei Eingabebilder mit üblichen Bildbearbeitungssoftware-{{cssxref("blend-mode", "Mischmodi")}}.
+
+Der Attributwert ist ein {{cssxref("custom-ident")}}. Wenn angegeben, können Grafiken, die aus der Verarbeitung dieses Filterprimitivs resultieren, durch ein {{SVGAttr("in")}} Attribut auf einem nachfolgenden Filterprimitiv innerhalb desselben {{SVGElement("filter")}} Elements referenziert werden.
+
+Wenn kein `result` Attribut definiert ist, sind `result.baseVal` und `result.animVal` des Filters leere Zeichenfolgen, und die Ausgabe des `<feBlend>` Filters wird nur als implizite Eingabe in das nächste Filterprimitiv wiederverwendbar sein, wenn dieses Filterprimitiv keinen Wert für sein `in` Attribut angibt.
+
+## Wert
+
+Ein [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+## Beispiel
+
+```js
+const feBlendElement = document.querySelector("feBlend");
+const filterName = feBlendElement.result;
+console.log(filterName.baseVal); // the filter's assigned name
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEBlendElement.in1`](/de/docs/Web/API/SVGFEBlendElement/in1)
+- {{cssxref("custom-ident")}} Datentyp
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfeblendelement/width/index.md b/files/de/web/api/svgfeblendelement/width/index.md
new file mode 100644
index 000000000..e03d67fcf
--- /dev/null
+++ b/files/de/web/api/svgfeblendelement/width/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEBlendElement: width-Eigenschaft"
+short-title: width
+slug: Web/API/SVGFEBlendElement/width
+l10n:
+  sourceCommit: ebf665a2679f308eb8e4dc7330864b4661bcdb9c
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`width`**-Eigenschaft des [`SVGFEBlendElement`](/de/docs/Web/API/SVGFEBlendElement)-Interfaces beschreibt die horizontale Größe einer SVG-Filterprimitive als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feBlend")}}-Element und das Filterprimitive-Attribut {{SVGAttr("width")}} wider. Das Attribut ist eine [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage), relativ zur Breite des Filterbereichs. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Einheiten des Benutzerkoordinatensystems.
+
+Das `<feBlend>` SVG-Filter mischt zwei Eingabebilder mit gängigen Bildbearbeitungs-{{cssxref("blend-mode", "Überblendmodi")}}.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feBlend = document.querySelector("feBlend");
+const horizontalSize = feBlend.width;
+console.log(horizontalSize.baseVal.value); // the `width` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEBlendElement.height`](/de/docs/Web/API/SVGFEBlendElement/height)
+- CSS-Datentyp {{cssxref("blend-mode")}}
+- CSS-Eigenschaft {{cssxref("mix-blend-mode")}}
diff --git a/files/de/web/api/svgfeblendelement/x/index.md b/files/de/web/api/svgfeblendelement/x/index.md
new file mode 100644
index 000000000..3dd42e174
--- /dev/null
+++ b/files/de/web/api/svgfeblendelement/x/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEBlendElement: x-Eigenschaft"
+short-title: x
+slug: Web/API/SVGFEBlendElement/x
+l10n:
+  sourceCommit: ebf665a2679f308eb8e4dc7330864b4661bcdb9c
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte Eigenschaft **`x`** des [`SVGFEBlendElement`](/de/docs/Web/API/SVGFEBlendElement)-Interfaces beschreibt die horizontale Koordinate der Position einer SVG-Filterprimitive als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des SVG-Attributs {{SVGAttr("x")}} der {{SVGElement("feBlend")}}-Elementfilterprimitive wider. Das `<feBlend>` SVG-Filter vereint zwei Eingabebilder miteinander und nutzt dabei allgemein gebräuchliche Bildbearbeitungssoftware-{{cssxref("blend-mode", "Mischmodi")}}.
+
+Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerskoordinatensystem, die den angegebenen Abstand vom Ursprung des Benutzerskoordinatensystems entlang der x-Achse darstellt. Wenn das `x`-Attribut einen Prozentwert hat, ist der Eigenschaftswert relativ zur Breite der Filterregion in Einheiten des Benutzerskoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feBlend = document.querySelector("feBlend");
+const leftPosition = feBlend.x;
+console.log(leftPosition.baseVal.value); // the `x` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEBlendElement.y`](/de/docs/Web/API/SVGFEBlendElement/y)
+- CSS-Datentyp {{cssxref("blend-mode")}}
+- CSS-Eigenschaft {{cssxref("mix-blend-mode")}}
diff --git a/files/de/web/api/svgfeblendelement/y/index.md b/files/de/web/api/svgfeblendelement/y/index.md
new file mode 100644
index 000000000..a8a368d80
--- /dev/null
+++ b/files/de/web/api/svgfeblendelement/y/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEBlendElement: y-Eigenschaft"
+short-title: "y"
+slug: Web/API/SVGFEBlendElement/y
+l10n:
+  sourceCommit: ebf665a2679f308eb8e4dc7330864b4661bcdb9c
+---
+
+{{APIRef("SVG")}}
+
+Die **`y`**-Schreibgeschützte Eigenschaft des [`SVGFEBlendElement`](/de/docs/Web/API/SVGFEBlendElement)-Interfaces beschreibt die vertikale Koordinate der Position einer SVG-Filterprimitive als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des Filterprimitive-Attributs {{SVGAttr("y")}} des {{SVGElement("feBlend")}}-Elements wider. Das `<feBlend>`-SVG-Filter blendet zwei Eingabebilder unter Verwendung von in Bildbearbeitungssoftware häufig verwendeten {{cssxref("blend-mode", "Mischmodi")}} miteinander.
+
+Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die den angegebenen Abstand vom Ursprung des Benutzerkoordinatensystems entlang der y-Achse darstellt. Wenn das `y`-Attribut ein Prozentwert ist, ist der Eigenschaftswert relativ zur Höhe des Filterbereichs in Einheiten des Benutzerkoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feBlend = document.querySelector("feBlend");
+const topPosition = feBlend.y;
+console.log(topPosition.baseVal.value); // the `y` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEBlendElement.x`](/de/docs/Web/API/SVGFEBlendElement/x)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfecolormatrixelement/height/index.md b/files/de/web/api/svgfecolormatrixelement/height/index.md
new file mode 100644
index 000000000..d1d859b85
--- /dev/null
+++ b/files/de/web/api/svgfecolormatrixelement/height/index.md
@@ -0,0 +1,44 @@
+---
+title: "SVGFEColorMatrixElement: height-Eigenschaft"
+short-title: height
+slug: Web/API/SVGFEColorMatrixElement/height
+l10n:
+  sourceCommit: ac0a3f797c6c81e964f49bf0f491cd08154d848f
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`height`**-Eigenschaft der Schnittstelle [`SVGFEColorMatrixElement`](/de/docs/Web/API/SVGFEColorMatrixElement) beschreibt die vertikale Größe einer SVG-Filter-Primitiven als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feColorMatrix")}}-Element und das Filterprimitiv-Attribut {{SVGAttr("height")}} wider. Der `<feColorMatrix>`-Filter wendet eine Matrixtransformation auf die {{Glossary("RGB", "RGB")}}-Farb- und {{Glossary("alpha", "Alpha")}}-Werte an.
+
+Das Attribut ist ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Höhe des Filterbereichs. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Benutzerkoordinatensystemeinheiten.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feColorMatrix = document.querySelector("feColorMatrix");
+const verticalSize = feColorMatrix.height;
+console.log(verticalSize.baseVal.value); // the `height` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEColorMatrixElement.width`](/de/docs/Web/API/SVGFEColorMatrixElement/width)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
+- [CSS Filter-Effekte](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfecolormatrixelement/result/index.md b/files/de/web/api/svgfecolormatrixelement/result/index.md
new file mode 100644
index 000000000..a3a5863ee
--- /dev/null
+++ b/files/de/web/api/svgfecolormatrixelement/result/index.md
@@ -0,0 +1,45 @@
+---
+title: "SVGFEColorMatrixElement: result-Eigenschaft"
+short-title: result
+slug: Web/API/SVGFEColorMatrixElement/result
+l10n:
+  sourceCommit: ac0a3f797c6c81e964f49bf0f491cd08154d848f
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`result`**-Eigenschaft der [`SVGFEColorMatrixElement`](/de/docs/Web/API/SVGFEColorMatrixElement)-Schnittstelle beschreibt den zugewiesenen Namen eines SVG-Filterprimitivelements als [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+Sie spiegelt das {{SVGElement("feColorMatrix")}}-Elementattribut {{SVGAttr("result")}} wider. Der `<feColorMatrix>`-Filter wendet eine Matrixtransformation auf die {{Glossary("RGB", "RGB")}}-Farbe und die {{Glossary("alpha", "Alpha")}}-Werte an. Der Attributwert ist ein {{cssxref("custom-ident")}}. Wenn angegeben, können Grafiken, die aus der Verarbeitung dieses Filterprimitivs resultieren, durch ein {{SVGAttr("in")}}-Attribut auf einem nachfolgenden Filterprimitive innerhalb desselben {{SVGElement("filter")}}-Elements referenziert werden.
+
+Wenn kein `result`-Attribut definiert ist, sind die `result.baseVal` und `result.animVal` des Filters leere Zeichenfolgen. Das Ergebnis des `<feColorMatrix>`-Filters steht dann nur zur Wiederverwendung als impliziter Eingang für das nächste Filterprimitive zur Verfügung, wenn dieses Filterprimitive keinen Wert für sein `in`-Attribut bereitstellt.
+
+## Wert
+
+Ein [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+## Beispiel
+
+```js
+const feColorMatrixElement = document.querySelector("feColorMatrix");
+const filterName = feColorMatrixElement.result;
+console.log(filterName.baseVal); // the filter's assigned name
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEColorMatrixElement.in1`](/de/docs/Web/API/SVGFEColorMatrixElement/in1)
+- {{cssxref("custom-ident")}} Datentyp
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
+- [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfecolormatrixelement/width/index.md b/files/de/web/api/svgfecolormatrixelement/width/index.md
new file mode 100644
index 000000000..b638baa4f
--- /dev/null
+++ b/files/de/web/api/svgfecolormatrixelement/width/index.md
@@ -0,0 +1,42 @@
+---
+title: "SVGFEColorMatrixElement: width-Eigenschaft"
+short-title: width
+slug: Web/API/SVGFEColorMatrixElement/width
+l10n:
+  sourceCommit: ac0a3f797c6c81e964f49bf0f491cd08154d848f
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`width`**-Eigenschaft des [`SVGFEColorMatrixElement`](/de/docs/Web/API/SVGFEColorMatrixElement)-Interfaces beschreibt die horizontale Größe eines SVG-Filterprimitivs als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feColorMatrix")}}-Element und dessen {{SVGAttr("width")}}-Filterprimitiv-Attribut wider. Der `<feColorMatrix>`-Filter wendet eine Matrixtransformation auf die {{Glossary("RGB", "RGB")}}-Farb- und {{Glossary("alpha", "Alpha")}}-Werte an. Das Attribut ist ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`\<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Breite des Filterbereichs. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Einheiten des Benutzerkoordinatensystems.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feColorMatrix = document.querySelector("feColorMatrix");
+const horizontalSize = feColorMatrix.width;
+console.log(horizontalSize.baseVal.value); // the `width` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEColorMatrixElement.height`](/de/docs/Web/API/SVGFEColorMatrixElement/height)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
+- [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfecolormatrixelement/x/index.md b/files/de/web/api/svgfecolormatrixelement/x/index.md
new file mode 100644
index 000000000..7ecad05ce
--- /dev/null
+++ b/files/de/web/api/svgfecolormatrixelement/x/index.md
@@ -0,0 +1,42 @@
+---
+title: "SVGFEColorMatrixElement: x Eigenschaft"
+short-title: x
+slug: Web/API/SVGFEColorMatrixElement/x
+l10n:
+  sourceCommit: ac0a3f797c6c81e964f49bf0f491cd08154d848f
+---
+
+{{APIRef("SVG")}}
+
+Die **`x`** schreibgeschützte Eigenschaft des [`SVGFEColorMatrixElement`](/de/docs/Web/API/SVGFEColorMatrixElement)-Interfaces beschreibt die horizontale Koordinate der Position eines SVG-Filterprimitivs als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des {{SVGElement("feColorMatrix")}}-Element-Attributs {{SVGAttr("x")}} des Filterprimitivs wider. Der `<feColorMatrix>`-Filter wendet eine Matrixtransformation auf die {{Glossary("RGB", "RGB")}}-Farb- und {{Glossary("alpha", "Alpha")}}-Werte an. Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die den gegebenen Abstand vom Ursprung des Benutzerkoordinatensystems entlang der x-Achse darstellt. Wenn das `x`-Attribut einen Prozentwert hat, ist der Eigenschaftswert relativ zur Breite des Filterbereichs in Einheiten des Benutzerkoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feColorMatrix = document.querySelector("feColorMatrix");
+const leftPosition = feColorMatrix.x;
+console.log(leftPosition.baseVal.value); // the `x` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEColorMatrixElement.y`](/de/docs/Web/API/SVGFEColorMatrixElement/y)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
+- [CSS filter effects](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Applying SVG effects to HTML content](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfecolormatrixelement/y/index.md b/files/de/web/api/svgfecolormatrixelement/y/index.md
new file mode 100644
index 000000000..2bd4ce4c1
--- /dev/null
+++ b/files/de/web/api/svgfecolormatrixelement/y/index.md
@@ -0,0 +1,42 @@
+---
+title: "SVGFEColorMatrixElement: y-Eigenschaft"
+short-title: "y"
+slug: Web/API/SVGFEColorMatrixElement/y
+l10n:
+  sourceCommit: ac0a3f797c6c81e964f49bf0f491cd08154d848f
+---
+
+{{APIRef("SVG")}}
+
+Die **`y`**-Leseeigenschaft des [`SVGFEColorMatrixElement`](/de/docs/Web/API/SVGFEColorMatrixElement)-Interfaces beschreibt die vertikale Koordinate der Position eines SVG-Filterprimitives als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des {{SVGElement("feColorMatrix")}}-Elements, des Attributs {{SVGAttr("y")}} eines Filterprimitives wider. Der `<feColorMatrix>`-Filter wendet eine Matrixtransformation auf die {{Glossary("RGB", "RGB")}}-Farb- und {{Glossary("alpha", "alpha")}}-Werte an. Das Attribut ist entweder ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die den gegebenen Abstand vom Ursprung des Filters entlang der y-Achse darstellt. Wenn das `y`-Attribut einen Prozentwert hat, ist der Eigenschaftswert relativ zur Höhe der Filterregion in Benutzerkoordinatensystemeinheiten. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feColorMatrix = document.querySelector("feColorMatrix");
+const topPosition = feColorMatrix.y;
+console.log(topPosition.baseVal.value); // the `y` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEColorMatrixElement.x`](/de/docs/Web/API/SVGFEColorMatrixElement/x)
+- CSS-Datentyp {{cssxref("blend-mode")}}
+- CSS-Eigenschaft {{cssxref("mix-blend-mode")}}
+- [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG-Element {{SVGElement("filter")}}, SVG-Attribut {{SVGAttr("filter")}} in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfecomponenttransferelement/height/index.md b/files/de/web/api/svgfecomponenttransferelement/height/index.md
new file mode 100644
index 000000000..7c9c9d8fc
--- /dev/null
+++ b/files/de/web/api/svgfecomponenttransferelement/height/index.md
@@ -0,0 +1,40 @@
+---
+title: "SVGFEComponentTransferElement: height-Eigenschaft"
+short-title: height
+slug: Web/API/SVGFEComponentTransferElement/height
+l10n:
+  sourceCommit: 555feb3f59cfdea83d769ce9f38baebc679f0681
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`height`**-Eigenschaft der [`SVGFEComponentTransferElement`](/de/docs/Web/API/SVGFEComponentTransferElement)-Schnittstelle beschreibt die vertikale Größe einer SVG-Filterprimitive als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feComponentTransfer")}}-Element-Attribut {{SVGAttr("height")}} für die Filterprimitive wider. Der `<feComponentTransfer>`-Filter führt eine komponentenweise Farb- und Alphatransparenz-Neuzuordnung durch, die Helligkeits-, Kontrast-, Farbgleichgewichts- und Schwellenwertanpassungen ermöglicht.
+
+Das Attribut ist ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`\<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Höhe des Filterbereichs. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Benutzereinheit-Koordinaten.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComponentTransfer = document.querySelector("feComponentTransfer");
+const verticalSize = feComponentTransfer.height;
+console.log(verticalSize.baseVal.value); // the `height` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEComponentTransferElement.width`](/de/docs/Web/API/SVGFEComponentTransferElement/width)
+- {{SVGElement("feFuncR")}}, {{SVGElement("feFuncG")}}, {{SVGElement("feFuncB")}}, {{SVGElement("feFuncA")}}
diff --git a/files/de/web/api/svgfecomponenttransferelement/result/index.md b/files/de/web/api/svgfecomponenttransferelement/result/index.md
new file mode 100644
index 000000000..3d4d4a4af
--- /dev/null
+++ b/files/de/web/api/svgfecomponenttransferelement/result/index.md
@@ -0,0 +1,43 @@
+---
+title: "SVGFEComponentTransferElement: result-Eigenschaft"
+short-title: result
+slug: Web/API/SVGFEComponentTransferElement/result
+l10n:
+  sourceCommit: 555feb3f59cfdea83d769ce9f38baebc679f0681
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`result`**-Eigenschaft der [`SVGFEComponentTransferElement`](/de/docs/Web/API/SVGFEComponentTransferElement)-Schnittstelle beschreibt den zugewiesenen Namen eines SVG-Filterprimitivs als [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+Sie spiegelt das {{SVGElement("feComponentTransfer")}}-Element und dessen {{SVGAttr("result")}}-Attribut wider. Der Attributwert ist ein {{cssxref("custom-ident")}}. Wenn angegeben, können Grafiken, die aus der Verarbeitung dieses Filterprimitivs resultieren, durch ein {{SVGAttr("in")}}-Attribut auf einem nachfolgenden Filterprimitiv innerhalb desselben {{SVGElement("filter")}}-Elements referenziert werden.
+
+Falls kein `result`-Attribut definiert ist, sind `result.baseVal` und `result.animVal` des Filters leere Zeichenfolgen, und die Ausgabe des `<feComponentTransfer>`-Filters ist nur für die Wiederverwendung als implizite Eingabe für das nächste Filterprimitiv verfügbar, sofern dieses Filterprimitiv keinen Wert für sein `in`-Attribut bereitstellt.
+
+## Wert
+
+Ein [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+## Beispiel
+
+```js
+const feComponentTransferElement = document.querySelector(
+  "feComponentTransfer",
+);
+const filterName = feComponentTransferElement.result;
+console.log(filterName.baseVal); // the filter's assigned name
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEComponentTransferElement.in1`](/de/docs/Web/API/SVGFEComponentTransferElement/in1)
+- {{SVGElement("feFuncR")}}, {{SVGElement("feFuncG")}}, {{SVGElement("feFuncB")}}, {{SVGElement("feFuncA")}} Elemente
+- {{cssxref("custom-ident")}} Datentyp
diff --git a/files/de/web/api/svgfecomponenttransferelement/width/index.md b/files/de/web/api/svgfecomponenttransferelement/width/index.md
new file mode 100644
index 000000000..a13fa10d2
--- /dev/null
+++ b/files/de/web/api/svgfecomponenttransferelement/width/index.md
@@ -0,0 +1,38 @@
+---
+title: "SVGFEComponentTransferElement: width-Eigenschaft"
+short-title: width
+slug: Web/API/SVGFEComponentTransferElement/width
+l10n:
+  sourceCommit: 555feb3f59cfdea83d769ce9f38baebc679f0681
+---
+
+{{APIRef("SVG")}}
+
+Die **`width`**-Eigenschaft der [`SVGFEComponentTransferElement`](/de/docs/Web/API/SVGFEComponentTransferElement)-Schnittstelle, die nur gelesen werden kann, beschreibt die horizontale Größe einer SVG-Filterprimitive als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feComponentTransfer")}}-Element-Attribut {{SVGAttr("width")}} der Filterprimitive wider. Das Attribut ist ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`\<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Breite der Filterregion. Der Standardwert ist `100%`. Der Wert der Eigenschaft ist eine Länge in Benutzerkoordinatensystemeinheiten.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComponentTransfer = document.querySelector("feComponentTransfer");
+const horizontalSize = feComponentTransfer.width;
+console.log(horizontalSize.baseVal.value); // the `width` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEComponentTransferElement.height`](/de/docs/Web/API/SVGFEComponentTransferElement/height)
+- Elemente {{SVGElement("feFuncR")}}, {{SVGElement("feFuncG")}}, {{SVGElement("feFuncB")}}, {{SVGElement("feFuncA")}}
diff --git a/files/de/web/api/svgfecomponenttransferelement/x/index.md b/files/de/web/api/svgfecomponenttransferelement/x/index.md
new file mode 100644
index 000000000..1d5a658e9
--- /dev/null
+++ b/files/de/web/api/svgfecomponenttransferelement/x/index.md
@@ -0,0 +1,38 @@
+---
+title: "SVGFEComponentTransferElement: x-Eigenschaft"
+short-title: x
+slug: Web/API/SVGFEComponentTransferElement/x
+l10n:
+  sourceCommit: 555feb3f59cfdea83d769ce9f38baebc679f0681
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`x`**-Eigenschaft der [`SVGFEComponentTransferElement`](/de/docs/Web/API/SVGFEComponentTransferElement)-Schnittstelle beschreibt die horizontale Koordinate der Position eines SVG-Filterprimitivs als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des `x`-Filterprimitivattributs des {{SVGElement("feComponentTransfer")}}-Elements wider. Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die den gegebenen Abstand vom Ursprung des Benutzerkoordinatensystems entlang der x-Achse angibt. Wenn das `x`-Attribut einen Prozentwert hat, ist der Eigenschaftswert relativ zur Breite des Filterbereichs in Einheiten des Benutzerkoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComponentTransfer = document.querySelector("feComponentTransfer");
+const leftPosition = feComponentTransfer.x;
+console.log(leftPosition.baseVal.value); // the `x` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEComponentTransferElement.y`](/de/docs/Web/API/SVGFEComponentTransferElement/y)
+- {{SVGElement("feFuncR")}}, {{SVGElement("feFuncG")}}, {{SVGElement("feFuncB")}}, {{SVGElement("feFuncA")}}
diff --git a/files/de/web/api/svgfecomponenttransferelement/y/index.md b/files/de/web/api/svgfecomponenttransferelement/y/index.md
new file mode 100644
index 000000000..207b1202a
--- /dev/null
+++ b/files/de/web/api/svgfecomponenttransferelement/y/index.md
@@ -0,0 +1,38 @@
+---
+title: "SVGFEComponentTransferElement: y-Eigenschaft"
+short-title: "y"
+slug: Web/API/SVGFEComponentTransferElement/y
+l10n:
+  sourceCommit: 555feb3f59cfdea83d769ce9f38baebc679f0681
+---
+
+{{APIRef("SVG")}}
+
+Die **`y`**-Eigenschaft der Schnittstelle [`SVGFEComponentTransferElement`](/de/docs/Web/API/SVGFEComponentTransferElement) beschreibt die vertikale Koordinate der Position eines SVG-Filterprimitives als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des {{SVGElement("feComponentTransfer")}}-Elements und des {{SVGAttr("y")}}-Filterprimitiveattributs wider. Das Attribut ist ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Die `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die den angegebenen Abstand vom Ursprung des Filters entlang der y-Achse darstellt. Wenn das `y`-Attribut einen Prozentwert hat, ist der Eigenschaftswert relativ zur Höhe des Filterbereichs in Benutzerkoordinatensystemeinheiten. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComponentTransfer = document.querySelector("feComponentTransfer");
+const topPosition = feComponentTransfer.y;
+console.log(topPosition.baseVal.value); // the `y` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEComponentTransferElement.x`](/de/docs/Web/API/SVGFEComponentTransferElement/x)
+- {{SVGElement("feFuncR")}}, {{SVGElement("feFuncG")}}, {{SVGElement("feFuncB")}}, {{SVGElement("feFuncA")}}
diff --git a/files/de/web/api/svgfecompositeelement/height/index.md b/files/de/web/api/svgfecompositeelement/height/index.md
new file mode 100644
index 000000000..b262886c0
--- /dev/null
+++ b/files/de/web/api/svgfecompositeelement/height/index.md
@@ -0,0 +1,39 @@
+---
+title: "SVGFECompositeElement: height-Eigenschaft"
+short-title: height
+slug: Web/API/SVGFECompositeElement/height
+l10n:
+  sourceCommit: a5395de76cd0066aed71cf351029eb6e342b73d1
+---
+
+{{APIRef("SVG")}}
+
+Die **`height`**-Eigenschaft der [`SVGFECompositeElement`](/de/docs/Web/API/SVGFECompositeElement)-Schnittstelle beschreibt die vertikale Größe eines SVG-Filter-Primitives als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie reflektiert das {{SVGElement("feComposite")}}-Element und dessen {{SVGAttr("height")}}-Filter-Primitivattribut. Das `<feComposite>` SVG-Filter-Primitiv kombiniert zwei Eingabebilder mittels einer Porter-Duff-Kompositionsoperation. Das Attribut ist entweder ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`\<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Höhe des Filterbereichs. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Benutzereinheitensystemeinheiten.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComposite = document.querySelector("feComposite");
+const verticalSize = feComposite.height;
+console.log(verticalSize.baseVal.value); // the `height` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFECompositeElement.width`](/de/docs/Web/API/SVGFECompositeElement/width)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfecompositeelement/result/index.md b/files/de/web/api/svgfecompositeelement/result/index.md
new file mode 100644
index 000000000..7bd59d096
--- /dev/null
+++ b/files/de/web/api/svgfecompositeelement/result/index.md
@@ -0,0 +1,42 @@
+---
+title: "SVGFECompositeElement: result-Eigenschaft"
+short-title: result
+slug: Web/API/SVGFECompositeElement/result
+l10n:
+  sourceCommit: a5395de76cd0066aed71cf351029eb6e342b73d1
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`result`**-Eigenschaft der [`SVGFECompositeElement`](/de/docs/Web/API/SVGFECompositeElement)-Schnittstelle beschreibt den zugewiesenen Namen eines SVG-Filterprimitivs als [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+Sie spiegelt das {{SVGElement("feComposite")}}-Element über das {{SVGAttr("result")}}-Attribut wider. Das `<feComposite>` SVG-Filterprimitiv kombiniert zwei Eingabebilder mittels einer Porter-Duff-Kombinationsoperation. Der Attributwert ist eine {{cssxref("custom-ident")}}. Wenn angegeben, dann können Grafiken, die aus der Verarbeitung dieses Filterprimitivs resultieren, durch ein {{SVGAttr("in")}}-Attribut auf einem nachfolgenden Filterprimitiv innerhalb desselben {{SVGElement("filter")}}-Elements referenziert werden.
+
+Wenn kein `result`-Attribut definiert ist, sind die `result.baseVal` und `result.animVal` des Filters leere Zeichenketten, und die Ausgabe des `<feComposite>`-Filters wird nur als implizierte Eingabe für das nächste Filterprimitiv wiederverwendbar sein, wenn dieses Filterprimitiv keinen Wert für sein `in`-Attribut bereitstellt.
+
+## Wert
+
+Ein [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+## Beispiel
+
+```js
+const feCompositeElement = document.querySelector("feComposite");
+const filterName = feCompositeElement.result;
+console.log(filterName.baseVal); // the filter's assigned name
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFECompositeElement.in1`](/de/docs/Web/API/SVGFECompositeElement/in1)
+- {{cssxref("custom-ident")}} Datentyp
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfecompositeelement/width/index.md b/files/de/web/api/svgfecompositeelement/width/index.md
new file mode 100644
index 000000000..ee0f261be
--- /dev/null
+++ b/files/de/web/api/svgfecompositeelement/width/index.md
@@ -0,0 +1,39 @@
+---
+title: "SVGFECompositeElement: width-Eigenschaft"
+short-title: width
+slug: Web/API/SVGFECompositeElement/width
+l10n:
+  sourceCommit: a5395de76cd0066aed71cf351029eb6e342b73d1
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`width`**-Eigenschaft der Schnittstelle [`SVGFECompositeElement`](/de/docs/Web/API/SVGFECompositeElement) beschreibt die horizontale Größe einer SVG-Filterprimitive als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feComposite")}}-Element und dessen {{SVGAttr("width")}}-Attribut der Filterprimitive wider. Die `<feComposite>` SVG-Filterprimitive kombiniert zwei Eingabebilder mit einer Porter-Duff-Kompositionsoperation. Das Attribut ist entweder ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Breite des Filterbereichs. Der Standardwert ist `100%`. Der Wert der Eigenschaft ist eine Länge in Einheiten des Benutzerkoordinatensystems.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComposite = document.querySelector("feComposite");
+const horizontalSize = feComposite.width;
+console.log(horizontalSize.baseVal.value); // the `width` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFECompositeElement.height`](/de/docs/Web/API/SVGFECompositeElement/height)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfecompositeelement/x/index.md b/files/de/web/api/svgfecompositeelement/x/index.md
new file mode 100644
index 000000000..500057453
--- /dev/null
+++ b/files/de/web/api/svgfecompositeelement/x/index.md
@@ -0,0 +1,39 @@
+---
+title: "SVGFECompositeElement: x-Eigenschaft"
+short-title: x
+slug: Web/API/SVGFECompositeElement/x
+l10n:
+  sourceCommit: a5395de76cd0066aed71cf351029eb6e342b73d1
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`x`**-Eigenschaft der [`SVGFECompositeElement`](/de/docs/Web/API/SVGFECompositeElement)-Schnittstelle beschreibt die horizontale Koordinate der Position eines SVG-Filterprimitives als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des Filterprimitivattributs {{SVGAttr("x")}} des {{SVGElement("feComposite")}}-Elements wider. Das `<feComposite>` SVG-Filterprimitive kombiniert zwei Eingabebilder mittels einer Porter-Duff-Kompositionsoperation. Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem und entspricht der angegebenen Entfernung vom Ursprung des Benutzerkoordinatensystems entlang der x-Achse. Wenn das `x`-Attribut einen Prozentwert aufweist, ist der Eigenschaftswert relativ zur Breite der Filterregion in Einheiten des Benutzerkoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Eine [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComposite = document.querySelector("feComposite");
+const leftPosition = feComposite.x;
+console.log(leftPosition.baseVal.value); // the `x` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFECompositeElement.y`](/de/docs/Web/API/SVGFECompositeElement/y)
+- CSS-Datentyp {{cssxref("blend-mode")}}
+- CSS-Eigenschaft {{cssxref("mix-blend-mode")}}
diff --git a/files/de/web/api/svgfecompositeelement/y/index.md b/files/de/web/api/svgfecompositeelement/y/index.md
new file mode 100644
index 000000000..41977b74a
--- /dev/null
+++ b/files/de/web/api/svgfecompositeelement/y/index.md
@@ -0,0 +1,39 @@
+---
+title: "SVGFECompositeElement: y Eigenschaft"
+short-title: "y"
+slug: Web/API/SVGFECompositeElement/y
+l10n:
+  sourceCommit: a5395de76cd0066aed71cf351029eb6e342b73d1
+---
+
+{{APIRef("SVG")}}
+
+Die **`y`**-Eigenschaft des [`SVGFECompositeElement`](/de/docs/Web/API/SVGFECompositeElement)-Interfaces beschreibt die vertikale Koordinate der Position eines SVG-Filterprimitives als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des Filterprimitive-Attributs {{SVGAttr("y")}} des {{SVGElement("feComposite")}}-Elements wider. Das `<feComposite>` SVG-Filterprimitive kombiniert zwei Eingabebilder mit einer Porter-Duff-Compositing-Operation. Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die die angegebene Entfernung vom Ursprung des Filters entlang der y-Achse darstellt. Wenn das `y`-Attribut einen Prozentwert hat, ist der Eigenschaftswert relativ zur Höhe der Filterregion in Einheiten des Benutzerkoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feComposite = document.querySelector("feComposite");
+const topPosition = feComposite.y;
+console.log(topPosition.baseVal.value); // the `y` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFECompositeElement.x`](/de/docs/Web/API/SVGFECompositeElement/x)
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfeconvolvematrixelement/height/index.md b/files/de/web/api/svgfeconvolvematrixelement/height/index.md
new file mode 100644
index 000000000..230bc283f
--- /dev/null
+++ b/files/de/web/api/svgfeconvolvematrixelement/height/index.md
@@ -0,0 +1,40 @@
+---
+title: "SVGFEConvolveMatrixElement: height-Eigenschaft"
+short-title: height
+slug: Web/API/SVGFEConvolveMatrixElement/height
+l10n:
+  sourceCommit: e0bf626da04e5e1e21373fe4011e20fdcaae62a0
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`height`**-Eigenschaft des [`SVGFEConvolveMatrixElement`](/de/docs/Web/API/SVGFEConvolveMatrixElement)-Interfaces beschreibt die vertikale Größe einer SVG-Filterprimitive als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feConvolveMatrix")}}-Element wider, das Attribut {{SVGAttr("height")}} der Filterprimitive. Der `<feConvolveMatrix>`-Filter wendet einen Matrix-Faltungseffekt an, bei dem Pixel im Eingabebild mit benachbarten Pixeln kombiniert werden, um einen Faltungseffekt wie Weichzeichnen, Kantenerkennung, Schärfen, Prägen oder Abschrägen zu erzielen. Das Attribut ist eine [`<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Höhe der Filterregion. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Benutzersystem-Koordinateneinheiten.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feConvolveMatrix = document.querySelector("feConvolveMatrix");
+const verticalSize = feConvolveMatrix.height;
+console.log(verticalSize.baseVal.value); // the `height` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEConvolveMatrixElement.width`](/de/docs/Web/API/SVGFEConvolveMatrixElement/width)
+- Modul [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfeconvolvematrixelement/result/index.md b/files/de/web/api/svgfeconvolvematrixelement/result/index.md
new file mode 100644
index 000000000..583c9ef9b
--- /dev/null
+++ b/files/de/web/api/svgfeconvolvematrixelement/result/index.md
@@ -0,0 +1,45 @@
+---
+title: "SVGFEConvolveMatrixElement: Ergebnis-Eigenschaft"
+short-title: result
+slug: Web/API/SVGFEConvolveMatrixElement/result
+l10n:
+  sourceCommit: e0bf626da04e5e1e21373fe4011e20fdcaae62a0
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte Eigenschaft **`result`** des [`SVGFEConvolveMatrixElement`](/de/docs/Web/API/SVGFEConvolveMatrixElement)-Interfaces beschreibt den zugewiesenen Namen eines SVG-Filterprimitivs als [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+Sie spiegelt das {{SVGElement("feConvolveMatrix")}}-Elementattribut {{SVGAttr("result")}} wider. Der `<feConvolveMatrix>`-Filter wendet einen Matrixkonvolutionseffekt an, der Pixel im Eingabebild mit benachbarten Pixeln kombiniert, um einen Konvolutionseffekt wie Weichzeichnen, Kantenerkennung, Schärfen, Prägen oder Abfasen zu erzeugen.
+
+Der Attributwert ist ein {{cssxref("custom-ident")}}. Falls angegeben, können Grafiken, die aus der Verarbeitung dieses Filterprimitivs resultieren, durch ein {{SVGAttr("in")}}-Attribut auf einem nachfolgenden Filterprimitiv innerhalb desselben {{SVGElement("filter")}}-Elements referenziert werden.
+
+Wenn kein `result`-Attribut definiert ist, sind `result.baseVal` und `result.animVal` des Filters leere Zeichenfolgen, und die Ausgabe des `<feConvolveMatrix>`-Filters kann nur als implizite Eingabe in das nächste Filterprimitiv wiederverwendet werden, wenn dieses Filterprimitiv keinen Wert für sein `in`-Attribut bereitstellt.
+
+## Wert
+
+Ein [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+## Beispiel
+
+```js
+const feConvolveMatrixElement = document.querySelector("feConvolveMatrix");
+const filterName = feConvolveMatrixElement.result;
+console.log(filterName.baseVal); // the filter's assigned name
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEConvolveMatrixElement.in1`](/de/docs/Web/API/SVGFEConvolveMatrixElement/in1)
+- {{cssxref("custom-ident")}}-Datentyp
+- [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)-Modul
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfeconvolvematrixelement/width/index.md b/files/de/web/api/svgfeconvolvematrixelement/width/index.md
new file mode 100644
index 000000000..69eff5723
--- /dev/null
+++ b/files/de/web/api/svgfeconvolvematrixelement/width/index.md
@@ -0,0 +1,40 @@
+---
+title: "SVGFEConvolveMatrixElement: width-Eigenschaft"
+short-title: width
+slug: Web/API/SVGFEConvolveMatrixElement/width
+l10n:
+  sourceCommit: e0bf626da04e5e1e21373fe4011e20fdcaae62a0
+---
+
+{{APIRef("SVG")}}
+
+Die **`width`**-Schreibgeschützte Eigenschaft der [`SVGFEConvolveMatrixElement`](/de/docs/Web/API/SVGFEConvolveMatrixElement)-Schnittstelle beschreibt die horizontale Größe eines SVG-Filterprimitivs als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feConvolveMatrix")}}-Element und das Filterprimitivattribut {{SVGAttr("width")}} wider. Der `<feConvolveMatrix>`-Filter wendet einen Matrixfaltungseffekt an, bei dem Pixel im Eingabebild mit benachbarten Pixeln kombiniert werden, um einen Faltungseffekt wie Unschärfe, Kantenerkennung, Schärfung, Prägung oder Abschrägung zu erzeugen. Das Attribut ist ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Breite des Filterbereichs. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Einheiten des Benutzerkoordinatensystems.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feConvolveMatrix = document.querySelector("feConvolveMatrix");
+const horizontalSize = feConvolveMatrix.width;
+console.log(horizontalSize.baseVal.value); // the `width` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEConvolveMatrixElement.height`](/de/docs/Web/API/SVGFEConvolveMatrixElement/height)
+- Modul [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG {{SVGElement("filter")}}-Element, SVG-Attribut {{SVGAttr("filter")}} in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfeconvolvematrixelement/x/index.md b/files/de/web/api/svgfeconvolvematrixelement/x/index.md
new file mode 100644
index 000000000..1da765034
--- /dev/null
+++ b/files/de/web/api/svgfeconvolvematrixelement/x/index.md
@@ -0,0 +1,40 @@
+---
+title: "SVGFEConvolveMatrixElement: x-Eigenschaft"
+short-title: x
+slug: Web/API/SVGFEConvolveMatrixElement/x
+l10n:
+  sourceCommit: e0bf626da04e5e1e21373fe4011e20fdcaae62a0
+---
+
+{{APIRef("SVG")}}
+
+Die unveränderliche **`x`**-Eigenschaft der [`SVGFEConvolveMatrixElement`](/de/docs/Web/API/SVGFEConvolveMatrixElement)-Schnittstelle beschreibt die horizontale Koordinate der Position einer SVG-Filterprimitive als ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Attributwert der {{SVGElement("feConvolveMatrix")}}-Element-{{SVGAttr("x")}}-Filterprimitive wider. Der `<feConvolveMatrix>`-Filter wendet einen Matrixkonvolutionseffekt an, der Pixel im Eingabebild mit benachbarten Pixeln kombiniert, um einen Konvolutionseffekt wie Weichzeichnung, Kantenerkennung, Schärfung, Prägung oder Abschrägung zu erzeugen. Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Die `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die die gegebene Entfernung vom Ursprung des Benutzerkoordinatensystems entlang der x-Achse darstellt. Wenn das `x`-Attribut ein Prozentwert ist, ist der Eigenschaftswert relativ zur Breite des Filterbereichs in Benutzereinheitensystemeinheiten. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feConvolveMatrix = document.querySelector("feConvolveMatrix");
+const leftPosition = feConvolveMatrix.x;
+console.log(leftPosition.baseVal.value); // the `x` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEConvolveMatrixElement.y`](/de/docs/Web/API/SVGFEConvolveMatrixElement/y)
+- [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)-Modul
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfeconvolvematrixelement/y/index.md b/files/de/web/api/svgfeconvolvematrixelement/y/index.md
new file mode 100644
index 000000000..dff4b0ca5
--- /dev/null
+++ b/files/de/web/api/svgfeconvolvematrixelement/y/index.md
@@ -0,0 +1,42 @@
+---
+title: "SVGFEConvolveMatrixElement: y-Eigenschaft"
+short-title: "y"
+slug: Web/API/SVGFEConvolveMatrixElement/y
+l10n:
+  sourceCommit: e0bf626da04e5e1e21373fe4011e20fdcaae62a0
+---
+
+{{APIRef("SVG")}}
+
+Die **`y`** schreibgeschützte Eigenschaft der [`SVGFEConvolveMatrixElement`](/de/docs/Web/API/SVGFEConvolveMatrixElement)-Schnittstelle beschreibt die vertikale Koordinate der Position eines SVG-Filterprimitives als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des {{SVGElement("feConvolveMatrix")}}-Element-Attributs {{SVGAttr("y")}} wider. Der `<feConvolveMatrix>`-Filter wendet einen Matrix-Konvolutionseffekt an, der Pixel im Eingabebild mit benachbarten Pixeln kombiniert, um Effekte wie Unschärfe, Kantenerkennung, Schärfen, Prägen oder Abfasen zu erzeugen.
+
+Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die die angegebene Entfernung vom Ursprung des Filters entlang der y-Achse darstellt. Wenn das `y`-Attribut ein Prozentwert ist, ist der Eigenschaftswert relativ zur Höhe des Filterbereichs in Einheiten des Benutzerkoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feConvolveMatrix = document.querySelector("feConvolveMatrix");
+const topPosition = feConvolveMatrix.y;
+console.log(topPosition.baseVal.value); // the `y` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEConvolveMatrixElement.x`](/de/docs/Web/API/SVGFEConvolveMatrixElement/x)
+- Modul [CSS-Filtereffekte](/de/docs/Web/CSS/CSS_filter_effects)
+- SVG {{SVGElement("filter")}}-Element, SVG {{SVGAttr("filter")}}-Attribut in [SVG](/de/docs/Web/SVG)
+- [Anwenden von SVG-Effekten auf HTML-Inhalte](/de/docs/Web/SVG/Applying_SVG_effects_to_HTML_content)
diff --git a/files/de/web/api/svgfedisplacementmapelement/height/index.md b/files/de/web/api/svgfedisplacementmapelement/height/index.md
new file mode 100644
index 000000000..29251f8ce
--- /dev/null
+++ b/files/de/web/api/svgfedisplacementmapelement/height/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEDisplacementMapElement: height-Eigenschaft"
+short-title: height
+slug: Web/API/SVGFEDisplacementMapElement/height
+l10n:
+  sourceCommit: b85296a36664e26537fc181c65521d0aa8679fa6
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte Eigenschaft **`height`** der [`SVGFEDisplacementMapElement`](/de/docs/Web/API/SVGFEDisplacementMapElement)-Schnittstelle beschreibt die vertikale Größe einer SVG-Filterprimitive als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feDisplacementMap")}}-Element und dessen Filterprimitive-Attribut {{SVGAttr("height")}} wider. Das Attribut ist eine [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`\<percentage>`](/de/docs/Web/SVG/Content_type#percentage) relativ zur Höhe der Filterregion. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Einheiten des Benutzerskoordinatensystems.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feDisplacementMap = document.querySelector("feDisplacementMap");
+const verticalSize = feDisplacementMap.height;
+console.log(verticalSize.baseVal.value); // the `height` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEDisplacementMapElement.width`](/de/docs/Web/API/SVGFEDisplacementMapElement/width)
+- [`SVGFEImageElement`](/de/docs/Web/API/SVGFEImageElement) API und {{SVGElement("feImage")}}-Element
+- [`SVGFETurbulenceElement`](/de/docs/Web/API/SVGFETurbulenceElement) API und {{SVGElement("feTurbulence")}}-Element
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfedisplacementmapelement/result/index.md b/files/de/web/api/svgfedisplacementmapelement/result/index.md
new file mode 100644
index 000000000..43e89577b
--- /dev/null
+++ b/files/de/web/api/svgfedisplacementmapelement/result/index.md
@@ -0,0 +1,44 @@
+---
+title: "SVGFEDisplacementMapElement: result-Eigenschaft"
+short-title: result
+slug: Web/API/SVGFEDisplacementMapElement/result
+l10n:
+  sourceCommit: b85296a36664e26537fc181c65521d0aa8679fa6
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`result`**-Eigenschaft der [`SVGFEDisplacementMapElement`](/de/docs/Web/API/SVGFEDisplacementMapElement) Schnittstelle beschreibt den zugewiesenen Namen einer SVG-Filter-Primitiven als [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+Sie spiegelt das {{SVGElement("feDisplacementMap")}}-Element-Attribut {{SVGAttr("result")}} wider. Der Attributwert ist ein {{cssxref("custom-ident")}}. Wenn angegeben, können Grafiken, die aus der Verarbeitung dieses Filter-Primitivs resultieren, durch ein {{SVGAttr("in")}}-Attribut auf einem nachfolgenden Filter-Primtiv innerhalb desselben {{SVGElement("filter")}}-Elements referenziert werden.
+
+Wenn kein `result`-Attribut definiert ist, sind die `result.baseVal` und `result.animVal` des Filters leere Zeichenfolgen, und die Ausgabe des `<feDisplacementMap>`-Filters wird nur zur Wiederverwendung als implizite Eingabe in das nächste Filter-Primitiv verfügbar sein, wenn dieses Filter-Primitiv keinen Wert für sein `in`-Attribut angibt.
+
+## Wert
+
+Ein [`SVGAnimatedString`](/de/docs/Web/API/SVGAnimatedString).
+
+## Beispiel
+
+```js
+const feDisplacementMapElement = document.querySelector("feDisplacementMap");
+const filterName = feDisplacementMapElement.result;
+console.log(filterName.baseVal); // the filter's assigned name
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEDisplacementMapElement.in1`](/de/docs/Web/API/SVGFEDisplacementMapElement/in1)
+- {{cssxref("custom-ident")}} Datentyp
+- [`SVGFEImageElement`](/de/docs/Web/API/SVGFEImageElement) API und {{SVGElement("feImage")}} Element
+- [`SVGFETurbulenceElement`](/de/docs/Web/API/SVGFETurbulenceElement) API und {{SVGElement("feTurbulence")}} Element
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfedisplacementmapelement/width/index.md b/files/de/web/api/svgfedisplacementmapelement/width/index.md
new file mode 100644
index 000000000..d9ab504f5
--- /dev/null
+++ b/files/de/web/api/svgfedisplacementmapelement/width/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEDisplacementMapElement: Breite-Eigenschaft"
+short-title: width
+slug: Web/API/SVGFEDisplacementMapElement/width
+l10n:
+  sourceCommit: b85296a36664e26537fc181c65521d0aa8679fa6
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte **`width`**-Eigenschaft der [`SVGFEDisplacementMapElement`](/de/docs/Web/API/SVGFEDisplacementMapElement)-Schnittstelle beschreibt die horizontale Größe einer SVG-Filterprimitive als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt das {{SVGElement("feDisplacementMap")}}-Elementattribut {{SVGAttr("width")}} der Filterprimitive wider. Das Attribut ist eine [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder ein [`\<percentage>`](/de/docs/Web/SVG/Content_type#percentage), relativ zur Breite der Filterregion. Der Standardwert ist `100%`. Der Eigenschaftswert ist eine Länge in Einheiten des Benutzerkoordinatensystems.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feDisplacementMap = document.querySelector("feDisplacementMap");
+const horizontalSize = feDisplacementMap.width;
+console.log(horizontalSize.baseVal.value); // the `width` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEDisplacementMapElement.height`](/de/docs/Web/API/SVGFEDisplacementMapElement/height)
+- [`SVGFEImageElement`](/de/docs/Web/API/SVGFEImageElement)-API und {{SVGElement("feImage")}}-Element
+- [`SVGFETurbulenceElement`](/de/docs/Web/API/SVGFETurbulenceElement)-API und {{SVGElement("feTurbulence")}}-Element
+- CSS-Datentyp {{cssxref("blend-mode")}}
+- CSS-Eigenschaft {{cssxref("mix-blend-mode")}}
diff --git a/files/de/web/api/svgfedisplacementmapelement/x/index.md b/files/de/web/api/svgfedisplacementmapelement/x/index.md
new file mode 100644
index 000000000..9eb5e01b3
--- /dev/null
+++ b/files/de/web/api/svgfedisplacementmapelement/x/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEDisplacementMapElement: x-Eigenschaft"
+short-title: x
+slug: Web/API/SVGFEDisplacementMapElement/x
+l10n:
+  sourceCommit: b85296a36664e26537fc181c65521d0aa8679fa6
+---
+
+{{APIRef("SVG")}}
+
+Die schreibgeschützte Eigenschaft **`x`** des [`SVGFEDisplacementMapElement`](/de/docs/Web/API/SVGFEDisplacementMapElement)-Interfaces beschreibt die horizontale Koordinate der Position eines SVG-Filterprimitivs als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Es spiegelt den Wert des Filterprimitivattributs {{SVGAttr("x")}} des {{SVGElement("feDisplacementMap")}}-Elements wider. Das Attribut ist ein [`<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzokoordinatensystem, die die gegebene Entfernung vom Ursprung des Benutzokoordinatensystems entlang der x-Achse darstellt. Wenn das `x`-Attribut einen Prozentwert hat, bezieht sich der Eigenschaftswert auf die Breite des Filterbereichs in Benutzokoordinateneinheiten. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feDisplacementMap = document.querySelector("feDisplacementMap");
+const leftPosition = feDisplacementMap.x;
+console.log(leftPosition.baseVal.value); // the `x` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEDisplacementMapElement.y`](/de/docs/Web/API/SVGFEDisplacementMapElement/y)
+- [`SVGFEImageElement`](/de/docs/Web/API/SVGFEImageElement) API und {{SVGElement("feImage")}}-Element
+- [`SVGFETurbulenceElement`](/de/docs/Web/API/SVGFETurbulenceElement) API und {{SVGElement("feTurbulence")}}-Element
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/svgfedisplacementmapelement/y/index.md b/files/de/web/api/svgfedisplacementmapelement/y/index.md
new file mode 100644
index 000000000..4662df205
--- /dev/null
+++ b/files/de/web/api/svgfedisplacementmapelement/y/index.md
@@ -0,0 +1,41 @@
+---
+title: "SVGFEDisplacementMapElement: y-Eigenschaft"
+short-title: "y"
+slug: Web/API/SVGFEDisplacementMapElement/y
+l10n:
+  sourceCommit: b85296a36664e26537fc181c65521d0aa8679fa6
+---
+
+{{APIRef("SVG")}}
+
+Die **`y`** schreibgeschützte Eigenschaft des [`SVGFEDisplacementMapElement`](/de/docs/Web/API/SVGFEDisplacementMapElement)-Interfaces beschreibt die vertikale Koordinate der Position einer SVG-Filterprimitive als [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+Sie spiegelt den Wert des Filterprimitive-Attributs {{SVGAttr("y")}} des {{SVGElement("feDisplacementMap")}}-Elements wider. Das Attribut ist ein [`\<length>`](/de/docs/Web/SVG/Content_type#length) oder [`<percentage>`](/de/docs/Web/SVG/Content_type#percentage). Das `<coordinate>` ist eine Länge im Benutzerkoordinatensystem, die den angegebenen Abstand vom Ursprung des Filters entlang der y-Achse beschreibt. Wenn das `y`-Attribut einen Prozentwert hat, ist der Eigenschaftswert relativ zur Höhe der Filterregion in Einheiten des Benutzerkoordinatensystems. Der Standardwert ist `0`.
+
+## Wert
+
+Ein [`SVGAnimatedLength`](/de/docs/Web/API/SVGAnimatedLength).
+
+## Beispiel
+
+```js
+const feDisplacementMap = document.querySelector("feDisplacementMap");
+const topPosition = feDisplacementMap.y;
+console.log(topPosition.baseVal.value); // the `y` value
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`SVGFEDisplacementMapElement.x`](/de/docs/Web/API/SVGFEDisplacementMapElement/x)
+- [`SVGFEImageElement`](/de/docs/Web/API/SVGFEImageElement) API und das {{SVGElement("feImage")}}-Element
+- [`SVGFETurbulenceElement`](/de/docs/Web/API/SVGFETurbulenceElement) API und das {{SVGElement("feTurbulence")}}-Element
+- CSS {{cssxref("blend-mode")}} Datentyp
+- CSS {{cssxref("mix-blend-mode")}} Eigenschaft
diff --git a/files/de/web/api/window/requestanimationframe/index.md b/files/de/web/api/window/requestanimationframe/index.md
index 67737e8b4..dc73357c3 100644
--- a/files/de/web/api/window/requestanimationframe/index.md
+++ b/files/de/web/api/window/requestanimationframe/index.md
@@ -1,22 +1,23 @@
 ---
-title: "Window: requestAnimationFrame() Methode"
+title: "Window: requestAnimationFrame() method"
 short-title: requestAnimationFrame()
 slug: Web/API/Window/requestAnimationFrame
 l10n:
-  sourceCommit: 85d2ef85f395053ce12f3e2067b784a12eb77ae9
+  sourceCommit: 55cecdcd812a8e88851def4b9687171c05e6d505
 ---
 
 {{APIRef}}
 
-Die **`window.requestAnimationFrame()`** Methode teilt dem Browser mit, dass Sie eine Animation durchführen möchten. Sie fordert den Browser auf, eine vom Benutzer bereitgestellte Rückruffunktion vor dem nächsten Neuzeichnen aufzurufen.
+Die **`window.requestAnimationFrame()`**-Methode informiert den Browser darüber, dass Sie eine Animation durchführen möchten. Es fordert den Browser auf, eine vom Benutzer bereitgestellte Callback-Funktion vor dem nächsten Neuzeichnen aufzurufen.
 
-Die Häufigkeit der Aufrufe der Rückruffunktion stimmt im Allgemeinen mit der Bildschirmaktualisierungsrate überein. Die häufigste Aktualisierungsrate beträgt 60 Hz (60 Zyklen/Bilder pro Sekunde), aber 75 Hz, 120 Hz und 144 Hz sind ebenfalls weit verbreitet. `requestAnimationFrame()` Aufrufe werden in den meisten Browsern pausiert, wenn sie in Hintergrund-Tabs oder versteckten {{ HTMLElement("iframe") }}s ausgeführt werden, um die Leistung und die Akkulaufzeit zu verbessern.
+Die Häufigkeit der Aufrufe der Callback-Funktion entspricht im Allgemeinen der Bildwiederholfrequenz des Displays. Die gängigste Bildwiederholrate ist 60 Hz (60 Zyklen/Bilder pro Sekunde), obwohl auch 75 Hz, 120 Hz und 144 Hz weit verbreitet sind. Aufrufe von `requestAnimationFrame()` werden in den meisten Browsern pausiert, wenn sie in Hintergrund-Tabs oder in versteckten {{ HTMLElement("iframe") }}s ausgeführt werden, um die Leistung und die Akkulaufzeit zu verbessern.
 
 > [!NOTE]
-> Ihre Rückruffunktion muss `requestAnimationFrame()` erneut aufrufen, wenn Sie ein weiteres Bild animieren möchten. `requestAnimationFrame()` ist einmalig.
+> Ihre Callback-Funktion muss `requestAnimationFrame()` erneut aufrufen, wenn Sie einen weiteren Frame animieren möchten. `requestAnimationFrame()` ist einmalig.
 
 > [!WARNING]
-> Achten Sie darauf, immer das erste Argument (oder eine andere Methode zur Ermittlung der aktuellen Uhrzeit) zu verwenden, um zu berechnen, wie weit die Animation in einem Frame fortschreiten wird — **andernfalls läuft die Animation auf Bildschirmen mit hoher Bildwiederholrate schneller ab**. Weitere Informationen finden Sie in den unten stehenden Beispielen.
+> Achten Sie stets darauf, das erste Argument (oder eine andere Methode, um die aktuelle Zeit zu erhalten) zu verwenden, um zu berechnen, wie weit die Animation in einem Frame fortschreitet — **anderfalls läuft die Animation auf Bildschirmen mit hoher Bildwiederholrate schneller**.
+> Möglichkeiten dazu finden Sie in den unten stehenden Beispielen.
 
 ## Syntax
 
@@ -28,21 +29,28 @@ requestAnimationFrame(callback)
 
 - `callback`
 
-  - : Die Funktion, die aufgerufen wird, wenn es Zeit ist, Ihre Animation für das nächste Neuzeichnen zu aktualisieren. Diese Rückruffunktion erhält ein einzelnes Argument:
+  - : Die Funktion, die aufgerufen wird, wenn es Zeit ist, Ihre Animation für das nächste Neuzeichnen zu aktualisieren. Diese Callback-Funktion erhält ein einzelnes Argument:
 
     - `timestamp`
 
-      - : Ein [`DOMHighResTimeStamp`](/de/docs/Web/API/DOMHighResTimeStamp), der die Endzeit des Renderings des vorherigen Bildes angibt (basierend auf der Anzahl von Millisekunden seit dem [Zeitursprung](/de/docs/Web/API/Performance/timeOrigin)). Der Zeitstempel ist eine Dezimalzahl, in Millisekunden, jedoch mit einer minimalen Genauigkeit von 1 Millisekunde. Für `Window` Objekte (nicht `Workers`) ist es gleich [`document.timeline.currentTime`](/de/docs/Web/API/AnimationTimeline/currentTime). Dieser Zeitstempel wird zwischen allen Fenstern geteilt, die auf demselben Agenten ausgeführt werden (alle Fenster mit gleichem Ursprung und, was noch wichtiger ist, iframe mit gleichem Ursprung) — was das Synchronisieren von Animationen über mehrere `requestAnimationFrame` Rückrufe ermöglicht. Der Zeitstempelwert ähnelt auch dem Aufruf von [`performance.now()`](/de/docs/Web/API/Performance/now) zu Beginn der Rückruffunktion, ist jedoch nie derselbe Wert.
+      - : Ein [`DOMHighResTimeStamp`](/de/docs/Web/API/DOMHighResTimeStamp), der die Endzeit der Rendering des vorherigen Frames anzeigt (basierend auf der Anzahl der Millisekunden seit dem [time origin](/de/docs/Web/API/Performance/timeOrigin)). Der Zeitstempel ist eine Dezimalzahl in Millisekunden, jedoch mit einer minimalen Präzision von 1 Millisekunde. Für `Window`-Objekte (nicht `Workers`) entspricht er [`document.timeline.currentTime`](/de/docs/Web/API/AnimationTimeline/currentTime). Dieser Zeitstempel wird zwischen allen Fenstern geteilt, die auf dem gleichen Agenten laufen (alle gleichherkunftlichen Fenster und, noch wichtiger, gleichherkunftliche iframes) — was eine Synchronisation der Animationen über mehrere `requestAnimationFrame`-Callbacks hinweg ermöglicht. Der Zeitstempelwert ähnelt auch dem Aufruf von [`performance.now()`](/de/docs/Web/API/Performance/now) zu Beginn der Callback-Funktion, ist jedoch nie derselbe Wert.
 
-        Wenn mehrere Rückrufe, die durch `requestAnimationFrame()` in einem einzigen Frame eingereiht wurden, beginnen zu feuern, erhält jeder denselben Zeitstempel, obwohl während der Berechnung jeder vorhergehenden Rückrufbelastung Zeit vergangen ist.
+        Wenn mehrere durch `requestAnimationFrame()` gequeue-te Callbacks in einem einzelnen Frame zu feuern beginnen, erhält jeder den gleichen Zeitstempel, auch wenn während der Berechnung der Arbeitslast jedes vorherigen Callbacks Zeit verstrichen ist.
 
 ### Rückgabewert
 
-Ein `long` Integer-Wert, die Anforderungs-ID, die den Eintrag in der Rückrufliste eindeutig identifiziert. Dies ist ein von null verschiedener Wert, aber Sie sollten keine weiteren Annahmen über seinen Wert treffen. Diesen Wert können Sie an [`window.cancelAnimationFrame()`](/de/docs/Web/API/Window/cancelAnimationFrame) übergeben, um die Aktualisierungs-Rückrufanforderung abzubrechen.
+Ein `unsigned long` Integerwert, die Anfrage-ID, die den Eintrag in der Callback-Liste eindeutig identifiziert. Sie sollten keine Annahmen über seinen Wert machen. Sie können diesen Wert an [`window.cancelAnimationFrame()`](/de/docs/Web/API/Window/cancelAnimationFrame) übergeben, um die Neuzeichnungs-Callback-Anfrage abzubrechen.
+
+> [!WARNING]
+> Die Anfrage-ID wird typischerweise als ein sich pro Fenster erhöhender Zähler implementiert. Daher kann sie, auch wenn sie mit 1 zählt, überlaufen und schließlich 0 erreichen.
+> Obwohl es unwahrscheinlich ist, dass es bei kurzlebigen Anwendungen Probleme verursacht, sollten Sie `0` als Wächterwert für ungültige Anfrage-Identifikator-IDs vermeiden und stattdessen nicht erreichbare Werte wie `null` bevorzugen.
+> Die Spezifikation spezifiziert das Überlaufverhalten nicht, daher haben Browser voneinander abweichende Verhaltensweisen. Beim Überlaufen würde der Wert entweder auf 0 oder einen negativen Wert springen oder mit einem Fehler fehlschlagen.
+> Solange das Überlaufen keinen Fehler verursacht, sind Anfrage-IDs auch nicht wirklich einzigartig, da es nur eine endliche Anzahl von 32-Bit-Integern für möglicherweise unendlich viele Callbacks gibt.
+> Beachten Sie jedoch, dass es etwa 500 Tage dauern würde, um das Problem zu erreichen, wenn bei 60 Hz mit 100 Aufrufen von `requestAnimationFrame()` pro Frame gerendert wird.
 
 ## Beispiele
 
-In diesem Beispiel wird ein Element für 2 Sekunden (2000 Millisekunden) animiert. Das Element bewegt sich mit einer Geschwindigkeit von 0,1px/ms nach rechts, sodass seine relative Position (in CSS-Pixel) in Abhängigkeit von der seit Beginn der Animation verstrichenen Zeit (in Millisekunden) mit `0.1 * elapsed` berechnet werden kann. Die Endposition des Elements ist 200px (`0.1 * 2000`) rechts von seiner Ausgangsposition.
+In diesem Beispiel wird ein Element für 2 Sekunden (2000 Millisekunden) animiert. Das Element bewegt sich mit einer Geschwindigkeit von 0,1px/ms nach rechts, sodass seine relative Position (in CSS-Pixeln) in Abhängigkeit von der seit Beginn der Animation verstrichenen Zeit (in Millisekunden) mit `0.1 * elapsed` berechnet werden kann. Die Endposition des Elements ist 200px (`0.1 * 2000`) rechts von seiner ursprünglichen Position.
 
 ```js
 const element = document.getElementById("some-element-you-want-to-animate");
@@ -65,9 +73,9 @@ function step(timestamp) {
 requestAnimationFrame(step);
 ```
 
-Die folgenden drei Beispiele zeigen verschiedene Ansätze zum Festlegen des Nullpunkts in der Zeit, die Basislinie zur Berechnung des Fortschritts Ihrer Animation in jedem Frame. Wenn Sie eine Synchronisation mit einer externen Uhr vornehmen möchten, wie z.B. [`BaseAudioContext.currentTime`](/de/docs/Web/API/BaseAudioContext/currentTime), dann ist die höchste verfügbare Präzision die Dauer eines einzelnen Frames, 16,67ms @60Hz. Das Zeitstempel-Argument des Rückrufs stellt das Ende des vorherigen Frames dar, sodass der früheste Zeitpunkt, zu dem Ihre neu berechneten Werte gerendert werden, im nächsten Frame liegt.
+Die folgenden drei Beispiele veranschaulichen verschiedene Ansätze zur Festlegung des Nullpunkts, der Basislinie zur Berechnung des Fortschritts Ihrer Animation in jedem Frame. Wenn Sie mit einer externen Uhr synchronisieren möchten, wie zum Beispiel [`BaseAudioContext.currentTime`](/de/docs/Web/API/BaseAudioContext/currentTime), ist die höchste verfügbare Präzision die Dauer eines einzelnen Frames, 16,67ms @60hz. Das Zeitstempelargument des Callbacks repräsentiert das Ende des vorherigen Frames, sodass der früheste Zeitpunkt, zu dem Ihre neu berechneten Werte gerendert werden, im nächsten Frame liegt.
 
-Dieses Beispiel wartet, bis der erste Rückruf ausgeführt wird, um `zero` zu setzen. Wenn Ihre Animation bei Beginn auf einen neuen Wert springt, müssen Sie sie auf diese Weise strukturieren. Wenn Sie nichts Externes, wie z.B. Audio, synchronisieren müssen, wird dieser Ansatz empfohlen, da einige Browser eine Verzögerung von mehreren Frames zwischen dem initialen Aufruf von `requestAnimationFrame()` und dem ersten Aufruf der Rückruffunktion haben.
+Dieses Beispiel wartet, bis der erste Callback ausgeführt wird, um `zero` festzulegen. Wenn Ihre Animation beim Starten zu einem neuen Wert springt, müssen Sie sie auf diese Weise strukturieren. Wenn Sie nichts externes wie Audio synchronisieren müssen, wird dieser Ansatz empfohlen, da einige Browser eine Mehrframe-Verzögerung zwischen dem ersten Aufruf von `requestAnimationFrame()` und dem ersten Aufruf der Callback-Funktion haben.
 
 ```js
 let zero;
@@ -85,7 +93,7 @@ function animate(timestamp) {
 }
 ```
 
-Dieses Beispiel verwendet [`document.timeline.currentTime`](/de/docs/Web/API/AnimationTimeline/currentTime), um einen Nullwert vor dem ersten Aufruf von `requestAnimationFrame` zu setzen. `document.timeline.currentTime` stimmt mit dem `timestamp` Argument überein, sodass der Nullwert dem Zeitstempel des 0ten Frames entspricht.
+Dieses Beispiel verwendet [`document.timeline.currentTime`](/de/docs/Web/API/AnimationTimeline/currentTime), um einen Nullwert vor dem ersten Aufruf von `requestAnimationFrame` festzulegen. `document.timeline.currentTime` stimmt mit dem `timestamp`-Argument überein, sodass der Nullwert dem Zeitstempel des 0. Frames entspricht.
 
 ```js
 const zero = document.timeline.currentTime;
@@ -99,7 +107,8 @@ function animate(timestamp) {
 }
 ```
 
-Dieses Beispiel animiert mit [`performance.now()`](/de/docs/Web/API/Performance/now) anstelle des Zeitstempelwerts des Rückrufs. Sie könnten dies verwenden, um eine etwas höhere Synchronisationsgenauigkeit zu erreichen, obwohl der zusätzliche Grad der Präzision variabel und nicht sehr groß ist. Hinweis: Dieses Beispiel erlaubt Ihnen nicht, Animationsrückrufe zuverlässig zu synchronisieren.
+Dieses Beispiel animiert mithilfe von [`performance.now()`](/de/docs/Web/API/Performance/now) anstelle des Zeitstempelwerts des Callbacks. Sie könnten dies verwenden, um eine etwas höhere Synchronisationspräzision zu erreichen, obwohl der zusätzliche Grad an Präzision variabel ist und nicht viel zunimmt.
+Hinweis: Dieses Beispiel ermöglicht es Ihnen nicht, Animation-Callbacks zuverlässig zu synchronisieren.
 
 ```js
 const zero = performance.now();
@@ -125,5 +134,6 @@ function animate() {
 
 - [`Window.cancelAnimationFrame()`](/de/docs/Web/API/Window/cancelAnimationFrame)
 - [`DedicatedWorkerGlobalScope.requestAnimationFrame()`](/de/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame)
-- [Animating with JavaScript: from setInterval to requestAnimationFrame](https://hacks.mozilla.org/2011/08/animating-with-javascript-from-setinterval-to-requestanimationframe/) - Blogbeitrag
-- [TestUFO: Testen Sie Ihren Webbrowser auf requestAnimationFrame() Timing-Abweichungen](https://www.testufo.com/#test=animation-time-graph)
+- [Animieren mit JavaScript: vom setInterval zu requestAnimationFrame](https://hacks.mozilla.org/2011/08/animating-with-javascript-from-setinterval-to-requestanimationframe/) - Blogpost
+- [TestUFO: Testen Sie Ihren Webbrowser auf Timing-Abweichungen von requestAnimationFrame()](https://www.testufo.com/#test=animation-time-graph)
+- [Firefox wechselt zu uint32_t für die requestAnimationFrame-Anfrage-ID](https://phabricator.services.mozilla.com/rMOZILLACENTRAL149722297f033d5c3ad126d0c72edcb1cb96d72e)
diff --git a/files/de/web/css/_colon_open/index.md b/files/de/web/css/_colon_open/index.md
index 24015c6ac..6729ff72a 100644
--- a/files/de/web/css/_colon_open/index.md
+++ b/files/de/web/css/_colon_open/index.md
@@ -2,12 +2,12 @@
 title: ":open"
 slug: Web/CSS/:open
 l10n:
-  sourceCommit: 284fb56ed77bac755053d141d898d48d948548b0
+  sourceCommit: 62a6f2dbd99b39212f4c4c12aa2a6d499e447f46
 ---
 
-{{CSSRef}}
+{{CSSRef}}{{SeeCompatTable}}
 
-Die CSS-**`:open`**-[Pseudoklasse](/de/docs/Web/CSS/Pseudo-classes) selektiert Elemente im offenen Zustand. Sie funktioniert nur bei Elementen, die sowohl einen offenen als auch einen geschlossenen Zustand haben. Sie passt auf {{HTMLElement("details")}} und {{HTMLElement("dialog")}}, wenn diese sich im offenen Zustand befinden, und auf {{HTMLElement("select")}} und {{HTMLElement("input")}}, wenn sie in einem Modus sind, bei dem ein Auswahlfenster existiert und dieses angezeigt wird.
+Die **`:open`** [CSS](/de/docs/Web/CSS) [Pseudoklasse](/de/docs/Web/CSS/Pseudo-classes) selektiert Elemente im offenen Zustand. Sie funktioniert nur bei Elementen, die sowohl offene als auch geschlossene Zustände haben. Sie passt zu {{HTMLElement("details")}} und {{HTMLElement("dialog")}}, wenn diese im offenen Zustand sind, und passt zu {{HTMLElement("select")}} und {{HTMLElement("input")}}, wenn sie sich in Modi befinden, in denen ein Picker vorhanden ist und der Picker angezeigt wird.
 
 ## Syntax
 
diff --git a/files/de/web/html/element/heading_elements/index.md b/files/de/web/html/element/heading_elements/index.md
index 89933c25a..fa950b6d0 100644
--- a/files/de/web/html/element/heading_elements/index.md
+++ b/files/de/web/html/element/heading_elements/index.md
@@ -2,42 +2,42 @@
 title: "<h1>–<h6>: Die HTML-Abschnittsüberschriftselemente"
 slug: Web/HTML/Element/Heading_Elements
 l10n:
-  sourceCommit: 28b95210aef7cf62a6e9099a7c2f62ac37746823
+  sourceCommit: 55b649f8d53a715a1d6c915ae479354452a6dbaf
 ---
 
 {{HTMLSidebar}}
 
-Die **`<h1>`** bis **`<h6>`** [HTML](/de/docs/Web/HTML)-Elemente stellen sechs Ebenen von Abschnittsüberschriften dar. `<h1>` ist die höchste Abschnittsebene und `<h6>` die niedrigste. Standardmäßig erzeugen alle Überschriftselemente ein {{Glossary("Block-level_content", "block-level")}}-Box im Layout, die auf einer neuen Zeile beginnt und die volle Breite des umgebenden Blockes einnimmt.
+Die **`<h1>`** bis **`<h6>`** [HTML](/de/docs/Web/HTML) Elemente repräsentieren sechs Ebenen von Abschnittsüberschriften. `<h1>` ist die höchste Abschnittsebene und `<h6>` ist die niedrigste. Standardmäßig erstellen alle Überschriftselemente ein {{Glossary("Block-level_content", "Block-Level")}} Element im Layout, das auf einer neuen Zeile beginnt und die gesamte Breite des umschließenden Blocks einnimmt.
 
 {{EmbedInteractiveExample("pages/tabbed/h1-h6.html", "tabbed-standard")}}
 
 ## Attribute
 
-Diese Elemente enthalten nur die [globalen Attribute](/de/docs/Web/HTML/Global_attributes).
+Diese Elemente beinhalten nur die [globalen Attribute](/de/docs/Web/HTML/Global_attributes).
 
 ## Verwendungshinweise
 
-- Überschriftinformationen können von Benutzeragenten verwendet werden, um automatisch ein Inhaltsverzeichnis für ein Dokument zu erstellen.
-- Verwenden Sie keine Überschriftselemente, um Text zu verkleinern. Verwenden Sie stattdessen die {{Glossary("CSS", "CSS")}} {{cssxref("font-size")}}-Eigenschaft.
+- Überschrifteninformationen können von Benutzersoftware verwendet werden, um automatisch ein Inhaltsverzeichnis für ein Dokument zu erstellen.
+- Verwenden Sie keine Überschriftselemente, um Text zu verkleinern. Nutzen Sie stattdessen die {{Glossary("CSS", "CSS")}} {{cssxref("font-size")}} Eigenschaft.
 - Überspringen Sie keine Überschriftsebenen: Beginnen Sie immer mit `<h1>`, gefolgt von `<h2>` und so weiter.
 
 ### Vermeiden Sie die Verwendung mehrerer `<h1>`-Elemente auf einer Seite
 
-Die Verwendung mehrerer `<h1>`-Elemente auf einer Seite ist durch den HTML-Standard erlaubt (sofern sie nicht [verschachtelt](#verschachtelung) sind), wird jedoch nicht als Best Practice betrachtet. Eine Seite sollte im Allgemeinen ein einzelnes `<h1>`-Element haben, das den Inhalt der Seite beschreibt (ähnlich dem [`<title>`](/de/docs/Web/HTML/Element/title)-Element des Dokuments).
+Obwohl das Verwenden mehrerer `<h1>`-Elemente auf einer Seite gemäß dem HTML-Standard erlaubt ist (solange sie nicht [verschachtelt](#verschachtelung) sind), wird dies nicht als Best Practice betrachtet. Eine Seite sollte im Allgemeinen ein einzelnes `<h1>`-Element haben, das den Inhalt der Seite beschreibt (ähnlich dem [`<title>`](/de/docs/Web/HTML/Element/title) Element des Dokuments).
 
 > [!NOTE]
-> Die Verschachtelung mehrerer `<h1>`-Elemente in verschachtelten [sectioning elements](/de/docs/Web/HTML/Element#content_sectioning) war in früheren Versionen des HTML-Standards erlaubt. Dies wurde jedoch nie als Best Practice angesehen und ist jetzt nicht mehr konform. Lesen Sie mehr in [There Is No Document Outline Algorithm](https://adrianroselli.com/2016/08/there-is-no-document-outline-algorithm.html).
+> Das Verschachteln mehrerer `<h1>`-Elemente in verschachtelten [Abschnittselementen](/de/docs/Web/HTML/Element#content_sectioning) war in älteren Versionen des HTML-Standards erlaubt. Dies wurde jedoch nie als Best Practice angesehen und ist inzwischen nicht mehr konform. Lesen Sie mehr in [There Is No Document Outline Algorithm](https://adrianroselli.com/2016/08/there-is-no-document-outline-algorithm.html).
 
-Bevorzugen Sie es, nur ein `<h1>` pro Seite zu verwenden, und [verschachteln Sie Überschriften](#verschachtelung), ohne Ebenen zu überspringen.
+Bevorzugen Sie die Verwendung von nur einem `<h1>` pro Seite und [verschachteln Sie Überschriften](#verschachtelung) ohne Ebenen zu überspringen.
 
-### Festlegen einer einheitlichen Schriftgröße für `<h1>`
+### Ein einheitliches Schriftgrößenformat für `<h1>` festlegen
 
-Der [HTML-Standard](https://html.spec.whatwg.org/multipage/rendering.html#sections-and-headings) spezifiziert, dass `<h1>`-Elemente in einem `<section>`, `<article>`, `<aside>` oder `<nav>`-Element als `<h2>` gerendert werden sollten (kleinere {{cssxref("font-size")}} mit einem angepassten {{cssxref("margin-block")}}) oder als `<h3>`, wenn sie eine weitere Ebene verschachtelt sind, und so weiter.
+Der [HTML-Standard](https://html.spec.whatwg.org/multipage/rendering.html#sections-and-headings) spezifiziert, dass `<h1>`-Elemente in einem `<section>`, `<article>`, `<aside>` oder `<nav>` Element als `<h2>` (kleinere {{cssxref("font-size")}} mit angepasstem {{cssxref("margin-block")}}) oder als `<h3>`, wenn eine weitere Ebene verschachtelt ist, gerendert werden sollen.
 
 > [!NOTE]
-> Es gibt einen [Vorschlag](https://github.com/whatwg/html/issues/7867), diesen speziellen Standardstil zu entfernen, sodass `<h1>` immer denselben Standardstil hat. Dieser Vorschlag ist derzeit [in Firefox Nightly implementiert](/de/docs/Mozilla/Firefox/Experimental_features#ua_styles_for_h1_nested_in_sectioning_elements).
+> Es gibt einen [Vorschlag](https://github.com/whatwg/html/issues/7867), diesen speziellen Standardstil zu entfernen, sodass `<h1>` immer den gleichen Standardstil hat. Dieser Vorschlag ist aktuell [in Firefox Nightly implementiert](/de/docs/Mozilla/Firefox/Experimental_features#ua_styles_for_h1_nested_in_sectioning_elements).
 
-Um ein konsistentes `<h1>`-Rendering sicherzustellen, verwenden Sie die folgende Stilregel:
+Um ein einheitliches `<h1>`-Rendering sicherzustellen, verwenden Sie die folgende Stilregel:
 
 ```css
 h1 {
@@ -46,7 +46,7 @@ h1 {
 }
 ```
 
-Alternativ können Sie {{cssxref(":where()")}} verwenden, das keine Spezifität hat, um andere Stilregeln, die `<h1>` anvisieren, nicht zu überschreiben:
+Alternativ, um das Überschreiben anderer Stilregeln, die `<h1>` ansprechen, zu vermeiden, können Sie {{cssxref(":where()")}} verwenden, das keine Spezifität hat:
 
 ```css
 :where(h1) {
@@ -59,9 +59,9 @@ Alternativ können Sie {{cssxref(":where()")}} verwenden, das keine Spezifität
 
 ### Navigation
 
-Eine gängige Navigationstechnik für Benutzer von Screenreader-Software besteht darin, schnell von Überschrift zu Überschrift zu springen, um den Inhalt der Seite zu bestimmen. Aus diesem Grund ist es wichtig, keine Überschriftsebenen zu überspringen. Andernfalls könnte Verwirrung entstehen, da die navigierende Person sich fragen könnte, wo die fehlende Überschrift ist.
+Eine gängige Navigationstechnik für Benutzer von Bildschirmlesesoftware ist das schnelle Springen von Überschrift zu Überschrift, um den Inhalt der Seite zu bestimmen. Aufgrund dessen ist es wichtig, keine Überschriftsebenen zu überspringen. Andernfalls könnte Verwirrung entstehen, wenn sich der Benutzer fragt, wo die fehlende Überschrift ist.
 
-**Das sollten Sie vermeiden:**
+**Machen Sie das nicht:**
 
 ```html example-bad
 <h1>Heading level 1</h1>
@@ -79,9 +79,9 @@ Eine gängige Navigationstechnik für Benutzer von Screenreader-Software besteht
 
 #### Verschachtelung
 
-Überschriften können als Unterabschnitte verschachtelt werden, um die Organisation des Inhalts der Seite widerzuspiegeln. Die meisten Screenreader können auch eine geordnete Liste aller Überschriften auf einer Seite erstellen, die einer Person helfen kann, die Inhaltsstruktur schnell zu bestimmen und zu verschiedenen Überschriften zu navigieren.
+Überschriften können als Unterabschnitte verschachtelt werden, um die Organisation des Seiteninhalts widerzuspiegeln. Die meisten Bildschirmlesegeräte können auch eine geordnete Liste aller Überschriften auf einer Seite generieren, was einer Person hilft, schnell die Inhaltsstruktur zu erkennen und zu verschiedenen Überschriften zu navigieren.
 
-Gegeben sei die folgende Seitenstruktur:
+Basierend auf der folgenden Seitenstruktur:
 
 ```html
 <h1>Beetles</h1>
@@ -107,12 +107,12 @@ Gegeben sei die folgende Seitenstruktur:
 <h3>Abdomen</h3>
 ```
 
-Screenreader würden eine Liste wie diese erzeugen:
+Bildschirmlesesoftware würde eine Liste wie diese generieren:
 
 1. `h1` Käfer
 
    1. `h2` Etymologie
-   2. `h2` Verbreitung und Vielfalt
+   2. `h2` Verteilung und Vielfalt
    3. `h2` Evolution
 
       1. `h3` Spätes Paläozoikum
@@ -124,7 +124,7 @@ Screenreader würden eine Liste wie diese erzeugen:
 
       1. `h3` Kopf
 
-         1. `h4` Mundteile
+         1. `h4` Mundwerkzeuge
 
       2. `h3` Thorax
 
@@ -135,23 +135,23 @@ Screenreader würden eine Liste wie diese erzeugen:
       4. `h3` Flügel
       5. `h3` Abdomen
 
-Wenn Überschriften verschachtelt sind, können Überschriftsebenen beim Schließen eines Unterabschnitts "übersprungen" werden.
+Wenn Überschriften verschachtelt werden, dürfen Überschriftenebenen beim Schließen eines Unterabschnitts "übersprungen" werden.
 
-- [Headings • Page Structure • WAI Web Accessibility Tutorials](https://www.w3.org/WAI/tutorials/page-structure/headings/)
-- [MDN Understanding WCAG, Guideline 1.3 explanations](/de/docs/Web/Accessibility/Understanding_WCAG/Perceivable#guideline_1.3_—_create_content_that_can_be_presented_in_different_ways)
-- [Understanding Success Criterion 1.3.1 | W3C Understanding WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/content-structure-separation-programmatic.html)
-- [MDN Understanding WCAG, Guideline 2.4 explanations](/de/docs/Web/Accessibility/Understanding_WCAG/Operable#guideline_2.4_—_navigable_provide_ways_to_help_users_navigate_find_content_and_determine_where_they_are)
-- [Understanding Success Criterion 2.4.1 | W3C Understanding WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-skip.html)
-- [Understanding Success Criterion 2.4.6 | W3C Understanding WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-descriptive.html)
-- [Understanding Success Criterion 2.4.10 | W3C Understanding WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-headings.html)
+- [Überschriften • Seitenstruktur • WAI Web Accessibility Tutorials](https://www.w3.org/WAI/tutorials/page-structure/headings/)
+- [MDN Verständnis von WCAG, Guideline 1.3 Erklärungen](/de/docs/Web/Accessibility/Understanding_WCAG/Perceivable#guideline_1.3_—_create_content_that_can_be_presented_in_different_ways)
+- [Verständnis des Erfolgskriteriums 1.3.1 | W3C Verständnis WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/content-structure-separation-programmatic.html)
+- [MDN Verständnis von WCAG, Guideline 2.4 Erklärungen](/de/docs/Web/Accessibility/Understanding_WCAG/Operable#guideline_2.4_—_navigable_provide_ways_to_help_users_navigate_find_content_and_determine_where_they_are)
+- [Verständnis des Erfolgskriteriums 2.4.1 | W3C Verständnis WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-skip.html)
+- [Verständnis des Erfolgskriteriums 2.4.6 | W3C Verständnis WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-descriptive.html)
+- [Verständnis des Erfolgskriteriums 2.4.10 | W3C Verständnis WCAG 2.0](https://www.w3.org/TR/UNDERSTANDING-WCAG20/navigation-mechanisms-headings.html)
 
-### Kennzeichnung von Abschnittsinhalten
+### Beschriftung des Abschnittsinhalts
 
-Eine weitere gängige Navigationstechnik für Benutzer von Screenreader-Software besteht darin, eine Liste von [sectioning content](/de/docs/Web/HTML/Element#content_sectioning) zu erstellen und diese zur Bestimmung des Seitenlayouts zu verwenden.
+Eine weitere gängige Navigationstechnik für Benutzer von Bildschirmlesesoftware ist das Erzeugen einer Liste von [Inhaltsabschnitten](/de/docs/Web/HTML/Element#content_sectioning) und deren Nutzung, um das Layout der Seite zu bestimmen.
 
-Abschnittsinhalte können mit einer Kombination der Attribute [`aria-labelledby`](/de/docs/Web/Accessibility/ARIA/Attributes/aria-labelledby) und [`id`](/de/docs/Web/HTML/Global_attributes/id) gekennzeichnet werden, wobei das Label den Zweck des Abschnitts knapp beschreibt. Diese Technik ist nützlich in Situationen, in denen es mehr als ein Abschnittselement auf derselben Seite gibt.
+Inhaltsabschnitte können beschriftet werden, indem eine Kombination der [`aria-labelledby`](/de/docs/Web/Accessibility/ARIA/Attributes/aria-labelledby) und [`id`](/de/docs/Web/HTML/Global_attributes/id) Attribute verwendet wird, wobei die Beschriftung den Zweck des Abschnitts prägnant beschreibt. Diese Technik ist nützlich für Situationen, in denen es mehr als ein Abschnittselement auf derselben Seite gibt.
 
-#### Abschnittsinhalte-Beispiele
+#### Beispiele für Abschnittsinhalte
 
 ```html
 <header>
@@ -173,16 +173,16 @@ Abschnittsinhalte können mit einer Kombination der Attribute [`aria-labelledby`
 
 {{EmbedLiveSample('Sectioning_content_examples')}}
 
-In diesem Beispiel würde die Technologie zur Bildschirmlesung ankündigen, dass es zwei `{{HTMLElement("nav")}}`-Abschnitte gibt, einen namens "Primäre Navigation" und einen namens "Fußzeilen-Navigation". Wenn keine Labels angegeben wurden, müsste die Person, die die Bildschirmlesesoftware verwendet, möglicherweise den Inhalt jedes `nav`-Elements untersuchen, um deren Zweck zu bestimmen.
+In diesem Beispiel würde die Bildschirmlesetechnologie ankündigen, dass es zwei {{HTMLElement("nav")}} Abschnitte gibt, einen namens "Primäre Navigation" und einen namens "Fußzeilennavigation". Wenn keine Beschriftungen bereitgestellt würden, müsste die Person, die Bildschirmlesesoftware verwendet, möglicherweise den Inhalt jedes `nav`-Elements untersuchen, um deren Zweck zu bestimmen.
 
-- [Using the aria-labelledby attribute](/de/docs/Web/Accessibility/ARIA/Attributes/aria-labelledby)
-- [Labeling Regions • Page Structure • W3C WAI Web Accessibility Tutorials](https://www.w3.org/WAI/tutorials/page-structure/labels/#using-aria-labelledby)
+- [Verwendung des aria-labelledby Attributs](/de/docs/Web/Accessibility/ARIA/Attributes/aria-labelledby)
+- [Beschriftung von Regionen • Seitenstruktur • W3C WAI Web Accessibility Tutorials](https://www.w3.org/WAI/tutorials/page-structure/labels/#using-aria-labelledby)
 
 ## Beispiele
 
 ### Alle Überschriften
 
-Der folgende Code zeigt alle verwendeten Überschriftsebenen.
+Der folgende Code zeigt alle Verwendungsebenen von Überschriften.
 
 ```html
 <h1>Heading level 1</h1>
@@ -197,7 +197,7 @@ Der folgende Code zeigt alle verwendeten Überschriftsebenen.
 
 ### Beispielseite
 
-Der folgende Code zeigt einige Überschriften mit darunter liegendem Inhalt.
+Der folgende Code zeigt einige Überschriften mit etwas Inhalt darunter.
 
 ```html
 <h1>Heading elements</h1>
@@ -230,19 +230,19 @@ Der folgende Code zeigt einige Überschriften mit darunter liegendem Inhalt.
       <td>
         <a href="/de/docs/Web/HTML/Content_categories#flow_content"
           >Flussinhalt</a
-        >, Überschrifteninhalt, greifbarer Inhalt.
+        >, Überschrifteninhalt, erfassbarer Inhalt.
       </td>
     </tr>
     <tr>
-      <th scope="row">Zulässige Inhalte</th>
+      <th scope="row">Erlaubter Inhalt</th>
       <td>
         <a href="/de/docs/Web/HTML/Content_categories#phrasing_content"
-          >Phrasierungsinhalt</a
+          >Satzinhalt</a
         >.
       </td>
     </tr>
     <tr>
-      <th scope="row">Tag-Auslassungen</th>
+      <th scope="row">Tag-Auslassung</th>
       <td>Keine, sowohl das Start- als auch das End-Tag sind obligatorisch.</td>
     </tr>
     <tr>
@@ -251,14 +251,15 @@ Der folgende Code zeigt einige Überschriften mit darunter liegendem Inhalt.
         Jedes Element, das
         <a href="/de/docs/Web/HTML/Content_categories#flow_content"
           >Flussinhalt</a
-        > akzeptiert.
+        >
+        akzeptiert.
       </td>
     </tr>
     <tr>
-      <th scope="row">Implizierte ARIA-Rolle</th>
+      <th scope="row">Implizite ARIA-Rolle</th>
       <td>
         <a href="/de/docs/Web/Accessibility/ARIA/Roles/heading_role"
-          >Überschrift</a
+          >heading</a
         >
       </td>
     </tr>