chore(de): translate diff [2024-11-11]

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

Source: https://github.com/mdn/content/tree/4fbf43fdbf7b85aae6fd6a8f6586b7adfab27c99

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.

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.
```

files/de/glossary/baseline/typography/index.md

@@ -1,17 +1,20 @@
 ---
-title: Baseline (Typografie)
+title: Grundlinie (Typografie)
 slug: Glossary/Baseline/Typography
 l10n:
-  sourceCommit: 703476742325afe583b74ba0203ff0894b831110
+  sourceCommit: 58dd075cc106f92659ed0a940361969b117d47b1
 ---
 
 {{GlossarySidebar}}
 
-Die **Baseline** ist ein Begriff aus der europäischen und westasiatischen Typografie und bezeichnet eine imaginäre Linie, auf der die meisten Zeichen einer Schriftart ruhen.
+Eine **Grundlinie** ist eine imaginäre Linie entlang der Inline-Achse eines Linienkastens, entlang derer einzelne Schriftzeichen eines Textes ausgerichtet werden. Grundlinien leiten das Design von Schriftzeichen in einer Schriftart und die Ausrichtung von Schriftzeichen aus verschiedenen Schriftarten oder Schriftgrößen beim Setzen.
 
-Ostasiatische Schriften haben keine Baseline; jedes Glyph sitzt in einem quadratischen Kästchen, ohne Ascender oder Descender. Wenn sie mit Schriften gemischt werden, die eine niedrige Baseline haben, sollten ostasiatische Zeichen so gesetzt werden, dass die Unterseite des Zeichens zwischen der Baseline und der Descender-Höhe liegt.
+Die **alphabetische Grundlinie** ist der Wert des CSS-Keywords `baseline`. Der untere Teil der meisten alphabetischen Schriftzeichen ist typischerweise an der alphabetischen Grundlinie ausgerichtet; die meisten Zeichen europäischer und westasiatischer Schriften ruhen _auf_ der alphabetischen Grundlinie.
+
+Andere Schriftsysteme haben unterschiedliche Grundlinien. Zum Beispiel sind Tibetisch und ähnliche einkammerige Schriften mit einer starken, aber nicht absoluten Oberkante an der Unterseite einer "hängenden" Grundlinie ausgerichtet. Ostasiatische Schriften haben keine Grundlinie; jedes Schriftzeichen sitzt in einem quadratischen Kästchen, weder mit Auf- noch Abstrichen. Wenn sie mit Schriften mit tiefer Grundlinie gemischt werden, sollten ostasiatische Zeichen so gesetzt werden, dass der untere Teil des Zeichens zwischen der Grundlinie und der Abstrichhöhe liegt.
 
 ## Siehe auch
 
 - [CSS-Box-Ausrichtung](/de/docs/Web/CSS/CSS_box_alignment#types_of_alignment)
-- [Baseline (Typografie)](<https://en.wikipedia.org/wiki/Baseline_(typography)>) auf Wikipedia
+- Modul [CSS Inline-Layout](/de/docs/Web/CSS/CSS_inline_layout)
+- [Grundlinie (Typografie)](<https://en.wikipedia.org/wiki/Baseline_(typography)>) auf Wikipedia

files/de/web/api/domrectlist/index.md

@@ -0,0 +1,35 @@
+---
+title: DOMRectList
+slug: Web/API/DOMRectList
+l10n:
+  sourceCommit: f8554061e8e76aaa3f08ba1b5f9b939d436f5ded
+---
+
+{{APIRef("Geometry Interfaces")}}
+
+Die **`DOMRectList`**-Schnittstelle repräsentiert eine Sammlung von [`DOMRect`](/de/docs/Web/API/DOMRect)-Objekten, die typischerweise dazu verwendet wird, die Rechtecke zu halten, die mit einem bestimmten Element verbunden sind, wie Begrenzungsrahmen, die von Methoden wie [`getClientRects()`](/de/docs/Web/API/Element/getClientRects) zurückgegeben werden. Sie ermöglicht den Zugriff auf jedes Rechteck in der Liste über seinen Index sowie eine `length`-Eigenschaft, die die Gesamtanzahl der Rechtecke in der Liste angibt.
+
+> **Note**: `DOMRectList` existiert für die Kompatibilität mit älteren Webinhalten und wird nicht empfohlen, wenn neue APIs erstellt werden.
+
+## Instanz-Eigenschaften
+
+- [`DOMRectList.length`](/de/docs/Web/API/DOMRectList/length) {{ReadOnlyInline}}
+  - : Eine schreibgeschützte Eigenschaft, die die Gesamtanzahl der [`DOMRect`](/de/docs/Web/API/DOMRect)-Objekte in der `DOMRectList` zurückgibt.
+
+## Instanz-Methoden
+
+- [`DOMRectList.item`](/de/docs/Web/API/DOMRectList/item)
+  - : Gibt das [`DOMRect`](/de/docs/Web/API/DOMRect)-Objekt am angegebenen Index zurück. Wenn der `index` außerhalb des Bereichs liegt, wird `null` zurückgegeben.
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}
+
+## Siehe auch
+
+- [`DOMRect`](/de/docs/Web/API/DOMRect)
+- [`DOMRectReadOnly`](/de/docs/Web/API/DOMRectReadOnly)

files/de/web/api/domrectlist/item/index.md

@@ -0,0 +1,45 @@
+---
+title: "DOMRectList: Methode item()"
+short-title: item()
+slug: Web/API/DOMRectList/item
+l10n:
+  sourceCommit: f8554061e8e76aaa3f08ba1b5f9b939d436f5ded
+---
+
+{{APIRef("Geometry Interfaces")}}
+
+Die Methode [`DOMRectList`](/de/docs/Web/API/DOMRectList) `item()` gibt den [`DOMRect`](/de/docs/Web/API/DOMRect) am angegebenen Index innerhalb der Liste zurück oder `null`, wenn der Index außerhalb des gültigen Bereichs liegt.
+
+## Syntax
+
+```js-nolint
+rectList.item(index)
+```
+
+### Parameter
+
+- index
+  - : Ein nullbasierter Ganzzahlwert, der die Position des `DOMRect` in der `DOMRectList` angibt, die abgerufen werden soll.
+
+### Rückgabewert
+
+Ein [`DOMRect`](/de/docs/Web/API/DOMRect)-Objekt am angegebenen Index in der `DOMRectList`, oder null, wenn der Index größer oder gleich der Anzahl der Rechtecke in der Liste ist.
+
+## Beispiel
+
+```js
+const rects = document.getElementById("rects").getClientRects();
+console.log(rects.length); // Number of rectangles in the DOMRectList
+
+if (rects.length > 0) {
+  console.log(rects.item(0)); // Logs the first DOMRect object
+}
+```
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}

files/de/web/api/domrectlist/length/index.md

@@ -0,0 +1,48 @@
+---
+title: "DOMRectList: length-Eigenschaft"
+short-title: length
+slug: Web/API/DOMRectList/length
+l10n:
+  sourceCommit: f8554061e8e76aaa3f08ba1b5f9b939d436f5ded
+---
+
+{{APIRef("Geometry Interfaces")}}
+
+Die schreibgeschützte **`length`**-Eigenschaft des [`DOMRectList`](/de/docs/Web/API/DOMRectList)-Interfaces gibt die Anzahl der [`DOMRect`](/de/docs/Web/API/DOMRect)-Objekte in der Liste zurück.
+
+## Wert
+
+Ein positiver ganzzahliger Wert, der die Anzahl der `DOMRect`-Objekte in der `DOMRectList` darstellt. Wenn keine Rechtecke in der Liste vorhanden sind, ist `length` `0`.
+
+## Beispiele
+
+Im folgenden Beispiel rufen wir die Liste der Rechtecke für ein {{htmlelement("div")}}-Element mithilfe von [`Element.getClientRects()`](/de/docs/Web/API/Element/getClientRects) ab. Wir zeigen dann die Anzahl der Rechtecke in der Liste innerhalb eines anderen `<div>`-Elements auf der Seite an.
+
+Zuerst das HTML:
+
+```html
+<div id="box" style="width: 50px; height: 20px; border: 1px solid black;"></div>
+<div id="output"></div>
+```
+
+Nun das JavaScript:
+
+```js
+const box = document.getElementById("box");
+const rects = box.getClientRects();
+const output = document.getElementById("output");
+
+output.textContent = `Number of rectangles: ${rects.length}`;
+```
+
+Das Ausgabeergebnis sieht so aus:
+
+{{ EmbedLiveSample('Examples', '100%', 60) }}
+
+## Spezifikationen
+
+{{Specifications}}
+
+## Browser-Kompatibilität
+
+{{Compat}}

files/de/web/api/element/scrollintoview/index.md

@@ -1,14 +1,14 @@
 ---
-title: "Element: scrollIntoView() Methode"
+title: "Element: Methoden scrollIntoView()"
 short-title: scrollIntoView()
 slug: Web/API/Element/scrollIntoView
 l10n:
-  sourceCommit: 5c6765bacfdce92f66ce4b353ef50a1d78af6988
+  sourceCommit: 14f294a447447b484ec1589636d04af1a5794288
 ---
 
 {{APIRef("DOM")}}
 
-Die **`scrollIntoView()`**-Methode des [`Element`](/de/docs/Web/API/Element)-Interfaces scrollt die Vorfahren-Container des Elements, sodass das Element, auf dem `scrollIntoView()` aufgerufen wird, für den Benutzer sichtbar ist.
+Die Methode **`scrollIntoView()`** der [`Element`](/de/docs/Web/API/Element)-Schnittstelle scrollt die Vorfahren-Container des Elements so, dass das Element, auf dem `scrollIntoView()` aufgerufen wird, für den Benutzer sichtbar ist.
 
 ## Syntax
 
@@ -24,27 +24,29 @@ scrollIntoView(scrollIntoViewOptions)
 
   - : Ein boolescher Wert:
 
-    - Wenn `true`, wird die Oberseite des Elements mit der Oberseite des sichtbaren Bereichs des scrollbaren Vorfahren ausgerichtet. Entspricht `scrollIntoViewOptions: {block: "start", inline: "nearest"}`. Dies ist der Standardwert.
-    - Wenn `false`, wird die Unterseite des Elements mit der Unterseite des sichtbaren Bereichs des scrollbaren Vorfahren ausgerichtet. Entspricht `scrollIntoViewOptions: {block: "end", inline: "nearest"}`.
+    - Wenn `true`, wird das obere Ende des Elements oben im sichtbaren Bereich des scrollbaren Vorfahren ausgerichtet. Entspricht `scrollIntoViewOptions: {block: "start", inline: "nearest"}`. Dies ist der Standardwert.
+    - Wenn `false`, wird das untere Ende des Elements am unteren Rand des sichtbaren Bereichs des scrollbaren Vorfahren ausgerichtet. Entspricht `scrollIntoViewOptions: {block: "end", inline: "nearest"}`.
 
 - `scrollIntoViewOptions` {{optional_inline}}
   {{experimental_inline}}
 
   - : Ein Objekt mit den folgenden Eigenschaften:
 
     - `behavior` {{optional_inline}}
-      - : Bestimmt, ob das Scrollen sofort oder sanft animiert erfolgt. Diese Option ist ein String, der einen der folgenden Werte annehmen muss:
-        - `smooth`: das Scrollen sollte sanft animiert erfolgen
-        - `instant`: das Scrollen sollte sofort in einem einzigen Sprung erfolgen
+      - : Bestimmt, ob das Scrollen sofort erfolgt oder sich sanft animiert. Diese Option ist ein String, der einen der folgenden Werte haben muss:
+        - `smooth`: scrollen soll sanft animiert werden
+        - `instant`: scrollen soll sofort in einem einzigen Sprung erfolgen
         - `auto`: das Scrollverhalten wird durch den berechneten Wert von {{cssxref("scroll-behavior")}} bestimmt
     - `block` {{optional_inline}}
-      - : Definiert die vertikale Ausrichtung.
-        Einer von `start`, `center`, `end` oder
-        `nearest`. Standard ist `start`.
+      - : Definiert die vertikale Ausrichtung des Elements innerhalb des scrollbaren Vorfahren-Containers. Diese Option ist ein String und akzeptiert einen der folgenden Werte:
+        - `start`: Richtet die obere Kante des Elements mit der oberen Kante des scrollbaren Containers aus, sodass das Element vertikal am Anfang des sichtbaren Bereichs erscheint.
+        - `center`: Richtet das Element vertikal in der Mitte des scrollbaren Containers aus und positioniert es in der Mitte des sichtbaren Bereichs.
+        - `end`: Richtet die untere Kante des Elements mit der unteren Kante des scrollbaren Containers aus und platziert das Element am Ende des sichtbaren Bereichs vertikal.
+        - `nearest`: Scrollt das Element zur nächstgelegenen Kante in vertikaler Richtung. Wenn das Element näher an der oberen Kante des scrollbaren Containers ist, wird es oben ausgerichtet; wenn es näher an der unteren Kante ist, wird es unten ausgerichtet. Dies minimiert die Scrollentfernung.
+        - Standardmäßig `start`.
     - `inline` {{optional_inline}}
       - : Definiert die horizontale Ausrichtung.
-        Einer von `start`, `center`, `end` oder
-        `nearest`. Standard ist `nearest`.
+        Einer von `start`, `center`, `end` oder `nearest`. Standardmäßig `nearest`.
 
 ### Rückgabewert
 
@@ -63,7 +65,7 @@ element.scrollIntoView({ block: "end" });
 element.scrollIntoView({ behavior: "smooth", block: "end", inline: "nearest" });
 ```
 
-### Steuerung der Ausrichtung oben/unten
+### Kontrolle der oberen/unten Ausrichtung
 
 Standardmäßig wird das Element an der oberen (oder unteren) Kante des scrollbaren Vorfahren ausgerichtet. Um einen benutzerdefinierten Abstand zu definieren, verwenden Sie {{cssxref("scroll-margin-top")}} oder {{cssxref("scroll-margin-bottom")}}. Dies ist oft nützlich, wenn es einen festen Header auf der Seite gibt.