chore(de): translate diff [0d945ca6e3]

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

Source: mdn/content@0d945ca

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/_redirects.txt

@@ -3557,6 +3557,7 @@
 /de/docs/Glossary/Bézier_curve	/de/docs/Glossary/Bezier_curve
 /de/docs/Glossary/CSS_property	/de/docs/Glossary/property/CSS
 /de/docs/Glossary/Cleartext	/de/docs/Glossary/Plaintext
+/de/docs/Glossary/Clickjacking	/de/docs/Web/Security/Attacks/Clickjacking
 /de/docs/Glossary/Client_hints	/de/docs/Web/HTTP/Client_hints
 /de/docs/Glossary/Condition	/de/docs/Glossary/Conditional
 /de/docs/Glossary/Content_type	/de/docs/Glossary/MIME_type

files/de/glossary/csp/index.md

@@ -2,16 +2,16 @@
 title: CSP
 slug: Glossary/CSP
 l10n:
-  sourceCommit: 50e5edd07155de2eec2a8b6b2ad95820748cfec7
+  sourceCommit: 9c09d1ce824bd5e6ef879094428879c476ccbace
 ---
 
 {{GlossarySidebar}}
 
-Eine **CSP** ([Content Security Policy](/de/docs/Web/HTTP/CSP)) wird verwendet, um bestimmte Arten von webbasierten Angriffen zu erkennen und zu mindern, wie z. B. {{Glossary("Cross-site_scripting", "Cross-site_scripting")}}, {{Glossary("clickjacking", "clickjacking")}} und Dateninjektionen.
+Eine **CSP** ([Content Security Policy](/de/docs/Web/HTTP/CSP)) wird verwendet, um bestimmte Arten von Webseitenangriffen wie {{Glossary("Cross-site_scripting", "Cross-site_scripting")}}, [Clickjacking](/de/docs/Web/Security/Attacks/Clickjacking) und Dateninjektionen zu erkennen und zu mildern.
 
 Die Implementierung basiert auf einem {{Glossary("HTTP", "HTTP")}}-Header namens {{HTTPHeader("Content-Security-Policy")}}.
 
 ## Siehe auch
 
