chore(de): translate diff [2024-09-26]

Machine translation (MT) from English using gpt-4o-2024-08-06
and the system prompt below, followed by few manual fixes.

Range: mdn/content@d4c050c...2503df3

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

1. Format

   - The input is a Markdown file, preceded by YAML Frontmatter.
   - The output should be a Markdown file, preceded by YAML Frontmatter.
   - 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. YAML Frontmatter:

   - The YAML frontmatter _keys_ must remain **untouched** and **not translated**.
   - Translate only the values for `title` and `short-title`.
   - Keep technical terms like HTTP header names and Web API names in the `title` and `short-title` in **English**.

3. Language:

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

4. Code blocks:

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

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

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

7. Links and References:

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

Translate the following Markdown content from **English** to **German** while adhering to the rules above.
```

files/de/glossary/blink_element/index.md

@@ -0,0 +1,40 @@
+---
+title: blink-Element (<blink>-Tag)
+slug: Glossary/blink_element
+l10n:
+  sourceCommit: a4b72d0683826e060f72a82b297b41e0b162d909
+---
+
+{{GlossarySidebar}}
+
+Das **`<blink>`-Element** (blink-Tag) ist ein veraltetes HTML-Feature, das von Webbrowsern nicht mehr unterstützt und auf MDN nicht mehr dokumentiert wird. Es wurde verwendet, um Textinhalte ständig blinken zu lassen.
+
+## Kurze Geschichte
+
+In den frühen Tagen des Webs (Anfang bis Mitte der 90er Jahre) gab es nicht viele Möglichkeiten, Webseiten zu gestalten. Die [CSS](/de/docs/Web/CSS)-Spezifikation (Version 1) wurde erstmals 1996 veröffentlicht und erst viel später konsistent von Browsern übernommen. Vor CSS experimentierten Browser mit verschiedenen Features, um bestimmte Textabschnitte hervorzuheben und die Aufmerksamkeit des Benutzers zu erregen. Das `<blink>`-Element war eines dieser Features und wurde in frühen Versionen des [Netscape Navigator](/de/docs/Glossary/Netscape_Navigator) eingeführt; das {{htmlelement("marquee")}}-Element des [Internet Explorer](/de/docs/Glossary/Microsoft_Internet_Explorer) war ein anderes.
+
+Das `<blink>`-Element entstand anscheinend nach einem Gespräch in einer Bar in Mountain View zwischen dem Netscape-Ingenieur [Lou Montulli](https://en.wikipedia.org/wiki/Lou_Montulli) und seinen Kollegen. Als er am nächsten Morgen ins Büro kam, stellte er fest, dass einer seiner Kollegen die ganze Nacht wach geblieben war und es implementiert hatte ([hier die Geschichte lesen](https://web.archive.org/web/20220331020029/http://www.montulli.org/theoriginofthe%3Cblink%3Etag)).
+
+Obwohl es anfangs populär war, wurde `<blink>` wegen übermäßiger Verwendung stark kritisiert; viele Menschen fanden es störend. Wichtiger noch, es verschlechtert die Lesbarkeit und kann besonders problematisch für Benutzer mit Sehbehinderungen oder [kognitiven Störungen](/de/docs/Web/Accessibility/Cognitive_accessibility) wie Epilepsie oder ADHS sein. Es kann desorientierend sein oder im schlimmsten Fall sogar [Anfälle auslösen](/de/docs/Web/Accessibility/Seizure_disorders).
+
+`<blink>` wurde nie richtig spezifiziert und erreichte nie signifikante Unterstützung über verschiedene Browser hinweg. Es kann als ein Stück Webgeschichte betrachtet werden.
+
+## Syntax
+
+Das `<blink>`-Element wurde folgendermaßen verwendet:
+
+```html example-bad
+<blink>In alten Browsern habe ich vielleicht geblinkt</blink>
+```
+
+### Alternativen
+
+- Die CSS-{{cssxref("text-decoration-line")}}-Eigenschaft hat einen `blink`-Wert, der denselben Effekt haben sollte, aber die meisten modernen Browser ignorieren ihn.
+- Die JavaScript-Methode {{jsxref("String.blink()")}} umschließt einen Textstring in `<blink></blink>`-Tags, wobei dieses Element, wie bereits erwähnt, nirgendwo mehr unterstützt wird.
+- [CSS-Animationen](/de/docs/Web/CSS/CSS_animations) könnten immer noch verwendet werden, um blinkenden Text zu erstellen. Sie sollten jedoch blinkenden Text auf Webseiten aus den oben genannten Gründen vermeiden.
+
+## Siehe auch
+
+- [Blink-Element](https://en.wikipedia.org/wiki/Blink_element) auf Wikipedia
+- [WCAG 2.2.2: Pause, Stop, Hide](https://www.w3.org/WAI/WCAG21/Understanding/pause-stop-hide)
+- [WCAG 2.3.1: Drei Blitze oder unterhalb der Schwelle](https://www.w3.org/WAI/WCAG21/Understanding/three-flashes-or-below-threshold)

files/de/glossary/html_color_codes/index.md

@@ -0,0 +1,29 @@
+---
+title: HTML-Farbcodes
+slug: Glossary/html_color_codes
+l10n:
+  sourceCommit: a4b72d0683826e060f72a82b297b41e0b162d909
+---
+
+{{GlossarySidebar}}
+
+**HTML-Farbcodes** ist ein allgemeiner Begriff, der die frühesten verfügbaren Methoden zur Angabe von Farben auf Webseiten beschreibt. Dazu gehören HTML-Farbnamen wie `black`, `purple` und `aqua` sowie hexadezimale Notationen wie `#000000`, `#800080` und `#00ffff`. Diese wurden ursprünglich in den HTML-Spezifikationen definiert – siehe zum Beispiel die [HTML 3.2 Farbdefinitionen](https://www.w3.org/TR/2018/SPSD-html32-20180315/#colors) der ursprünglichen 16 HTML-Farben.
+
+Es ist nicht mehr korrekt, Farben im Web als "HTML-Farbcodes" oder "HTML-Farbnamen" zu bezeichnen. Farben werden jetzt im [CSS Color Module](/de/docs/Web/CSS/CSS_colors) angegeben und allgemein als CSS-Farben oder Web-Farben bekannt.
+
+## Siehe auch
+
+### Allgemeinwissen
+
+[Webfarben](https://en.wikipedia.org/wiki/Web_colors) auf Wikipedia
+
+### Technisches Nachschlagewerk
+
+Um Webfarben auf MDN nachzuschlagen, sehen Sie sich unsere CSS {{cssxref("<color>")}} Werte-Referenzdokumentation an, oder genauer:
+
+- Farbnamen: {{cssxref("<named-color>")}}.
+- Hexadezimale Notationen: {{cssxref("<hex-color>")}}.
+- Farb-Funktionen:
+  - [sRGB](/de/docs/Glossary/Color_space#rgb_color_spaces) Farbraum: {{CSSXref("color_value/hsl", "hsl()")}}, {{CSSXref("color_value/hwb", "hwb()")}}, und {{CSSXref("color_value/rgb", "rgb()")}}.
+  - [CIELAB](/de/docs/Glossary/Color_space#cielab_color_spaces) Farbraum: {{CSSXref("color_value/lab", "lab()")}} und {{CSSXref("color_value/lch", "lch()")}}, {{CSSXref("color_value/oklab", "oklab()")}}, und {{CSSXref("color_value/oklch", "oklch()")}}.
+  - Andere Farbräume: {{CSSXref("color_value/color", "color()")}}.

files/de/mozilla/add-ons/webextensions/content_scripts/cloneinto/index.md

@@ -0,0 +1,158 @@
+---
+title: cloneInto()
+slug: Mozilla/Add-ons/WebExtensions/Content_scripts/cloneInto
+l10n:
+  sourceCommit: 53ce499e73e05ff7d41c1cb27b7e9f008f1d3b6f
+---
+
+{{AddonSidebar()}}
+
+Diese Funktion bietet eine sichere Möglichkeit, ein Objekt, das in einem privilegierten Bereich definiert ist, zu nehmen und einen [strukturierten Klon](/de/docs/Web/API/Web_Workers_API/Structured_clone_algorithm) davon in einem weniger privilegierten Bereich zu erstellen. Es gibt eine Referenz auf den Klon zurück:
+
+```js
+var clonedObject = cloneInto(myObject, targetWindow);
+```
+
+Sie können dann den Klon einem Objekt im Zielbereich als Expando-Eigenschaft zuweisen, und Skripte, die in diesem Bereich laufen, können darauf zugreifen:
+
+```js
+targetWindow.foo = clonedObject;
+```
+
+Dies ermöglicht es privilegierten Code, wie einer Erweiterung, ein Objekt mit weniger privilegiertem Code, wie einem Skript auf einer Webseite, zu teilen.
+
+## Syntax
+
+```js-nolint
+let clonedObject = cloneInto(
+  obj,               // object
+  targetScope,       // object
+  options            // optional object
+);
+```
+
+### Parameter
+
+- `obj`
+  - : `object`. Das zu klonende Objekt.
+- `targetScope`
+  - : `object`. Das Objekt, an das das Objekt angehängt werden soll.
+- `options` {{optional_inline}}
+  - : `object`. Optionen für die Funktion.
+    - `cloneFunctions` {{optional_inline}}
+      - : `boolean`. Ob die Funktionen des Objekts geklont werden sollen. Standardmäßig `false`. Geklonte Funktionen haben die gleichen Eigenschaften wie Funktionen, die mit [`exportFunction`](/de/docs/Mozilla/Add-ons/WebExtensions/API/Content_scripts/exportFunction) exportiert werden. Siehe [Klonen von Objekten, die Funktionen haben](#klonen_von_objekten,_die_funktionen_haben). {{optional_inline}}
+    - `wrapReflectors` {{optional_inline}}
+      - : `boolean`. Ob DOM-Objekte als Referenz anstelle von Klonen übergeben werden sollen. DOM-Objekte sind normalerweise nicht klonbar. Standardmäßig `false`. Siehe [Klonen von Objekten, die DOM-Elemente enthalten](#klonen_von_objekten,_die_dom-elemente_enthalten).
+
+### Rückgabewert
+
+Eine Referenz auf das geklonte Objekt.
+
+## Beispiele
+
+Dieses Inhalts-Skript erstellt ein Objekt, klont es in das Inhaltsfenster und macht es zu einer Eigenschaft des globalen Inhaltsfensters:
+
+```js
+// content script
+var addonScriptObject = { greeting: "hello from your extension" };
+window.addonScriptObject = cloneInto(addonScriptObject, window);
+```
+
+Skripte, die auf der Seite laufen, können auf das Objekt zugreifen:
+
+```js
+// page script
+button.addEventListener(
+  "click",
+  function () {
+    console.log(window.addonScriptObject.greeting); // "hello from your extension"
+  },
+  false,
+);
+```
+
+Natürlich müssen Sie den Klon nicht direkt dem Fenster zuweisen; Sie können ihn auch einem anderen Objekt im Zielbereich zuweisen:
+
+```js
+// Content script
+window.foo.addonScriptObject = cloneInto(addonScriptObject, window);
+```
+
+Sie können es auch in eine Funktion auf der Seite übergeben. Angenommen, das Skript der Seite definiert eine Funktion wie diese:
+
+```js
+// page script
+function foo(greeting) {
+  console.log("they said: " + greeting.message);
+}
+```
+
+Das Inhalts-Skript kann ein Objekt definieren, es klonen und an diese Funktion übergeben:
+
+```js
+// content script
+var addonScriptObject = { message: "hello from your extension" };
+window.foo(cloneInto(addonScriptObject, window)); // "they said: hello from your extension"
+```
+
+### Klonen von Objekten, die Funktionen haben
+
+Falls das zu klonende Objekt Funktionen enthält, müssen Sie das `{cloneFunctions:true}`-Flag übergeben, sonst tritt ein Fehler auf. Wenn Sie dieses Flag übergeben, werden die Funktionen im Objekt auf die gleiche Weise geklont wie bei [`Components.utils.exportFunction`](/de/docs/Mozilla/Add-ons/WebExtensions/API/components/utils/exportFunction):
+
+```js
+// content script
+var addonScriptObject = {
+  greetMe: function () {
+    alert("hello from your extension");
+  },
+};
+window.addonScriptObject = cloneInto(addonScriptObject, window, {
+  cloneFunctions: true,
+});
+```
+
+```js
+// page script
+var test = document.getElementById("test");
+test.addEventListener(
+  "click",
+  function () {
+    window.addonScriptObject.greetMe();
+  },
+  false,
+);
+```
+
+### Klonen von Objekten, die DOM-Elemente enthalten
+
+Standardmäßig schlägt die Klonoperation fehl, wenn das zu klonende Objekt aus C++ reflektierte Objekte, wie DOM-Elemente, enthält. Wenn Sie das `{wrapReflectors:true}`-Flag übergeben, enthält das Objekt, das Sie klonen, diese Objekte:
+
+```js
+// content script
+var addonScriptObject = {
+  body: window.document.body,
+};
+window.addonScriptObject = cloneInto(addonScriptObject, window, {
+  wrapReflectors: true,
+});
+```
+
+```js
+// page script
+var test = document.getElementById("test");
+test.addEventListener(
+  "click",
+  function () {
+    console.log(window.addonScriptObject.body.innerHTML);
+  },
+  false,
+);
+```
+
+Der Zugriff auf diese Objekte im Zielbereich unterliegt den normalen [Skriptsicherheitsprüfungen](https://firefox-source-docs.mozilla.org/dom/scriptSecurity/index.html).
+
+{{WebExtExamples}}
+
+## Browser-Kompatibilität
+
+{{Compat}}