-- [Content Security Policy-Dokumentation](/de/docs/Web/HTTP/CSP)
+- [Content Security Policy Dokumentation](/de/docs/Web/HTTP/CSP)
 - [Content Security Policy auf Wikipedia](https://en.wikipedia.org/wiki/Content_Security_Policy)

files/de/learn/javascript/asynchronous/implementing_a_promise-based_api/index.md

@@ -1,38 +1,38 @@
 ---
-title: Anleitung zur Implementierung einer Promise-basierten API
+title: Anleitung zur Implementierung einer auf Promises basierenden API
 slug: Learn/JavaScript/Asynchronous/Implementing_a_promise-based_API
 l10n:
-  sourceCommit: 1b4e6d1156e8471d38deeea1567c35ef412c5f42
+  sourceCommit: e2a558f8e077395153b0e38ccdc6554b33fd87bd
 ---
 
 {{LearnSidebar}}{{PreviousMenuNext("Learn/JavaScript/Asynchronous/Promises", "Learn/JavaScript/Asynchronous/Introducing_workers", "Learn/JavaScript/Asynchronous")}}
 
-Im letzten Artikel haben wir besprochen, wie man APIs verwendet, die Promises zurückgeben. In diesem Artikel betrachten wir die andere Seite — wie man APIs _implementiert_, die Promises zurückgeben. Dies ist eine weitaus weniger häufige Aufgabe als die Nutzung von Promise-basierten APIs, aber es ist dennoch wissenswert.
+Im letzten Artikel haben wir besprochen, wie man APIs verwendet, die Promises zurückgeben. In diesem Artikel betrachten wir die andere Seite – wie man APIs _implementiert_, die Promises zurückgeben. Dies ist eine deutlich seltenere Aufgabe als die Verwendung auf Promises basierender APIs, aber es ist dennoch wissenswert.
 
 <table>
   <tbody>
     <tr>
       <th scope="row">Voraussetzungen:</th>
       <td>
-        Ein fundiertes Verständnis der JavaScript-Grundlagen, einschließlich Ereignisbehandlung und die Grundlagen von Promises.
+        Ein angemessenes Verständnis der grundlegenden JavaScript-Konzepte, einschließlich der Ereignisbehandlung und der Grundlagen von Promises.
       </td>
     </tr>
     <tr>
       <th scope="row">Ziel:</th>
-      <td>Verstehen, wie man Promise-basierte APIs implementiert.</td>
+      <td>Zu verstehen, wie man auf Promises basierende APIs implementiert.</td>
     </tr>
   </tbody>
 </table>
 
-Im Allgemeinen, wenn Sie eine promise-basierte API implementieren, werden Sie einen asynchronen Vorgang umwickeln, der Ereignisse, einfache Rückrufe oder ein Nachrichtenübermittlungsmodell verwenden könnte. Sie werden dafür sorgen, dass ein `Promise`-Objekt den Erfolg oder das Scheitern dieses Vorgangs richtig handhabt.
+Im Allgemeinen wird bei der Implementierung einer auf Promises basierenden API eine asynchrone Operation umschlossen, die Ereignisse, einfache Rückrufmethoden oder ein Nachrichtenaustauschmodell verwenden könnte. Sie organisieren ein `Promise`-Objekt, um den Erfolg oder das Scheitern dieser Operation ordnungsgemäß zu behandeln.
 
 ## Implementierung einer `alarm()` API
 
-In diesem Beispiel implementieren wir eine Promise-basierte Alarm-API, genannt `alarm()`. Diese Funktion nimmt als Argumente den Namen der Person, die geweckt werden soll, und eine Verzögerung in Millisekunden, die gewartet werden soll, bevor die Person geweckt wird. Nach der Verzögerung sendet die Funktion eine "Wake up!"-Nachricht, inklusive des Namens der Person, die geweckt werden muss.
+In diesem Beispiel implementieren wir eine auf Promises basierende Alarm-API, genannt `alarm()`. Sie nimmt als Argumente den Namen der aufzuweckenden Person und eine Verzögerung in Millisekunden, bevor die Person geweckt wird. Nach der Verzögerung sendet die Funktion eine "Aufwachen!"-Nachricht, einschließlich des Namens der Person, die aufgeweckt werden muss.
 
-### Umhüllung von setTimeout()
+### Verwendung von setTimeout()
 
-Wir verwenden die [`setTimeout()`](/de/docs/Web/API/Window/setTimeout) API, um unsere `alarm()`-Funktion zu implementieren. Die `setTimeout()`-API nimmt als Argumente eine Rückruffunktion und eine Verzögerung in Millisekunden entgegen. Wenn `setTimeout()` aufgerufen wird, startet es einen Timer, der auf die angegebene Verzögerung eingestellt ist, und ruft die gegebene Funktion auf, wenn die Zeit abläuft.
+Wir verwenden die [`setTimeout()`](/de/docs/Web/API/Window/setTimeout) API, um unsere `alarm()`-Funktion zu implementieren. Die `setTimeout()` API nimmt als Argumente eine Rückruffunktion und eine Verzögerung in Millisekunden. Wenn `setTimeout()` aufgerufen wird, startet es einen Timer, der auf die angegebene Verzögerung eingestellt ist, und ruft bei Ablauf der Zeit die gegebene Funktion auf.
 
 Im folgenden Beispiel rufen wir `setTimeout()` mit einer Rückruffunktion und einer Verzögerung von 1000 Millisekunden auf:
 
@@ -60,23 +60,23 @@ function setAlarm() {
 button.addEventListener("click", setAlarm);
 ```
 
-{{EmbedLiveSample("Wrapping setTimeout()", 600, 100)}}
+{{EmbedLiveSample("Verwendung von setTimeout()", 600, 100)}}
 
-### Der Promise()-Konstruktor
+### Der Promise() Konstruktor
 
-Unsere `alarm()`-Funktion wird ein `Promise` zurückgeben, das erfüllt wird, wenn der Timer abläuft. Es wird eine "Wake up!"-Nachricht an den `then()`-Handler übergeben und das Promise ablehnen, wenn der Anrufer einen negativen Verzögerungswert übergibt.
+Unsere `alarm()`-Funktion wird ein `Promise` zurückgeben, das erfüllt wird, wenn der Timer abläuft. Es wird eine "Aufwachen!"-Nachricht an den `then()`-Handler übergeben und das Promise ablehnen, wenn der Aufrufer einen negativen Verzögerungswert angibt.
 
-Der Schlüsselkomponente hier ist der {{jsxref("Promise/Promise", "Promise()")}}-Konstruktor. Der `Promise()`-Konstruktor nimmt als Argument eine einzelne Funktion entgegen. Wir nennen diese Funktion den `executor`. Wenn Sie ein neues Promise erstellen, bieten Sie die Implementierung des Executors an.
+Der entscheidende Bestandteil hier ist der {{jsxref("Promise/Promise", "Promise()")}}-Konstruktor. Der `Promise()`-Konstruktor nimmt eine einzelne Funktion als Argument. Wir nennen diese Funktion den `executor`. Wenn Sie ein neues Promise erstellen, liefern Sie die Implementierung des Executors.
 
-Diese Executor-Funktion selbst nimmt zwei Argumente entgegen, die beide auch Funktionen sind und konventionell `resolve` und `reject` genannt werden. In Ihrer Executor-Implementierung rufen Sie die grundlegende asynchrone Funktion auf. Wenn die asynchrone Funktion erfolgreich ist, rufen Sie `resolve` auf, und wenn sie fehlschlägt, rufen Sie `reject` auf. Wenn die Executor-Funktion einen Fehler wirft, wird `reject` automatisch aufgerufen. Sie können einen einzelnen Parameter jeden Typs an `resolve` und `reject` übergeben.
+Diese Executor-Funktion selbst nimmt zwei Argumente, die beide ebenfalls Funktionen sind, und die konventionell `resolve` und `reject` genannt werden. In Ihrer Executor-Implementierung rufen Sie die zugrunde liegende asynchrone Funktion auf. Wenn die asynchrone Funktion erfolgreich ist, rufen Sie `resolve` auf, und wenn sie fehlschlägt, rufen Sie `reject` auf. Wenn die Executor-Funktion einen Fehler auslöst, wird `reject` automatisch aufgerufen. Sie können einen einzelnen Parameter beliebigen Typs in `resolve` und `reject` übergeben.
 
-So können wir `alarm()` wie folgt implementieren:
+So können wir `alarm()` implementieren:
 
 ```js
 function alarm(person, delay) {
   return new Promise((resolve, reject) => {
     if (delay < 0) {
-      throw new Error("Alarm delay must not be negative");
+      reject(new Error("Alarm delay must not be negative"));
     }
     setTimeout(() => {
       resolve(`Wake up, ${person}!`);
@@ -85,15 +85,15 @@ function alarm(person, delay) {
 }
 ```
 
-Diese Funktion erstellt und gibt ein neues `Promise` zurück. Im Executor für das Promise:
+Diese Funktion erstellt und gibt ein neues `Promise` zurück. Innerhalb des Executors für das Promise:
 
-- überprüfen wir, dass `delay` nicht negativ ist, und werfen einen Fehler, wenn es so ist.
+- Überprüfen wir, ob `delay` nicht negativ ist, und rufen `reject` mit einem benutzerdefinierten Fehler auf, wenn dies der Fall ist.
 
-- rufen wir `setTimeout()` auf, übergeben eine Rückruffunktion und `delay`. Die Rückruffunktion wird aufgerufen, wenn der Timer abläuft, und im Rückruf rufen wir `resolve` auf, wobei wir unsere "Wake up!"-Nachricht übergeben.
+- Rufen wir `setTimeout()` auf, übergeben einen Rückruf und `delay`. Der Rückruf wird aufgerufen, wenn der Timer abläuft, und im Rückruf rufen wir `resolve` auf und übergeben unsere `"Aufwachen!"`-Nachricht.
 
-## Verwendung der `alarm()` API
+## Verwendung der alarm() API
 
-Dieser Teil sollte aus dem letzten Artikel ziemlich vertraut sein. Wir können `alarm()` aufrufen und auf dem zurückgegebenen Promise `then()` und `catch()` aufrufen, um Handler für das Erfüllen und Ablehnen des Promises festzulegen.
+Dieser Teil sollte Ihnen aus dem letzten Artikel vertraut sein. Wir können `alarm()` aufrufen und auf dem zurückgegebenen Promise `then()` und `catch()` aufrufen, um Handler für die Erfüllung und Ablehnung des Promises festzulegen.
 
 ```html hidden
 <div>
@@ -130,7 +130,7 @@ const output = document.querySelector("#output");
 function alarm(person, delay) {
   return new Promise((resolve, reject) => {
     if (delay < 0) {
-      throw new Error("Alarm delay must not be negative");
+      reject(new Error("Alarm delay must not be negative"));
     }
     setTimeout(() => {
       resolve(`Wake up, ${person}!`);
@@ -145,13 +145,13 @@ button.addEventListener("click", () => {
 });
 ```
 
-{{EmbedLiveSample("Using the alarm() API", 600, 160)}}
+{{EmbedLiveSample("Verwendung der alarm() API", 600, 160)}}
 
-Versuchen Sie, verschiedene Werte für "Name" und "Delay" einzustellen. Versuchen Sie, einen negativen Wert für "Delay" einzustellen.
+Versuchen Sie, verschiedene Werte für "Name" und "Verzögerung" zu setzen. Versuchen Sie, einen negativen Wert für "Verzögerung" zu setzen.
 
-## Verwendung von async und await mit der `alarm()` API
+## Verwendung von async und await mit der alarm() API
 
-Da `alarm()` ein `Promise` zurückgibt, können wir alles mit ihm machen, was wir mit jedem anderen Promise auch machen könnten: Promise-Ketten, `Promise.all()` und `async` / `await`:
+Da `alarm()` ein `Promise` zurückgibt, können wir alles damit machen, was wir mit jedem anderen Promise tun könnten: Promise-Chaining, `Promise.all()` und `async` / `await`:
 
 ```html hidden
 <div>
@@ -188,7 +188,7 @@ const output = document.querySelector("#output");
 function alarm(person, delay) {
   return new Promise((resolve, reject) => {
     if (delay < 0) {
-      throw new Error("Alarm delay must not be negative");
+      reject(new Error("Alarm delay must not be negative"));
     }
     setTimeout(() => {
       resolve(`Wake up, ${person}!`);
@@ -206,7 +206,7 @@ button.addEventListener("click", async () => {
 });
 ```
 
-{{EmbedLiveSample("Using async and await with the alarm() API", 600, 160)}}
+{{EmbedLiveSample("Verwendung von async und await mit der alarm() API", 600, 160)}}
 
 ## Siehe auch