rework of DE translation (#2806)

* started rework of translation to DE, added translation rules and dictionary

* reworks DE translation of JSONata /editor-client/locales/de/jsonata.json

* rework DE translation of editor-client

* moved /editor-client/locales/de/README.md to Wiki https://github.com/node-red/node-red/wiki/Design:-i18n-de

* Update README.md

* Update README.md

* Create README.md

* Create README.md

* fixed #2: "Sie müssen ..., um ... zu können"

* fixed #3

* fixed #4 and removed unnecessary spaces

* fixed #5

* fixed #6, added missing dots, removed unnecessary spaces

* fixed #7, #8, #9

* fixed #10, #11, #12, #13, #14, #15

* fixed #17, #18, 19

* fixed #19

* moved /editor-client/locales/de/dictionary.csv to https://github.com/heikokue/node-red-designs/blob/i18n-de/designs/i18n-de/dictionary.csv

* reworked DE translation of runtime

* fine-tuned DE translation of editor-client

* reworked DE translation of common nodes, fine-tuned editor-client

* reworked DE translation of all nodes, fine-tuned editor-client, intotips, jsonata & runtime

* small i18n fixes

.gitignore

@@ -7,7 +7,9 @@
 .sessions.json
 .settings
 .tern-project
+.i18n-editor-metadata
 *.backup
+*.bak
 *_cred*
 coverage
 credentials.json
@@ -24,3 +26,4 @@ docs
 !packages/node_modules/**/docs
 .vscode
 .nyc_output
+sync.ffs_db

packages/node_modules/@node-red/editor-client/locales/de/infotips.json

@@ -1,23 +1,23 @@
 {
-  "info" : {
+    "info": {
-    "tip0" : "Sie können die ausgewählten Nodes oder Verbindungen mit {{ core:delete-selection }} entfernen.",
+        "tip0": "Sie können die ausgewählten Nodes oder Verbindungen mit {{ core:delete-selection }} entfernen",
-    "tip1" : "Suche nach Nodes mit {{ core:search }}",
+        "tip1": "Sie können nach Nodes mit  {{ core:search }} suchen",
-    "tip2" : "{{ core:toggle-sidebar }} schaltet die Ansicht dieser Seitenleiste ein.",
+        "tip2": "{{ core:toggle-sidebar }} blendet die Seitenleiste ein/aus",
-    "tip3" : "Sie können Ihre Palette von Nodes mit {{ core:manage-palette }} verwalten.",
+        "tip3": "Sie können Ihre Node-Palette mit {{ core:manage-palette }} verwalten",
-    "tip4" : "Ihre Flow-Konfigurations-Nodes werden in der Seitenleiste angezeigt. Es kann über das Menü oder mit {{ core:show-config-tab }} aufgerufen werden.",
+        "tip4": "Ihre Flow-Konfigurationsnodes werden in der Seitenleiste angezeigt, die über das Menü oder mit {{ core:show-config-tab }} angezeigt werden kann",
-    "tip5" : "Aktiviert oder inaktiviert diese Tipps von der Option in den Einstellungen",
+        "tip5": "Aktiviere oder deaktiviere diese Tipps in den Benutzereinstellungen",
-    "tip6" : "Verschieben Sie die ausgewählten Nodes mit Hilfe der [left] [up] [down] und [right] Tasten. Halten Sie [Shift] gedrückt, um das Fenster weiter zu schieben",
+        "tip6": "Sie können die ausgewählten Nodes mit den [left]/[up]/[down]/[right]-Tasten verschieben. Wenn Sie dabei [Shift] gedrückt halten, können Sie den Fensterausschnitt verschieben.",
-    "tip7" : "Wenn Sie einen Node auf eine Verbindung ziehen, wird er in die Verbindung eingefügt.",
+        "tip7": "Wenn Sie ein Node auf eine Verbindung ziehen, wird es in die Verbindung eingefügt",
-    "tip8" : "Die ausgewählten Nodes exportieren oder die aktuelle Registerkarte mit {{ core:show-export-dialog }}",
+        "tip8": "Sie können die ausgewählten Nodes oder den aktuellen Flow-Tab mit {{ core:show-export-dialog }} exportieren",
-    "tip9" : "Importieren Sie einen Flow, indem Sie sein JSON in den Editor ziehen oder mit {{ core:show-import-dialog }}.",
+        "tip9": "Sie können einen Flow importieren, indem Sie sein JSON in den Editor ziehen oder mittels {{ core:show-import-dialog }}",
-    "tip10" : "[Umschalt] [Klicken] und ziehen Sie auf einen Node-Anschluss, um alle angeschlossenen Verbindungen oder nur die ausgewählte zu verschieben.",
+        "tip10": "Halten Sie [Shift] beim [Klicken] auf ein Node gedrückt, um auch alle verbundenen Nodes mit zu verschieben",
-    "tip11" : "Die Registerkarte \"Info\" mit {{ core:show-info-tab }} oder der Registerkarte \"Debug\" mit {{ core:show-debug-tab }} anzeigen",
+        "tip11": "Sie können den Tab 'Info' mit {{ core:show-info-tab }} oder den Tab 'Debug' mit {{ core:show-debug-tab }} anzeigen lassen",
-    "tip12" : "[ctrl] [Klicken] in den Arbeitsbereich, um den Schnellhinzufügedialog zu öffnen.",
+        "tip12": "Halten Sie [Strg] beim [Klicken] in den Arbeitsbereich gedrückt, um den Schnellhinzufügedialog öffnen",
-    "tip13" : "Halten Sie [ctrl] gedrückt, wenn Sie auf einem Node-Anschluss klicken, um eine Schnellverbindung zu aktivieren.",
+        "tip13": "Halten Sie [Strg] beim [Klicken] auf einen Node-Anschluss gedrückt, um eine Verbindung nur durch kurzes [Klicken] (ohne Halten) zu verlegen",
-    "tip14" : "Halten Sie [Umschalt] gedrückt, wenn Sie auf einen Node klicken, um auch alle verbundenen Nodes auszuwählen.",
+        "tip14": "Halten Sie [Shift] beim [Klicken] auf ein Node gedrückt, um auch alle verbundenen Nodes mit auszuwählen",
-    "tip15" : "Halten Sie [ctrl] gedrückt, wenn Sie auf einen Node klicken, um ihn aus der aktuellen Auswahl hinzuzufügen oder zu entfernen.",
+        "tip15": "Halten Sie [Strg] beim [Klicken] auf ein Node gedrückt, um es zu der aktuellen Auswahl hinzuzufügen oder aus ihr zu entfernen",
-    "tip16" : "Indexzungen wechseln mit {{ core:show-previous-tab }} und {{ core:show-next-tab }}",
+        "tip16": "Sie können die Flow-Tabs mit {{ core:show-previous-tab }} und {{ core:show-next-tab }} wechseln",
-    "tip17" : "Sie können die Änderungen im Editierrahmen des Nodes mit {{ core:confirm-edit-tray }} bestätigen oder sie mit {{ core:cancel-edit-tray }} abbrechen.",
+        "tip17": "Sie können die Änderungen im Node-Editor mit {{ core:confirm-edit-tray }} bestätigen oder sie mit {{ core:cancel-edit-tray }} verwerfen",
-    "tip18" : "Durch Drücken von {{ core:edit-selected-node }} wird der erste Node in der aktuellen Auswahl bearbeitet."
+        "tip18": "Sie können mit {{ core:edit-selected-node }} den ersten Node in der aktuellen Auswahl bearbeiten"
     }
 }

packages/node_modules/@node-red/editor-client/locales/de/jsonata.json

@@ -1,222 +1,274 @@
 {
-  "$string" : {
+    "$string": {
-    "args" : "arg",
+        "args": "arg[, prettify]",
-    "desc" : "Transformiert den Parameter *arg* in eine Zeichenfolge mit den folgenden Transformationsregeln:\n\n -Zeichenfolgen bleiben unverändert\n -Funktionen werden in eine leere Zeichenfolge konvertiert\n -Numerische Unendlichkeit und NaN lösen einen Fehler aus, da sie nicht als JSON-Nummer dargestellt werden können.\n -Alle anderen Werte werden mit Hilfe der Funktion 'JSON.stringify' in eine JSON-Zeichenfolge konvertiert."
+        "desc": "Wandelt `arg` in eine Zeichenfolge um gemäß der folgenden Regeln:\n\n- Zeichenfolgen (string) bleiben unverändert\n- Funktionen werden in eine leere Zeichenfolge konvertiert\n- Numerische Unendlichkeit und NaN lösen einen Fehler aus, da sie nicht als JSON-Zahlenwert dargestellt werden können.\n- Alle anderen Werte werden mit Hilfe der Funktion `JSON.stringify` in eine JSON-Zeichenfolge konvertiert. Wenn `prettify` `true` ist, wird \"prettified\" JSON erzeugt. Z. B. Eine Zeile pro Feld und Zeilen werden eingeschoben basierend auf der Feldtiefe."
     },
-  "$length" : {
+    "$length": {
-    "args" : "str",
+        "args": "str",
-    "desc" : "Gibt die Anzahl der Zeichen in der Zeichenfolge `str` zurück. Es wird ein Fehler ausgelöst, wenn `str` keine Zeichenfolge ist."
+        "desc": "Gibt die Zeichenanzahl von `str` zurück. Es wird ein Fehler ausgelöst, wenn `str` keine Zeichenfolge ist."
     },
-  "$substring" : {
+    "$substring": {
-    "args" : "str, start [, länge]",
+        "args": "str, start [, length]",
-    "desc" : "Gibt eine Zeichenfolge zurück, die die Zeichen im ersten Parameter `str` beginnend bei Position `start` (Null-Offset) enthält. Wenn \"length\" angegeben ist, enthält die Unterzeichenfolge maximal \"Länge\" Zeichen. Wenn `start` negativ ist, gibt es die Anzahl der Zeichen am Ende von `str`  an."
+        "desc": "Gibt eine Teilzeichenfolge zurück, die die Zeichen in `str` beginnend bei Position `start` (Null-Offset) enthält. Wenn `length` vorgegeben ist, enthält die rückgegebene Zeichenfolge maximal die in `length` vorgegebene Zeichenanzahl. Wenn `start` negativ ist, werden die Zeichen vom Ende aus gezählt von `str` zurückgegeben."
     },
-  "$substringBefore" : {
+    "$substringBefore": {
-    "args" : "str, chars",
+        "args": "str, chars",
-    "desc" : "Gibt die Unterzeichenfolge vor dem ersten Auftreten der Zeichenfolge `chars` in `str` zurück. Falls `str` nicht `chars` enthält, gibt es `str` zurück."
+        "desc": "Gibt die Teilzeichenfolge vor dem ersten Auftreten der Zeichenfolge `chars` in `str` zurück. Falls `str` nicht `chars` enthält, wird `str` zurückgegeben."
     },
-  "$substringAfter" : {
+    "$substringAfter": {
-    "args" : "str, chars",
+        "args": "str, chars",
-    "desc" : "Gibt die Unterzeichenfolge nach dem ersten Auftreten der Zeichenfolge `chars` in `str` zurück. Falls `str` nicht `chars` enthält, gibt es `str` zurück."
+        "desc": "Gibt die Teilzeichenfolge nach dem ersten Auftreten der Zeichenfolge `chars` in `str` zurück. Falls `str` nicht `chars` enthält, wird `str` zurückgegeben."
     },
-  "$uppercase" : {
+    "$uppercase": {
-    "args" : "str",
+        "args": "str",
-    "desc" : "Gibt eine Zeichenfolge mit allen Zeichen von `str` zurück, die in Großbuchstaben konvertiert werden."
+        "desc": "Gibt veränderten `str` zurück, bei dem allen Zeichen in Großbuchstaben umgewandelt wurden."
     },
-  "$lowercase" : {
+    "$lowercase": {
-    "args" : "str",
+        "args": "str",
-    "desc" : "Gibt eine Zeichenfolge mit allen Zeichen von `str` in Kleinbuchstaben zurück."
+        "desc": "Gibt veränderten `str` zurück, bei dem allen Zeichen in Kleinbuchstaben umgewandelt wurden."
     },
-  "$trim" : {
+    "$trim": {
-    "args" : "str",
+        "args": "[str]",
-    "desc" : "Normalisiert und trimmt alle Leerzeichen in `str` durch Anwenden der folgenden Schritte:\n\n -Alle Tabulatorstopps, Wagenrückläufe und Zeilenvorschübe werden durch Leerzeichen ersetzt.\n-Zusammenhängende Folgen von Räumen werden auf einen einzigen Raum reduziert.\n-Trailing und führende Plätze werden entfernt.\n\n Wenn 'str' nicht angegeben ist (d. h. Diese Funktion wird ohne Argumente aufgerufen), dann wird der Kontextwert als Wert von `str` verwendet. Es wird ein Fehler ausgelöst, wenn `str` keine Zeichenfolge ist."
+        "desc": "Normalisiert und trimmt alle Leerzeichen in `str` durch Anwenden der folgenden Schritte:\n\n- Alle Tabulatoren, Wagenrückläufe (returns) und Zeilenvorschübe (line feeds) werden durch Leerzeichen ersetzt.\n- Zusammenhängende Folgen von Leerzeichen werden auf ein einzelnes Leerzeichen reduziert.\n- Leerzeichen am Anfang und am Ende werden entfernt.\n\nWenn `str` nicht vorgegeben ist (d.h. diese Funktion wird ohne Parameter aufgerufen), dann wird der Kontextwert als Wert von `str` verwendet. Es wird ein Fehler ausgelöst, wenn `str` keine Zeichenfolge ist."
     },
-  "$contains" : {
+    "$contains": {
-    "args" : "str, Muster",
+        "args": "str, pattern",
-    "desc" : "Gibt `true` zurück, wenn `str` durch `Muster` abgeglichen wird, sonst gibt es `false` zurück. Wenn 'str' nicht angegeben ist (d. h. Diese Funktion wird mit einem Argument aufgerufen), dann wird der Kontextwert als Wert von `str` verwendet. Der Parameter 'Muster' kann entweder eine Zeichenfolge oder ein regulärer Ausdruck sein."
+        "desc": "Gibt `false` zurück, wenn `pattern` als Teilzeichenfolge in `str` enthalten ist, sonst gibt sie `false` zurück. Wenn `str` nicht vorgegeben ist (d. h. Diese Funktion wird mit einem Parameter aufgerufen), dann wird der Kontextwert als Wert von `str` verwendet. `pattern` kann entweder eine Zeichenfolge oder ein regulärer Ausdruck sein."
     },
-  "$split" : {
+    "$split": {
-    "args" : "str [, Trennzeichen] [, Grenzwert]",
+        "args": "str [, separator] [, limit]",
-    "desc" : "Teilt den Parameter 'str' in einem Array mit Unterzeichenfolgen. Es ist ein Fehler, wenn `str` keine Zeichenfolge ist. Der optionale Parameter 'Trennzeichen' gibt die Zeichen in der `str` an, um die es entweder als Zeichenfolge oder als regulärer Ausdruck geteilt werden soll. Wenn 'Trennzeichen' nicht angegeben wird, wird die leere Zeichenfolge angenommen, und `str` wird in ein Array aus einzelnen Zeichen aufgeteilt. Es handelt sich um einen Fehler, wenn `Trennzeichen' keine Zeichenfolge ist. Der optionale Parameter 'Grenzwert' ist eine Zahl, die die maximale Anzahl von Unterzeichenfolgen angibt, die in das resultierende Array eingeschlossen werden sollen. Alle zusätzlichen Unterzeichenfolgen werden gelöscht. Wenn 'Grenzwert' nicht angegeben wird, wird ' str ` vollständig geteilt, wobei die Größe des resultierenden Arrays nicht begrenzt ist. Es handelt sich um einen Fehler, wenn `Grenzwert' keine nicht negative Zahl ist."
+        "desc": "Teilt `str` in einem Array mit Teilzeichenfolgen. Es ergibt einen Fehler, wenn `str` keine Zeichenfolge ist.\n\nDer optionale Parameter `separator` gibt die Zeichen in der `str` an, anhand dem, vorgegeben entweder als Zeichenfolge oder als regulärer Ausdruck, `str` geteilt werden soll. Wenn `separator` nicht vorgegeben wird, wird ein leerer String als `separator` angenommen und `str` wird in ein Array aus einzelnen Zeichen aufgeteilt. Es handelt sich um einen Fehler, wenn `separator` leer ist.\n\nDer optionale Parameter `limit` ist eine Zahl, die die maximale Anzahl von Teilzeichenfolgen angibt, die in dem rückzugebenen Array enthalten sein sollen. Alle zusätzlichen Teilzeichenfolgen werden verworfen. Wenn `limit` nicht vorgegeben wird, wird `str` vollständig geteilt, wobei die Größe des resultierenden Arrays nicht begrenzt ist. Es handelt sich um einen Fehler, wenn `limit` eine negative Zahl ist."
     },
-  "$join" : {
+    "$join": {
-    "args" : "array [, Trennzeichen]",
+        "args": "array [, separator]",
-    "desc" : "Verkettet ein Array von Komponentenzeichenfolgen in eine einzelne verkettete Zeichenfolge mit jeder Komponentenzeichenfolge, die durch den optionalen Parameter 'separator' getrennt ist. Es ist ein Fehler, wenn die Eingabe `Array` ein Element enthält, das keine Zeichenfolge ist. Wenn 'Trennzeichen' nicht angegeben wird, wird davon ausgegangen, dass es sich um eine leere Zeichenfolge handelt, d. h. Zwischen den Komponentenzeichenfolgen ist kein Trennzeichen vorhanden. Es handelt sich um einen Fehler, wenn `Trennzeichen' keine Zeichenfolge ist."
+        "desc": "Verkettet ein Array von Zeichenfolgen zu einer einzigen Zeichenfolge, wobei die einzelnen Zeichenfolgen durch den optionalen Trennzeichen-Parameter `separator` getrennt sind. Es ergibt einen Fehler, wenn das `array` ein Element enthält, das keine Zeichenfolge ist. Wenn `separator` nicht vorgegeben wird, wird davon ausgegangen, dass es sich um eine leere Zeichenfolge handelt, d.h. zwischen den einzelnen Zeichenfolgen wird kein Trennzeichen eingefügt. Es handelt sich um einen Fehler, wenn `separator` keine Zeichenfolge ist."
     },
-  "$match" : {
+    "$match": {
-    "args" : "str, Muster [, Grenzwert]",
+        "args": "str, pattern [, limit]",
-    "desc" : "Wendet die Zeichenfolge `str`  an den regulären Ausdruck `Muster` an und gibt ein Array von Objekten zurück, wobei jedes Objekt Informationen zu jedem Vorkommen einer Übereinstimmung in `str` enthält."
+        "desc": "Wendet den regulären Ausdruck `pattern` auf die Zeichenfolge `str` an und gibt ein Array von Objekten zurück, die Informationen zu jedem Vorkommen von `pattern` in `str` enthält."
     },
-  "$replace" : {
+    "$replace": {
-    "args" : "str, Muster, Ersatz [, Grenzwert]",
+        "args": "str, pattern, replacement [, limit]",
-    "desc" : "Findet Vorkommen von `Muster` in `str` und ersetzt sie durch `Ersatz`.\n\nDer optionale Parameter 'Grenzwert' ist die maximale Anzahl an Ersetzungen."
+        "desc": "Findet Vorkommen von `pattern` in `str` und ersetzt sie durch `replacement`.\n\nDer optionale Parameter `limit` ist die maximale Anzahl an Ersetzungen."
     },
-  "$now" : {
+    "$now": {
-    "args" : "",
+        "args": "",
-    "desc" : "Generiert einen Zeitstempel im ISO-8601-kompatiblen Format und gibt sie als Zeichenfolge zurück."
+        "desc": "Generiert einen Zeitstempel im ISO-8601-kompatiblen Format und gibt sie als Zeichenfolge zurück."
     },
-  "$base64encode" : {
+    "$base64encode": {
-    "args" : "Zeichenfolge",
+        "args": "str",
-    "desc" : "Konvertiert eine ASCII-Zeichenfolge in eine Basis-64-Darstellung. Jedes Zeichen in der Zeichenfolge wird als Byte mit binären Daten behandelt. Dies setzt voraus, dass alle Zeichen in der Zeichenfolge im Bereich von 0x00 bis 0xFF liegen, der alle Zeichen in URI-codierten Zeichenfolgen enthält. Unicode-Zeichen außerhalb dieses Bereichs werden nicht unterstützt."
+        "desc": "Konvertiert eine ASCII-Zeichenfolge `str` in eine Basis-64-Darstellung. Jedes Zeichen in `str` wird als Byte mit binären Daten behandelt. Dies setzt voraus, dass alle Zeichen in der Zeichenfolge im Bereich von 0x00 bis 0xFF liegen, der alle Zeichen in URI-codierten Zeichenfolgen enthält. Unicode-Zeichen außerhalb dieses Bereichs werden nicht unterstützt."
     },
-  "$base64decode" : {
+    "$base64decode": {
-    "args" : "Zeichenfolge",
+        "args": "str",
-    "desc" : "Konvertiert die Basis-64-codierten Byte in eine Zeichenfolge unter Verwendung einer UTF-8-Unicode-Codepage."
+        "desc": "Konvertiert den Basis-64-codierten `str` in eine Zeichenfolge unter Verwendung einer UTF-8-Unicode-Codepage."
     },
-  "$number" : {
+    "$number": {
-    "args" : "arg",
+        "args": "arg",
-    "desc" : "Der Parameter 'arg' wird unter Verwendung der folgenden Regeln für das Casting in eine Zahl verwendet:\n\n -Zahlen bleiben unverändert\n -Zeichenfolgen, die eine Folge von Zeichen enthalten, die eine rechtliche JSON-Nummer darstellen, werden in diese Zahl konvertiert.\n -Alle anderen Werte bewirken, dass ein Fehler ausgelöst wird."
+        "desc": "Wandelt `arg` unter Verwendung der folgenden Regeln in eine Zahl um:\n\n- Zahlen bleiben unverändert\n- Zeichenfolgen, die eine Folge von Zeichen enthalten, die einen echten JSON-Zahlenwert darstellen, werden in die entsprechende Zahl konvertiert.\n- Alle anderen Werte bewirken, dass ein Fehler ausgelöst wird."
     },
-  "$abs" : {
+    "$abs": {
-    "args" : "Anzahl",
+        "args": "number",
-    "desc" : "Gibt den absoluten Wert des Parameters 'Zahl' zurück."
+        "desc": "Gibt den absoluten Wert von `number` zurück."
     },
-  "$floor" : {
+    "$floor": {
-    "args" : "Anzahl",
+        "args": "number",
-    "desc" : "Gibt den Wert von 'Zahl' auf die nächste ganze Zahl zurück, die kleiner oder gleich 'Zahl' ist."
+        "desc": "Gibt `number` abgerundet auf die nächste ganze Zahl zurück, die kleiner oder gleich `number` ist."
     },
-  "$ceil" : {
+    "$ceil": {
-    "args" : "Anzahl",
+        "args": "number",
-    "desc" : "Gibt den Wert von 'Zahl' auf die nächste ganze Zahl zurück, die größer oder gleich 'Zahl' ist."
+        "desc": "Gibt `number` aufgerundet auf die nächste ganze Zahl zurück, die größer oder gleich `number` ist."
     },
-  "$round" : {
+    "$round": {
-    "args" : "Zahl [, Genauigkeit]",
+        "args": "number [, precision]",
-    "desc" : "Gibt den Wert des Parameters `Zahl` zurück, der auf die Anzahl der Dezimalstellen gerundet wird, die durch den optionalen Parameter 'Genauigkeit' angegeben wird."
+        "desc": "Gibt `number` gerundet auf die Anzahl der Nachkommastellen zurück, welche durch den optionalen Parameter `precision` vorgegeben ist."
     },
-  "$power" : {
+    "$power": {
-    "args" : "Basis, Exponent",
+        "args": "base, exponent",
-    "desc" : "Gibt den Wert von `Basis` potenziert mit `Exponent` zurück."
+        "desc": "Gibt `base` potenziert mit `exponent` zurück."
     },
-  "$sqrt" : {
+    "$sqrt": {
-    "args" : "Zahl",
+        "args": "number",
-    "desc" : "Gibt die Quadratwurzel des Werts des Parameters 'Zahl' zurück."
+        "desc": "Gibt die Quadratwurzel von `number` zurück."
     },
-  "$random" : {
+    "$random": {
-    "args" : "",
+        "args": "",
-    "desc" : "Gibt eine Pseudozufallszahl größer-gleich null und kleiner als eins zurück."
+        "desc": "Gibt eine Pseudozufallszahl größer-gleich null und kleiner als eins zurück."
     },
-  "$millis" : {
+    "$millis": {
-    "args" : "",
+        "args": "",
-    "desc" : "Gibt die Anzahl der Millisekunden seit der Unix-Epoche (1. Januar 1970 (UTC)) als Zahl zurück. Alle Invocationen von `$millis ()` innerhalb einer Auswertung eines Ausdrucks geben alle denselben Wert zurück."
+        "desc": "Gibt die aktuelle Anzahl der Millisekunden seit Beginn der Unix-Zeitrechnung (1. Januar 1970 UTC) als Zahl zurück. Alle Aufrufe von `$millis()` innerhalb der Auswertung eines Ausdrucks geben alle denselben Wert zurück."
     },
-  "$sum" : {
+    "$sum": {
-    "args" : "Array",
+        "args": "array",
-    "desc" : "Gibt die arithmetische Summe eines `Array` von Zahlen zurück. Es ist ein Fehler, wenn die Eingabe `Array` ein Element enthält, das keine Zahl ist."
+        "desc": "Gibt die arithmetische Summe eines `array` von Zahlen zurück. Es ergibt einen Fehler, wenn `array` ein Element enthält, das keine Zahl ist."
     },
-  "$max" : {
+    "$max": {
-    "args" : "Array",
+        "args": "array",
-    "desc" : "Gibt die maximale Anzahl in einem `Array` von Zahlen zurück. Es ist ein Fehler, wenn die Eingabe `Array` ein Element enthält, das keine Zahl ist."
+        "desc": "Gibt die größte Zahl von einem `array` von Zahlen zurück. Es ergibt einen Fehler, wenn `array` ein Element enthält, das keine Zahl ist."
     },
-  "$min" : {
+    "$min": {
-    "args" : "Array",
+        "args": "array",
-    "desc" : "Gibt die minimale Zahl in einem `Array` von Zahlen zurück. Es ist ein Fehler, wenn die Eingabe `Array` ein Element enthält, das keine Zahl ist."
+        "desc": "Gibt die kleinste Zahl von einem `array` von Zahlen zurück. Es ergibt einen Fehler, wenn `array` ein Element enthält, das keine Zahl ist."
     },
-  "$average" : {
+    "$average": {
-    "args" : "Array",
+        "args": "array",
-    "desc" : "Gibt den Mittelwert eines `Array` von Zahlen zurück. Es ist ein Fehler, wenn die Eingabe `Array` ein Element enthält, das keine Zahl ist."
+        "desc": "Gibt den Mittelwert eines `array` von Zahlen zurück. Es ergibt einen Fehler, wenn `array` ein Element enthält, das keine Zahl ist."
     },
-  "$boolean" : {
+    "$boolean": {
-    "args" : "arg",
+        "args": "arg",
-    "desc" : "Castet das Argument mit den folgenden Regeln in einen Booleschen Wert:\n\n -` Boolean ': nicht geändert\n -` string `: leer: `false`\n -` string `: nicht leer: `true`\n -` Zahl `: ` 0 `: ` falsch `\n -` Zahl `: Nicht-Null: `true`\n -` null `: `false`\n -` array `: leer: `false`\n -` array `: enthält ein Mitglied, das auf `true` setzt: `true`\n -` array `: alle Member werden in `false` umgesetzt: `false`\n -` object `: empty: `false`\n -` object `: non-empty: `true`\n -` Funktion `: ` falsch `"
+        "desc": "Wandelt `arg` gemäß folgender Regeln in einen booleschen Wert um:\n\n- `Boolean`: unverändert\n- `string`: leer → `false`, nicht leer → `true`\n- `Zahl`: `0` → `falsch`, Nicht-Null → `true`\n- `null` → `false`\n- `array`: leer → `false`, enthält mindestens ein Element, das `true` ist → `true`, alle Elemente sind `false` → `false`\n- `object`: leer → `false`, nicht leer → `true`\n- `function`: `false`"
     },
-  "$not" : {
+    "$not": {
-    "args" : "arg",
+        "args": "arg",
-    "desc" : "Gibt den Booleschen Wert NOT für das Argument zurück. `arg` wird zuerst in einen Booleschen Wert umgesetzt."
+        "desc": "Gibt den invertierten booleschen Wert von `arg` zurück. `arg` wird zuerst in einen booleschen Wert umgesetzt."
     },
-  "$exists" : {
+    "$exists": {
-    "args" : "arg",
+        "args": "arg",
-    "desc" : "Gibt den Booleschen Wert 'true' zurück, wenn der Ausdruck `arg` als Wert ausgewertet wird, oder 'false', wenn der Ausdruck nicht mit einem anderen Ausdruck übereinstimmt (z. B. ein Pfad zu einer nicht vorhandenen Feldreferenz)."
+        "desc": "Gibt den booleschen Wert `true` zurück, wenn der Ausdruck `arg` zu einem Wert ausgewertet wird, oder `false`, wenn der Ausdruck nicht mit einem anderen Ausdruck übereinstimmt (z. B. ein Pfad zu einer nicht vorhandenen Feldreferenz)."
     },
-  "$count" : {
+    "$count": {
-    "args" : "Array",
+        "args": "array",
-    "desc" : "Gibt die Anzahl der Elemente in dem Array zurück."
+        "desc": "Gibt die Anzahl der Elemente in dem Array `array` zurück."
     },
-  "$append" : {
+    "$append": {
-    "args" : "Array, Array",
+        "args": "array, array",
-    "desc" : "Hängen Sie zwei Arrays an."
+        "desc": "Verkettet zwei Arrays miteinander."
     },
-  "$sort" : {
+    "$sort": {
-    "args" : "array [, Funktion]",
+        "args": "array [, function]",
-    "desc" : "Gibt ein Array zurück, das alle Werte im Parameter 'array' enthält, aber in der Reihenfolge sortiert wird.\n\nWenn ein Vergleichsoperator 'function' angegeben wird, muss es sich um eine Funktion handeln, die zwei Parameter benötigt:\n\n` Funktion (links, rechts) `\n\nDiese Funktion wird durch den Sortieralgorithmus aufgerufen, um zwei Werte links und rechts zu vergleichen. Wenn der Wert von links nach dem Wert von rechts in der gewünschten Sortierreihenfolge platziert werden soll, muss die Funktion den Booleschen Wert 'true' zurückgeben, um einen Auslagerungsspeicher anzuzeigen. Andernfalls muss 'false' zurückgegeben werden."
+        "desc": "Gibt ein Array zurück, das alle Elemente vom `array` in sortierter Reihenfolge enthält.\n\nWenn ein Vergleichsoperator `function` vorgegeben wird, muss es sich um eine Funktion handeln, die zwei Parameter benötigt:\n\n`function(left, right)`\n\nDiese Funktion wird durch den Sortieralgorithmus aufgerufen, um zwei Elemente links und rechts zu vergleichen. Wenn das linke Element nach dem rechten in der gewünschten Sortierreihenfolge platziert werden soll, muss die Funktion den booleschen Wert `true` zurückgeben, um eine Vertauschung anzuzeigen. Andernfalls muss `false` zurückgegeben werden."
     },
-  "$reverse" : {
+    "$reverse": {
-    "args" : "Array",
+        "args": "array",
-    "desc" : "Gibt ein Array zurück, das alle Werte aus dem Parameter 'array' enthält, aber in umgekehrter Reihenfolge."
+        "desc": "Gibt ein Array zurück, das alle Elemente vom `array` in umgekehrter Reihenfolge enthält."
     },
-  "$shuffle" : {
+    "$shuffle": {
-    "args" : "Array",
+        "args": "array",
-    "desc" : "Gibt ein Array zurück, das alle Werte aus dem Parameter ` array ` enthält, aber in zufälliger Reihenfolge geschattiert ist."
+        "desc": "Gibt ein Array zurück, das alle Elemente vom `array` in zufälliger Reihenfolge enthält."
     },
-  "$zip" : {
+    "$zip": {
-    "args" : "Array, ...",
+        "args": "array, ...",
-    "desc" : "Gibt ein konvolviertes (gezipptes) Array zurück, das gruppierte Arrays von Werten aus den Argumenten ` array1 ` ... ` arrayN ' aus Index 0, 1, 2 ... enthält."
+        "desc": "Gibt ein gepacktes (geziptes) Array zurück, das gruppierte Arrays der Elemente von `array1` ... `arrayN` aus Index 0, 1, 2 ... enthält."
     },
-  "$keys" : {
+    "$keys": {
-    "args" : "Objekt",
+        "args": "object",
-    "desc" : "Gibt ein Array zurück, das die Schlüssel in dem Objekt enthält. Wenn es sich bei dem Argument um ein Array von Objekten handelt, enthält das zurückgegebene Array eine deduplizierte Liste aller Schlüssel in allen Objekten."
+        "desc": "Gibt ein Array zurück, das die Schlüssel in dem Objekt `object` enthält. Wenn es sich bei dem Parameter um ein Array von Objekten handelt, enthält das zurückgegebene Array eine deduplizierte Liste aller Schlüssel in allen Objekten."
     },
-  "$lookup" : {
+    "$lookup": {
-    "args" : "Objekt, Schlüssel",
+        "args": "object, key",
-    "desc" : "Gibt den Wert zurück, der dem Schlüssel im Objekt zugeordnet ist. Wenn es sich bei dem ersten Argument um ein Array von Objekten handelt, werden alle Objekte im Array durchsucht, und die Werte, die mit allen Vorkommen des Schlüssels verknüpft sind, werden zurückgegeben."
+        "desc": "Gibt den Wert zurück, der dem Schlüssel `key` im Objekt `object` zugeordnet ist. Wenn es sich bei dem ersten Parameter um ein Array von Objekten handelt, werden alle Objekte im Array durchsucht, und die Werte, die mit allen Vorkommen des Schlüssels verknüpft sind, werden zurückgegeben."
     },
-  "$spread" : {
+    "$spread": {
-    "args" : "Objekt",
+        "args": "object",
-    "desc" : "Teilt ein Objekt, das Schlüssel/Wert-Paare enthält, in ein Array von Objekten, von denen jedes ein einzelnes Schlüssel/Wert-Paar aus dem Eingabeobjekt hat. Wenn es sich bei dem Parameter um ein Array von Objekten handelt, enthält die resultierende Feldgruppe ein Objekt für jedes Schlüssel/Wert-Paar in jedem Objekt in der angegebenen Feldgruppe."
+        "desc": "Teilt ein Objekt `object`, das Schlüssel/Wert-Paare enthält, in ein Array von Objekten, von denen jedes ein einzelnes Schlüssel/Wert-Paar aus dem Eingabeobjekt hat. Wenn es sich bei dem Parameter um ein Array von Objekten handelt, enthält die resultierende Feldgruppe ein Objekt für jedes Schlüssel/Wert-Paar in jedem Objekt in der vorgegebenen Feldgruppe."
     },
-  "$merge" : {
+    "$merge": {
-    "args" : "array <object>",
+        "args": "array<object>",
-    "desc" : "Mischt ein Array von ` Objekten ` in ein einzelnes ` Objekt `, das alle Schlüssel/Wert-Paare aus jedem der Objekte in dem Eingabe-Array enthält. Wenn eines der Eingabeobjekte denselben Schlüssel enthält, enthält das zurückgegebene Objekt den Wert des letzten Objekts in der Feldgruppe. Es handelt sich um einen Fehler, wenn das Eingabe-Array ein Element enthält, das kein Objekt ist."
+        "desc": "Fügt ein Array von Objekt-Elementen `object` in ein einzelnes Objekt `object` zusammen, das alle Schlüssel/Wert-Paare aus jedem der Objekte in dem Ausgangs-Array enthält. Wenn eines der Ausgangs-Objekte denselben Schlüssel enthält, enthält das zurückgegebene Objekt den Wert des letzten Objekts des Arrays. Es handelt sich um einen Fehler, wenn das Ausgangs-Array ein Element enthält, das kein Objekt ist."
     },
-  "$sift" : {
+    "$sift": {
-    "args" : "Objekt, Funktion",
+        "args": "object, function",
-    "desc" : "Gibt ein Objekt zurück, das nur die Schlüssel/Wert-Paare aus dem Parameter 'object' enthält, die die Prädikat ` funktion ' erfüllen, die als zweiter Parameter übergeben wird.\n\nDie Funktion ` function `, die als zweiter Parameter angegeben wird, muss die folgende Signatur aufweisen:\n\n` function (value [, key [, object]]) `"
+        "desc": "Gibt ein Objekt zurück, das nur die Schlüssel/Wert-Paare aus dem Parameter `object` enthält, die die Prädikat `function` erfüllen, die als zweiter Parameter übergeben wird.\n\nDie Funktion `function`, die als zweiter Parameter vorgegeben wird, muss die folgende Signatur aufweisen:\n\n`function(value [, key [, object]])`"
     },
-  "$each" : {
+    "$each": {
-    "args" : "Objekt, Funktion",
+        "args": "object, function",
-    "desc" : "Gibt ein Array zurück, das die Werte enthält, die von der Funktion ` function ` zurückgegeben werden, wenn sie auf jedes Schlüssel/Wert-Paar im ` object ` angewendet werden."
+        "desc": "Gibt ein Array zurück, das die Werte enthält, die von der Funktion `function` zurückgegeben werden, wenn sie auf jedes Schlüssel/Wert-Paar im `object` angewendet werden."
     },
-  "$map" : {
+    "$map": {
-    "args" : "Array, Funktion",
+        "args": "array, function",
-    "desc" : "Gibt ein Array zurück, das die Ergebnisse der Anwendung des Parameters ` function ` auf jeden Wert im Parameter 'array' enthält.\n\nDie Funktion ` function `, die als zweiter Parameter angegeben wird, muss die folgende Signatur aufweisen:\n\n` function (value [, index [, array]]) `"
+        "desc": "Gibt ein Array zurück, das die Ergebnisse von `function`, angewendet auf jedes Element von `array`, enthält.\n\nDie Funktion `function`, die als zweiter Parameter vorgegeben wird, muss die folgende Signatur aufweisen:\n\n`function(value [, index [, array]])`"
     },
-  "$filter" : {
+    "$filter": {
-    "args" : "Array, Funktion",
+        "args": "array, function",
-    "desc" : "Gibt ein Array zurück, das nur die Werte im Parameter 'array' enthält, die das Prädikat ` funktion ` erfüllen.\n\nDie Funktion ` function `, die als zweiter Parameter angegeben wird, muss die folgende Signatur aufweisen:\n\n` function (value [, index [, array]]) `"
+        "desc": "Gibt ein Array zurück, das nur die Elemente von `array` enthält, die das Eigenschaft `function` erfüllen.\n\nDie Funktion `function`, die als zweiter Parameter vorgegeben wird, muss die folgende Signatur aufweisen:\n\n`function(value [, index [, array]])`"
     },
-  "$reduce" : {
+    "$reduce": {
-    "args" : "array, function [, init]",
+        "args": "array, function [, init]",
-    "desc" : "Gibt einen aggregierten Wert zurück, der aus der Anwendung des Parameters ` function 'nacheinander auf jeden Wert in' array ` in Kombination mit dem Ergebnis der vorherigen Anwendung der Funktion angewendet wurde.\n\nDie Funktion muss zwei Argumente akzeptieren und verhält sich wie ein Infix-Operator zwischen jedem Wert innerhalb des ` Array `.\n\nDer optionale Parameter 'init' wird als Anfangswert in der Aggregation verwendet."
+        "desc": "Gibt einen aggregierten Wert zurück, der aus der Anwendung des Parameters `function` nacheinander auf jedes Element in `array` in Kombination mit dem Ergebnis der vorherigen Anwendung der Funktion angewendet wurde.\n\nDie Funktion muss zwei Parameter akzeptieren und verhält sich wie ein Infix-Operator zwischen jedem Element innerhalb des `array`.\n\nDer optionale Parameter `init` wird als Anfangswert in der Aggregation verwendet."
     },
-  "$flowContext" : {
+    "$flowContext": {
-    "args" : "Zeichenfolge [, Zeichenfolge]",
+        "args": "str [, str]",
-    "desc" : "Ruft eine Flusskontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ \"Node-RED\"."
+        "desc": "Ruft eine Flow-Kontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ `Node-RED`."
     },
-  "$globalContext" : {
+    "$globalContext": {
-    "args" : "Zeichenfolge [, Zeichenfolge]",
+        "args": "str [, str]",
-    "desc" : "Ruft eine globale Kontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ \"Node-RED\"."
+        "desc": "Ruft eine globale Kontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ `Node-RED`."
     },
-  "$pad" : {
+    "$pad": {
-    "args" : "string, width [, char]",
+        "args": "str, width [, char]",
-    "desc" : "Gibt eine Kopie der ` Zeichenfolge ` mit zusätzlichen Aufenthalten zurück, falls erforderlich, so dass die Gesamtzahl der Zeichen mindestens der absolute Wert des Parameters 'width' ist.\n\nWenn ` width ` eine positive Zahl ist, wird die Zeichenfolge nach rechts aufgefüllt. Wenn sie negativ ist, wird sie nach links geplisften.\n\nDas optionale Argument 'char' gibt die Padding-Zeichen an, die verwendet werden sollen. Wenn keine Angabe gemacht wird, wird standardmäßig der Wert für das Leerzeichen angenommen."
+        "desc": "Gibt eine aufgefüllte Kopie von `str` zurück, so dass (falls erforderlich) die Gesamtzahl der Zeichen mindestens dem absoluten Wert von `width` entspricht.\n\nWenn `width` eine positive Zahl ist, wird die Zeichenfolge nach rechts aufgefüllt. Wenn sie negativ ist, wird sie nach links aufgefüllt.\n\nDer optionale Parameter `char` gibt die Auffüll-Zeichen an, die verwendet werden sollen. Wenn keine Angabe gemacht wird, wird standardmäßig mit Leerzeichen aufgefüllt."
     },
-  "$fromMillis" : {
+    "$fromMillis": {
-    "args" : "Anzahl",
+        "args": "number",
-    "desc" : "Konvertieren Sie eine Zahl, die Millisekunden seit der Unix-Epoche (1. Januar 1970 (UTC)) enthält in eine Zeitangabe im ISO 8601-Format."
+        "desc": "Konvertiert `number`, die die Millisekunden seit Beginn der Unix-Zeitrechnung (1. Januar 1970 UTC) enthält, in eine Zeitangabe im ISO 8601-Format."
     },
-  "$formatNumber" : {
+    "$formatNumber": {
-    "args" : "Zahl, Bild [, Optionen]",
+        "args": "number, picture [, options]",
-    "desc" : "Transformiere die `Zahl` an eine Zeichenfolge und formatiert sie in eine dezimale Darstellung, wie in der 'Bild' -Zeichenfolge angegeben.\n\n Das Verhalten dieser Funktion ist mit der XPath/XQuery-Funktion fn:formatnummer konsistent, wie sie in der XPath F&O 3.1-Spezifikation definiert ist. Der Parameter für die Bildzeichenfolge definiert, wie die Zahl formatiert ist und hat die gleiche Syntax wie fn:format-number.\n\nDas optionale dritte Argument ` Optionen ` wird verwendet, um die standardmäßigen länderspezifischen Formatierungszeichen, wie z. B. das Dezimaltrennzeichen, zu überschreiben. Wenn dieses Argument angegeben wird, muss es sich um ein Objekt handeln, das Name/Wert-Paare enthält, die im Abschnitt mit dem Dezimalformat der XPath F&O 3.1-Spezifikation angegeben sind."
+        "desc": "Wandelt `number` in eine Zeichenfolge um und formatiert sie in eine dezimale Darstellung, wie im `picture`-String-Parameter vorgegeben.\n\nDas Verhalten dieser Funktion ist mit der XPath/XQuery-Funktion fn:formatnummer konsistent, wie sie in der XPath F&O 3.1-Spezifikation definiert ist. Der `picture`-String-Parameter definiert, wie die Zahl formatiert ist und hat die gleiche Syntax wie fn:format-number.\n\nDer optionale dritte Parameter `options` wird verwendet, um die standardmäßigen länderspezifischen Formatierungszeichen, wie z. B. das Dezimaltrennzeichen, zu überschreiben. Wenn dieser Parameter vorgegeben wird, muss es sich um ein Objekt handeln, das Name/Wert-Paare enthält, die im Abschnitt mit dem Dezimalformat der XPath F&O 3.1-Spezifikation vorgegeben sind."
     },
-  "$formatBase" : {
+    "$formatBase": {
-    "args" : "Zahl [, Radix]",
+        "args": "number [, radix]",
-    "desc" : "Transformiere die `Zahl` in eine Zeichenfolge und formatiert sie in eine ganze Zahl, die in der durch das `radix` -Argument angegebenen Zahlenbasis dargestellt wird. Wenn 'radix' nicht angegeben wird, wird standardmäßig die Basis 10 verwendet. 'radix` kann zwischen 2 und 36 liegen, andernfalls wird ein Fehler ausgelöst."
+        "desc": "Wandelt `number` in eine Zeichenfolge um und formatiert sie in eine ganze Zahl, die in der durch den `radix`-Parameter vorgegebenen Zahlenbasis dargestellt wird. Wenn `radix` nicht vorgegeben wird, wird standardmäßig die Basis 10 verwendet. `radix` kann zwischen 2 und 36 liegen, andernfalls wird ein Fehler ausgelöst."
     },
-  "$toMillis" : {
+    "$toMillis": {
-    "args" : "timestamp",
+        "args": "timestamp",
-    "desc" : "Konvertieren Sie eine Zeitangabe im ISO 8601-Format in die Anzahl der Millisekunden seit der Unix-Epoche (1. Januar 1970 (UTC)) als Zahl. Es wird ein Fehler ausgelöst, wenn die Zeichenfolge nicht das richtige Format hat."
+        "desc": "Konvertiert eine Zeitangabe `timestamp` im ISO 8601-Format in die Anzahl der Millisekunden seit Beginn der Unix-Zeitrechnung (1. Januar 1970 UTC). Es wird ein Fehler ausgelöst, wenn die Zeichenfolge nicht das richtige Format hat."
     },
-  "$env" : {
+    "$env": {
-    "args" : "arg",
+        "args": "arg",
-    "desc" : "Gibt den Wert einer Umgebungsvariablen zurück.\n\nDies ist eine definierte Funktion vom Typ \"Node-RED\"."
+        "desc": "Gibt den Wert einer Umgebungsvariablen zurück.\n\nDies ist eine definierte Funktion vom Typ `Node-RED`."
+    },
+    "$eval": {
+        "args": "expr [, context]",
+        "desc": "Analysiert (parse) und evaluiert den String `expr`, welcher JSON or a JSONata Ausdrücke enthält, unter Benutzung des aktuellen Kontextes für die Evaluierung."
+    },
+    "$formatInteger": {
+        "args": "number, picture",
+        "desc": "Wandelt `number` in eine Zeichenfolge um und formatiert sie in einer Ganzzahl-Darstellung, spezifiziert durch den `picture`-String-Parameter. Der `picture`-String-Parameter definiert, wie die Zahl `number` formatiert werden soll und hat den selben Syntax wie `fn:format-integer` der XPath F&O 3.1 Spezifikation."
+    },
+    "$parseInteger": {
+        "args": "str, picture",
+        "desc": "Wandelt den Inhalt von `str` in eine Ganzzahl `integer` (als JSON Zahl), spezifiziert durch den `picture`-String-Parameter. Der `picture`-String-Parameter hat das selbe Format wie `$formatInteger`."
+    },
+    "$error": {
+        "args": "[str]",
+        "desc": "Erzeugt eine Fehlermeldung. Der optionale String `str` ersetzt die Standardmeldung `$error() function evaluated`."
+    },
+    "$assert": {
+        "args": "arg, str",
+        "desc": "Wenn `arg` gleich `true` ist, liefert die Function `undefined` zurück. Wenn `arg` gleich `false` ist, wird ein Ausnahmefehler gemeldet mit dem String_Parameter `str` als Meldetext."
+    },
+    "$single": {
+        "args": "array, function",
+        "desc": "Gibt ein einziges Element aus `array` zurück, welches die Bedingung `function` erfüllt (d.h. die Funktion `function` gibt den booleschen Wert `true` zurück, wenn das Element übergeben werden soll). Sie meldet einen Ausnahmefehler, wenn die Anzahl der Elemente mit erfüllter Bedingung (`function` ist `true`) nicht genau eins ist.\n\nDie Funktion `function` sollte in der folgenden Art vorgegeben werden: `function(value [, index [, array]])` wobei `value` für jedes Element des Arrays gilt, `index` ist die Position dieses Elements und das gesamte Array `array` wird als dritter Parameter übergeben."
+    },
+    "$encodeUrlComponent": {
+        "args": "str",
+        "desc": "Kodiert eine URL-Komponente (Uniform Resource Locator), indem jedes Vorkommen bestimmter Zeichen durch eine, zwei, drei oder vier Escape-Sequenzen ersetzt wird, die die UTF-8-Kodierung des Zeichens darstellen.\n\nBeispiel: `$encodeUrlComponent(\"?x=test\")` => `\"%3Fx%3Dtest\"`"
+    },
+    "$encodeUrl": {
+        "args": "str",
+        "desc": "Kodiert eine URL (Uniform Resource Locator), indem jedes Vorkommen bestimmter Zeichen durch eine, zwei, drei oder vier Escape-Sequenzen ersetzt wird, die die UTF-8-Kodierung des Zeichens darstellen.\n\nBeispiel: `$encodeUrl(\"https://mozilla.org/?x=шеллы\")` => `\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\"`"
+    },
+    "$decodeUrlComponent": {
+        "args": "str",
+        "desc": "Dekodiert eine URL-Komponente (Uniform Resource Locator) zuvor erzeugt von encodeUrlComponent.\n\nBeispiel: `$decodeUrlComponent(\"%3Fx%3Dtest\")` => `\"?x=test\"`"
+    },
+    "$decodeUrl": {
+        "args": "str",
+        "desc": "Dekodiert eine URL (Uniform Resource Locator) zuvor erzeugt von encodeUrl.\n\nBeispiel: `$decodeUrl(\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\")` => `\"https://mozilla.org/?x=шеллы\"`"
+    },
+    "$distinct": {
+        "args": "array",
+        "desc": "Liefert ein `array` zurück, bei dem doppelte Elemente entfernt wurden."
+    },
+    "$type": {
+        "args": "value",
+        "desc": "Liefert den Typ von `value` als String. When `value` undefiniert ist, wird `undefined` zurückgeliefert."
+    },
+    "$moment": {
+        "args": "[str]",
+        "desc": "Liefert ein `date` Objekt unter Benutzung der Moment Library."
     }
 }

packages/node_modules/@node-red/nodes/locales/de/common/20-inject.html

@@ -13,26 +13,34 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 -->
-
 <script type="text/html" data-help-name="inject">
-  <p> Injiziert eine Nachricht manuell oder in regelmäßigen Intervallen in einen Nachrichtenflow. 
+    <p>Injektion einer Nachricht manuell oder in regelmäßigen Intervallen in einen Flow.
-    Bei den Nutzdaten kann es sich um eine Vielzahl von Typen handeln, einschließlich Zeichenfolgen, JavaScript-Objekte oder die aktuelle Zeit. </p>
+       Bei den Nutzdaten (Payload) der Nachricht kann es sich um eine Vielzahl von Typen handeln,
-    <h3> Ausgaben </h3>
+       einschließlich Zeichenfolgen (string), JavaScript-Objekte oder die aktuelle Zeit.</p>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt> Nutzdaten <span class="property-type"> verschiedene Tyoen </span> </dt>
+        <dt>payload<span class="property-type">Verschiedene Typen</span></dt>
-        <dd> Die konfigurierten Nutzdaten der Nachricht. </dd>
+        <dd>Eingestellte Nutzdaten (Payload) der Nachricht</dd>
-        <dt class="optional"> Topic  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt class="optional">topic<span class="property-type">string</span></dt>
-        <dd> Eine optionale Eigenschaft, die im Node konfiguriert werden kann. </dd>
+        <dd>Optional nutzbare Nachrichten-Eigenschaft</dd>
     </dl>
-    <h3> Details </h3>
+    <h3>Details</h3>
-    <p> Der Inject-Node kann einen Flow mit einem bestimmten Nutzdatenwert starten.
+    <p>Der <span style="background-color:Gainsboro">inject</span>-Node kann einen Flow mit einstellbaren Nutzdaten (Payload) starten.
-    Der Standard-Payload ist die aktuelle Zeit als Zeitstempel seit dem 1. Januar 1970 in Millisekunden. </p>
+       Der voreingestellte Payload ist die aktuelle Zeit als Zeitstempel in Millisekunden
-    <p> Der Node unterstützt auch die Injektion von Zeichenfolgen, Zahlen, Boolescher Daten, JavaScript-Objekten oder flow/globalen Kontextwerten. </p>
+       seit Beginn der Unix-Zeitrechnung (1. Januar 1970 UTC).</p>
-    <p> Der Node wird standardmäßig manuell ausgelöst, indem Sie im Editor auf seine Schaltfläche klicken. Er kann auch in regelmäßigen Abständen oder nach einem Zeitplan injizieren. </p>
+    <p>Der Node unterstützt auch die Injektion von Zeichenfolgen, Zahlenwerten, Booleschen Werten,
-    <p> Er kann auch so konfiguriert werden, dass er jedes Mal, wenn der Flow gestartet wird einen Wert injiziert. </p>
+       JavaScript-Objekten oder Flow-lokalen oder globalen Kontextwerten.</p>
-    <p> Das maximale  <i> Intervall </i> , das angegeben werden kann, beträgt etwa 596 Stunden/24 Tage. Wenn Sie jedoch Intervalle grösser als 24h verwenden wollen, sollten Sie einen Scheduler-Node verwenden, der mit Stromausfällen und Neustarts besser umgehen kann. </p>
+    <p>Der Node wird normalerweise manuell ausgelöst, indem im Editor auf seine Schaltfläche geklickt wird.
-    <p> <b> Hinweis </b>: Die Optionen  <i> "Intervall zwischen den Zeiten" </i>  und  <i> "Zu einem bestimmten Zeitpunkt" </i>  verwenden das Standardcron-System.
+       Er kann auch in regelmäßigen Intervallen oder nach einem Zeitplan injizieren.</p>
-    Dies bedeutet, dass 20 Minuten bedeuten, dass der Event in der nächsten Stunde, 20 Minuten nach der Stunde und 40 Minuten nach der Stunde - aber nicht in 20 Minuten Zeit.
+    <p>Er kann auch so eingestellt werden, dass er jedes Mal einen Wert injiziert, wenn der Flow gestartet wird.</p>
-    Wenn Sie alle 20 Minuten ab sofort verwenden möchten, verwenden Sie die Option  <i> "interval" </i> . </p>
+    <p>Das maximal einstellbare Intervall beträgt etwa 596 Stunden bzw. 24 Tage.
-    <p> <b> Hinweis </b>: Um eine neue Zeile in eine Zeichenfolge einzuschließen, müssen Sie einen Funktions-Node verwenden, um die Nutzdaten zu erstellen. </p>
+       Wenn jedoch Intervalle größer als 24h benötigt werden, sollte ein <span style="background-color:Gainsboro">scheduler</span>-Node verwendet werden,
+       der mit Stromausfällen und Neustarts besser umgehen kann.</p>
+    <p><b>Hinweis:</b> Die Optionen <i>"Intervall zwischen Uhrzeiten"</i> und <i>"Täglicher Zeitpunkt"</i>
+       verwenden das Standard-Cron-System.</p>
+    <p>Beispiel "Intervall zwischen Uhrzeiten": Von 3:00 bis 4:00 in 15-Minuten-Intervall ergibt die Zeitpunkte
+       3:00, 3:15, 3:30, 3:45 und 4:00.</p>
+    <p>Wenn Sie alle 20 Minuten ab sofort verwenden möchten, verwenden Sie die Option<i>"Intervall"</i>.</p>
+    <p><b>Hinweis:</b> Um einen Zeilenvorschub in eine Zeichenfolge einzuschließen, muss ein Funktions-Node
+       zur Erstellung der Nutzdaten (Payload) verwendet werden.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/common/21-debug.html

@@ -15,18 +15,18 @@
 -->
 
 <script type="text/html" data-help-name="debug">
-  <p> Zeigt die ausgewählten Nachrichteneigenschaften auf der Registerkarte "Debug" und 
+    <p>Anzeige ausgewählter Nachrichten wahlweise im Debug-Tab, als Node-Status und in der Systemkonsole.
-    optional im Laufzeitprotokoll an. Standardmäßig wird  <code>msg.payload</code> angezeigt. </p>
+       Standardmäßig wird <code>msg.payload</code> angezeigt.</p>
-  <h3> Details </h3>
+    <h3>Details</h3>
-  <p> Die Registerkarte "Debug" bietet eine strukturierte Sicht der Nachrichten an 
+    <p>Der Debug-Tab zeigt ein strukturiertes Protokoll der empfangenen Nachrichten an,
-    wodurch die ihre Struktur leichter zu verstehen ist. </p>
+       wodurch die ihre Struktur leichter zu verstehen ist.</p>
-  <p> JavaScript-Objekte und -Arrays können nach Bedarf ausgeblendet und eingeblendet werden. 
+    <p>JavaScript-Objekte und -Arrays können nach Bedarf ein- und ausgeblendet werden.
-    Bufferobjekte können, wenn möglich, als Rohdaten oder als Zeichenfolge angezeigt werden. </p>
+       Binäre Puffer-Objekte (buffer objects) können nach Möglichkeit als Rohdaten oder als Zeichenfolge (string) angezeigt werden.</p>
-  <p> Neben jeder Nachricht enthält die Registerkarte "Debug" Informationen über den Zeitpunkt, 
+    <p>Neben der eigentlichen Nachricht werden im Debug-Tab auch der Empfangszeitpunkt,
-    zu dem die Nachricht empfangen wurde, den Node, der sie gesendet hat, und den Typ der Nachricht.
+       der empfangende <span style="background-color:Gainsboro">debug</span>-Node, sowie Name und Typ der Nachricht protokolliert.
-    Wenn Sie auf die ID des Quellen-Nodes klicken, wird dieser Node innerhalb des Arbeitsbereichs angezeigt. </p>
+       Durch Klicken auf die Node-ID wird der entsprechende <span style="background-color:Gainsboro">debug</span>-Node im Arbeitsbereich angezeigt.</p>
-  <p> Die Schaltfläche auf dem Node kann verwendet werden, um die Ausgabe zu aktivieren oder zu inaktivieren.
+    <p>Die Schaltfläche des <span style="background-color:Gainsboro">debug</span>-Nodes kann verwendet werden, um die Debug-Ausgabe ein- und auszuschalten.
-    Es wird empfohlen, alle Debug-Nodes, die nicht verwendet werden, zu inaktivieren oder zu entfernen. </p>
+       Es ist empfehlenswert, alle nicht verwendeten <span style="background-color:Gainsboro">debug</span>-Nodes zu deaktivieren oder gleich zu entfernen.</p>
-  <p> Der Node kann auch so konfiguriert werden, dass er alle Nachrichten an das Laufzeitprotokoll sendet,
+    <p>Der <span style="background-color:Gainsboro">debug</span>-Node kann auch so eingestellt werden, dass außerdem alle Nachrichten in der Systemkonsole ausgegeben und/oder
-    oder dass er kurze (32 Zeichen) an den Statustext unter dem Debug-Node sendet. </p>
+       als kurze Statustexte (max. 32 Zeichen) unter dem <span style="background-color:Gainsboro">debug</span>-Node angezeigt werden.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/common/24-complete.html

@@ -0,0 +1,29 @@
+<!--
+  Copyright JS Foundation and other contributors, http://js.foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<script type="text/html" data-help-name="complete">
+    <p>Anstoß eines weiteren Flows, wenn ein anderer Node seine Nachrichtenbearbeitung abgeschlossen hat.</p>
+    <h3>Details</h3>
+    <p>Wenn ein Node die Bearbeitung seiner Nachrichten abgeschlossen hat,
+       kann der <span style="background-color:Gainsboro">complete</span>-Node dazu benutzt werden, einen weiteren Flow anzustoßen.</p>
+    <p>Der Node kann z. B. mit einem anderen Node ohne Ausgang verknüpft werden
+       (z. B. E-Mail-Sende-Node), um den Flow fortzusetzen.</p>
+    <p>Im Node werden dazu die zu überwachenden Nodes des selben Flows ausgewählt.
+       Im Gegensatz zum <span style="background-color:Gainsboro">catch</span>-Node besteht hier jedoch nicht die Auswahlmöglichkeit aller Nodes des Flows.</p>
+    <p>Nicht alle Nodes können diesen Node anstoßen.
+       Es hängt davon ab, ob die auslösenden Knoten diese Funktion unterstützen,
+       welche erst mit Node-RED 1.0 eingeführt wurde.</p>
+</script>

packages/node_modules/@node-red/nodes/locales/de/common/25-catch.html

@@ -15,27 +15,27 @@
 -->
 
 <script type="text/html" data-help-name="catch">
-    <p> Fängt Fehler von Nodes auf derselben Registerkarte ab. </p>
+    <p>Abfang von Fehlern von Nodes im selben Flow-Tab.</p>
-    <h3> Ausgaben </h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt> error.message <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>error.message<span class="property-type">string</span></dt>
-        <dd> die Fehlernachricht. </dd>
+        <dd>Fehlermeldung</dd>
-        <dt> error.source.id  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>error.source.id<span class="property-type">string</span></dt>
-        <dd> Die ID des Nodes, der den Fehler ausgelöst hat. </dd>
+        <dd>ID des fehlerauslösenden Nodes</dd>
-        <dt> error.source.type  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>error.source.type<span class="property-type">string</span></dt>
-        <dd> Der Typ des Nodes, der den Fehler ausgelöst hat. </dd>
+        <dd>Typ des fehlerauslösenden Nodes</dd>
-        <dt> error.source.name  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>error.source.name<span class="property-type">string</span></dt>
-        <dd> Der Name des Nodes (falls festgelegt), der den Fehler ausgelöst hat. </dd>
+        <dd>Name des fehlerauslösenden Nodes (falls festgelegt)</dd>
     </dl>
-    <h3> Details </h3>
+    <h3>Details</h3>
-    <p> Wenn ein Node bei der Verarbeitung einer Nachricht einen Fehler auslöst, wird der Flow in der Regel
+    <p>Wenn ein Node bei der Verarbeitung einer Nachricht einen Fehler verursacht, wird der Flow in der Regel angehalten.
-       angehalten. Dieser Node kann verwendet werden, um diese Fehler abzufangen und sie mit einem
+       Der <span style="background-color:Gainsboro">catch</span>-Node kann verwendet werden, um diese Fehler abzufangen und sie mit einem dedizierten Flow zu bearbeiten.</p>
-       dedizierten Flow zu bearbeiten. </p>
+    <p>Der Node fängt standardmäßig die Fehler aller Nodes im selben Flow ab.
-    <p> Der Node fängt standardmäßig Fehler ab, die von einem beliebigen Node auf derselben Registerkarte ausgelöst werden. Alternativ
+       Alternativ kann er auch an bestimmte Nodes gebunden werden.</p>
-   kann er an einen bestimmten Node gebunden werden. </p>
+    <p>Wenn ein Fehler ausgelöst wird, empfangen alle angebundenen <span style="background-color:Gainsboro">catch</span>-Nodes die Fehlermeldung.</p>
-    <p> Wenn ein Fehler ausgelöst wird, empfangen alle übereinstimmenden Fehlerabfang-Node die Nachricht. </p>
+    <p>Wenn ein Fehler in einem Subflow ausgelöst wird, wird der Fehler von einem <span style="background-color:Gainsboro">catch</span>-Node
-    <p> Wenn ein Fehler in einem Subflow ausgelöst wird, wird der Fehler von einem Fehlerabfang-Node
+       innerhalb des Subflows abgefangen.
-       innerhalb des Subflows abgefangen. Wenn keine vorhanden sind, wird zu dem Tab geleitet, 
+       Wenn im Subflow keine <span style="background-color:Gainsboro">catch</span>-Nodes vorhanden sind, wird die Fehlermeldung eine Ebene höher zum Flow weitergereicht,
-       in der sich die Subflow-Instanz befindet. </p>
+       in der sich die Subflow-Instanz befindet.</p>
-   <p> Wenn die Nachricht bereits über eine Eigenschaft  <code>error</code>  verfügt, wird sie nach  <code>_error</code> kopiert. </p>
+    <p>Wenn die Nachricht bereits über eine <code>error</code>-Eigenschaft verfügt, wird sie nach <code>_error</code> kopiert.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/common/25-status.html

@@ -15,20 +15,20 @@
 -->
 
 <script type="text/html" data-help-name="status">
-    <p> Berichtet Statusnachrichten von anderen Node auf derselben Registerkarte. </p>
+    <p>Berichten von Statusnachrichten anderer Nodes im selben Flow.</p>
-    <h3> Ausgaben </h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt> status.text  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>status.text<span class="property-type">string</span></dt>
-        <dd> Statustext </dd>
+        <dd>Statustext</dd>
-        <dt> status.source.type  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>status.source.type<span class="property-type">string</span></dt>
-        <dd> Der Typ des Nodes, der den Status gemeldet hat </dd>
+        <dd>Typ des statusmeldenden Nodes</dd>
-        <dt> status.source.id  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>status.source.id<span class="property-type">string</span></dt>
-        <dd> Die ID des Nodes, der den Status gemeldet hat. </dd>
+        <dd>ID des statusmeldenden Nodes</dd>
-        <dt> status.source.name  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>status.source.name<span class="property-type">string</span></dt>
-        <dd> Der Name des Nodes (falls gesetzt), der den Status gemeldet hat. </dd>
+        <dd>Name des statusmeldenden Nodes (falls festgelegt)</dd>
     </dl>
-    <h3> Details </h3>
+    <h3>Details</h3>
-   <p> Dieser Node erzeugt keine <code>Nutzdaten</code>. </p>
+    <p>Dieser Node erzeugt keine Nutzdaten (Payload).</p>
-   <p> Standardmäßig meldet der Node den Status für alle Node auf derselben Registerkarte.
+    <p>Der Node meldet standardmäßig den Status aller Nodes im selben Flow.
-   Er kann so konfiguriert werden, dass der Status für einzelne Nodes selektiv gemeldet wird. </p>
+       Alternativ kann er auch an bestimmte Nodes gebunden werden.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/common/60-link.html

@@ -15,23 +15,23 @@
 -->
 
 <script type="text/html" data-help-name="link in">
-   <p> Erstellt virtuelle Verbindungen zwischen Flows. </p>
+    <p>Erstellung virtueller Verbindungen (Links) zwischen Flows.</p>
-   <h3> Details </h3>
+    <h3>Details</h3>
-   <p> Der Node kann mit jedem beliebigen  <code>Link-out</code> Node auf einer beliebigen Registerkarte verbunden werden.
+    <p>Der Node kann mit jedem beliebigen <span style="background-color:Gainsboro">link&nbsp;out</span>-Node in einen beliebigen Flow-Tab verlinkt werden.
-      Sobald sie verbunden sind, verhalten sie sich so, als wären sie direkt verbunden. </p>
+       Sobald sie verlinkt sind, verhalten sie sich so, als wären sie direkt miteinander verbunden.</p>
-   <p> Die Verbindungen zwischen Verknüpfungs-Node werden nur angezeigt, wenn ein Verknüpfungs-Node ausgewählt ist.
+    <p>Die Links zwischen Link-Nodes werden nur angezeigt, wenn ein Link-Node ausgewählt ist.
-      Wenn Verbindungen zu anderen Registerkarten vorhanden sind, wird ein virtueller Node angezeigt, auf den geklickt werden kann,
+       Wenn Links zu anderen Flow-Tabs vorhanden sind, werden virtuelle Link-Nodes als Gegenparts angezeigt,
-      um zur entsprechenden Registerkarte zu springen. </p>
+       über die durch Klicken zum entsprechenden Flow-Tab gesprungen werden kann.</p>
-   <p> <b> Hinweis:  </b> Links können nicht in einem Subflow erstellt oder aus einem Subflow heraus erstellt werden. </p>
+    <p><b>Hinweis:</b> Links können zu Subflows weder rein- noch rausgehend erstellt werden.</p>
 </script>
 
 <script type="text/html" data-help-name="link out">
-   <p> Erstellt virtuelle Verbindungen zwischen Flows. </p>
+    <p>Erstellung virtueller Verbindungen (Links) zwischen Flows.</p>
-   <h3> Details </h3>
+    <h3>Details</h3>
-   <p> Der Node kann mit jedem beliebigen  <code>Link-out</code> Node auf einer beliebigen Registerkarte verbunden werden.
+    <p>Der Node kann mit jedem beliebigen <span style="background-color:Gainsboro">link&nbsp;in</span>-Node in einen beliebigen Flow-Tab verlinkt werden.
-      Sobald sie verbunden sind, verhalten sie sich so, als wären sie direkt verbunden. </p>
+       Sobald sie verlinkt sind, verhalten sie sich so, als wären sie direkt miteinander verbunden.</p>
-   <p> Die Verbindungen zwischen Verknüpfungs-Node werden nur angezeigt, wenn ein Verknüpfungs-Node ausgewählt ist.
+    <p>Die Links zwischen Link-Nodes werden nur angezeigt, wenn ein Link-Node ausgewählt ist.
-      Wenn Verbindungen zu anderen Registerkarten vorhanden sind, wird ein virtueller Node angezeigt, auf den geklickt werden kann,
+       Wenn Links zu anderen Flow-Tabs vorhanden sind, werden virtuelle Link-Nodes als Gegenparts angezeigt,
-      um zur entsprechenden Registerkarte zu springen. </p>
+       über die durch Klicken zum entsprechenden Flow-Tab gesprungen werden kann.</p>
-   <p> <b> Hinweis:  </b> Links können nicht in einem Subflow erstellt oder aus einem Subflow heraus erstellt werden. </p>
+    <p><b>Hinweis:</b> Links können zu Subflows weder rein- noch rausgehend erstellt werden.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/common/90-comment.html

@@ -15,8 +15,8 @@
 -->
 
 <script type="text/html" data-help-name="comment">
-    <p>Ein Node, der zur Kommentierung der Flows verwendet werden kann.</p>
+    <p>Kommentierung von Flows.</p>
     <h3>Details</h3>
-    <p>Das Textfeld des Node akzeptiert die Markdown Syntax. Der eingegebene Text wird dann in diesem Informations Panel angezeigt.
+    <p>Das Textfeld des Nodes verwendet den Markdown-Syntax.
-    </p>
+       Der eingegebene Text wird in der Info-Seitenleiste angezeigt.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/common/98-unknown.html

@@ -15,14 +15,14 @@
 -->
 
 <script type="text/html" data-help-name="unknown">
-    <p>Dieser Node ist von einem Typ, der in der aktuellen Node-RED Installation unbekannt ist.</p>
+    <p>Unbekannter Node-Typ für diese Node-RED-Installation.</p>
     <h3>Details</h3>
-    <p><i>Wenn der Flow im aktuellen Zustand eingesetzt wird, bleibt die Konfiguration erhalten 
+    <p><i>Wenn Sie den Node in diesem Zustand übernehmen (Deploy), wird die Konfiguration beibehalten,
-      aber der Flow wird nicht starten bis der vermisste Node Typ installiert ist.</i></p>
+       aber der Flow wird erst gestartet, wenn der fehlende Node-Typ installiert ist.</i></p>
-    <p>Benutzen Sie die <code>Menu - Palette anpassen</code> Option um nach Nodes zu suchen und sie zu installieren
+    <p>Benutzen Sie  Menü-Option <code>Palette verwalten</code>, um die fehlenden Nodes zu suchen und zu installieren,
-      oder verwenden Sie <b>npm install &lt;module&gt;</b> um die vermissten Module zu installieren. 
+       oder verwenden Sie <b>npm install &lt;module&gt;</b>, um die fehlenden Module zu installieren.
-      Starten Sie danach Node-RED neu und importieren Sie die Node erneut.</p>
+       Starten Sie danach Node-RED neu und importieren Sie die Nodes erneut.</p>
-    <p>Es ist möglich, dass der Nodetyp bereits installiert ist, aber bestimmte Abhängigkeiten vermisst werden.
+    <p>Es ist möglich, dass der Node-Typ bereits installiert ist, aber bestimmte Abhängigkeiten vermisst werden.
-      Prüfen Sie das Node-RED Protokoll auf Fehlernachrichten in Bezug auf den vermissten Nodetyp.</p>
+       Prüfen Sie das Node-RED-Protokoll auf Fehlermeldungen in Bezug auf den vermissten Node-Typ.</p>
-    <p>Andernfalls kontaktieren Sie den Author des Flows um Informationen über den vermissten Nodetyp zu bekommen.</p>
+    <p>Andernfalls kontaktieren Sie den Entwickler des Nodes, um Informationen über den vermissten Node-Typ zu bekommen.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/function/10-function.html

@@ -15,41 +15,47 @@
 -->
 
 <script type="text/html" data-help-name="function">
-  <p> Ein JavaScript-Funktionsblock, der für die Nachrichten ausgeführt werden soll, die vom Node empfangen werden. </p>
+    <p>JavaScript-Funktion zur Weiterverarbeitung eingehender Nachrichten.</p>
-  <p> Die Nachrichten werden als JavaScript-Objekt mit dem Namen  <code>msg</code> übergeben. </p>
+    <p>Die empfangenen Nachrichten werden der Funktion als JavaScript-Objekt mit dem Namen <code>msg</code> übergeben.</p>
-  <p> Er erwartet eine Eigenschaft  <code> msg.payload </code> , die den Hauptteil der Nachricht enthält. </p>
+    <p>Per Konvention enthält die <code>msg.payload</code>-Eigenschaft die eigentliche Nachricht.</p>
-  <p> Die Funktion wird erwartet, dass ein Nachrichtenobjekt (oder mehrere Nachrichtenobjekte) zurückgegeben werden, kann aber
+    <p>Von der Funktion wird erwartet, dass sie ein (oder mehrere) Nachrichtenobjekt(e) zurückgibt.
-     auch nichts zurückzugeben, um einen Flow zu stoppen. </p>
+       Es kann aber auch nichts zurückgeben werden, um einen Flow zu stoppen.</p>
-  <h3> Details </h3>
+    <p>In den <b>Start</b>-Tab kann Code eingetragen werden, der beim Node-Start ausgeführt wird.
-  <p> Siehe  <a target="_blank" href="http://nodered.org/docs/writing-functions.html"> Onlinedokumentation </a> für weitere Informationen 
+       In den <b>Stopp</b>-Tab kann Code eingetragen werden, der beim Node-Stopp ausgeführt wird.</p>
-    zum Schreiben von Funktionen. </p>
+    <p>Wenn ein promise-Objekt aus dem Start-Code zurückgegeben wird,
-  <h4> Nachrichten senden </h4>
+       beginnt danach die reguläre Verarbeitung der Eingangsnachrichten.</p>
-  <p> Die Funktion kann die Nachrichten zurückgeben, die sie an die nächsten Node inm Flow weitergeben möchte
+    <h3>Details</h3>
-    oder kann  <code>node.send (msg)</code> aufrufen. </p>
+    <p>Siehe  <a target="_blank" href="http://nodered.org/docs/writing-functions.html">Onlinedokumentation</a>
-  <p> Es kann Folgendes zurückgeben/senden: </p>
+       für weitere Informationen zum Schreiben von Funktionen.</p>
+    <h4>Nachrichten senden</h4>
+    <p>Die Funktion kann die Nachrichten zurückgeben, die sie an die nächsten Nodes im Flow weitergeben möchte,
+       oder kann <code>node.send(msg)</code> aufrufen.</p>
+    <p>Es kann folgendes zurückgeben/senden werden:</p>
     <ul>
-    <li> Ein einzelnes Nachrichtenobjekt-übergeben an Node, die mit der ersten Ausgabe verbunden sind </li>
+        <li>Ein einzelnes Nachrichtenobjekt, das an Nodes am ersten Ausgang übergeben wird</li>
-    <li> ein Array von Nachrichtenobjekten, die an Nodes übergeben werden, die mit den entsprechenden Ausgaben verbunden sind </li>
+        <li>Ein Array von Nachrichtenobjekten, die an die Nodes an den entsprechenden Ausgängen übergeben werden</li>
     </ul>
-  <p> Wenn ein Element des Arrays selbst ein Array von Nachrichten ist, werden mehrere Nachrichten an die entsprechende Ausgabe gesendet. </p>
+    <p><b>Hinweis:</b> Der Start-Code wird nur während der Initialisierung des Nodes ausgeführt.
-  <p> Wenn null zurückgegeben wird, entweder durch sich selbst oder als Element des Arrays, wird die Nachricht nicht weitergegeben. </p>
+       Wenn <code>node.send</code> im Start-Code aufgerufen wird, können nachfolgende Nodes die Nachricht möglicherweise nicht empfangen.</p>
-  <h4> Protokollierung und Fehlerbehandlung </h4>
+    <p>Wenn ein Element des Arrays selbst ein Array von Nachrichten ist, werden mehrere Nachrichten an den entsprechenden Ausgang gesendet.</p>
-  <p>Um alle Informationen zu protokollieren oder einen Fehler zu melden, sind die folgenden Funktionen verfügbar: </p>
+    <p>Wenn null zurückgegeben wird, entweder direkt oder als ein Array-Element, wird keine Nachricht weitergegeben.</p>
+    <h4>Protokollierung und Fehlerbehandlung</h4>
+    <p>Um alle Informationen zu protokollieren oder einen Fehler zu melden, sind die folgenden Funktionen verfügbar:</p>
     <ul>
-        <li> <code>node.log ("Protokollnachricht")</code> </li>
+        <li><code>node.log("Protokollnachricht")</code></li>
-        <li> <code>node.warn (" Warning")</code> </li>
+        <li><code>node.warn("Warnmeldungstext")</code></li>
-        <li> <code>node.error ("Error")</code> </li>
+        <li><code>node.error("Fehlermeldungstext")</code></li>
     </ul>
     </p>
-  <p> Der Catch-Node kann auch zur Bearbeitung von Fehlern verwendet werden. So rufen Sie einen Catch-Node auf:
+    <p>Der <span style="background-color:Gainsboro">catch</span>-Node kann auch zur Bearbeitung von Fehlern verwendet werden.
-  Übergeben Sie <code>msg</code> als zweites Argument an <code>node.error</code>:</p>
+       Er wird aufgerufen, indem <code>msg</code> als zweites Argument an <code>node.error</code> übergeben wird:</p>
-  <pre>node.error ("Error" ,msg);</pre>
+    <pre>node.error("Fehlermeldungstext" ,msg);</pre>
-  <h4> Auf Node-Informationen zugreifen </h4>
+    <h4>Zugriff auf Node-Informationen</h4>
-  <p> Im Funktionsblock können die ID und der Name des Nodes mit den folgenden Eigenschaften referenziert werden: </p>
+    <p>Im Funktionsblock können die ID und der Name des Nodes mit den folgenden Eigenschaften referenziert werden:</p>
     <ul>
-      <li> <code>node.id</code> - ID des Nodes </li>
+        <li><code>node.id</code> - ID des Nodes</li>
-      <li> <code>node.name</code> - Name des Nodes </li>
+        <li><code>node.name</code> - Name des Nodes</li>
     </ul>
-  <h4> Umgebungsvariablen verwenden </h4>
+    <h4>Umgebungsvariablen verwenden</h4>
-  <p> Auf Umgebungsvariablen kann mit  <code>env.get ("MY_ENV_VAR")</code> zugegriffen werden. </p>
+    <p>Auf Umgebungsvariablen kann mit <code>env.get("Umgebungsvariablenname")</code> zugegriffen werden.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/function/10-switch.html

@@ -15,35 +15,32 @@
 -->
 
 <script type="text/html" data-help-name="switch">
-    <p>Weiterleitung von Nachrichten basierend auf den Werten ihrer Eigenschaften oder der Position der Sequenz.</p>
+    <p>Weiterleitung von Nachrichten basierend auf den Werten ihrer Eigenschaften oder Position in der Sequenz.</p>
     <h3>Details</h3>
-    <p>Wenn eine Nachricht ankommt, wertet der Node jede der definierten Regeln aus
+    <p>Bei Eingang einer Nachricht wertet der Node einstellbare Regeln aus und
-        und leitet die Nachricht an die entsprechenden Ausgänge der übereinstimmenden Regeln weiter.</p>
+       leitet die Nachricht an den entsprechenden Ausgang der erfüllten Regel weiter.</p>
-    <p>Optional kann der Node so eingestellt werden, dass er die Auswertung von Regeln einstellt,
+    <p>Optional kann der Node so eingestellt werden, dass er die Auswertung nach der ersten erfüllten Regel beendet.</p>
-        sobald er eine passende Regel findet.</p>
+    <p>Die Regeln können anhand einer einzelnen Nachrichteneigenschaft, einer Flow- oder globalen Kontext-Eigenschaft oder
-    <p>Die Regeln können anhand einer einzelnen Nachrichteneigenschaft, 
+       anhand dem Ergebnis eines JSONata-Ausdrucks ausgewertet werden.</p>
-        einer Flow- oder globalen Kontext-Eigenschaft oder dem Ergebniss eines JSONata-Ausdrucks ausgewertet werden.</p>
     <h4>Regeln</h4>
     <p>Es gibt vier Regeltypen:</p>
     <ol>
-        <li><b>Value</b> Regeln werden gegen die konfigurierte Eigenschaft ausgewertet.</li>
+        <li><b>value rules:</b> Regeln werden hinsichtlich einer eingestellten Eigenschaft ausgewertet</li>
-        <li><b>Sequence</b> Regeln können auf Nachrichtenfolgen verwendet werden, 
+        <li><b>sequence rules:</b> Regeln beziehen sich auf Nachrichtensequenzen,
-            wie sie beispielsweise durch den Split-Node erzeugt werden.</li>
+            wie sie beispielsweise durch den <span style="background-color:Gainsboro">split</span>-Node erzeugt werden</li>
-        <li>Es kann ein JSONata <b>Expression</b> bereitgestellt werden, 
+        <li>Ein <b>JSONata-Ausdruck</b> kann die gesamte Eingangsnachricht auswerten und einen <code>true</code>-Wert zurückliefern,
-            der anhand der gesamten Nachricht bewertet wird und eine Übereinstimmung erzeugt, 
+            um eine Regelerfüllung zu signalisieren</li>
-            wenn der Ausdruck einen wahren Wert zurückgibt.</li>
+        <li>Die <b>ansonsten</b>-Regel wird angewendet, wenn keine vorhergehende Regel übereinstimmt</li>
-        <li>Eine <b>Andernfalls</b> Regel kann verwendet werden, um eine Übereinstimmung herzustellen, 
-            wenn keine der vorhergehenden Regeln übereinstimmt.</li>
     </ol>
     <h4>Bemerkungen</h4>
-    <p>Die <code>is true/false</code> und <code>is null</code> Regeln führen strenge Vergleiche mit diesen Typen durch. 
+    <p>Die Regeln <code>ist true/false</code> und <code>ist null</code> führen strenge Vergleiche mit diesen Typen durch.
        Sie konvertieren nicht zwischen den Typen.</p>
-    <p>Die <code>is empty</code>Regel passt nur für Strings, Arrays und Buffer, die eine Länge von 0 haben
+    <p>Die Regeln <code>ist leer</code> und <code>ist nicht leer</code> können nur für Zeichenfolgen (string), Datenfelder (array) und binäre Puffer (buffer) benutzt werden,
-         oder Objekte, die keine Eigenschaften haben aber nicht für <code>null</code> oder <code>undefiniert</code>.</p>
+       sowie für Objekte, bei denen auf die Anzahl der Eigenschaften geprüft wird.
-    <h4>Behandlung von Nachrichtenfolgen</h4>
+       Die Regel ist niemals erfült, wenn die Eigenschaft einen <code>boolean</code>-, <code>null</code>- oder <code>undefined</code>-Wert hat.
-    <p>Standardmäßig ändert der Node nicht  die Eigenschaft <code>msg.parts</code> für Nachrichten,
+    <h4>Behandlung von Nachrichtensequenzen</h4>
-        die Teil einer Sequenz sind.</p>
+    <p>Standardmäßig ändert der Node nicht die <code>msg.parts</code>-Eigenschaft für Nachrichten, die Teil einer Sequenz sind.</p>
-    <p>Die Option <b>Nachrichtenfolgen neu erstellen</b> kann aktiviert werden, um neue Nachrichtenfolgen für jede passende Regel zu generieren. 
+    <p>Bei aktivierter Option <b>Nachrichtensequenzen erzeugen</b> werden Nachrichtensequenzen für jede passende Regel erzeugt.
        In diesem Modus puffert der Node die gesamte eingehende Sequenz, bevor er die neuen Sequenzen weiter sendet.
        Mit der Laufzeiteinstellung <code>nodeMessageBufferMaxLength</code> kann begrenzt werden,
        wie viele Nachrichten im Node zwischengespeichert werden sollen.</p>

packages/node_modules/@node-red/nodes/locales/de/function/15-change.html

@@ -15,24 +15,24 @@
 -->
 
 <script type="text/html" data-help-name="change">
-    <p>Setzen, Ändern, Löschen oder Verschieben von Eigenschaften einer Nachricht, eines Flow-Kontextes oder eines globalen Kontextes.</p>
+    <p>Setzen, Ändern, Löschen oder Verschieben von Eigenschaften einer Nachricht, eines Flow- oder eines globalen Kontextes.</p>
-    <p>Der Node kann mehrere Regeln angeben, die in der Reihenfolge ihrer Definition angewendet werden.</p>
+    <p>Im Node können mehrere Regeln definiert werden, die in vorgegebener Reihenfolge abgearbeitet werden.</p>
     <h3>Details</h3>
     <p>Die verfügbaren Operationen sind:</p>
     <dl class="message-properties">
         <dt>Setze</dt>
-    <dd>Setzt eine Eigenschaft. Der Wert kann eine Vielzahl von verschiedenen Typen sein 
+        <dd>Setzen einer Eigenschaft.
-        oder aus einer bestehenden Nachricht oder einer Kontext-Eigenschaft übernommen werden.</dd>
+            Der Wert kann eine Vielzahl von verschiedenen Typen sein oder
+            von einer bestehenden Nachricht- oder einer Kontext-Eigenschaft übernommen werden</dd>
         <dt>Ändere</dt>
-    <dd>Suchen und Ersetzen von Teilen der Eigenschaft. Wenn reguläre Ausdrücke aktiviert sind, 
+        <dd>Suchen und Ersetzen von Teilen einer Eigenschaft.
-        kann die Eigenschaft "Ersetzen mit" sogenante Capture groups beinhalten, z.B. <code>$1</code>. 
+            Wenn reguläre Ausdrücke verwendet werden, kann auch durch sogenannte Capture Groups ersetzt werden, z. B. <code>$1</code>.
-        Ersetzen ändert den Typ nur, wenn eine vollständige Übereinstimmung vorliegt.</dd>
+            Beim Ersetzen wird der Typ nur geändert, wenn eine vollständige Übereinstimmung vorliegt.</dd>
-    <dt>Löschen</dt>
+        <dt>Lösche</dt>
-    <dd>Löscht eine Eigenschaft.</dd>
+        <dd>Löschen einer Eigenschaft</dd>
         <dt>Verschiebe</dt>
-    <dd>Verschiebt eine Eigneschft oder benennt sie um.</dd>
+        <dd>Verschieben oder umbenennen einer Eigenschaft</dd>
     </dl>
-    <p>Der Typ "expression" verwendet die Abfrage- und Ausdruckssprache 
+    <!-- <p>Der Typ "expression" verwendet die Abfrage- und Ausdruckssprache <a href="http://jsonata.org/" target="_new">JSONata</a>.</p> -->
-        <a href="http://jsonata.org/" target="_new">JSONata</a>.
+    <!-- was ist mit "expression" gemeint?!? vermutlich nicht mehr aktuell -->
-    </p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/function/16-range.html

@@ -15,23 +15,30 @@
 -->
 
 <script type="text/html" data-help-name="range">
-    <p>Ordnet einen numerischen Wert einem anderen Bereich zu..</p>
+    <p>Umskalierung eines Zahlenwertes auf einen anderen Wertebereich.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">Zahl</span></dt>
+        <dt>payload<span class="property-type">number</span></dt>
         <dd>Der Payload <i>muss</i> eine Zahl sein.
-            Alles andere wird versucht als Zahl interpretiert zu werden und abgelehnt, wenn das fehlschlägt.</dd>
+            Alles andere wird versucht als Zahl interpretiert zu werden und bei Fehlschlag abgelehnt.</dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">Zahl</span></dt>
+        <dt>payload<span class="property-type">number</span></dt>
-        <dd>Der Wert, der dem neuen Bereich zugeordnet ist.</dd>
+        <dd>Der auf den neuen Wertebereich umgerechnete Zahlenwert</dd>
     </dl>
     <h3>Details</h3>
     <p>Dieser Node skaliert den empfangenen Wert linear.
-        Standardmäßig ist das Ergebnis nicht auf den im Node definierten Bereich beschränkt.</p>
+       Standardmäßig ist das Ergebnis nicht auf Ausgangswertebereich beschränkt.</p>
-    <p><i>Skalieren und begrenzen auf den Zielbereich</i> bedeutet, 
+    <p><i>Skalierung und Begrenzung</i> bedeutet,
-        dass das Ergebnis niemals außerhalb des im Ergebnisbereich angegebenen Bereichs liegt.</p>
+       dass das Ergebnis niemals außerhalb des Ausgangswertebereich liegt.</p>
-    <p><Skalieren und Umhüllen innerhalb des Zielbereichs</i> bedeutet, 
+    <p><i>Skalieren und Begrenzung mit Überlauf</i> bedeutet,
-        dass das Ergebnis innerhalb des Ergebnisbereichs umgepackt wird.</p>
+       dass das Ergebnis in den Ausgangswertebereich <i>über- bzw. umlaufend gepackt</i> wird.</p>
+    <p>Beispiel einer Skalierung vom Eingangswerterbereich 0-10 auf Ausgangswertebereich 0-100:</p>
+    <table style="outline-width:#888 solid thin">
+        <tr><th width="260px">Modus</th><th width="110px">Eingangswert</th><th width="110px">Ausgangswert</th></tr>
+        <tr><td><center>Skalieren</center></td><td><center>12</center></td><td><center>120</center></td></tr>
+        <tr><td><center>Skalieren und begrenzen</center></td><td><center>12</center></td><td><center>100</center></td></tr>
+        <tr><td><center>Skalieren und begrenzen mit Überlauf</center></td><td><center>12</center></td><td><center>20</center></td></tr>
+    </table>
 </script>

packages/node_modules/@node-red/nodes/locales/de/function/80-template.html

@@ -15,39 +15,43 @@
 -->
 
 <script type="text/html" data-help-name="template">
-  <p> Legt eine Eigenschaft fest, die auf der bereitgestellten Vorlage basiert. </p>
+    <p>Festlegen einer Eigenschaft anhand einer Vorlage (template).</p>
-  <h3> Eingaben </h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-      <dt> msg  <span class="property-type"> Objekt </span> </dt>
+        <dt>msg<span class="property-type">object</span></dt>
-      <dd> Ein msg Objekt, das Informationen zum Füllen der Vorlage enthält. </dd>
+        <dd>msg-Objekt mit Informationen zum Befüllen der Vorlage</dd>
-      <dt class="optional"> template  <span class="property-type">Zeichenfolge</span> </dt>
+        <dt class="optional">template<span class="property-type">string</span></dt>
-      <dd> Eine Schablone, die aus msg.payload gefüllt werden soll. Falls es nicht in der Editieranzeige konfiguriert ist, kann 
+        <dd>Mit msg.payload zu befüllende Vorlage.
-       kann es als Eigenschaft von msg gesetzt werden. </dd>
+            Falls nicht im Editorfenster angegeben, kann die Vorlage auch als Eigenschaft von msg vorgegeben werden.</dd>
     </dl>
-  <h3> Ausgaben </h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-      <dt> msg  <span class="property-type"> Objekt </span> </dt>
+        <dt>msg<span class="property-type">object</span></dt>
-      <dd> Eine Nachricht die durch Verbindung der konfigurierten Vorlage mit den Eigenschaften aus der eingehenden Nachricht gebildet wird. </dd>
+        <dd>Nachricht auf Basis der Vorlage und gefüllt mit Eigenschaften aus der eingehenden Nachricht</dd>
     </dl>
-  <h3> Details </h3>
+    <h3>Details</h3>
-  <p> Die Vorlage verwendet standardmäßig das  <i> <a href="http://mustache.github.io/mustache.5.html" target="_blank"> mustache </a> </i>
+    <p>Die Vorlage verwendet standardmäßig das
-  Format, das kann aber bei Bedarf ausgeschaltet werden. </p>
+      <i><a href="http://mustache.github.io/mustache.5.html" target="_blank">Mustache</a></i>-Format,
-  <p> Beispiel: Wenn eine Vorlage von:
+      was aber bei Bedarf ausgeschaltet werden kann.</p>
-  <pre> Hallo {{payload.name}}. Heute ist {{date}} </pre>
+    <p>Beispiel: Wenn die Vorlage</p>
-  <p> eine Nachricht empfangt, die folgendes enthält:
+    <pre>Hallo {{payload.name}}. Heute ist {{date}}</pre>
-  <pre>{
+    <p>die Nachricht</p>
+    <pre>
+{
   date: "Montag",
   payload: {
     name: "Fred"
   }
-}</pre>
+}
-  <p> wird die resultierende Nachrich wie folgt sein:
+    </pre>
-  <pre> Hallo Fred. Heute ist Montag </pre>
+    <p>empfängt, wird die resultierende Ausgangsnachricht wie folgt sein:</p>
-  <p> Es ist möglich, eine Eigenschaft aus dem Flowkontext oder dem globalen Kontext zu verwenden. 
+    <pre>Hallo Fred. Heute ist Montag</pre>
-    Verwenden Sie einfach  <code>{{flow.name}}</code>  oder
+    <p>Es ist möglich, eine Eigenschaft aus dem Flowkontext oder dem globalen Kontext zu verwenden,
-  <code>{{global.name}}</code> oder für den persistenten Speicher <code>store</code> verwenden <code>{{flow[store].name}}</code> oder
+       indem <code>{{flow.name}}</code> oder <code>{{global.name}}</code> verwendet wird.
-  <code>{{global[store].name}}</code>.
+       Oder für den persistenten Speicher <code>store</code> kann <code>{{flow[store].name}}</code> oder
-  <p> <b>Hinweis: </b> Standardmäßig wird <i>mustache</i> alle HTML-Entitäten in den Werten die es ersetzt mit Escape behandeln.
+       <code>{{global[store].name}}</code> verwendet werden.
-     Um dies zu verhindern, verwenden Sie <code>{{{triple}}}</code> Klammern.
+    <p><b>Hinweis:</b> Standardmäßig werden bei <i>Mustache</i> sog. <i>Escaper</i>
-
+       bei allen nicht-numerischen und HTML-Entitäten erzeugt.
+       Z. B. <code>&</code> wird durch <code>&amp;amp;</code> ersetzt.
+       Um dies zu verhindern, müssen <code>{{{dreifache}}}</code> Klammern verwendet werden.
 </script>

packages/node_modules/@node-red/nodes/locales/de/function/89-delay.html

@@ -13,33 +13,29 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 -->
-
 <script type="text/html" data-help-name="delay">
-    <p> Verzögert jede Nachricht, die den Node durchläuft oder begrenzt die Geschwindigkeit, mit der sie übergeben werden können. </p>
+    <p>Verzögerung von Nachrichten oder Begrenzung ihrer Durchlaufrate.</p>
-    <h3> Eingaben </h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional"> delay  <span class="property-type"> Zahl </span> </dt>
+        <dt class="optional">delay<span class="property-type">number</span></dt>
-        <dd> Legt die Verzögerung (in Millisekunden) fest, die auf die Nachricht angewendet werden soll. Dies
+        <dd>Legt die Verzögerung in Millisekunden fest, die auf die Nachricht angewendet werden soll.
-            Option gilt nur, wenn der Node so konfiguriert ist, dass er Nachrichten zulässt,
+            Zur Nutzung dieser Option muss <i>Verzög. mit msg.delay überschreibbar</i> aktiviert sein.</dd>
-            die das konfigurierte Standardverzögerungsintervall überschreiben. </dd>
+        <dt class="optional">reset</dt>
-            <dt class="optional"> zurücksetzen </dt>
+        <dd>Wenn bei der empfangenen Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist,
-            <dd> Wenn für die empfangene Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist, werden alle
+            werden alle im Node gepufferten Nachrichten gelöscht</dd>
-                ausstehende Nachrichten gelöscht, die vom Node noch gehalten werden. </dd>
+        <dt class="optional">flush</dt>
-            <dt class="optional"> Flush </dt>
+        <dd>Wenn bei der empfangenen Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist,
-            <dd> Wenn für die empfangene Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist, werden alle
+            werden alle im Node gepufferten Nachrichten sofort gesendet</dd>
-                ausstehende Nachrichten, die vom noch Node gehalten werden, sofort gesendet. </dd>
     </dl>
-    <h3> Details </h3>
+    <h3>Details</h3>
-    <p> Wenn das Verzögerungsintervall für die Verzögerung von Nachrichten konfiguriert ist, kann es sich um einen festen Wert,
+    <p>Wenn Verzögerung als Nachrichtenaktion eingestellt ist, kann die Verzögerungszeit ein fixer Wert,
-        einen Zufallswert innerhalb eines Bereichs oder einen dynamisch für jede Nachricht festgelegten Wert handeln. </p>
+       ein Zufallswert innerhalb eines Bereichs oder ein für jede Nachricht dynamisch vorgebbarer Wert handeln.</p>
-    <p> Bei der Konfiguration von Begrenzungen werden die Nachrichten über den konfigurierten Zeitraum verteilt. 
+    <p>Bei Begrenzung auf Nachrichtenrate werden die Nachrichten über den eingestellten Zeitraum verteilt.
-        Der Status zeigt die Anzahl der Nachrichten an, die sich derzeit in der Warteschlange befinden. 
+       Der Status zeigt die Anzahl der sich aktuell in der Warteschlange befindlichen Nachrichten an.
-        Zwíschenzeitlich entreffende Nachrichten können gegebenenfalls verworfen werden.</p>
+       Zwischenzeitlich eintreffende Nachrichten können optional beim Eintreffen verworfen werden.</p>
-    </p>
+    <p>Die Ratenbegrenzung kann auf alle Nachrichten angewendet werden oder
-    <p> Die Ratenbegrenzung kann auf alle Nachrichten angewendet werden
+       die Nachrichten werden anhand des <code>msg.topic</code>-Wertes gruppiert.
-        oder sie werden gemäß des Wertes von <code>msg.topic</code> gruppiert. 
+       Bei der Gruppierung werden zwischenzeitlich eintreffende Nachrichten automatisch gelöscht.
-        Bei der Gruppierung werden zwíschenzeitlich eintreffende Nachrichten automatisch gelöscht. 
+       In jedem Zeitintervall werden die neuesten Nachricht entweder für alle oder
-        In jedes Zeitintervall kann der Node entweder die aktuellste Nachricht für alle Themen
+       für das nächste Thema (Topic) in der Reihe gesendet.</p>
-        oder die neueste Nachricht für das nächste Topic freigeben.
-    </p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/function/89-trigger.html

@@ -15,30 +15,36 @@
 -->
 
 <script type="text/html" data-help-name="trigger">
-    <p> Wenn der Trigger ausgelöst wird, kann eine Nachricht gesendet werden und dann optional eine weitere Nachricht , 
+    <p>Senden einer und optional einer weiteren verzögerten Nachricht bei Auslösung (Trigger),
-        sofern der Trigger nicht verlängert oder zurückgesetzt wird. </p>
+       sofern der Trigger nicht verlängert oder zurückgesetzt wird.</p>
-
+    <h3>Eingangsdaten</h3>
-    <h3> Eingaben </h3>
     <dl class="message-properties">
-        <dt class="optional"> reset </dt>
+        <dt class="optional">delay<span class="property-type">number</span></dt>
-        <dd> Wenn eine Nachricht mit dieser Eigenschaft empfangen wird, wird jeder aktuelle Zeitlimit oder Wiederholung 
+        <dd>Legt die Verzögerung in Millisekunden fest, die auf die Nachricht angewendet werden soll.
-            zrückgesetzt und es wird keine Nachricht ausgelöst. </dd>
+            Zur Nutzung dieser Funktion muss die Option <i>Verzögerung mit msg.delay überschreibbar</i> aktiviert sein.</dd>
+        <dt class="optional">reset</dt>
+        <dd>Bei Empfang einer Nachricht mit dieser Eigenschaft wird jede Verzögerung oder Wiederholung
+            rückgesetzt und keine weitere Nachricht gesendet</dd>
     </dl>
-
+    <h3>Details</h3>
-    <h3> Details </h3>
+    <p>Dieser Node kann verwendet werden, um ein Zeitlimit in einem Flow zu erstellen.
-    <p> Dieser Node kann verwendet werden, um ein Zeitlimit in einem Flow zu erstellen. Wenn er eine Nachricht empfängt, wird
+       Bei Empfang einer Nachricht wird standardmäßig eine Nachricht mit einem <code>payload</code> von <code>1</code> versendet.
-        standardmäßig wird eine Nachricht mit einer <code>payload</code> von <code>1</code> versandt.
+       Optional wird nach einer einstellbaren Wartezeit (standardmäßig 250 ms) eine zweite Nachricht
-        Anschließend wartet er 250 ms, bevor er eine zweite Nachricht mit einer <code>payload</code> von <code>0</code> sendet.
+       mit einem <code>payload</code> von <code>0</code> sendet.
-        Dies kann beispielsweise zum Blinken einer LED verwendet werden, die an einen Raspberry Pi GPIO-Pin angeschlossen ist.</p>
+       Dies kann beispielsweise zum Blinken einer LED verwendet werden, die an einen GPIO-Pin des Raspberry Pi angeschlossen ist.</p>
-    <p> Die Nutzdaten jeder gesendeten Nachricht können für eine Vielzahl von Werten konfiguriert werden, 
+    <p>Als Nutzdaten (Payload) jeder zu sendenen Nachricht können eine Vielzahl von Werten eingestellt werden inklusive der Option,
-        einschließlich der Option, nichts zu senden. Wenn Sie beispielsweise die Anfangsnachricht auf <i>nichts</i> setzen und
+       überhaupt nicht zu senden.
-        Auswahl der Option zum Erweitern des Zeitgebers mit jeder empfangenen Nachricht dann wird der Node als Überwachungszeitgeber agieren
+       Wenn beispielsweise die erste Ausgnagsnachricht auf <i>nichts</i> gesetzt und die Option
-        und nur dann eine Nachricht senden, wenn innerhalb des konfigurierten Erweiterungszeitraums keine Nachricht empfangen wird. </p>
+       <i>Verzögerung verlängern bei Eingang neuer Nachrichten</i> aktiviert ist,
-    <p> Wenn der Node auf den Typ  <i>Zeichenfolge</i>  gesetzt ist, unterstützt der Node die Syntax der Mustache-Vorlage. </p>
+       agiert der Node als Überwachungszeitgeber (Watchdog-Timer).
-    <p> Wenn der Node eine Nachricht mit einer Eigenschaft  <code>reset</code>  oder einer <code>payload</code> die mit dem Wert in der
+       Er sendet hier nur dann eine Nachricht, wenn innerhalb der eingestellten Verzögerungszeit keine Nachricht empfangen wird.</p>
-        Node-Konfiguration übereinstimmt, wird jede beliebige Zeitlimitüberschreitung oder Wiederholung gelöscht,
+    <p>Beim Nachrichtentyp <i>Zeichenfolge (string)</i> werden auch <i><a href="http://mustache.github.io/mustache.5.html" target="_blank">Mustache</a></i>-Vorlagen unterstützt.</p>
-        die sich derzeit in Bearbeitung befindet und es wird keine Nachricht ausgelöst. </p>
+    <p>Wenn eine Nachricht mit der <code>reset</code> oder <code>payload</code>-Eigenschaft gleich dem konfigurierten Wert empfangen wird,
-    <p> Der Node kann so konfiguriert werden, dass er eine Nachricht in einem regulären Intervall sendet,
+       wird eine laufende Verzögerung oder Wiederholung rückgesetzt und keine Nachricht gesendet.</p>
-        bis er durch eine empfangene Nachricht zurückgesetzt wird. </p>
+    <p>Der Node kann auch so eingestellt werden, dass er eine Nachricht normal in den vorgegebenen Intervallen sendet,
-    <p> Optional kann der Node so konfiguriert werden, dass er Nachrichten für jedes <code>msg.topic</code> als separate Datenströme behandelt. </p>
+       bis er durch eine empfangene Nachricht rückgesetzt wird.</p>
+    <p>Außerdem kann der Node auch so eingestellt werden, dass er Nachrichten anhand einer einstellbaren <code>msg</code>-Eigenschaft
+       als separate Nachrichtenströme behandelt.</p>
+    <p>Der Status zeigt die Aktivität des Nodes an.
+       Bei Verwendung mehrerer Nachrichtenströme zeigt der Status deren aktuelle Anzahl an.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/function/90-exec.html

@@ -15,69 +15,75 @@
 -->
 
 <script type="text/html" data-help-name="exec">
-    <p> Führt einen Systembefehl aus und gibt seine Ausgabe zurück. </p>
+    <p>Ausführung eines Systembefehls und Rückgabe seiner Ausgabe.</p>
-    <p> Der Node kann so konfiguriert werden, dass er entweder wartet, bis der Befehl abgeschlossen ist,
+    <p>Der Node kann so eingestellt werden, dass er entweder bis zum Befehlabschluss wartet (exec) oder
-        oder die Ausgabe so sendet wie der Befehl sie generiert. </p>
+       die Ausgabe sogleich sendet (spawn), wie der Befehl sie generiert.</p>
-    <p> Der Befehl, der ausgeführt wird, kann im Node konfiguriert oder von der empfangenen Nachricht übergeben werden. </p>
+    <p>Der auszuführende Befehl kann im Node eingestellt und/oder
-
+       über die empfangene Nachricht übergeben werden.</p>
-    <h3> Eingaben </h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional">payload<span class="property-type"> Zeichenfolge </span> </dt>
+        <dt class="optional">payload<span class="property-type">string</span></dt>
-        <dd> wird an den ausgeführten Befehl angehängt  </dd>
+        <dd>Wird an auszuführenden Befehl angehängt, sofern im Node aktiviert</dd>
-        <dt class="optional"> kill  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt class="optional">kill<span class="property-type">string</span></dt>
-        <dd> Der Typ des Kill-Signals, das einen vorhandenen exec-Node-Prozess gesendet wird. </dd>
+        <dd>Typ des Kill-Signals, das an den zu beendenden <span style="background-color:Gainsboro">exec</span>-Node-Prozess gesendet wird</dd>
-        <dt class="optional"> pid  <span class="property-type"> Zahl|Zeichenfolge </span> </dt>
+        <dt class="optional">pid<span class="property-type">number | string</span></dt>
-        <dd> Die Prozess-ID eines vorhandenen exec-Node-Prozesses, der beendet werden soll. </dd>
+        <dd>Prozess-ID des zu beendenden <span style="background-color:Gainsboro">exec</span>-Node-Prozesses</dd>
     </dl>
-
+    <h3>Ausgangsdaten</h3>
-    <h3> Ausgaben </h3>
     <ol class="node-ports">
-        <li> Standardausgabe
+        <li>Standardausgabe (stdout)
             <dl class="message-properties">
-                <dt> payload  <span class="property-type"> Zeichenfolge </span> </dt>
+                <dt>payload<span class="property-type">string</span></dt>
-                <dd> die Standardausgabe des Befehls. </dd>
+                <dd>Standardausgabe des Befehls</dd>
             </dl>
             <dl class="message-properties">
-                <dt> rc  <span class="property-type"> Objekt </span> </dt>
+                <dt>rc<span class="property-type">object</span></dt>
-                <dd> Eine Kopie des Rückkehrcodeobjekts (auch an Port 3 verfügbar) - nur im Ausführungsmodus verfügbar </dd>
+                <dd>Rückgabe-Code-Objekts (auch an Port 3 verfügbar) - nur im exec-Modus verfügbar</dd>
             </dl>
         </li>
-        <li> Standardfehler
+        <li>Standardfehlerausgabe (stderr)
             <dl class="message-properties">
-                <dt> payload  <span class="property-type"> Zeichenfolge </span> </dt>
+                <dt>payload<span class="property-type">string</span></dt>
-                <dd> Standardfehlerausgabe des Befehls. </dd>
+                <dd>Standardfehlerausgabe des Befehls</dd>
             </dl>
             <dl class="message-properties">
-                <dt> rc  <span class="property-type"> Objekt </span> </dt>
+                <dt>rc<span class="property-type">object</span></dt>
-                <dd> Eine Kopie des Rückkehrcodeobjekts (auch an Port 3 verfügbar) - nur im Ausführungsmodus verfügbar </dd>
+                <dd>Rückgabe-Code-Objekts (auch an Port 3 verfügbar) - nur im exec-Modus verfügbar</dd>
             </dl>
         </li>
-        <li> Rückkehrcode
+        <li>Rückgabe-Code
             <dl class="message-properties">
-                <dt> payload  <span class="property-type"> Objekt </span> </dt>
+                <dt>payload<span class="property-type">object</span></dt>
-                <dd> ein Objekt, das den Rückkehrcode und gegebenfals <code>Nachricht</code>,  <code>Signal</code> Eigenschaften enthält. </dd>
+                <dd>Objekt mit dem Rückgabe-Code und gegebenenfalls <code>message</code> oder <code>signal</code>-Eigenschaften</dd>
             </dl>
         </li>
     </ol>
-    <h3> Details </h3>
+    <h3>Details</h3>
-    <p> Standardmäßig verwendet der Systemaufruf  <code>exec</code> , der den Befehl aufruft, darauf wartet, dass er ausgeführt wird und anschließend
+    <p>Standardmäßig wartet der zur Befehlsausführung genutzte Systemaufruf <code>exec</code>,
-    gibt dessen Ausgabe zurück. Ein erfolgreicher Befehl sollte z. B. den Rückkehrcode  <code>{ code: 0 }</code> haben. </p>
+       bis die Ausführung abgeschlossen ist, und gibt anschließend dessen Ausgaben zurück.
-    <p> Optional kann stattdessen <code>spawn</code> verwendet werden, wodurch die Ausgaben von Standardausgabe und Standardfehler zurückgegeben werden während
+       Ein erfolgreich ausgeführter Befehl sollte z. B. den Rückgabe-Code <code>{ code: 0 }</code> haben.</p>
-    der Befehl ausgeführt wird, in der Regel Zeile für Zeile. Nach Abschluss des Befehles gibt sie ein Objekt 
+    <p>Optional kann stattdessen <code>spawn</code> verwendet werden, wodurch die Standardausgabe und Standardfehlerausgabe
-    am 3. Port zurück. Ein erfolgreicher Befehl sollte z. B.  <code>{ code: 0 }</code> zurückgeben. </p>
+       bereits während der Befehlsausführung in der Regel Zeile für Zeile rückgegeben werden.
-    <p> Fehler können zusätzliche Informationen über den dritten Port als <code>msg.payload</code> zurückgeben, 
+       Nach Befehlsabschluss wird ein Objekt am 3. Port ausgegeben.
-        z. B. eine <code>message</code> Zeichenfolge oder <code>Signal</code> zeichenfolge. </p>
+       Ein erfolgreich ausgeführter Befehl sollte z. B. <code>{ code: 0 }</code> zurückgeben.</p>
-    <p> Der Befehl, der ausgeführt wird, ist innerhalb des Nodes definiert, mit einer Option zum Anhängen von  <code> msg.payload </code>
+    <p>Fehler können zusätzliche Informationen über den dritten Port als <code>msg.payload</code> zurückgeben,
-        und einer weiteren Gruppe von Parametern. </p>
+       z. B. eine <code>message</code>- oder <code>signal</code>-Zeichenfolge.</p>
-    <p> Befehle oder Parameter mit Leerzeichen müssen in Anführungszeichen eingeschlossen werden: <code> "Dies ist ein einzelner Parameter" </code> </p>
+    <p>Der auszuführende Befehl wird innerhalb des Nodes mit der Option zum Anhängen von
-    <p> Die zurückgegebenen <code>Nutzdaten</code>  sind in der Regel ein  <i>string</i>, es sei denn, es werden nicht UTF8-Zeichen erkannt, in denen
+       <code>msg.payload</code> und weiteren Parametern definiert.</p>
-    falls es sich um einen  <i>Buffer</i> handelt. </p>
+    <p>Befehle oder Parameter mit Leerzeichen sollten in Anführungszeichen eingeschlossen werden,
-    <p> Das Statussymbol und die PID des Nodes werden angezeigt, während der Node aktiv ist. Änderungen an dieser Funktion können vom Node  <code> Status </code>  gelesen werden. </p>
+       z. B. <code>"Dies ist ein einzelner Parameter"</code></p>
-    <h4> Prozesse beenden </h4>
+    <p>Die zurückgegebenen Daten (Payload) sind in der Regel eine <i>Zeichenfolge (string)</i>,
-    <p> Wird <code>msg.kill</code>  gesendet, wird ein einzelner aktiver Prozess beendet. <code>msg.kill</code>  sollte eine Zeichenfolge sein, die
+       außer es werden nicht UTF-8-Zeichen wie bei einem <i>binären Puffer (buffer)</i> erkannt.</p>
-    Der Typ des Signals, der gesendet werden soll, z. B.  <code>SIGINT</code>,  <code>SIGQUIT</code>  oder  <code>SIGHUP</code>.
+    <p>Bei einem aktiven Node werden Status und die PID angezeigt.
-    Der Standardwert ist  <code>SIGTERM</code> , wenn er auf eine leere Zeichenfolge gesetzt ist. </p>
+       Änderungen können mittels <span style="background-color:Gainsboro">status</span>-Node gelesen werden.</p>
-    <p> Wenn der Node mehr als einen Prozess ausführt, muss  <code>msg.pid</code>  ebenfalls mit dem Wert der zu ermordenen PID festgelegt werden. </p>
+    <h4>Prozesse beenden</h4>
-    <p> Wenn ein Wert im Feld  <code>Zeitlimit</code>  angegeben wird, wird der Prozess automatisch beendet, wenn der Prozess nicht abgeschlossen ist, wenn die angegebene Anzahl von Sekunden abgelaufen ist. </p>
+    <p>Durch Senden von <code>msg.kill</code> wird ein einzelner aktiver Prozess beendet.
-    <p> Tipp: Wenn Sie eine Python-App ausführen, müssen Sie möglicherweise den Parameter  <code>-u</code>  verwenden, um die Ausgabe zu stoppen, die gepuffert wird. </p>
+       <code>msg.kill</code> sollte als Zeichenfolge (string) den Signaltyp enthalten,
+       z. B. <code>SIGINT</code>, <code>SIGQUIT</code> oder <code>SIGHUP</code>.
+       Der Standardwert ist <code>SIGTERM</code>, wenn die Zeichenfolge leer ist.</p>
+    <p>Wenn der Node mehr als einen Befehl bzw. Prozess ausführt,
+       muss zusätzlich über <code>msg.pid</code> die PID des zu beendenden Prozesses übergeben werden.</p>
+    <p>Wenn ein <code>Zeitlimit</code> angegeben ist, wird der Prozess automatisch nach Ablauf der Zeit beendet.</p>
+    <p>Tipp: Wenn Sie eine Python-App ausführen, müssen Sie möglicherweise den Parameter <code>-u</code> verwenden,
+       um die Ausgabepufferung zu stoppen.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/05-tls.html

@@ -15,5 +15,5 @@
 -->
 
 <script type="text/html" data-help-name="tls-config">
-    <p>Konfigurationsoptionen für TLS Verbindungen.</p>
+    <p>Konfigurationsoptionen für TLS-Verbindungen.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/06-httpproxy.html

@@ -15,9 +15,8 @@
 -->
 
 <script type="text/html" data-help-name="http proxy">
-    <p>Konfigurationsoptionen für den HTTP Proxy.</p>
+    <p>Konfigurationsoptionen für HTTP-Proxy.</p>
-
     <h3>Details</h3>
-    <p>Wenn auf ein Host verwended wird, der in der Liste der zu ignorierenden Hosts aufgeführt ist, 
+    <p>Wenn auf einen Host zugegriffen wird, der auf der Liste der zu ignorierenden Hosts steht,
        wird kein Proxy benutzt.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/10-mqtt.html

@@ -12,72 +12,80 @@
 -->
 
 <script type="text/html" data-help-name="mqtt in">
-   <p> Stellt eine Verbindung zu einem MQTT-Broker her und subskribiert Nachrichten zu dem angegebenen Topic. </p>
+    <p>Verbindungsherstellung zu einem MQTT-Broker und Abonnement von Topic-Nachrichten.</p>
-   <h3> Ausgaben </h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-      <dt> payload  <span class="property-type"> Zeichenfolge | Buffer </span> </dt>
+        <dt>payload<span class="property-type">string | buffer</span></dt>
-      <dd> eine Zeichenfolge, sofern sie nicht als binärer Buffer erkannt wird. </dd>
+        <dd>Zeichenfolge, sofern sie nicht als binärer Puffer (buffer) erkannt wurde</dd>
-      <dt> topic  <span class="property-type"> Zeichenfolge </span> </dt>
+        <dt>topic<span class="property-type">string</span></dt>
-      <dd> Das MQTT-Topic verwendet <code>/</code> als Trennzeichen für die Hierarchie. </dd>
+        <dd>MQTT-Topic mit / (Schrägstrich) als Hierarchie-Trennzeichen</dd>
-      <dt> qos  <span class="property-type"> Zahl </span>  </dt>
+        <dt>qos<span class="property-type">number</span></dt>
-      <dd> 0: fire und forget 1: mindestens einmal 2: einmal und nur einmal. </dd>
+        <dd>QoS (Quality of Service)<br/>
-      <dt> retain  <span class="property-type"> boolean </span> </dt>
+            0: Einmal gesendet ohne Empfangsgarantie (fire und forget)<br/>
-      <dd> true gibt an, dass die Nachricht retained wurde und älter sein kann. </dd>
+            1: Garantiert mindestens einmal empfangen (at least once)<br/>
+            2: Garantiert exakt einmal empfangen (once and once only)</dd>
+        <dt>retain<span class="property-type">boolean</span></dt>
+        <dd>Bei <code>true</code> kann es eine aufbewahrte ältere Nachricht sein</dd>
     </dl>
-   <h3> Details </h3>
+    <h3>Details</h3>
-   Das Subscribete Topic kann MQTT-Platzhalterzeichen, + für eine Ebene, # für mehrere Ebenen umfassen. </p>
+    <p>Das abonnierte Topic darf  MQTT-Platzhalterzeichen (wildcards) enthalten (+ für eine Ebene und # für mehrere Ebenen).</p>
-   <p> Dieser Node erfordert eine Verbindung zu einem MQTT-Broker, der über die Auswahlliste selektiert werden kann.
+    <p>Dieser Node erfordert eine Verbindung zu einem MQTT-Broker, der über die Auswahlliste selektiert werden kann.
-      Eine neue Konfiguration wird durch Klicken auf das Stiftsymbol erstellt. </p>
+       Eine neue Verbindung wird durch Klicken auf das Stiftsymbol erstellt.</p>
-   <p> Mehrere MQTT-Nodes (in oder out) können bei Bedarf dieselbe Brokerverbindung nutzen. </p>
+    <p>Mehrere MQTT-Nodes (in oder out) können bei Bedarf dieselbe Broker-Verbindung nutzen.</p>
 </script>
 
 <script type="text/html" data-help-name="mqtt out">
-    <p>Stellt eine Verbindung zu einem MQTT-Broker her und publiziert Nachrichten.</p>
+    <p>Verbindungsherstellung zu einem MQTT-Broker und publizieren von Topic-Nachrichten.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-       <dt>payload <span class="property-type">Zeichenfolge | Buffer</span></dt>
+        <dt>payload<span class="property-type">string | buffer</span></dt>
-       <dd>die meisten Benutzer präferieren einfach Textnachrichten aber es können auch binäre Buffer publiziert werden.</dd>
+        <dd>Zu publiziernde Nutzdaten.<br/>
-       <dt class="optional">topic <span class="property-type">string</span></dt>
+            Wenn nicht gesetzt wird keine Nachricht gesendet.
-       <dd> Das MQTT-Topic zu dem publiziert wird. Es verwendet <code>/</code> als Trennzeichen für die Hierarchie.</dd>
+            Um eine leere Nachricht zu senden, muss eine leere Zeichenfolge (string) übergeben werden.</dd>
-
+        <dt class="optional">topic<span class="property-type">string</span></dt>
-       <dt class="optional">qos <span class="property-type">number</span></dt>
+        <dd>MQTT-Topic mit / (Schrägstrich) als Hierarchie-Trennzeichen</dd>
-       <dd>0: fire und forget 1: mindestens einmal 2: einmal und nur einmal. Default 0.</dd>
+        <dt class="optional">qos<span class="property-type">number</span></dt>
-
+        <dd>QoS (Quality of Service)<br/>
-       <dt class="optional">retain <span class="property-type">boolean</span></dt>
+            0: Einmal gesendet ohne Empfangsgarantie (fire und forget)<br/>
-       <dd>Wenn dieser Wert auf <code>true</code> gesetzt ist, wird die Nachricht auf dem Broker gehalten. Default false.</dd>
+            1: Garantiert mindestens einmal empfangen (at least once)<br/>
+            2: Garantiert exakt einmal empfangen (once and once only)</dd>
+        <dt class="optional">retain<span class="property-type">boolean</span></dt>
+        <dd>Bei <code>true</code> wird die Nachricht beim Broker aufbewahrt.
+            Standard (default) ist <code>false</code>.</dd>
     </dl>
     <h3>Details</h3>
-      <code> msg.payload </code>  wird als Nutzdaten der zu veröffentlichenden Nachricht verwendet.
+    <p><code>msg.payload</code> wird als Nutzdaten (Payload) der zu publizierenden Nachricht verwendet.
-      Wenn er ein Objekt enthält, wird es in eine JSON-Zeichenfolge konvertiert, bevor es gesendet wird.
+       Wenn es ein Objekt enthält, wird es vorm Senden in eine JSON-Zeichenfolge (string) konvertiert.
-      Wenn er einen binären Buffer enthält, wird die Nachricht unverändert veröffentlicht. </p>
+       Wenn es einen binären Puffer (buffer) enthält, wird die Nachricht unverändert gesendet.</p>
-      <p> Das verwendete Topic kann im Node konfiguriert werden oder, falls es leer gelassen wird,
+    <p>Das Topic kann im Node eingestellt werden oder, falls leer gelassen,
-      durch <code>msg.topic</code> festgelegt werden. </p>
+       durch <code>msg.topic</code> vorgegeben werden.</p>
-      <p> Ebenso können die QoS- und retain-Werte im Node konfiguriert werden oder, falls vorhanden,
+    <p>Ebenso können die QoS- und Retain-Werte im Node eingestellt werden oder, falls leer gelassen,
-      durch <code>msg.qos</code> bzw. <code>msg.retain</code> festgelegt werden. 
+       durch <code>msg.qos</code> bzw. <code>msg.retain</code> vorgegeben werden.
-      Sie können eine zuvor auf einem Topic auf dem Broker retainte Nachricht löschen,
+       Um ein beim Broker vorgehaltenes Topic zu löschen,
-      indem eine leere Nachricht an dieses Topic gesendet wird und die Markierung 'retain' gesetzt ist.</p>
+       kann eine leere Nachricht mit dem Topic und Retain gleich <code>true</code> gesendet werden.</p>
     <p>Dieser Node erfordert eine Verbindung zu einem MQTT-Broker, der über die Auswahlliste selektiert werden kann.
-      Eine neue Konfiguration wird durch Klicken auf das Stiftsymbol erstellt.</p>
+       Eine neue Verbindung wird durch Klicken auf das Stiftsymbol erstellt.</p>
-    <p>Mehrere MQTT-Nodes (in oder out) können bei Bedarf dieselbe Brokerverbindung nutzen.</p>
+    <p>Mehrere MQTT-Nodes (in oder out) können bei Bedarf dieselbe Broker-Verbindung nutzen.</p>
 </script>
 
 <script type="text/html" data-help-name="mqtt-broker">
-   <p> Konfiguration für eine Verbindung zu einem MQTT-Broker. </p>
+    <p>Konfiguration der Verbindung zu einem MQTT-Broker.</p>
-   <p> Diese Konfiguration erstellt eine Verbindung zu einem Broker, die anschließend von den 
+    <p>Diese Konfiguration erstellt eine einzelne Verbindung zu einem Broker,
-      Nodes <code>MQTT In</code> und <code>MQTT Out</code> verwendet werden. </p>
+       welche anschließend von den <span style="background-color:Gainsboro">mqtt&nbsp;in</span>- und
-   <p> Der Node generiert eine beliebige Client-ID, falls sie nicht definiert ist und der Node für die Verwendung
+       <span style="background-color:Gainsboro">mqtt out</span>-Nodes verwendet werden.</p>
-      einer bereinigten Sitzung (Clean Session) konfiguriert ist. Wenn eine Client-ID festgelegt ist, 
+    <p>Der Node generiert eine beliebige Client-ID, falls sie nicht vorgegeben ist und der
-      muss sie für den Broker, zu dem Sie eine Verbindung herstellen, eindeutig sein. </p>
+       Node eine bereinigte Sitzung (clean session) verwenden soll.
-   <h3> Nachricht bei Verbindungsaufbau </h3>
+       Wenn eine Client-ID vorgegeben wird, muss sie für den Broker eindeutig sein, zu dem die Verbindung hergestellt werden soll.</p>
-   <p> Dies ist eine Nachricht, die vom Broker in dem konfigurierten Topic veröffentlicht wird, wenn die Verbindung hergestellt wurde. </p>
+    <h3>Nachricht bei Verbindungsaufbau</h3>
-   <h3> Nachricht bei Verbindungsbeendigung </h3>
+    <p>Diese Nachricht wird vom Broker mit dem eingestellten Topic publiziert, wenn die Verbindung hergestellt wurde.</p>
-   <p> Dies ist eine Nachricht, die vom Broker in dem konfigurierten Topic veröffentlicht wird, wenn die Verbindung normal geschlossen wird -
+    <h3>Nachricht vor Verbindungsabbau</h3>
-      entweder durch erneute Implementierung des Nodes oder durch Herunterfahren von Node-RED. </p>
+    <p>Diese Nachricht wird vom Broker mit dem eingestellten Topic publiziert, bevor die Verbindung normal abgebaut wird,
-   <h3> Nachricht bei unerwarteter Verbindungsbeendigung</h3>
+       egal ob durch erneute Übernahme (deploy) des Nodes oder durch Herunterfahren von Node-RED.</p>
-   <p> Dies ist eine Nachricht, die vom Broker in dem konfigurierten Topic veröffentlicht wird,
+    <h3>Nachricht bei unerwarteten Verbindungsabbruch</h3>
-      wenn die Verbindung unerwartet geschlossen wird 
+    <p>Diese Nachricht wird vom Broker mit dem eingestellten Topic veröffentlicht,
-   <h3> WebSockets </h3>
+       wenn die Verbindung unerwartet abgebrochen ist.</p>
-   <p> Der Node kann für die Verwendung einer WebSocket-Verbindung konfiguriert werden.
+    <h3>WebSockets</h3>
-      Dazu wird im Server-Feld eine vollständigen URI für die Verbindung angegeben. Beispiel: </p>
+    <p>Der Node kann für die Verwendung einer WebSocket-Verbindung eingestellt werden.
-   <pre> ws://example.com:4000/mqtt </pre>
+       Dazu ist im Server-Feld die vollständige URI für die Verbindung vorzugeben. Beispiel:</p>
+    <pre>ws://example.com:4000/mqtt</pre>
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/21-httpin.html

@@ -15,83 +15,84 @@
 -->
 
 <script type="text/html" data-help-name="http in">
-    <p>Erstellt einen HTTP Endpunkt zur Erzeugung von Web Services.</p>
+    <p>Erstellung eines HTTP-Endpunktes zur Erzeugung von Web-Diensten.</p>
-    <h3>Outputs</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>Nutzdaten</dt>
+        <dt>payload</dt>
-        <dd>Für eine GET-Anforderung ist ein Objekt mit beliebigen Parametern der Abfragezeichenfolge oder der 
+        <dd>Für eine GET-Anforderung enthält es ein Objekt aller Abfrage-Parameter (query string parameters).
-            Hauptteil (Body) der HTTP-Anforderung enthalten</dd>
+            Ansonsten enthält es den Hauptteil (Body) der HTTP-Anforderung.</dd>
-        <dt>req<span class="property-type">Objekt</span></dt>
+        <dt>req<span class="property-type">object</span></dt>
-        <dd>Ein HTTP Anforderungsobjekt. Dieses Objekt enthält mehrere Eigenschaften, 
+        <dd>HTTP Anforderungsobjekt.<br/>
-            die Informationen zu der Anforderung bereitstellen.
+            Es enthält mehrere Eigenschaften, die Informationen zu der Anforderung bereitstellen.
             <ul>
-             <li><code>body</code> - Der Hauptteil der eingehenden Anforderung. Das Format hängt von der Anforderung ab.</li>
+                <li><code>body</code>: Hauptteil der eingehenden Anforderung. Das Format hängt von der Anforderung ab.</li>
-             <li><code>headers</code> - ein Objekt, dass den HTTP Header enthält.</li>
+                <li><code>headers</code>: Objekt mit HTTP-Request-Header</li>
-             <li><code>query</code> - ein Objekt, dass die Anfrage Parameter enthält.</li>
+                <li><code>query</code>: Objekt mit Anfrage-Parametern (query string parameters)</li>
-             <li><code>params</code> - ein Objekt, dass die Routing Parameter enthält</li>
+                <li><code>params</code>: Objekt mit den Routing-Parametern</li>
-             <li><code>cookies</code> - ein Objekt, dass die Cookies der Anfrage enthät..</li>
+                <li><code>cookies</code>: Objekt mit den Cookies der Anfrage</li>
-             <li><code>files</code> - wenn die Funktion aktieviert ist, enthält dieses Objekt alle Dateien, 
+                <li><code>files</code>: Objekt mit allen Dateien, die mit der POST-Anforderung gesendet wurden, sofern im Node aktiviert</li>
-                die mit der POST-Anforderung gesendet wurden.</li>
             </ul>
         </dd>
-        <dt>res<span class="property-type">Objekt</span></dt>
+        <dt>res<span class="property-type">object</span></dt>
-        <dd>Ein HTTP-Antwortobjekt. Diese Eigenschaft sollte nicht direkt verwendet werden.
+        <dd>HTTP-Antwortobjekt.<br/>
-            Der <code>HTTP Response</code> Node dokumentiert, wie auf eine Anforderung reagiert wird.
+            Diese Eigenschaft sollte nicht direkt verwendet werden.
-            Diese Eigenschaft muss an die Nachricht angehängt bleiben, die an den Antwort-Node übergeben wird.</dd>
+            Im <span style="background-color:Gainsboro">http&nbsp;response</span>-Node ist dokumentiert, wie auf eine Anforderung reagiert wird.
+            Diese Eigenschaft muss an der Nachricht angehängt bleiben, die an den Antwort-Node übergeben wird.</dd>
     </dl>
     <h3>Details</h3>
-    <p> Der Node ist auf dem konfigurierten Pfad für Anforderungen eines bestimmten Typs empfangsbereit.
+    <p>Der Node ist auf dem eingestellten Pfad für Anforderungen eines bestimmten Typs empfangsbereit.
        Der Pfad kann vollständig angegeben werden, z. B. <code>/user</code> oder benannte Parameter beinhalten,
        die einen beliebigen Wert akzeptieren, z. B. <code>/user/:name</code>.
-        Wenn benannte Parameter verwendet werden, kann auf ihren tatsachlichen Wert über <code> msg.req.params</code> 
+       Wenn benannte Parameter verwendet werden, kann auf ihren aktuellen Wert über <code>msg.req.params</code>
-        zugegriffen werden. </p>
+       zugegriffen werden.</p>
-    <p> Für Anforderungen, die einen Hauptteil enthalten, wie z.B. POST oder PUT, wird der Inhalt der 
+    <p>Für Anforderungen, die einen Hauptteil (Body) enthalten, wie z. B. POST oder PUT, wird der Inhalt der
        Anforderung über <code>msg.payload</code> verfügbar gemacht.</p>
-    <p> Wenn der Inhaltstyp der Anforderung ermittelt werden kann, wird der Hauptteil syntaktisch analysiert.
+    <p>Wenn der Inhaltstyp der Anforderung ermittelt werden kann, wird der Hauptteil als passender Typ analysiert.
-        Wenn zum Beispiel <code> application/json</code> erkannt wurde, die Darstellung in der JavaScript-Objekt Notation. </p>
+       Z. B. <code>application/json</code> wird zu einem JavaScript-Objekt analysiert.</p>
-    <p> <b> Hinweis:</b> Dieser Node sendet keine Antwort an die Anforderung. Der Flow
+    <p><b>Hinweis:</b> Dieser Node sendet keine Antwort an die Anforderung.
-        muss einen code>HTTP Response</code> Node enthalten, um die Anforderung abzuschließen. </p>
+       Der Flow muss einen <span style="background-color:Gainsboro">http&nbsp;response</span>-Node enthalten,
+       um die Anforderung zu vervollständigen.</p>
 </script>
 
 <script type="text/html" data-help-name="http response">
-    <p>Sendet Antworten auf Anforderungen, die von einem code>HTTP In</code> Node empfangen wurden. </p>
+    <p>Senden von Antworten auf Anforderungen, die von einem <span style="background-color:Gainsboro">http&nbsp;in</span>-Node empfangen wurden.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">Zeichenfolge</span> </dt>
+        <dt>payload<span class="property-type">string</span></dt>
-        <dd>Der Hauptteil der Antwort.</dd>
+        <dd>Hauptteil (Body) der Antwort</dd>
-        <dt class="optional">statusCode<span class="property-type">Zahl</span> </dt>
+        <dt class="optional">statusCode<span class="property-type">number</span></dt>
-        <dd>Wenn festgelegt wird diese als Antwortstatuscode verwendet. Standardwert: 200. </dd>
+        <dd>Wenn gesetzt, wird diese als Antwort-Statuscode verwendet. Standardwert: 200</dd>
-        <dt class="optional">Header<span class="property-type">Objekt</span> </dt>
+        <dt class="optional">headers<span class="property-type">object</span></dt>
-        <dd> Wenn festgelegt enthält es die HTTP-Header, die in die Antwort mit eingeschlossen werden sollen. </dd>
+        <dd>Wenn gesetzt, enthält es die HTTP-Header für die Antwort</dd>
-        <dt class="optional">Cookies<span class="property-type">Objekt</span> </dt>
+        <dt class="optional">cookies<span class="property-type">object</span></dt>
-        <dd> Wenn festgelegt kann es zum Setzen oder Löschen von Cookies verwendet werden. </dd>
+        <dd>Wenn gesetzt, kann es zum Setzen oder Löschen von Cookies verwendet werden</dd>
     </dl>
     <h3>Details</h3>
-    <p>Der <code>StatusCode</code> und die <code>Header</code> können auch innerhalb des Node gesetzt werden.
+    <p>Der <code>statusCode</code> und die <code>headers</code> können auch innerhalb des Node angegeben werden.
-        Wenn eine Eigenschaft innerhalb des Nodes festgelegt wird,
+       Wenn eine Eigenschaft innerhalb des Nodes angegeben ist,
        kann sie nicht durch die entsprechende Nachrichteneigenschaft überschrieben werden.</p>
-    <h4>Behandlung von Cookies</h4>
+    <h4>Cookie-Behandlung</h4>
-    <p> Die Eigenschaft <code>Cookies</code> muss ein Objekt mit Name/Wert-Paaren sein.
+    <p>Die <code>cookies</code>-Eigenschaft muss ein Objekt mit Name/Wert-Paaren sein.
-    Bei dem Wert kann es sich entweder um eine Zeichenfolge handeln, um den Wert des Cookies mit Standardwert festzulegen 
+       Bei dem Wert kann es sich entweder um eine Zeichenfolge (string) zur Festlegung des Cookies mit Standardwerten handeln
-    oder es kann ein Objekt mit Optionen sein. <p>
+       oder es kann ein Objekt mit Optionen sein.</p>
-    <p> Im folgenden Beispiel werden zwei Cookies festgelegt - einer mit dem Namen <code>name</code> mit
+    <p>Im folgenden Beispiel werden zwei Cookies festgelegt - einer mit dem Namen <code>name</code> und dem
-    einem Wert von <code>nick</code> und der andere als <code>session</code> mit einem Wert von 
+       Wert <code>nick</code> und der andere <code>session</code> mit dem Wert
-    <code>1234</code> und einer festgelegten Ablaufzeit von 15 Minuten. </p>
+       <code>1234</code> und einer festgelegten Ablaufzeit von 15 Minuten.</p>
        <pre>
 msg.cookies = {
     name: 'nick',
     session: {
         value: '1234',
         maxAge: 900000
-    } } </pre>
+    }
-    <p>Die gültigen Optionen sind: </p>
+}</pre>
+    <p>Die gültigen Optionen sind:</p>
     <ul>
-    <li><code>Domäne</code> -(Zeichenfolge) Domänenname für das Cookie </li>
+        <li><code>domain</code>: Domänenname für das Cookie, angegeben als Zeichenfolge (string)</li>
-    <li><code>expires</code> -(Datum) Ablaufzeit in GMT. Wenn Sie keinen Wert angeben oder auf 0 setzen, wird ein Sitzungscookie erstellt. </li>
+        <li><code>expires</code>: Ablaufzeit in GMT. Wenn nicht vorgeben oder Null (0), wird ein Sitzungscookie erstellt.</li>
-    <li><code>maxAge</code> -(Zeichenfolge) Ablaufzeit in Bezug auf die aktuelle Zeit in Millisekunden </li>
+        <li><code>maxAge</code>: Ablaufzeit in Bezug auf die aktuelle Zeit in Millisekunden, angegeben als Zeichenfolge (string)</li>
-    <li><code>Pfad</code> -(String) Pfad für das Cookie. Standardwert: / </li>
+        <li><code>path</code>: Pfad für das Cookie. Standardwert: / (Schrägstrich), angegeben als Zeichenfolge (string)</li>
-    <li><code>value</code> -(String) der Wert, der für das Cookie verwendet werden soll </li>
+        <li><code>value</code>: Wert, der für das Cookie verwendet werden soll, angegeben als Zeichenfolge (string)</li>
     </ul>
-    <p> Um ein Cookie zu löschen, setzen Sie seinen  <code>value</code> auf <code>null</code>. </p>
+    <p>Um ein Cookie zu löschen, ist sein <code>value</code> auf <code>null</code> zu setzen.</p>
-
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/21-httprequest.html

@@ -15,72 +15,84 @@
 -->
 
 <script type="text/html" data-help-name="http request">
-    <p>Sendet HTTP-Anforderungen und gibt die Antwort zurück.</p>
+    <p>Senden von HTTP-Anforderungen und Rückgabe der Antwort.</p>
-
+    <h3>Eingangsdaten</h3>
-    <h3>Eingaben</h3>
     <dl class="message-properties">
-        <dt class="optional">url <span class="property-type">String</span></dt>
+        <dt class="optional">url<span class="property-type">string</span></dt>
-        <dd>Wenn nicht im Node konfiguriert, setzt diese optionale Eigenschaft die URL der Anforderung.</dd>
+        <dd>Wenn nicht im Node eingestellt, setzt diese optionale Eigenschaft die URL der Anforderung</dd>
-        <dt class="optional">method <span class="property-type">String</span></dt>
+        <dt class="optional">method<span class="property-type">string</span></dt>
-        <dd>Wenn nicht im Node konfiguriert, setzt diese optionale Eigenschaft die HTTP-Methode der Anforderung.
+        <dd>Wenn nicht im Node eingestellt, setzt diese optionale Eigenschaft die HTTP-Methode der Anforderung
-            Muss einer von <code>GET</code>, <code>PUT</code>, <code>POST</code>, <code>PATCH</code> oder <code>DELETE</code> sein.</dd>
+            (<code>GET</code>, <code>PUT</code>, <code>POST</code>, <code>PATCH</code> oder <code>DELETE</code>)</dd>
-        <dt class="optional">headers <span class="property-type">Objekt</span></dt>
+        <dt class="optional">headers<span class="property-type">object</span></dt>
-        <dd>Setzt die HTTP-Header der Anforderung.</dd>
+        <dd>HTTP-Header der Anforderung</dd>
-        <dt class="optional">cookies <span class="property-type">Objekt</span></dt>
+        <dt class="optional">cookies<span class="property-type">object</span></dt>
-        <dd>Wenn gesetzt, kann es verwendet werden, um Cookies mit der Anforderung zu senden.</dd>
+        <dd>Wenn gesetzt, kann es verwendet werden, um Cookies mit der Anforderung zu senden</dd>
         <dt class="optional">payload</dt>
-        <dd>Wird als Hauptteil der Anforderung gesendet.</dd>
+        <dd>Hauptteil der Anforderung</dd>
         <dt class="optional">rejectUnauthorized</dt>
-        <dd>Wenn auf <code>false</code> gesetzt, können Anforderungen an https-Sites gesendet werden, die selbst signierte Zertifikate verwenden.</dd>
+        <dd>Wenn auf <code>false</code> gesetzt, können Anforderungen an https-Sites gesendet werden, die selbst signierte Zertifikate verwenden</dd>
         <dt class="optional">followRedirects</dt>
-        <dd>Wenn auf <code>false</code> gesetzt, wird ein folgendes Redirect (HTTP 301) verhindert. 
+        <dd>Wenn auf <code>false</code> gesetzt, wird ein nachfolgendes Redirect (HTTP 301) verhindert.
-            In der Standardeinstellung ist <code>true</code>.</dd>
+            Standard ist <code>true</code>.</dd>
         <dt class="optional">requestTimeout</dt>
         <dd>Wenn dieser Wert auf eine positive Zahl eingestellt ist,
-            wird damit der global eingestellte Parameter <code>httpRequestTimeout</code> überschrieben.</dd>
+            wird damit der global eingestellte Parameter <code>httpRequestTimeout</code> überschrieben</dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">String | Objekt | Buffer</span></dt>
+        <dt>payload<span class="property-type">string | object | buffer</span></dt>
-        <dd>Der Hauptteil der Antwort. Der Node kann konfiguriert werden, um den Hauptteil als String zurückzugeben,
+        <dd>Hauptteil der Antwort.<br/>
-            zu versuchen, ihn als JSON-String zu analysieren oder ihn als binären Buffer zu belassen.</dd>
+            Der Node kann eingestellt werden, um den Hauptteil als String zurückzugeben,
-        <dt>statusCode <span class="property-type">Zahl</span></dt>
+            zu versuchen, ihn als JSON-String zu analysieren oder ihn als binären Puffer (buffer) zu belassen.</dd>
-        <dd>Der Statuscode der Antwort oder der Fehlercode, wenn die Anforderung nicht abgeschlossen werden konnte.</dd>
+        <dt>statusCode<span class="property-type">number</span></dt>
-        <dt>headers <span class="property-type">Objekt</span></dt>
+        <dd>Statuscode der Antwort oder der Fehlercode, wenn die Anforderung nicht abgeschlossen werden konnte</dd>
-        <dd>Ein Objekt, das die HTTP-Header der Antwort enthält.</dd>
+        <dt>headers<span class="property-type">object</span></dt>
-        <dt>responseUrl <span class="property-type">String</span></dt>
+        <dd>Objekt mit dem HTTP-Header der Antwort</dd>
+        <dt>responseUrl<span class="property-type">string</span></dt>
         <dd>Falls während der Bearbeitung der Anforderung Umleitungen aufgetreten sind, ist diese Eigenschaft die letzte umgelenkte URL.
             Andernfalls die URL der ursprünglichen Anforderung.</dd>
-        <dt>responseCookies <span class="property-type">Objekt</span></dt>
+        <dt>responseCookies<span class="property-type">object</span></dt>
-        <dd>Wenn die Antwort Cookies enthält, ist dieses Element ein Objekt von Namen/Wertpaaren für jedes Cookie.</dd>
+        <dd>Wenn die Antwort Cookies enthält, ist dieses Element ein Objekt von Name/Wert-Paaren für jedes Cookie</dd>
     </dl>
     <h3>Details</h3>
-    <p>Wenn innerhalb des Nodes konfiguriert, kann die URL-Eigenschaft
+    <p>Wenn innerhalb des Nodes eingestellt, kann die URL-Eigenschaft
-        <a href="http://mustache.github.io/mustache.5.html" target="_blank">mustache-style</a> Tags enthalten. 
+       <a href="http://mustache.github.io/mustache.5.html" target="_blank">mustache-style</a>-Tags enthalten.
-        Diese ermöglicht es, die URL aus den Werten der eingehenden Nachricht aufzubauen. 
+       Diese ermöglichen es, die URL aus den Werten der eingehenden Nachricht aufzubauen.
-        Wenn die URL beispielsweise auf <code>example.com/{{{topic}}}</code> gesetzt ist, 
+       Wenn die URL beispielsweise <code>example.com/{{{topic}}}</code> lautet,
        wird der Wert von <code>msg.topic</code> automatisch eingefügt.
-        Die Verwendung von {{{....}} hindert den Mustache am Escaping von Zeichen wie / & etc.</p>
+       Die Verwendung von {{{...}} hindert Mustache am Escaping von Zeichen wie z. B. / & usw.</p>
-    <p><b>Note</b>: Wenn Node-RED hinter einem Proxy läuft, sollte die Umgebungsvariable <code>http_proxy=...</code> gesetzt 
+    <p><b>Hinweis:</b> Wenn Node-RED hinter einem Proxy läuft, sollte die Umgebungsvariable <code>http_proxy=...</code>
-        und Node-RED neu gestartet werden, oder eine Proxy Konfiguration wird verwendet. 
+       gesetzt und Node-RED neu gestartet werden.
-        Wenn die Proxy-Konfiguration verwendet wird, hat diese Konfiguration Vorrang vor der Umgebungsvariablen.</p>
+       Alternativ kann eine Proxy-Konfiguration verwendet werden, die dann Vorrang vor der Umgebungsvariable hat.</p>
-    <h4>Verwendung mehrerer HTTP-Anforderungs-Node</h4>
+    <h4>Verwendung mehrerer HTTP-Anforderungs-Nodes</h4>
-    <p>Um mehr als einen dieser Node im gleichen Flow verwenden zu können,
+    <p>Um mehr als einen dieser Nodes im gleichen Flow verwenden zu können,
-        ist Vorsicht bei der Verwendung der Eigenschaft <code>msg.headers</code> geboten 
+       ist Aufmerksamkeit bei der Verwendung der <code>msg.headers</code>-Eigenschaft gefordert.
-        Der erste Node setzt diese Eigenschaft mit  dem Antwortheader.
+       Der erste Node setzt diese Eigenschaft mit dem Antwort-Header.
-        Der nächste Node verwendet dann diese Header für seine Anfrage - diese sind aber in der Regel nicht die Richtigen.
+       Der nächste Node verwendet dann diesen Header für seine Anfrage, was aber nicht die richtige Art und Weise ist.
-        Wenn die Eigenschaft <code>msg.headers</code> zwischen den Nodes unverändert bleibt, wird sie vom zweiten Node ignoriert.
+       Wenn die <code>msg.headers</code>-Eigenschaft zwischen den Nodes unverändert bleibt, wird sie vom zweiten Node ignoriert.
-        Um benutzerdefinierte Header festzulegen, sollte <code>msg.headers</code> zuerst gelöscht 
+       Um benutzerdefinierte Header festzulegen, sollte <code>msg.headers</code> zuerst gelöscht oder
-        oder auf ein leeres Objekt gesetzt werden: <code>{}</code>.</p>
+       auf ein leeres Objekt gesetzt werden: <code>{}</code></p>
     <h4>Behandlung von Cookies</h4>
-    <p>Die an den Node übergebene Eigenschaft <code>cookies</code> muss ein Objekt von Name/Wert Paaren sein.
+    <p>Die an den Node übergebene <code>cookies</code>-Eigenschaft muss ein Objekt von Name/Wert-Paaren sein.
        Der Wert kann entweder ein String sein, um den Wert des Cookies zu setzen,
-        oder es kann ein Objekt mit einer einzigen <code>value</code> Eigenschaft sein.<p>
+       oder es kann ein Objekt mit einer einzigen <code>value</code>-Eigenschaft sein.<p>
-    <p>Alle von der Anforderung zurückgegebenen Cookies werden unter der Eigenschaft <code>responseCookies</code> zurückgegeben.</p>
+    <p>Alle auf Anforderung zurückgegebene Cookies werden über die <code>responseCookies</code>-Eigenschaft zurückgegeben.</p>
     <h4>Behandlung von Content-Typen</h4>
     <p>Wenn <code>msg.payload</code> ein Objekt ist, setzt der Node automatisch den Inhaltstyp der Anforderung
        auf <code>application/json</code> und kodiert den Hauptteil als solchen.</p>
-    <p>Um die Anforderung als Formulardaten zu kodieren, 
+    <p>Um die Anforderung als Formulardaten zu kodieren, sollte <code>msg.headers["content-type"]</code> auf
-        sollte <code>msg.headers["content-type"]</code> auf <code>application/x-wwww-form-urlencoded</code> gesetzt werden.</p>
+       <code>application/x-wwww-form-urlencoded</code> gesetzt werden.</p>
-
+    <h4>Datei-Upload</h4>
+    <p>Um einen Datei-Upload umzusetzen, sollte <code>msg.headers["content-type"]</code> auf <code>multipart/form-data</code>
+       gesetzt werden und das an den Node zu sendende <code>msg.payload</code> muss ein Objekt mit folgender Struktur sein:</p>
+    <pre><code>{
+    "KEY": {
+        "value": FILE_CONTENTS,
+        "options": {
+            "filename": "FILENAME"
+        }
+    }
+}</code></pre>
+    <p>Die Inhalte von <code>KEY</code>, <code>FILE_CONTENTS</code> und <code>FILENAME</code>
+       sollten auf passende Werte gesetzt sein.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/22-websocket.html

@@ -15,28 +15,28 @@
 -->
 
 <script type="text/html" data-help-name="websocket in">
-    <p>WebSocket Eingangs-Node.</p>
+    <p>WebSocket-Eingangs-Node.</p>
     <p>Standardmäßig befinden sich die vom WebSocket empfangenen Daten in <code>msg.payload</code>.
-        Der Socket kann konfiguriert werden, um einen korrekt gebildeten JSON-String zu erwarten,
+       Der Socket kann eingestellt werden, einen korrekt gebildeten JSON-Zeichenfolge (string) zu erwarten.
-        in diesem Fall wird er das JSON analysieren und das resultierende Objekt als gesamte Nachricht senden.</p>
+       In diesem Fall wird das JSON analysiert (parse) und das resultierende Objekt als gesamte Nachricht gesendet.</p>
 </script>
 
 <script type="text/html" data-help-name="websocket out">
-    <p>WebSocket Ausgabe-Node.</p>
+    <p>WebSocket-Ausgang-Node.</p>
     <p>Standardmäßig wird <code>msg.payload</code> über den WebSocket gesendet.
-       Der Socket kann so konfiguriert werden, dass er das gesamte <code>msg</code> Objekt als JSON-String kodiert und über den WebSocket sendet.</p>
+       Der Socket kann eingestellt werden, das gesamte <code>msg</code>-Objekt als JSON-Zeichenfolge (string) zu kodieren und
-
+       über den WebSocket zu senden.</p>
-    <p>Wenn die an diesem Node ankommende Nachricht an einem WebSocket-Eingangs-Node begann,
+    <p>Wenn die an diesem Node ankommende Nachricht von einem WebSocket-Eingangs-Node ausgeht,
        wird die Nachricht an den Client zurückgesendet, der den Flow ausgelöst hat.
-        Andernfalls wird die Nachricht an alle verbundenen Clients gesendet..</p>
+       Andernfalls wird die Nachricht an alle verbundenen Clients gesendet.</p>
-    <p>Wenn eine Nachricht, die an einem WebSocket-Eingangsnoten gestartet wurde, an alle verbunden Clients gesendet werden soll,
+    <p>Wenn eine von einem WebSocket-Eingangs-Node ausgehende Nachricht an alle verbundenen Clients gesendet werden soll,
-        muss die Eigenschaft <code>msg._session</code> innerhalb des Flow gelöscht werden.</p>
+       muss die <code>msg._session</code>-Eigenschaft im Flow gelöscht werden.</p>
 </script>
 
 <script type="text/html" data-help-name="websocket-listener">
-   <p>Dieser Konfigurations-Node erstellt einen WebSocket Server-Endpunkt unter Verwendung des angegebenen Pfades.</p>
+    <p>Konfigurations-Node zur Erstellung eines WebSocket-Server-Endpunktes mit vorgegebenen Pfad.</p>
 </script>
 
 <script type="text/html" data-help-name="websocket-client">
-   <p>Dieser Konfigurations-Node verbindet einen WebSocket-Client mit der angegebenen URL.</p>
+    <p>Konfigurations-Node zur Verbindung eines WebSocket-Clients mit vorgegebener URL.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/31-tcpin.html

@@ -15,31 +15,33 @@
 -->
 
 <script type="text/html" data-help-name="tcp in">
-    <p>Bietet eine Auswahl an TCP-Eingängen. Kann sich entweder mit einem entfernten TCP-Port verbinden oder eingehende Verbindungen akzeptieren.</p>
+    <p>TCP-Eingang zur Verbindung mit einem entfernten TCP-Port oder Akzeptanz eingehender Verbindungen.</p>
-    <p><b>Note: </b>Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
+    <p><b>Hinweis:</b> Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administrator-Zugriffsrechte,
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+       um Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
 </script>
 
 <script type="text/html" data-help-name="tcp out">
-    <p>Bietet eine Auswahl an TCP-Ausgängen. Kann sich entweder mit einem entfernten TCP-Port verbinden,
+    <p>TCP-Ausgang zur Verbindung mit einem entfernten TCP-Port, Akzeptanz eingehender Verbindungen oder
-       eingehende Verbindungen akzeptieren oder auf Nachrichten antworten, die von einem TCP-In-Node empfangen werden.</p>
+       Antwort auf Nachrichten, die von einem <b>tcp&nbsp;in</b>-Node empfangen werden.</p>
-       <p>Nur der Inhalt von <code>msg.payload</code> wird gesendet.</p>
+    <p>Nur der <code>msg.payload</code>-Inhalt wird gesendet.</p>
-    <p>Wenn <code>msg.payload</code> einen String beinhaltet, die eine Base64-Kodierung von binären
+    <p>Wenn <code>msg.payload</code> einen String mit Base64-Kodierung von binären Daten beinhaltet,
-        Daten darstellt, wird die <code>Dekodiere Base64</codes> Option dazu führen, 
+       bewirkt die Option <i>Base64-Nachricht dekodieren</i>,
-        dass sie wieder in Binärdaten umgewandelt wird bevor sie verschickt werden.</p>
+       dass sie vorm Senden wieder in Binärdaten umgewandelt wird.</p>
-    <p>Wenn <code>msg._session</code> nicht vorhanden ist, wird der Payload an <b>alle</b> alle verbundenen Clients gesendet.</p>
+    <p>Wenn <code>msg._session</code> nicht vorhanden ist,
-    <p><b>Note: </b>Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
+       werden die Nutzdaten (Payload) an <b>alle</b> verbundenen Clients gesendet.</p>
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+    <p><b>Hinweis:</b> Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administrator-Zugriffsrechte,
+       um Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
 </script>
 
 <script type="text/html" data-help-name="tcp request">
-    <p>Ein einfacher TCP-Anforderungs-Node - sendet die <code>msg.payload</code> an einen Server-TCP-Port und erwartet eine Antwort.</p>
+    <p>Einfacher TCP-Anforderungs-Node zum
-    <p>Verbindet sich, sendet die "Anforderung" und liest die "Antwort". Der Node wartet entweder auf eine vorgegebene Anzahl von
+       Senden von <code>msg.payload</code> an einen Server-TCP-Port und erwarten einer Antwort.</p>
-        Zeichen in einen festen Buffer, auf ein bestimmtes Zeichen oder einen festen Timeout ab der ersten Antwort,
+    <p>Der Node verbindet sich, sendet einen <i>request</i> (Anfrage) und liest den <i>response</i> (Antwort).
-        bevor er die Verbindug schliesst und die Daten an den Flow zurück gibt. 
+       Er kann entweder eine vorgegebene Zeichenanzahl in einem festen Puffer abzählen,
-        Alternativ hält der Node die Verbindung ständig offen. </p>
+       auf ein passendes Zeichen zur Rückkehr reagieren, ein festes Zeitlimit ab der ersten Antwort abwarten und dann rückkehren,
-    <p>Die Antwort wird in <code>msg.payload</code> als Buffer ausgegeben, so dass sie unter Umständen mit einer
+       endlos auf Daten warten oder sofort die Verbindug schliessen, ohne auf Antwort zu warten.</p>
-        <code> .toString()>/code> Funktion umgewandelt werden müssen.</p>
+    <p>Die Antwort wird in <code>msg.payload</code> als binärer Puffer (buffer) ausgegeben,
-    <p>Wenn <code>tcp host</code> oder <code>port</code> leer gelassen werden, 
+       sodass sie ggf. mit der <code>.toString()</code>-Funktion umgewandelt werden kann.</p>
-        müssen diese mit den Eigenschaften <code>msg.host</code> und <code>msg.port</code> übergeben werden.</p>
+    <p>Wenn <i>Server</i> oder <i>Port</code> nicht vorgegeben werden,
+       müssen diese mit den <code>msg.host</code>- und <code>msg.port</code>-Eigenschaften übergeben werden.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/network/32-udp.html

@@ -15,20 +15,21 @@
 -->
 
 <script type="text/html" data-help-name="udp in">
-    <p>Ein UDP-Eingangs-Node, der eine <code>msg.payload</code> erzeugt, die einen
+    <p>UDP-Eingangs-Node zur Erzeugung einer <code>msg.payload</code> mit Buffer, String oder base64-kodierten String.
-        Buffer, Strings oder base64-kodierter String enthält. Multicast wird unterstützt.</p>
+       Multicast wird unterstützt.</p>
-    <p>Über die Eigenschaften <code>msg.ip</code> und <code>msg.port</code> kann auf die Werte der 
+    <p>Über die Eigenschaften <code>msg.ip</code> und <code>msg.port</code> können IP-Addresse und Port vorgeben werden,
-    IP Addresse und des Ports zugegriffen werden, von dem die Nachtricht empfangen wurde.</p>
+       von dem die Nachtrichten empfangen werden.</p>
-    <p><b>Note</b>: Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
+    <p><b>Hinweis:</b> Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administrator-Zugriffsrechte,
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+       um Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
 </script>
 
 <script type="text/html" data-help-name="udp out">
-    <p>Dieser Node sendet <code>msg.payload</code> an den angegebenen UDP-Host und Port. Multicast wird unterstützt.</p>
+    <p>UDP-Ausgangs-Node zum Senden von <code>msg.payload</code> an vorgegebenen UDP-Host und -Port.
-    <p>Sie können <code>msg.ip</code> und <code>msg.port</code> verwenden, um die Zielwerte festzulegen, 
+       Multicast wird unterstützt.</p>
-        aber die statisch im Node konfigurierten Werte haben Vorrang.</p>
+    <p>Über die Eigenschaften <code>msg.ip</code> und <code>msg.port</code> können IP-Addresse und Port vorgeben werden,
-    <p>Wenn Sie Broadcast auswählen, stellen Sie entweder die Adresse auf die lokale Broadcast-IP-Adresse 
+       an den die Nachtrichten gesendet werden. Statisch im Node vorgebene Werte haben aber Vorrang.</p>
-        oder versuchen Sie es mit 255.255.255.255, was die globale Broadcast-Adresse ist.</p>
+    <p>Bei Verwendung von Broadcast sollte die Adresse auf die lokale Broadcast-IP-Adresse oder
-    <p><b>Note</b>: Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
+       auf 255.255.255.255 (globale Broadcast-Adresse) eingestellt werden.</p>
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+    <p><b>Hinweis:</b> Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administrator-Zugriffsrechte,
+       um Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/parsers/70-CSV.html

@@ -15,33 +15,43 @@
 -->
 
 <script type="text/html" data-help-name="csv">
-    <p>Konvertiert zwischen einem CSV-formatierten String und ihrer JavaScript-Objektdarstellung in beide Richtungen.</p>
+    <p>Konvertierung zwischen einer CSV-formatierten Zeichenfolge (string) und ihrer JavaScript-Objektdarstellung in beide Richtungen.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | Array | String</span></dt>
+        <dt>payload<span class="property-type">object | array | string</span></dt>
-        <dd>Ein JavaScript Objekt, Array oder CSV String.</dd>
+        <dd>JavaScript-Objekt, Array oder CSV-Zeichenfolge</dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | Array | String</span></dt>
+        <dt>payload<span class="property-type">object | array | string</span></dt>
         <dd>
             <ul>
-            <li>Wenn die Eingabe ein String ist, wird versucht sie als CSV zu analysieren und
+                <li>Wenn die Eingangsdaten ein Zeichenfolge (string) sind, wird versucht, sie als CSV zu analysieren (parse),
-                es wird für jede Zeile ein JavaScript-Objekt mit Schlüssel/Wertpaaren erstellt. 
+                    und es wird für jede Zeile ein JavaScript-Objekt mit Schlüssel/Wert-Paaren erstellt.
-                Der Node sendet dann entweder eine Nachricht für jede Zeile oder eine einzelne Nachricht mit einem Array von Objekten.</li>
+                    Der Node sendet dann entweder eine Nachricht für jede CSV-Zeile oder
-            <li>Wenn die Eingabe ein JavaScript-Objekt ist, wird versucht ein CSV-String zu erzeugen.</li>
+                    eine einzige Nachricht mit einem Array von Objekten.</li>
-            <li>Wenn die Eingabe ein Array mit einfachen Werten ist, wird ein einzeiliger CSV-String erstellt.</li>
+                <li>Wenn die Eingangsdaten ein JavaScript-Objekt sind, wird versucht, eine CSV-Zeichenfolge zu erzeugen</li>
-            <li>Wenn die Eingabe ein Array von Arrays oder ein Array von Objekten ist, wird ein mehrzeiliger CSV-String erstellt.</li>
+                <li>Wenn die Eingangsdaten ein Array mit einfachen Werten sind, wird eine einzeilige CSV-Zeichenfolge erstellt</li>
+                <li>Wenn die Eingangsdaten ein Array von Arrays oder Objekten sind, wird ein mehrzeiliger CSV-Zeichenfolge erstellt</li>
             </ul>
         </dd>
     </dl>
     <h3>Details</h3>
-    <p>Die Spaltenvorlage kann eine geordnete Liste von Spaltennamen enthalten. Bei der Konvertierung von CSV in ein Objekt werden die 
+    <p>Die Spaltenvorlage besteht aus der geordneten und durch Komma getrennten Liste der Spaltennamen.
-        Spaltennamen als Eigenschaftsname verwendet. Alternativ können die Spaltennamen auch aus der ersten Zeile des CSV übernommen werden.</p>
+       Bei der Konvertierung von CSV nach Objekt werden die Spaltennamen als Eigenschaftsnamen verwendet.
+       Alternativ können die Spaltennamen auch aus der ersten Zeile des CSV übernommen werden.</p>
     <p>Bei der Konvertierung nach CSV wird die Spaltenvorlage verwendet, um festzustellen,
        welche Eigenschaften aus dem Objekt in welcher Reihenfolge extrahiert werden sollen.</p>
-    <p>Wenn die Eingabe ein Array ist, wird die Spaltenvorlage nur verwendet, um optional eine Reihe von Spaltentiteln zu erzeugen.</p>
+    <p>Wenn die Spaltenvorlage nicht vorgegeben ist, kann eine einfache, Komma getrennte Liste über
-    <p>Der Node kann eine mehrteilige Eingabe akzeptieren, solange die Eigenschaft <code>parts</code> korrekt gesetzt ist.</p>
+       die <code>msg.columns</code>-Eigenschaft übergeben werden, um vorzugeben, was der Node extrahieren soll.
-    <p>Wenn mehrere Nachrichten ausgeben werden, sind ihre <code>parts</code>-Eigenschaft festgelegt und sie bilden eine vollständige Nachrichtensequenz.</p>
+       Wenn das nicht vorgegeben ist, werden alle Objekt-Eigenschaften in der Reihenfolge ausgegeben,
-    <p><b>Note:</b> die Spaltenvorlage muss kommagetrennt sein - auch wenn für die Daten ein anderes Trennzeichen gewählt wird.</p>
+       wie die Eigenschaften in der ersten Zeile gefunden wurden.</p>
+    <p>Wenn die Eingangsdaten ein Array sind, wird die Spaltenvorlage nur verwendet,
+       um optional eine Reihe von Spaltentiteln zu erzeugen.</p>
+    <p>Mit der Option <i>Zahlenwerte ermitteln</i> werden Zeichenfolgen als Zahlenwerte ausgewertet, z. B. der mittlere Wert der CSV-Zeile <code>1,"1.5",2</code></p>
+    <p>Mit der Option <i>Leere Zeichenfolgen (string) einbeziehen</i> werden auch leere Zeichenfolgen übergeben, z. B. der mittlere Wert der CSV-Zeile <code>"1","",3</code></p>
+    <p>Mit der Option <i>Nullwerte einbeziehen</i> werden auch Nullwerte rückgegeben, z. B. der mittlere Wert der CSV-Zeile <code>"1",,3</code></p>
+    <p>Der Node kann mehrteilige Eingangsdaten akzeptieren, solange die <code>parts</code>-Eigenschaft korrekt gesetzt ist.</p>
+    <p>Wenn mehrere Nachrichten ausgegeben werden, sind ihre <code>parts</code>-Eigenschaften gesetzt und sie bilden eine vollständige Nachrichtensequenz.</p>
+    <p><b>Hinweis:</b>Die Spaltenvorlage muss Komma-getrennt sein, auch wenn für die Daten ein anderes Trennzeichen gewählt wird.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/parsers/70-HTML.html

@@ -15,23 +15,23 @@
 -->
 
 <script type="text/html" data-help-name="html">
-    <p>Extrahiert unter Verwendung eines CSS-Selektors Elemente aus einem HTML-Dokument, das sich in <code>msg.payload</code> befindet.</p>
+    <p>Extraktion von Elementen unter Verwendung eines CSS-Selektors aus einem HTML-Dokument, das sich in <code>msg.payload</code> befindet.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-    <dt>payload <span class="property-type">String</span></dt>
+        <dt>payload<span class="property-type">string</span></dt>
-    <dd>der html-String, aus der Elemente extrahiert werden sollen.</dd>
+        <dd>HTML-Zeichenfolge (string), aus dem Elemente extrahiert werden sollen</dd>
-    <dt class="optional">select <span class="property-type">String</span></dt>
+        <dt class="optional">select<span class="property-type">string</span></dt>
-    <dd>wenn nicht im Edit-Panel konfiguriert, kann der Selektor als Eigenschaft der Nachricht übergeben werden.</dd>
+        <dd>Sofern nicht im Node vorgegeben, kann der Selektor auch als <code>msg.select</code>-Eigenschaft übergeben werden</dd>
-</dl>
+    </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">Array | String</span></dt>
+        <dt>payload<span class="property-type">array | string</span></dt>
-        <dd>das Ergebnis kann entweder eine einzelne Nachricht mit eine, Payload sein, das ein Array der übereinstimmenden Elemente enthält
+        <dd>Das Ergebnis kann entweder eine einzelne Nachricht mit dem Array der passendes Elemente oder
-            oder mehrere Nachrichten, die jeweils ein passendes Element enthalten. 
+            mehrere Nachrichten mit je einem passenden Element sein.
-            Wenn mehrere Nachrichten gesendet werden, haben sie auch <code>parts</code> gesetzt.</dd>
+            Wenn mehrere Nachrichten gesendet werden, enthalten sie auch die <code>parts</code>-Eigenschaft.</dd>
     </dl>
     <h3>Details</h3>
-    <p>Dieser Node unterstützt eine Kombination aus CSS- und jQuery-Selektoren. Siehe die
+    <p>Dieser Node unterstützt eine Kombination aus CSS- und jQuery-Selektoren.
-        <a href="https://github.com/fb55/CSSselect#user-content-supported-selectors" target="_blank">css-select Dokumentation</a> 
+       Siehe die <a href="https://github.com/fb55/CSSselect#user-content-supported-selectors" target="_blank">css-select Dokumentation</a>
        für weitere Informationen über die unterstützte Syntax.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/parsers/70-JSON.html

@@ -15,37 +15,40 @@
 -->
 
 <script type="text/html" data-help-name="json">
-    <p>Konvertiert zwischen einem JSON-String und seiner JavaScript-Objektdarstellung in beide Richtungen.</p>
+    <p>Konvertierung zwischen JSON-Zeichenfolge (string) und JavaScript-Objektdarstellung in beide Richtungen.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
+        <dt>payload<span class="property-type">object | string</span></dt>
-        <dd>Ein JavaScript Objekt oder ein String.</dd>
+        <dd>JavaScript-Objekt oder JSON-Zeichenfolge (string)</dd>
-        <dt>schema<span class="property-type">Objekt</span></dt>
+        <dt>schema<span class="property-type">object</span></dt>
-        <dd>Ein optionales JSON Schema Objekt gegen das das JSON Objekt validiert wird.</dd>
+        <dd>Optionales JSON-Schema-Objekt, gegen das das JSON-Objekt validiert wird</dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
+        <dt>payload<span class="property-type">object | string</span></dt>
         <dd>
             <ul>
-                <li>Wenn die Eingabe ein JSON-String ist, wird versucht ihn in ein JavaScript-Objekt zu parsen..</li>
+                <li>Wenn die Eingangsdaten eine JSON-Zeichenfolge (string) darstellen, wird versucht sie in ein JavaScript-Objekt zu analysieren (parsen).</li>
-                <li>Wenn die Eingabe ein JavaScript-Objekt ist, wird ein JSON-String erstellt. Der String kann optional gut formatiert werden.</li>
+                <li>Wenn die Eingangsdaten ein JavaScript-Objekt darstellen, wird eine JSON-Zeichenfolge (string) erstellt.
+                    Die Zeichenfolge (string) kann optional gut leserlich formatiert werden.</li>
             </ul>
         </dd>
-        <dt>schemaError<span class="property-type">Array</span></dt>
+        <dt>schemaError<span class="property-type">array</span></dt>
-        <dd>Wenn die JSON-Schemavalidierung fehlschlägt, wird für den <code>Catch</code> Node eine <code>schemaError</code> Eigenschaft erstellt,
+        <dd>Wenn die JSON-Schema-Validierung fehlschlägt, wird für den <span style="background-color:Gainsboro">catch</span>-Node eine <code>schemaError</code>-Eigenschaft erstellt,
-            die ein Array von Fehlern enthält.</dd>
+            die ein Array von Fehlern enthält</dd>
     </dl>
     <h3>Details</h3>
-    <p>Standardmäßig arbeitet der Node mit <code>msg.payload</code>, kann aber so konfiguriert werden, dass eine beliebige
+    <p>Standardmäßig verarbeitet der Node <code>msg.payload</code>,
-        Nachrichteneigenschaft konvertiert wird.</p>
+       kann aber auch eine beliebige Nachrichteneigenschaft konvertieren.</p>
-    <p>Der Node kann auch konfiguriert werden, um eine bestimmte Kodierung sicherzustellen, anstatt zwischen den beiden umzuschalten.
+    <p>Die Konvertierungsrichtung kann im Node auch vorgegeben werden, um eine bestimmte Ziel-Kodierung sicherzustellen.
-        Dies kann z.B. mit dem <code>HTTP In</code> Node benutzt werden, um sicherzustellen, dass der Payload ein analysiertes Objekt ist,
+       Dies kann z. B. zusammen mit dem <span style="background-color:Gainsboro">http&nbsp;in</span>-Node benutzt werden, um sicherzustellen,
-        auch wenn eine eingehende Anfrage seinen Inhaltstyp nicht korrekt eingestellt hat, damit der <code>HTTP In</code> Node
+       dass die Nutzdaten (Payload) ein analysiertes (parsed) Objekt ist,
-        die Konvertierung durchführen kann.</p>
+       auch wenn eine eingehende Anfrage seinen Inhaltstyp nicht korrekt eingestellt hat,
-    <p>Wenn der Node so konfiguriert ist, dass die Eigenschaft als String kodiert wird, und es einen String empfängt,
+       damit der <span style="background-color:Gainsboro">http&nbsp;in</span>-Node die Konvertierung durchführen kann.</p>
+    <p>Wenn der Node auf Zeichenfolgen-Eingang (string) eingestellt ist und es einen String empfängt,
        werden keine weiteren Prüfungen der Eigenschaft durchgeführt.
-        Es wird weder prüfen, ob der String ein gültiges JSON enthält noch wird er ihn neu formatieren, wenn die Format-Option ausgewählt ist.</p>
+       Der Node prüft weder, ob die Zeichenfolge (string) ein gültiges JSON enthält, noch wird er ihn neu formatieren,
-    <p>Für weitere Details über das JSON-Schema 
+       wenn die Format-Option ausgewählt ist.</p>
-        können Sie die <a href="http://json-schema.org/latest/json-schema-validation.html">Spezifikation</a> einsehen.</p>
+    <p>Für weitere Details über das JSON-Schema siehe die
+       <a href="http://json-schema.org/latest/json-schema-validation.html">JSON-Schema-Spezifikation</a>.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/parsers/70-XML.html

@@ -15,29 +15,31 @@
 -->
 
 <script type="text/html" data-help-name="xml">
-    <p>Konvertiert zwischen einem XML-String und seiner JavaScript-Objektdarstellung - in beiden Richtungen.</p>
+    <p>Konvertierung zwischen XML-Zeichenfolge (string) und JavaScript-Objekt in beiden Richtungen.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
+        <dt>payload<span class="property-type">object | string</span></dt>
-        <dd>Ein JavaScript Objekt oder ein XML String.</dd>
+        <dd>JavaScript-Objekt oder XML-Zeichenfolge (string)</dd>
-        <dt class="optional">options <span class="property-type">Objekt</span></dt>
+        <dt class="optional">options<span class="property-type">object</span></dt>
-        <dd>This optional property can be used to pass in any of the options supported by the underlying
+        <dd>Optionale Eigenschaft zur Übergabe von Optionen an die Konvertier-Bibliothek von und zu XML.
-            library used to convert to and from XML. See <a href="https://github.com/Leonidas-from-XIV/node-xml2js/blob/master/README.md#options" target="_blank">the xml2js docs</a>
+            Siehe <a href="https://github.com/Leonidas-from-XIV/node-xml2js/blob/master/README.md#options" target="_blank">xml2js Dokumente</a>
-            for more information.</dd>
+            für weitere Informationen.</dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
+        <dt>payload<span class="property-type">object | string</span></dt>
         <dd>
             <ul>
-                <li>Wenn die Eingabe ein String ist, wird versucht sie als XML zu analysieren und daraus ein JavaScript-Objekt zu erstellen.</li>
+                <li>Wenn die Eingangsdaten eine Zeichenfolge (string) sind,
-                <li>Wenn die Eingabe ein JavaScript-Objekt ist, wird versucht ein XML-String zu erstellen.</li>
+                    wird versucht sie als XML zu analysieren (parse) und daraus ein JavaScript-Objekt zu erstellen.</li>
+                <li>Wenn die Eingangsdaten ein JavaScript-Objekt darstellen,
+                    wird versucht daraus ein XML-Zeichenfolge (string) zu erstellen.</li>
             </ul>
         </dd>
     </dl>
     <h3>Details</h3>
-    <p>Bei der Konvertierung zwischen XML und einem Objekt werden standardmäßig alle XML-Attribute als Eigenschaft namens <code>$</code> hinzugefügt. 
+    <p>Bei der Konvertierung zwischen XML und einem Objekt werden standardmäßig alle XML-Attribute als Eigenschaft mit Namen <code>$</code> hinzugefügt.
-        Jeder Textinhalt wird als Eigenschaft namens <code>_</code> hinzugefügt. 
+       Jeder Textinhalt wird als Eigenschaft mit Namen <code>_</code> hinzugefügt.
        Diese Eigenschaftsnamen können in der Node-Konfiguration angegeben werden.</p>
     <p>Zum Beispiel wird das folgende XML wie dargestellt konvertiert:</p>
     <pre>&lt;p class="tag"&gt;Hello World&lt;/p&gt;</pre>

packages/node_modules/@node-red/nodes/locales/de/parsers/70-YAML.html

@@ -15,19 +15,19 @@
 -->
 
 <script type="text/html" data-help-name="yaml">
-    <p>Konvertiert zwischen einer YAML-formatierten String und ihrer JavaScript-Objektdarstellung in beide Richtungen.</p>
+    <p>Konvertierung zwischen YAML-formatierter Zeichenfolge (string) und JavaScript-Objekt-Darstellung in beide Richtungen.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
+        <dt>payload<span class="property-type">object | string</span></dt>
-        <dd>Ein JavaScript Objekt oder ein YAML String.</dd>
+        <dd>JavaScript-Objekt oder YAML-Zeichenfolge (string)</dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
+        <dt>payload<span class="property-type">object | string</span></dt>
         <dd>
             <ul>
-                <li>Wenn die Eingabe ein YAML-String ist, wird versucht ihn in ein JavaScript-Objekt zu parsen.</li>
+                <li>Wenn die Eingangsdaten eine YAML-Zeichenfolge (string) sind, wird versucht daraus ein JavaScript-Objekt zu erzeugen.</li>
-                <li>Wenn die Eingabe ein JavaScript-Objekt ist, wird ein YAML-String erstellt.</li>
+                <li>Wenn die Eingangsdaten ein JavaScript-Objekt darstellt, wird daraus eine YAML-Zeichenfolge (string) erstellt.</li>
             </ul>
         </dd>
     </dl>

packages/node_modules/@node-red/nodes/locales/de/sequence/17-split.html

@@ -15,147 +15,148 @@
 -->
 
 <script type="text/html" data-help-name="split">
-    <p>Teilt eine Nachricht in eine Folge von Nachrichten auf.</p>
+    <p>Aufteilung einer Nachricht in Nachrichtensequenzen.</p>
-
+    <h3>Eingangsdaten</h3>
-    <h3>Eingaben</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String | Array | Buffer</span></dt>
+        <dt>payload<span class="property-type">object | string | array | buffer</span></dt>
-        <dd>Das Verhalten des Nodes wird durch den Typ der <code>msg.payload</code> bestimmt:
+        <dd>Das Node-Verhalten wird durch den <code>msg.payload</code>-Typ bestimmt:
             <ul>
-                <li><b>String</b>/<b>Buffer</b> - die Nachricht wird anhand des angegebenen Zeichens (Standard: <code>\n</code>),
+                <li><b>Zeichenfolge (string) / Binärer Puffer (buffer):</b> Die Nachricht wird anhand des vorgegebenen Zeichens (Standard: <code>\n</code>),
-                    der Buffersequenz oder in feste Längen aufgeteilt.</li>
+                    der Buffer-Sequenz oder in feste Längen aufgeteilt</li>
-                <li><b>Array</b> - die Nachricht wird entweder in einzelne Array-Elemente oder Arrays mit fester Länge aufgeteilt.</li>
+                <li><b>Datenfeld (array):</b> Die Nachricht wird entweder in einzelne Array-Elemente oder Arrays mit fester Länge aufgeteilt</li>
-                <li><b>Objekt</b> - es wird für jedes Schlüssel-Wert-Paar des Objekts eine Nachricht gesendet.</li>
+                <li><b>Objekt (object):</b> Jedes Schlüssel/Wert-Paar wird einzeln als Nachricht gesendet</li>
             </ul>
         </dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>parts<span class="property-type">Objekt</span></dt>
+        <dt>parts<span class="property-type">object</span></dt>
-        <dd>Diese Eigenschaft enthält Informationen darüber, wie die Nachricht von der ursprünglichen Nachricht getrennt wurde. 
+        <dd>Diese Eigenschaft enthält Informationen darüber, wie die Nachricht von der ursprünglichen Nachricht abgeteilt wurde.
-            Wenn sie an einen Node <b>join</b> übergeben werden,
+            Bei Übergabe an ein <span style="background-color:Gainsboro">join</span>-Node kann die Sequenz wieder zu einer einzigen Nachricht zusammengeführt werden.
-            kann die Sequenz wieder zu einer einzigen Nachricht zusammengefasst werden. 
             Diese Eigenschaft hat die folgenden Eigenschaften:
             <ul>
-            <li><code>id</code> - ein Identifikator für die Gruppe der Nachrichten</li>
+                <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
-            <li><code>index</code> - die Position innerhalb der Gruppep</li>
+                <li><code>index</code>: Position innerhalb der Gruppe</li>
-            <li><code>count</code> - falls bekannt, die Gesamtzahl der Nachrichten in der Gruppe. Siehe dazu unten "Streaming-Modus".</li>
+                <li><code>count</code>: Gesamtzahl der Nachrichten in der Gruppe (sofern bekannt). Siehe dazu unten <i>Streaming-Modus</i>.</li>
-            <li><code>type</code> - die Art der Nachricht - string/array/object/buffer</li>
+                <li><code>type</code>: Nachrichtentyp string/array/object/buffer</li>
-            <li><code>ch</code> - für ein String oder einen Buffer, die Daten, die für das Aufteilen der Nachricht verwendet wurden, entweder als String oder als Array von Bytes.</li>
+                <li><code>ch</code>: Die für das Aufteilen der String- oder Buffer-Nachricht verwendeten Daten, entweder als String oder als Byte-Array.</li>
-            <li><code>key</code> - für ein Objekt, den Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde. Der Node kann konfiguriert werden, um diesen Wert auch in andere Nachrichteneigenschaften zu kopieren, wie z.B. <code>msg.topic</code>.</li>
+                <li><code>key</code>: Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde (nur bei einem Objekt).
-            <li><code>len</code> - die Länge jeder Nachricht, wenn sie durch einen Wert fester Länge aufgeteilt wird.</li>
+                    Optional kann dieser Wert auch in andere Nachrichteneigenschaft kopiert werden, wie z. B. <code>msg.topic</code>.</li>
+                <li><code>len</code>: Nachrichtenlänge bei Aufteilung in feste Längen</li>
             </ul>
         </dd>
     </dl>
     <h3>Details</h3>
     <p>Dieser Node macht es einfach, einen Flow zu erstellen, der gemeinsame Aktionen über eine Sequenz von Nachrichten ausführt,
-        bevor er den Node <b>join</b> verwendet und die Sequenz zu einer einzigen Nachricht neu kombiniert.</p>
+       bevor die Sequenz mittels <span style="background-color:Gainsboro">join</span>-Node wieder zu einer einzigen Nachricht neu kombiniert wird.</p>
-    <p>Es verwendet die Eigenschaft <code>msg.parts</code>, um die einzelnen Teile einer Sequenz zu verfolgen.</p>
+    <p>Der Node verwendet die <code>msg.parts</code>-Eigenschaft, um die einzelnen Sequenzteile nachzuverfolgen.</p>
-    <h4>Streaming Modus</h4>
+    <h4>Streaming-Modus</h4>
-    <p>Der Node kann auch zum Wiederaufbereiten eines Nachrichtenstroms verwendet werden.
+    <p>Der Node kann auch zum Aufbereiten eines Nachrichtenstroms verwendet werden.
-        So kann beispielsweise ein serielles Gerät, das <code><newline/code>-terminierte Befehle sendet, 
+       So kann beispielsweise ein serielles Gerät, das <code>newline</code>-terminierte Befehle sendet,
-        eine einzelne Nachricht mit einem Teilbefehl am Ende liefern. 
+       eine Nachricht mit einem noch unvollständigen Befehl am Ende liefern.
-        Im Streaming-Modus teilt dieser Node eine Nachricht auf und sendet jedes komplette Segment.
+       Im Streaming-Modus teilt der Node die Nachricht in komplette Befehlsegmente auf.
-        Befindet er sich am Ende eines Teilsegments, hält der Node es fest und wird es der nächsten empfangenen Nachricht voranstellen.
+       Befindet sich am Nachrichtenende ein unvollständiges Befehlsegment,
-    </p>
+       so wird es im Node aufbewahrt und der nächsten empfangenen Nachricht vorangestellt.</p>
-    <p>Wenn der Node in diesem Modus arbeitet, setzt er die Eigenschaft <code>msg.parts.count</code> nicht, da er nicht weiß, wie viele Nachrichten im Stream zu erwarten sind.
+    <p>In diesem Modus wird die <code>msg.parts.count</code>-Eigenschaft nicht gesetzt,
-        Das bedeutet, dass er nicht mit dem <b>join</b> Node im Automatikmodus verwendet werden kann.</p>
+       da die Anzahl der zu erwartenden Nachrichten im Stream unbekannt ist.
+       Das bedeutet, dass ein nachfolgender <span style="background-color:Gainsboro">join</span>-Node nicht im Automatikmodus verwendet werden kann.</p>
 </script>
 
 <script type="text/html" data-help-name="join">
-    <p>Verbindet Sequenzen von Nachrichten zu einer einzigen Nachricht.</p>
+    <p>Verbindung von Nachrichtensequenzen zu einer einzigen Nachricht.</p>
     <p>Es sind drei Modi verfügbar:</p>
     <dl>
-        <dt>automatisch</dt>
+        <dt>Automatisch</dt>
-        <dd>Wenn es mit dem Node <b>split</b> gepaart wird, verbindet es automatisch die Nachrichten, um die durchgeführte Aufteilung rückgängig zu machen.</dd>
+        <dd>In Kombination mit dem <span style="background-color:Gainsboro">split</span>-Node verbindet es automatisch die Nachrichten, um die zuvor durchgeführte Aufteilung rückgängig zu machen</dd>
-        <dt>manual</dt>
+        <dt>Manuell</dt>
-        <dd>Die Sequenzen von Nachrichten können auf verschiedene Weise verknüpft werden.</dd>
+        <dd>Die Nachrichtensequenzen können auf verschiedene Weisen verbunden werden</dd>
-        <dt>Reihenfolge reduzieren</dt>
+        <dt>Sequenz reduzieren</dt>
-        <dd>Einen Ausdruck auf alle Nachrichten in einer Sequenz anwenden, um sie auf eine einzige Nachricht zu reduzieren.</dd>
+        <dd>Einen Ausdruck auf alle Nachrichten einer Sequenz anwenden, um sie auf eine einzige Nachricht zu reduzieren</dd>
     </dl>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional">parts<span class="property-type">Objekt</span></dt>
+        <dt class="optional">parts<span class="property-type">object</span></dt>
-        <dd>Um automatisch einer Nachrichtensequenz beizutreten, sollten sie alle über diese Eigenschaft verfügen. 
+            <dd>Zur automatischen Verbindung einer Nachrichtensequenz sollten alle über diese Eigenschaft verfügen.
-            Der Node <b>split</b> erzeugt diese Eigenschaft, sie kann aber manuell erstellt werden.
+                Der <span style="background-color:Gainsboro">split</span>-Node erzeugt diese Eigenschaft, sie kann aber auch manuell erstellt werden.
-            Es hat die folgenden Eigenschaften:
+                Sie hat die folgenden Eigenschaften:
                 <ul>
-                    <li><code>id</code> - ein Identifikator für die Gruppe der Nachrichten</li>
+                <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
-                    <li><code>index</code> - die Position innerhalb der Gruppep</li>
+                <li><code>index</code>: Position innerhalb der Gruppe</li>
-                    <li><code>count</code> - fie Gesamtzahl der Nachrichten in der Gruppe.</li>
+                <li><code>count</code>: Gesamtzahl der Nachrichten in der Gruppe (sofern bekannt). Siehe dazu unten "Streaming-Modus".</li>
-                    <li><code>type</code> - die Art der Nachricht - string/array/object/buffer</li>
+                <li><code>type</code>: Nachrichtentyp string/array/object/buffer</li>
-                    <li><code>ch</code> - für ein String oder einen Buffer, die Daten, die für das Aufteilen der Nachricht verwendet wurden, entweder als String oder als Array von Bytes.</li>
+                <li><code>ch</code>: Die für das Aufteilen der String- oder Buffer-Nachricht verwendeten Daten, entweder als String oder als Byte-Array.</li>
-                    <li><code>key</code> - für ein Objekt, den Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde.</li>
+                <li><code>key</code>: Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde (nur bei einem Objekt).
-                    <li><code>len</code> - die Länge jeder Nachricht, wenn sie durch einen Wert fester Länge aufgeteilt wird.</li>
+                    Optional kann dieser Wert auch in andere Nachrichteneigenschaft kopiert werden, wie z. B. <code>msg.topic</code>.</li>
+                <li><code>len</code>: Nachrichtenlänge bei Aufteilung in feste Längen</li>
                 </ul>
             </dd>
         <dt class="optional">complete</dt>
-        <dd>Wenn gesetzt, sendet der Node seine Ausgangsnachricht im aktuellen Zustand.</dd>
+        <dd>Wenn gesetzt, werden die Nutzdaten (Payload) hinzugefügt und die Ausgangsnachricht im aktuellen Zustand gesendet</dd>
     </dl>
     <h3>Details</h3>
 
     <h4>Automatischer Modus</h4>
-    <p>Der automatische Modus verwendet die Eigenschaft <code>parts</code> der eingehenden Nachrichten, um festzulegen, 
+    <p>Der automatische Modus verwendet die <code>parts</code>-Eigenschaften der eingehenden Nachrichten,
-        wie die Sequenz verknüpft werden soll. 
+       um die Sequenz in richtiger Reihenfolge zu verknüpften.
-        Dies ermöglicht es ihm, die Aktion eines <b>split</b>-Nodes automatisch rückgängig zu machen.
+       Dies ermöglicht die Aufteilung des <span style="background-color:Gainsboro">split</span>-Nodes automatisch rückgängig zu machen.</p>
-    </p>
+
     <h4>Manueller Modus</h4>
-    <p>Wenn der Node für die Zusammenführung im manuellen Modus konfiguriert ist,
+    <p>Im manuellen Modus werden Nachrichtensequenzen auf verschiedenen Arten zusammengefügt:</p>
-        kann er Sequenzen von Nachrichten zu einer Reihe von verschiedenen Ergebnissen zusammenfügen:</p>
     <ul>
-        <li>ein <b>String </b> oder <b>Buffer</b> - erstellt durch Verbinden der ausgewählten Eigenschaft
+        <li><b>String</b> oder <b>Buffer</b>: Verbinden der ausgewählten Eigenschaft jeder Nachricht
-            jeder Nachricht mit den angegebenen Join-Zeichen oder dem angegebenen Buffer.</li>
+        mit den vorgegebenen Join-Zeichen oder -Buffer</li>
-        <li>ein <b>Array</b> - erstellt durch Hinzufügen jeder ausgewählten Eigenschaft oder einer ganzen Nachricht zum Ausgangsarray.</li>
+        <li><b>Array</b>: Erstellung eines Ausgangsarrays durch Hinzufügen jeder ausgewählten Eigenschaft oder ganzer Nachrichten</li>
-        <li>ein <b>Schlüssel/Wert-Objekt</b> - erstellt durch Verwendung einer Eigenschaft jeder Nachricht, um den Schlüssel zu bestimmen, 
+        <li><b>Schlüssel/Wert-Objekt</b>: Erzeugung von Schlüssel und Wert aus Eigenschaft jeder Nachricht</li>
-            unter dem der gewünschte Wert gespeichert ist.</li>
+        <li><b>Zusammengeführtes Objekt</b>: Erzeugung durch Zusammenführen der Eigenschaften jeder Nachricht als ein einziges Objekt</li>
-        <li>ein <b>zusammengefügtes Objekt</b> - erstellt durch Zusammenführen der Eigenschaft jeder Nachricht unter einem einzigen Objekt.</li>
     </ul>
-    <p>Die anderen Eigenschaften der Ausgangsnachricht werden aus der letzten empfangenen Nachricht entnommen, bevor das Ergebnis gesendet wird.</p>
+    <p>Die anderen Eigenschaften der Ausgangsnachricht werden von der zuletzt empfangenen Nachricht übernommen,
-    <p>Mit <i>count</i> kann angegeben werden, wie viele Nachrichten vor dem Erzeugen der Ausgabemeldung empfangen werden sollen.
+       bevor das Ergebnis gesendet wird.</p>
-        Bei Objektausgaben kann der Node nach Erreichen dieser Anzahl konfiguriert werden,
+    <p>Mit <i>Anzahl</i> kann vorgegeben werden, wie viele Nachrichten vor dem Erzeugen der Ausgangsnadchricht empfangen werden sollen.
-        um für jede nachfolgende empfangene Nachricht eine Nachricht zu senden.</p>
+       Bei Objektausgaben kann der Node nach Erreichen dieser Anzahl so eingestellt werden,
-    <p>Ein <i>Timeout</i> kann so eingestellt werden, dass das Senden einer neuen Nachricht mit dem ausgelöst wird, was bisher empfangen wurde.</p>
+       dass er bei jeder nachfolgenden empfangenen Nachricht eine weitere Nachricht sendet.</p>
-    <p>Wenn eine Nachricht mit der Eigenschaft <b>msg.complete</b> empfangen wird, wird die Ausgabemeldung finalisiert und gesendet.
+    <p>Mittels <i>Zeitablauf</i> kann das Senden einer neuen Nachricht mit dem Inhalt ausgelöst werden, was bisher empfangen wurde.</p>
+    <p>Wenn eine Nachricht mit der <code>msg.complete</code>-Eigenschaft empfangen wird,
+       wird die Ausgangsnachricht finalisiert und gesendet.
        Dadurch wird die Zählung aller Teile zurückgesetzt.</p>
-    <p>Wenn eine Nachricht mit der Eigenschaft <b>msg.reset</b> empfangen wird, wird die teilweise vollständige Nachricht gelöscht und nicht gesendet.
+    <p>Wenn eine Nachricht mit der <code>msg.reset</code>-Eigenschaft empfangen wird,
+       wird die unvollständige Nachricht gelöscht und nicht gesendet.
        Dadurch wird die Zählung aller Teile zurückgesetzt.</p>
 
-    <h4>Reduktion der Sequenz Modus</h4>
+    <h4>Modus Sequenz reduzieren</h4>
-    <p>Wenn sie so konfiguriert sind, dass sie sich im Reduktionsmodus befinden, wird auf jede Nachricht in einer Sequenz ein Ausdruck angewendet 
+    <p>In diesem Modus wird auf jede Nachricht einer Sequenz ein Ausdruck angewendet und
-        und das Ergebnis zu einer einzigen Nachricht zusammengefasst.</p>
+       das Ergebnis zu einer einzigen Nachricht akkumuliert.</p>
-
     <dl class="message-properties">
         <dt>Anfangswert</dt>
-        <dd>Der Anfangswert des kumulierten Wertes (<code>$A</code>).</dd>
+        <dd>Anfangswert des akkumulierten Wertes (<code>$A</code>)</dd>
-        <dt>Reduktionsausdruck</dt>
+        <dt>Reduktions-Ausdruck</dt>
-        <dd>Ein JSONata-Ausdruck, der für jede Nachricht in der Sequenz aufgerufen wird.
+        <dd>JSONata-Ausdruck, der für jede Nachricht in der Sequenz aufgerufen wird.
-                Das Ergebnis wird als kumulierter Wert an den nächsten Aufruf des Ausdrucks übergeben.
+            Das Ergebnis wird als akkumulierter Wert an den nächsten Aufruf des Ausdrucks übergeben.
-                Im Ausdruck können die folgenden speziellen Variablen verwendet werden:
-            <ul>
-                <li><code>$A</code>: der kumulierte Wert, </li>
-                <li><code>$I</code>: Index der Nachricht innerhalb der Squenz, </li>
-                <li><code>$N</code>: Anzahl der Nachrichten in der Sequenz.</li>
-            </ul>
-        </dd>
-        <dt>Fix-up Ausdruck</dt>
-        <dd>Ein optionaler JSONata-Ausdruck, der angewendet wird, nachdem der Reduzierungsausdruck auf alle Nachrichten in der Sequenz angewendet wurde.
             Im Ausdruck können folgende spezielle Variablen verwendet werden:
             <ul>
-                <li><code>$A</code>: der kumulierte Wert, </li>
+                <li><code>$A</code>: Akkumulierter Wert</li>
-                <li><code>$N</code>: Anzahl der Nachrichten in der Sequenz.</li>
+                <li><code>$I</code>: Index der Nachricht innerhalb der Sequenz</li>
+                <li><code>$N</code>: Anzahl der Nachrichten der Sequenz</li>
             </ul>
         </dd>
-        <p>Standardmäßig wird der Reduktionsausdruck in der Reihenfolge von der ersten bis zur letzten Nachricht der Sequenz angewendet. 
+        <dt>Fix-up-Ausdruck</dt>
+        <dd>Optionaler JSONata-Ausdruck, der nach Anwendung des Reduktions-Ausdrucks auf alle Nachrichten in der Sequenz angewendet wird.
+            Im Ausdruck können folgende spezielle Variablen verwendet werden:
+            <ul>
+                <li><code>$A</code>: Akkumulierter Wert</li>
+                <li><code>$N</code>: Anzahl der Nachrichten der Sequenz</li>
+            </ul>
+        </dd>
+        <p>Standardmäßig wird der Reduktions-Ausdruck in Reihenfolge von der ersten bis zur letzten Nachricht der Sequenz angewendet.
            Er kann optional in umgekehrter Reihenfolge angewendet werden.</p>
     </dl>
-    <p><b>Beispiel:</b> Die folgenden Einstellungen berechnen bei einer Folge von Zahlenwerten den Mittelwert:
+    <p><b>Beispiel:</b> Die folgenden Einstellungen berechnen bei einer Sequenz von Zahlenwerten den Mittelwert:
         <ul>
-            <li><b>Reduce expression</b>: <code>$A+payload</code></li>
+            <li><b>Reduktions-Ausdruck:</b> <code>$A+payload</code></li>
-            <li><b>Initial value</b>: <code>0</code></li>
+            <li><b>Anfangswert:</b> <code>0</code></li>
-            <li><b>Fix-up expression</b>: <code>$A/$N</code></li>
+            <li><b>Fix-up-Ausdruck:</b> <code>$A/$N</code></li>
         </ul>
     </p>
-    <h4>Speichern von Nachrichtens</h4>
+    <h4>Speichern von Nachrichten</h4>
     <p>Dieser Node puffert Nachrichten intern, um sequenzübergreifend zu arbeiten.
        Mit der Laufzeiteinstellung <code>nodeMessageBufferMaxLength</code> kann begrenzt werden,
        wie viele Nachrichten im Node zwischengespeichert werden sollen.</p>

packages/node_modules/@node-red/nodes/locales/de/sequence/18-sort.html

@@ -15,31 +15,31 @@
 -->
 
 <script type="text/html" data-help-name="sort">
-    <p>Eine Funktion, die die Nachrichteneigenschaft oder eine Folge von Nachrichten sortiert.</p>
+    <p>Sortierung einer Nachrichteneigenschaft oder einer Nachrichtensequenz.</p>
-    <p>Wenn der Node konfiguriert ist, um die Nachrichteneigenschaft zu sortieren,
+    <p>Der Node sortiert entweder das Array der vorgegebenen Nachrichteneigenschaft oder
-        sortiert er Array-Daten, auf die von der angegebenen Nachrichteneigenschaft verwiesen wird.</p>
+       die Reihenfolge einer Nachrichtensequenz neu.</p>
-    <p>Wenn der Node konfiguriert ist, um eine Folge von Nachrichten zu sortieren, ordnet er die Nachrichten neu.</p>
     <p>Die Sortierreihenfolge kann sein:</p>
     <ul>
-        <li><b>aufsteigend</b>,</li>
+        <li><b>aufsteigend</b> oder</li>
-        <li><b>absteigend</b>.</li>
+        <li><b>absteigend</b></li>
     </ul>
-    <p>Für Zahlen kann die numerische Reihenfolge durch ein Kontrollkästchen festgelegt werden.</p>
+    <p>Für Zahlenwerte kann die numerische Sortierreihenfolge festgelegt werden.</p>
-    <p>Der Sortierschlüssel kann ein Elementwert oder ein JSONata-Ausdruck zum Sortieren des Eigenschaftswerts 
+    <p>Der Sortierschlüssel kann ein Elementwert oder ein JSONata-Ausdruck beim Sortieren einer Nachrichteneigenschaft
-        oder eine Nachrichteneigenschaft oder ein JSONata-Ausdruck zum Sortieren einer Nachrichtensequenz sein.<p>
+       bzw. eine Nachrichteneigenschaft oder ein JSONata-Ausdruck beim Sortieren einer Nachrichtensequenz sein.<p>
-    <p>Beim Sortieren einer Nachrichtenfolge verlässt sich der SortierNode auf die empfangenen Nachrichten, bei denen <code>msg.parts</code> gesetzt ist.
+    <p>Zum Sortieren einer Nachrichtensequenz benötigt der <span style="background-color:Gainsboro">sort</span>-Node die gesetzte <code>msg.parts</code>-Eigenschaft bei den empfangenen Nachrichten.
-        Der Split-Node erzeugt diese Eigenschaft, kann aber manuell angelegt werden.  Es hat die folgenden Eigenschaften:</p>
+       Diese Eigenschaft wird vom <span style="background-color:Gainsboro">split</span>-Node erzeugt und kann aber auch manuell erzeugt werden.
+       Sie hat die folgenden Eigenschaften:</p>
     <p>
         <ul>
-            <li><code>id</code> - ein Identifikator für die Gruppe der Nachrichten</li>
+            <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
-            <li><code>index</code> - die Position innerhalb einer Gruppe</li>
+            <li><code>index</code>: Position innerhalb der Gruppe</li>
-            <li><code>count</code> - die Anzahl von Nachrichten in einer Gruppe</li>
+            <li><code>count</code>: Gesamtzahl der Nachrichten in der Gruppe</li>
         </ul>
     </p>
-    <p><b>Note:</b> Dieser Node speichert intern Nachrichten für seinen Betrieb.  Um einen unerwarteten Speicherverbrauch zu vermeiden, kann die maximale Anzahl der gespeicherten Nachrichten angegeben werden.
+    <p><b>Hinweis:</b> Dieser Node speichert intern Nachrichten um seine Aufgabe erfüllen zu können.
-        Standardmäßig ist die Anzahl der Nachrichten nicht begrenzt.
+       Um einen unerwarteten Speicherverbrauch zu vermeiden, kann die Anzahl der gespeicherten Nachrichten begrenzt werden.
-        <ul>
+       Standardmäßig ist die Nachrichtenanzahl nicht begrenzt.
-            <li>Es kann die Eigenschaft <code>nodeMessageBufferMaxLength</code> in der Datei <b>settings.js</b> gesetzt werden.</li>
+       Mit der Laufzeiteinstellung <code>nodeMessageBufferMaxLength</code> kann begrenzt werden,
-        </ul>
+       wie viele Nachrichten im Node zwischengespeichert werden sollen.</p>
     </p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/sequence/19-batch.html

@@ -15,27 +15,29 @@
 -->
 
 <script type="text/html" data-help-name="batch">
-    <p>Erstellt Sequenzen von Nachrichten nach verschiedenen Regeln.</p>
+    <p>Erstellung von Nachrichtensequenzen nach verschiedenen Regeln.</p>
     <h3>Details</h3>
     <p>Es gibt drei Modi für die Erstellung von Nachrichtensequenzen:</p>
     <dl>
-        <dt>Anzahl der Nachrichten</dt>
+        <dt>Gruppierung anhand Nachrichtenanzahl</dt>
-        <dd>Die Nachrichten werden zu Sequenzen einer bestimmten Länge gruppiert. Die Option <b>Überlappung</b>
+        <dd>Die Nachrichten werden zu Sequenzen einer vorgegebenen Länge gruppiert.
-            gibt an, wie viele Nachrichten vom Ende einer Sequenz am Anfang der nächsten Sequenz wiederholt werden sollen.</dd>
+            Die Option <i>Überlappung</i> gibt an, wie viele Nachrichten vom Ende einer Sequenz
+            am Anfang der nächsten Sequenz wiederholt werden sollen.</dd>
 
-        <dt>Zeitintervall</dt>
+        <dt>Gruppierung anhand Zeitintervall</dt>
-        <dd>Gruppiert Nachrichten, die innerhalb des angegebenen Intervalls eingehen. Wenn keine Nachrichten 
+        <dd>Gruppierung von Nachrichten, die innerhalb des vorgegebenen Intervalls eingehen.
-            innerhalb des Intervalls ankommen, kann der Node optional eine leere Nachricht senden.</dd>
+            Wenn keine Nachrichten innerhalb des Intervalls eingehen, kann der Node optional eine leere Nachricht senden.</dd>
 
-        <dt>Sequenzen verketten/dt>
+        <dt>Verknüpfung von Sequenzen</dt>
-        <dd>Erzeugt eine Nachrichtensequenz durch die Verkettung eingehender Sequenzen. Jede Nachricht muss eine <code>msg.topic</code> 
+        <dd>Erzeugt eine Nachrichtensequenz durch die Verkettung eingehender Sequenzen.
-            und eine <code>msg.parts</code> Eigenschaft haben, um die Sequenz identifizieren zu können. 
+            Jede Nachricht muss eine <code>msg.topic</code>- und eine <code>msg.parts</code>-Eigenschaft haben,
-            Der Node ist mit einer Liste von <code>topic</code> konfiguriert,
+            damit die Sequenz identifiziert werden kann.
-             mit der die Reihenfolge der Verkettung der Sequenzen definiert wird.</dd>
+            Der Node wird mit einer Liste von <code>topic</code>-Werten eingestellt,
+            mit der die Verknüpfungs-Reihenfolge der Sequenzen definiert wird.</dd>
 
     </dl>
     <h4>Speichern der Nachrichten</h4>
-    <p>Dieser Node puffert Nachrichten intern, um sequenzübergreifend arbeiten zu können. Die Laufzeiteinstellung
+    <p>Dieser Node puffert Nachrichten intern, um sequenzübergreifend arbeiten zu können.
-        <code>nodeMessageBufferMaxLength</code> kann verwendet werden, um die Anzahl der Nachrichten zu begrenzen 
+       Mit der Laufzeiteinstellung <code>nodeMessageBufferMaxLength</code> kann begrenzt werden,
-        die vom Node gepuffert werden.</p>
+       wie viele Nachrichten im Node zwischengespeichert werden sollen.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/storage/10-file.html

@@ -15,58 +15,48 @@
 -->
 
 <script type="text/html" data-help-name="file">
-    <p>Schreibt <code>msg.payload</code> in eine Datei, wobei entweder der vorhandene Inhalt hinzugefügt oder ersetzt wird.
+    <p>Schreiben von <code>msg.payload</code> in eine Datei entweder hinzufügend oder ersetzend.
-        Alternativ kann die Datei auch gelöscht werden.</p>
+       Alternativ Löschen der Datei.</p>
-    <h3>Eingaben</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional">filename <span class="property-type">String</span></dt>
+        <dt class="optional">filename<span class="property-type">string</span></dt>
-        <dd>Wenn nicht im Node konfiguriert, legt diese optionale Eigenschaft den Namen der zu aktualisierenden Datei fest.</dd>
+        <dd>Sofern nicht im Node eingestellt, legt diese optionale Eigenschaft den Namen der zu aktualisierenden Datei fest</dd>
     </dl>
-    <h3>Ausgaben</h3>
+    <h3>Ausgangsdaten</h3>
-    <p>Nach Abschluss des Schreibvorgangs wird die Eingangsnachricht an den Ausgangsport gesendet.</p>
+    <p>Nach Abschluss des Schreibvorgangs wird die Eingangsnachricht an den Ausgang gesendet.</p>
     <h3>Details</h3>
-    <p>Jeder Nachrichten-Payload wird am Ende der Datei hinzugefügt und optional dazwischen ein Zeilenumbruchzeichen.</p>
+    <p>Jede Nachrichten-Nutzdaten (Payload) werden standardmäßig am Ende der Datei hinzugefügt,
+       optional mit Zeilenumbruchzeichen (\n) nach jeder Nachricht.</p>
     <p>Wenn <code>msg.filename</code> verwendet wird, wird die Datei nach jedem Schreiben geschlossen.
-        Für eine optimale Leistung verwenden Sie einen festen Dateinamen.</p>
+       Für eine optimale Leistung sollten feste Dateinamen verwendet werden.</p>
-    <p>Es kann konfiguriert werden, dass die gesamte Datei überschrieben wird und nicht angehängt wird. Zum Beispiel 
+    <p>Alternativ kann angegeben werden, dass die gesamte Datei überschrieben wird.
-        beim Schreiben von Binärdaten in eine Datei wie bei einem Bild, sollte diese Option verwendet werden 
+       Zum Beispiel wird diese Option beim Schreiben von Binärdaten in eine Datei verwendet,
-        und die Option, einen Zeilenumbruch anzuhängen, sollte deaktiviert sein.</p>
+       wo dann auch die Zeilenumbruch-Hinzufüge-Option deaktiviert sein sollte.</p>
-    <p>Alternativ kann dieser Node konfiguriert werden, um die Datei zu löschen.</p>
+    <p>Alternativ kann dieser Node so eingestellt werden, dass er die Datei löscht.</p>
 </script>
 
 <script type="text/html" data-help-name="file in">
-    <p>Reads the contents of a file as either a string or binary buffer.</p>
+    <p>Lesen von Dateiinhalt als Zeichenfolge (string) oder binären Puffer (buffer).</p>
-    <h3>Inputs</h3>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional">filename <span class="property-type">string</span></dt>
+        <dt class="optional">filename<span class="property-type">string</span></dt>
-        <dd>if not set in the node configuration, this property sets the filename to read.</dd>
+        <dd>Sofern nicht im Node eingestellt, legt diese optionale Eigenschaft den Namen der zu lesenden Datei fest</dd>
     </dl>
-    <h3>Outputs</h3>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">string | buffer</span></dt>
+        <dt>payload<span class="property-type">string | buffer</span></dt>
-        <dd>The contents of the file as either a string or binary buffer.</dd>
+        <dd>Dateiinhalt entweder als Zeichenfolge (string) oder binärer Puffer (buffer)</dd>
-        <dt class="optional">filename <span class="property-type">string</span></dt>
+        <dt class="optional">filename<span class="property-type">string</span></dt>
-        <dd>If not configured in the node, this optional property sets the name of the file to be read.</dd>
+        <dd>Sofern nicht im Node eingestellt, enthält diese optionale Eigenschaft den Namen der zu lesenden Datei</dd>
-        <dt class="optional">error <span class="property-type">object</span></dt>
-        <dd><i>deprecated</i>: If enabled in the node, when the node hits an error
-            reading the file, it will send a message with no <code>payload</code>
-            and this <code>error</code> property set to the error details. This
-            mode of behaviour is deprecated and not enabled by default for new
-            instances of the node. See below for more information.</dd>
     </dl>
     <h3>Details</h3>
-    <p>The filename should be an absolute path, otherwise it will be relative to
+    <p>Der Dateiname sollte ein absoluter Pfad sein.
-    the working directory of the Node-RED process.</p>
+       Andernfalls wird er relativ zum Arbeitsverzeichnis des Node-RED-Prozesses angewandt.</p>
-    <p>On Windows, path separators may need to be escaped, for example: <code>\\Users\\myUser</code>.</p>
+    <p>Unter Windows müssen die Pfadtrenner (\) in Escape-Codes umgewandelt werden, z. B.: <code>\\Users\\myUser</code>.</p>
-    <p>Optionally, a text file can be split into lines, outputting one message per line, or a binary file
+    <p>Optional kann eine Textdatei in einzelne Zeilen mit jeweils eine Nachricht pro Zeile aufgeteilt werden.
-    split into smaller buffer chunks - the chunk size being operating system dependant, but typically 64k (Linux/Mac) or 41k (Windows).</p>
+       Eine Binärdatei wird in kleine Teile in Größe abhängig vom Betriebssystem aufgeteilt,
-    <p>When split into multiple messages, each message will have a <code>parts</code>
+       aber typischerweise 64k (Linux/Mac) oder 41k (Windows).</p>
-    property set, forming a complete message sequence.</p>
+    <p>Bei Aufteilung in mehrere Nachrichten besitzt jede eine <code>parts</code>-Eigenschaft,
-    <h4>Legacy error handling</h4>
+       welche eine komplette Nachrichten-Sequenz bildet.</p>
-    <p>Before Node-RED 0.17, if this node hit an error whilst reading the file, it would
+    <p>Fehler sollten mittels <span style="background-color:Gainsboro">catch</span>-Nodes abgefangen und behandelt werden.</p>
-    send a message with no <code>msg.payload</code> and <code>msg.error</code> set to the
-    details of the error. This is a deprecated mode of behaviour for the node that new
-    instances will not do. If required, this mode can be re-enabled within the node
-    configuration.</p>
-    <p>Errors should be caught and handled using a Catch node.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/de/storage/23-watch.html

@@ -15,15 +15,17 @@
 -->
 
 <script type="text/html" data-help-name="watch">
-    <p>Überwacht ein Verzeichnis oder eine Datei auf Änderungen.</p>
+    <p>Überwachung eines Verzeichnisses oder einer Datei auf Änderungen.</p>
-    <p>Es kann eine kommagetrennte Liste von Verzeichnissen und/oder Dateien eingeben werden. 
+    <p>Es kann eine kommagetrennte Liste von Verzeichnissen und/oder Dateien angegeben werden.
-      Es müssen Anführungszeichen "...." um alle Einträge gesetzt werden, die Leerzeichen enthalten.</p>
+       Es müssen Anführungszeichen "..." um alle Leerzeichen enthaltenden Einträge gesetzt werden.</p>
-    <p>Unter Windows muss in allen Verzeichnisnamen doppelte Backslashes \\\ verwendet werden.</p>
+    <p>Unter Windows müssen in allen Verzeichnisnamen doppelte Schrägstriche \\ verwendet werden.</p>
-    <p>Der vollständige Dateiname der tatsächlich geänderten Datei wird in <code>msg.payload</code> und <code>msg.filename</code> eingetragen, 
+    <p>Der vollständige Dateiname der geänderten Datei wird in <code>msg.payload</code> und <code>msg.filename</code> gemeldet,
-      während eine stringifizierte Version der Überwachungsliste in <code>msg.topic</code> zurückgegeben wird.</p>
+       während die Überwachungsliste in <code>msg.topic</code> zurückgegeben wird.</p>
-    <p><code>msg.file</code> enthält nur den kurzen Dateinamen der geänderten Datei. <code>msg.type</code> hat den Typ des geänderten  Elements, 
+    <p><code>msg.file</code> enthält nur den kurzen Dateinamen der geänderten Datei.
-      normalerweise <i>file</i> oder <i>directory</i>, während <code>msg.size</code> die Dateigröße in Bytes enthält.</p>
+       <code>msg.type</code> enthält den Typ des geänderten Elements, normalerweise <i>file</i> oder <i>directory</i>,
-    <p>Natürlich ist unter Linux <i>alles</i> eine Datei und kann somit beobachtet werden...</p>
+       während <code>msg.size</code> die Dateigröße in Bytes enthält.</p>
-    <p><b>Note: </b>Das Verzeichnis oder die Datei muss vorhanden sein, um beobachtet zu werden. Wenn die Datei
+    <p>Natürlich ist unter Linux <i>alles</i> eine Datei und kann somit beobachtet werden ...</p>
-      oder das Verzeichnis gelöscht wird, kann es nicht mehr überwacht werden, auch wenn es wieder neu erstellt wird.</p>
+    <p><b>Hinweis:</b> Das Verzeichnis oder die Datei muss vorhanden sein, um beobachtet werden zu können.
+       Wenn die Datei oder das Verzeichnis gelöscht wird, kann es nicht weiter überwacht werden,
+       auch wenn sie/es wieder neu erstellt wird.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/en-US/messages.json

@@ -217,7 +217,7 @@
             "modules": "Modules"
         },
         "text": {
-            "initialize": "// Code added here will be run once\n// whenever the node is deployed.\n",
+            "initialize": "// Code added here will be run once\n// whenever the node is started.\n",
             "finalize": "// Code added here will be run when the\n// node is being stopped or re-deployed.\n"
         },
         "require": {

packages/node_modules/@node-red/nodes/locales/en-US/network/21-httpin.html

@@ -75,7 +75,7 @@
     <h4>Cookie handling</h4>
     <p>The <code>cookies</code> property must be an object of name/value pairs.
     The value can be either a string to set the value of the cookie with default
-    options, or it can be an object of options.<p>
+    options, or it can be an object of options.</p>
     <p>The following example sets two cookies - one called <code>name</code> with
     a value of <code>nick</code>, the other called <code>session</code> with a
     value of <code>1234</code> and an expiry set to 15 minutes.</p>

packages/node_modules/@node-red/nodes/locales/en-US/sequence/17-split.html

@@ -116,9 +116,9 @@
     For object outputs, once this count has been reached, the node can be configured to send a message for each subsequent message
     received.</p>
     <p>A <i>timeout</i> can be set to trigger sending the new message using whatever has been received so far.</p>
-    <p>If a message is received with the <b>msg.complete</b> property set, the output message is finalised and sent.
+    <p>If a message is received with the <code>msg.complete</code> property set, the output message is finalised and sent.
     This resets any part counts.</p>
-    <p>If a message is received with the <b>msg.reset</b> property set, the partly complete message is deleted and not sent.
+    <p>If a message is received with the <code>msg.reset</code> property set, the partly complete message is deleted and not sent.
     This resets any part counts.</p>
 
     <h4>Reduce Sequence mode</h4>

packages/node_modules/@node-red/nodes/locales/en-US/sequence/19-batch.html

@@ -39,5 +39,5 @@
     <p>This node will buffer messages internally in order to work across sequences. The
        runtime setting <code>nodeMessageBufferMaxLength</code> can be used to limit how many messages nodes
        will buffer.</p>
-    <p>If a message is received with the <b>msg.reset</b> property set, the buffered messages are deleted and not sent.</p>
+    <p>If a message is received with the <code>msg.reset</code> property set, the buffered messages are deleted and not sent.</p>
 </script>

packages/node_modules/@node-red/nodes/locales/ja/sequence/19-batch.html

@@ -31,6 +31,6 @@
     </dl>
     <h4>メッセージの蓄積</h4>
     <p>このノードの処理ではメッセージ列の処理のためメッセージを内部に蓄積します。<b>settings.js</b>の<code>nodeMessageBufferMaxLength</code>を指定することで蓄積するメッセージの最大値を制限することができます。</p>
-    <p>メッセージが<b>msg.reset</b>プロパティを持つ場合、蓄積したメッセージを削除し送信を行いません。</p>
+    <p>メッセージが<code>msg.reset</code>プロパティを持つ場合、蓄積したメッセージを削除し送信を行いません。</p>
 
 </script>

packages/node_modules/@node-red/nodes/locales/ru/sequence/17-split.html

@@ -126,10 +126,10 @@
     Свойство <i>время (сек)</i> может быть установлено, чтобы инициировать отправку нового сообщения с использованием всего, что было получено до сих пор.
   </p>
   <p>
-    Если сообщение получено с установленным свойством <b>msg.complete</b>, выходное сообщение завершается и отправляется. Это сбрасывает любой подсчет частей.
+    Если сообщение получено с установленным свойством <code>msg.complete</code>, выходное сообщение завершается и отправляется. Это сбрасывает любой подсчет частей.
   </p>
   <p>
-    Если сообщение получено с установленным свойством <b>msg.reset</b>, частично завершенное сообщение удаляется и не отправляется. Это сбрасывает любой подсчет частей.
+    Если сообщение получено с установленным свойством <code>msg.reset</code>, частично завершенное сообщение удаляется и не отправляется. Это сбрасывает любой подсчет частей.
   </p>
 
   <h4>Режим агрегации последовательности</h4>

packages/node_modules/@node-red/nodes/locales/ru/sequence/19-batch.html

@@ -40,6 +40,6 @@
     Этот узел будет буферизировать сообщения внутри, чтобы работать с последовательностями. Параметр <code>nodeMessageBufferMaxLength</code> можно использовать для ограничения количества сообщений, которые узел будут буферизовать.
   </p>
   <p>
-    Если сообщение получено с установленным свойством <b>msg.reset</b>, буферизованные сообщения удаляются и не отправляются.
+    Если сообщение получено с установленным свойством <code>msg.reset</code>, буферизованные сообщения удаляются и не отправляются.
   </p>
 </script>

packages/node_modules/@node-red/nodes/locales/zh-CN/sequence/17-split.html

@@ -95,8 +95,8 @@
     <p>输出消息的其他属性都取自发送结果前的最后一条消息。</p>
     <p>可以用<i>计数</i>来确定应接收多少条消息来进行合并。对于对象输出，可以设置为达到此计数后的每条后续消息都发送一条输出。</p>
     <p>可以用<i>超时</i>来设置发送新消息之前的等待时间。</p>
-    <p>如果收到设置了<b>msg.complete</b>属性的消息时发送输出消息并重置消息列数。</p>
+    <p>如果收到设置了<code>msg.complete</code>属性的消息时发送输出消息并重置消息列数。</p>
-    <p>如果收到设置了<b>msg.reset</b>属性的消息，则部分收到的消息将被删除而不发送，同时重置消息列数。</p>
+    <p>如果收到设置了<code>msg.reset</code>属性的消息，则部分收到的消息将被删除而不发送，同时重置消息列数。</p>
 
     <h4>列聚合模式</h4>
     <p>选择列聚合模式时，将表达式应用于组成消息列的每条消息，并使用聚合值组成一条消息。</p>

packages/node_modules/@node-red/nodes/locales/zh-TW/sequence/17-split.html

@@ -95,8 +95,8 @@
     <p>輸出消息的其他屬性都取自發送結果前的最後一條消息。</p>
     <p>可以用<i>計數</i>來確定應接收多少條消息來進行合並。對于對象輸出，可以設置爲達到此計數後的每條後續消息都發送一條輸出。</p>
     <p>可以用<i>超時</i>來設置發送新消息之前的等待時間。</p>
-    <p>如果收到設置了<b>msg.complete</b>屬性的消息時發送輸出消息並重置消息列數。</p>
+    <p>如果收到設置了<code>msg.complete</code>屬性的消息時發送輸出消息並重置消息列數。</p>
-    <p>如果收到設置了<b>msg.reset</b>屬性的消息，則部分收到的消息將被刪除而不發送，同時重置消息列數。</p>
+    <p>如果收到設置了<code>msg.reset</code>屬性的消息，則部分收到的消息將被刪除而不發送，同時重置消息列數。</p>
 
     <h4>列聚合模式</h4>
     <p>選擇列聚合模式時，將表達式應用于組成消息列的每條消息，並使用聚合值組成一條消息。</p>

packages/node_modules/@node-red/runtime/locales/de/runtime.json

@@ -1,164 +1,185 @@
 {
-  "runtime" : {
+  "runtime": {
-    "welcome" : "Willkommen bei Node-RED!",
+    "welcome": "Willkommen bei Node-RED!",
-    "version" : "__component__ Version: __version__",
+    "version": "__component__ Version: __version__",
-    "unsupported_version" : "Nicht unterstützte Version von __component__. Erfordert: __requires__ Gefunden: __version__",
+    "unsupported_version": "Nicht unterstützte Version von __component__. Erforderlich: __requires__, jedoch gefunden: __version__",
-    "paths" : {
+    "paths": {
-      "settings" : "Einstellungsdatei: __path__",
+      "settings": "Einstellungsdatei: __path__",
-      "httpStatic" : "HTTP-Statisch: __path__"
+      "httpStatic": "HTTP-Statisch: __path__"
     }
   },
-  "server" : {
+
-    "loading" : "Paletten-Nodes werden geladen",
+  "server": {
-    "palette-editor" : {
+    "loading": "Paletten-Nodes werden geladen",
-      "disabled" : "Paletteneditor inaktiviert: Benutzereinstellungen",
+    "palette-editor": {
-      "npm-not-found" : "Paletteneditor inaktiviert: Befehl 'npm' nicht gefunden"
+      "disabled": "Paletteneditor deaktiviert: Benutzereinstellungen",
+      "npm-not-found": "Paletteneditor deaktiviert: Befehl 'npm' nicht gefunden",
+      "npm-too-old": "Paletteneditor deaktiviert: npm-Version ist zu alt. Erforderlich: npm >= 3.x"
     },
-    "errors" : "Registrieren des Node-Typs __count__ ist fehlgeschlagen.",
+    "errors": "Fehler beim Registrieren von __count__ Node-Type",
-    "errors_plural" : "Fehler beim Registrieren von __count__ -Node-Typen",
+    "errors_plural": "Fehler beim Registrieren von __count__ Node-Typen",
-    "errors-help" : "Mit -v ausführen, um Details zu erfahren",
+    "errors-help": "Mit der Option -v ausführen, um weitere Details zu erfahren",
-    "missing-modules" : "Fehlende Node-Module:",
+    "missing-modules": "Fehlende Node-Module:",
-    "node-version-mismatch" : "Das Node-Modul kann in dieser Version nicht geladen werden. Erfordert: __version__ ",
+    "node-version-mismatch": "Das Node-Modul kann nicht in dieser Version geladen werden. Erforderlich: __version__",
-    "type-already-registered" : "'__type__' bereits von Modul __module__ registriert",
+    "type-already-registered": "Der Typ '__type__' ist bereits von Modul '__module__' registriert",
-    "removing-modules" : "Module aus der Konfiguration entfernen",
+    "removing-modules": "Entferne Module aus der Konfiguration",
-    "added-types" : "Hinzugefügte Node-Typen:",
+    "added-types": "Hinzugefügte Node-Typen:",
-    "removed-types" : "Entfernte Node-Typen:",
+    "removed-types": "Entfernte Node-Typen:",
-    "install" : {
+    "install": {
-      "invalid" : "Ungültiger Modulname",
+      "invalid": "Ungültiger Modulname",
-      "installing" : "Modul wird installiert: __name__, Version: __version__",
+      "installing": "Modul wird installiert: __name__, Version: __version__",
-      "installed" : "Installiertes Modul: __name__",
+      "installed": "Installiertes Modul: __name__",
-      "install-failed" : "Installation fehlgeschlagen",
+      "install-failed": "Installation fehlgeschlagen",
-      "install-failed-long" : "Die Installation des Moduls __name__ ist fehlgeschlagen:",
+      "install-failed-long": "Installation des Moduls __name__ ist fehlgeschlagen:",
-      "install-failed-not-found" : "Das Modul '$t(server.install.install-failed-long') wurde nicht gefunden.",
+      "install-failed-not-found": "Das Modul $t(server.install.install-failed-long) wurde nicht gefunden",
-      "upgrading" : "Modul wird aktualisiert: __name__ auf Version: __version__",
+      "install-failed-name": "$t(server.install.install-failed-long). Ungültiger Modulname: __name__",
-      "upgraded" : "Erweitertes Modul: __name__. Neustart von Node-RED für die Verwendung der neuen Version",
+      "install-failed-url": "$t(server.install.install-failed-long). Ungültige URL: __url__",
-      "upgrade-failed-not-found" : "$t(server.install.install-failed-long) Version nicht gefunden",
+      "upgrading": "Upgrade von Modul __name__ auf Version __version__ gestartet",
-      "uninstalling" : "Modul wird deinstalliert: __name__",
+      "upgraded": "Upgrade von Modul __name__ war erfolgreich. Neustart von Node-RED für die Verwendung der neuen Version erforderlich.",
-      "uninstall-failed" : "Deinstallation fehlgeschlagen",
+      "upgrade-failed-not-found": "Upgrade fehlgeschlagen. $t(server.install.install-failed-long). Version nicht gefunden.",
-      "uninstall-failed-long" : "Das Deinstallieren des Moduls __name__ ist fehlgeschlagen:",
+      "uninstalling": "Das Modul __name__ wird deinstalliert",
-      "uninstalled" : "Nicht installiertes Modul: __name__"
+      "uninstall-failed": "Deinstallation fehlgeschlagen",
+      "uninstall-failed-long": "Die Deinstallation des Moduls __name__ ist fehlgeschlagen:",
+      "uninstalled": "Das Modul __name__ ist deinstalliert"
     },
-    "unable-to-listen" : "Zuhören auf __listenpath__ nicht möglich.",
+    "unable-to-listen": "Überwachen (listen) von __listenpath__ nicht möglich",
-    "port-in-use" : "Fehler: Port wird verwendet",
+    "port-in-use": "Fehler: Port wird verwendet",
-    "uncaught-exception" : "Nicht abgefangene Ausnahmebedingung:",
+    "uncaught-exception": "Nicht abgefangene Ausnahmebedingung:",
-    "admin-ui-disabled" : "Administratorbenutzerschnittstelle inaktiviert",
+    "admin-ui-disabled": "Administrator-Benutzeroberfläche deaktiv",
-    "now-running" : "Server wird jetzt auf __listenpath__ ausgeführt.",
+    "now-running": "Server wird jetzt auf __listenpath__ ausgeführt",
-    "failed-to-start" : "Starten des Servers fehlgeschlagen:",
+    "failed-to-start": "Starten des Servers fehlgeschlagen:",
-    "headless-mode" : "Ausführung im Headless-Modus",
+    "headless-mode": "Server läuft im Headless-Modus",
-    "httpadminauth-deprecated" : "Die Verwendung von httpAdminAuth wird nicht weiter unterstützt. Verwenden Sie stattdessen adminAuth."
+    "httpadminauth-deprecated": "Die Verwendung von httpAdminAuth wird nicht weiter unterstützt. Verwenden Sie stattdessen adminAuth.",
-  },
+    "https": {
-  "api" : {
+      "refresh-interval": "Erneuerung der https-Einstellungen erfolgt alle __interval__ Stunden",
-    "flows" : {
+      "settings-refreshed": "https-Einstellungen wurden erneuert",
-      "error-save" : "Fehler beim Speichern der Flows: __message__",
+      "refresh-failed": "Erneuerung der https-Einstellungen fehlgeschlagen: __message__",
-      "error-reload" : "Fehler beim erneuten Laden von Flows: __message__"
+      "nodejs-version": "httpsRefreshInterval erfordert Node.js 11 or later",
-    },
+      "function-required": "httpsRefreshInterval erfordert die https-Eigenschaft in Form einer Funktion"
-    "library" : {
-      "error-load-entry" : "Fehler beim Laden des Bibliothekseintrags '__path__': __message__",
-      "error-save-entry" : "Fehler beim Speichern des Bibliothekseintrags '__path__': __message__",
-      "error-load-flow" : "Fehler beim Laden von Flow '__path__': __message__",
-      "error-save-flow" : "Fehler beim Speichern des Flows '__path__': __message__"
-    },
-    "nodes" : {
-      "enabled" : "Aktivierte Node-Typen:",
-      "disabled" : "Inaktivierte Node-Typen:",
-      "error-enable" : "Der Node konnte nicht aktiviert werden:"
     }
   },
-  "comms" : {
+
-    "error" : "Kommunikationskanalfehler: __message__",
+  "api": {
-    "error-server" : "Kommunikationsserverfehler: __message__",
+    "flows": {
-    "error-send" : "Fehler beim Senden der Kommunikation: __message__"
+      "error-save": "Fehler beim Speichern der Flows: __message__",
+      "error-reload": "Fehler beim erneuten Laden der Flows: __message__"
     },
-  "settings" : {
+    "library": {
-    "user-not-available" : "Benutzereinstellungen können nicht gespeichert werden: __message__",
+      "error-load-entry": "Fehler beim Laden des Bibliothekseintrags '__path__': __message__",
-    "not-available" : "Einstellungen nicht verfügbar",
+      "error-save-entry": "Fehler beim Speichern des Bibliothekseintrags '__path__': __message__",
-    "property-read-only" : "Eigenschaft '__prop__' ist schreibgeschützt"
+      "error-load-flow": "Fehler beim Laden des Flows '__path__': __message__",
+      "error-save-flow": "Fehler beim Speichern des Flows '__path__': __message__"
     },
-  "nodes" : {
+    "nodes": {
-    "credentials" : {
+      "enabled": "Aktivierte Node-Typen:",
-      "error" : "Fehler beim Laden der Berechtigungsnachweise: __message__",
+      "disabled": "Deaktivierte Node-Typen:",
-      "error-saving" : "Fehler beim Speichern der Berechtigungsnachweise: __message__",
+      "error-enable": "Der Node konnte nicht aktiviert werden:"
-      "not-registered" : "Der Berechtigungsnachweistyp '__type__' ist nicht registriert.",
+    }
-      "system-key-warning" : "\n\n---------------------------------------------------------------------\nDie Datei mit den Datenflowberechtigungsnachweisen wird mit einem vom System generierten Schlüssel verschlüsselt.\n\nWenn der vom System generierte Schlüssel aus irgendeinem Grund verloren geht, werden Ihre Berechtigungsnachweise\nDie Datei kann nicht wiederhergestellt werden. Sie müssen sie löschen und erneut eingeben.\nIhre Berechtigungsnachweise.\n\nSie sollten Ihren eigenen Schlüssel mit Hilfe der Option 'credentialSecret' in\nIhre Einstellungsdatei. Node-RED wird dann Ihre Berechtigungsnachweise erneut verschlüsseln.\nDatei mit dem ausgewählten Schlüssel beim nächsten Deployen einer Änderung verwenden.\n---------------------------------------------------------------------\n"
   },
-    "flows" : {
+
-      "registered-missing" : "Fehlender Typ registriert: __type__",
+  "comms": {
-      "error" : "Fehler beim Laden von Flows: __message__",
+    "error": "Kommunikationskanal-Fehler: __message__",
-      "starting-modified-nodes" : "Modifizierte Nodes werden gestartet",
+    "error-server": "Kommunikationsserver-Fehler: __message__",
-      "starting-modified-flows" : "Modifizierte Flows werden gestartet",
+    "error-send": "Kommunikationsende-Fehler: __message__"
-      "starting-flows" : "Flows starten",
-      "started-modified-nodes" : "Gestartete geänderte Nodes",
-      "started-modified-flows" : "Gestartete geänderte Flows",
-      "started-flows" : "Flows gestartet",
-      "stopping-modified-nodes" : "Modifizierte Nodes werden gestoppt",
-      "stopping-modified-flows" : "Modifizierte Flows werden gestoppt",
-      "stopping-flows" : "Flows stoppen",
-      "stopped-modified-nodes" : "Geänderte Nodes gestoppt",
-      "stopped-modified-flows" : "Geänderte Flows gestoppt",
-      "stopped-flows" : "Flows gestoppt",
-      "stopped" : "Gestoppt",
-      "stopping-error" : "Fehler beim Stoppen des Nodes: __message__",
-      "added-flow" : "Flow hinzufügen: __label__",
-      "updated-flow" : "Aktualisierter Flow: __label__",
-      "removed-flow" : "Entfernter Flow: __label__",
-      "missing-types" : "Warten auf fehlende Typen, die registriert werden sollen:",
-      "missing-type-provided" : " -__type__ (wird von npm Modul __module__ bereitgestellt)",
-      "missing-type-install-1" : "Führen Sie die folgenden Schritte aus, um eines der fehlenden Module zu installieren:",
-      "missing-type-install-2" : "im Verzeichnis:"
   },
-    "flow" : {
+
-      "unknown-type" : "Unbekannter Typ: __type__",
+  "settings": {
-      "missing-types" : "Fehlende Typen",
+    "user-not-available": "Benutzereinstellungen konnten nicht gespeichert werden: __message__",
-      "error-loop" : "Nachricht überschritt die maximale Anzahl der Wiederholungen"
+    "not-available": "Einstellungen nicht verfügbar",
+    "property-read-only": "Die Eigenschaft '__prop__ 'ist schreibgeschützt"
   },
-    "index" : {
+
-      "unrecognised-id" : "Nicht erkannte ID: __id__",
+  "nodes": {
-      "type-in-use" : "Typ in Verwendung: __msg__",
+    "credentials": {
-      "unrecognised-module" : "Nicht erkannes Modul: __module__"
+      "error": "Fehler beim Laden der Berechtigungen: __message__",
+      "error-saving": "Fehler beim Speichern der Berechtigungen: __message__",
+      "not-registered": "Der Berechtigung-Typ '__type__' ist nicht registriert",
+      "system-key-warning": "\n---------------------------------------------------------------------\nDie Datei mit den Flow-Berechtigungen wird mit einem vom System\ngenerierten Schlüssel verschlüsselt.\nWenn der vom System generierte Schlüssel aus irgendeinem Grund\nverloren geht, kann die Datei mit den Berechtigungen nicht\nwiederhergestellt werden. Sie muss dann gelöscht und die\nBerechtigungen müssen erneut eingestellt werden.\nEs sollte ein eigener Schlüssel mit Hilfe der Option\n'credentialSecret' in der Einstellungsdatei vorgegeben werden.\nNode-RED wird dann die Datei mit den Flow-Berechtigungen\nbei der nächsten Übernahme (Deploy) einer Änderung erneut\nverschlüsseln.\n---------------------------------------------------------------------"
     },
-    "registry" : {
+    "flows": {
-      "localfilesystem" : {
+      "safe-mode": "Die Flows sind gestoppt im abgesicherten Modus. Übernahme (Deploy) zum Starten.",
-        "module-not-found" : "Modul '__module__' wurde nicht gefunden."
+      "registered-missing": "Fehlender Typ registriert: __type__",
+      "error": "Fehler beim Laden der Flows: __message__",
+      "starting-modified-nodes": "Geänderte Nodes werden gestartet",
+      "starting-modified-flows": "Geänderte Flows werden gestartet",
+      "starting-flows": "Flows werden gestartet",
+      "started-modified-nodes": "Geänderte Nodes sind gestartet",
+      "started-modified-flows": "Geänderte Flows sind gestartet",
+      "started-flows": "Flows sind gestartet",
+      "stopping-modified-nodes": "Geänderte Nodes werden gestoppt",
+      "stopping-modified-flows": "Geänderte Flows werden gestoppt",
+      "stopping-flows": "Flows werden gestoppt",
+      "stopped-modified-nodes": "Geänderte Nodes sind gestoppt",
+      "stopped-modified-flows": "Geänderte Flows sind gestoppt",
+      "stopped-flows": "Flows sind gestoppt",
+      "stopped": "gestoppt",
+      "stopping-error": "Fehler beim Stoppen des Nodes: __message__",
+      "added-flow": "Flow wird hinzugefügt: __label__",
+      "updated-flow": "Aktualisierter Flow: __label__",
+      "removed-flow": "Entfernter Flow: __label__",
+      "missing-types": "Warten auf Registrierung fehlender Typen:",
+      "missing-type-provided": " - __type__ (wird vom npm-Modul __module__ bereitgestellt)",
+      "missing-type-install-1": "Um die fehlenden Module zu installieren, ist zu starten:",
+      "missing-type-install-2": "Im Verzeichnis:"
+    },
+    "flow": {
+      "unknown-type": "Unbekannter Typ: __type__",
+      "missing-types": "Fehlende Typen",
+      "error-loop": "Maximale Anzahl der Meldungen überschritten"
+    },
+    "index": {
+      "unrecognised-id": "Unbekannte ID: __id__",
+      "type-in-use": "Typ in Verwendung: __msg__",
+      "unrecognised-module": "Unbekanntes Modul: __module__"
+    },
+    "registry": {
+      "localfilesystem": {
+        "module-not-found": "Das Modul '__module__' wurde nicht gefunden"
       }
     }
   },
-  "storage" : {
+
-    "index" : {
+  "storage": {
-      "forbidden-flow-name" : "Unzulässiger Flowname"
+    "index": {
+      "forbidden-flow-name": "Unzulässiger Flow-Name"
     },
-    "localfilesystem" : {
+    "localfilesystem": {
-      "user-dir" : "Benutzerverzeichnis: __path__",
+      "user-dir": "Benutzerverzeichnis: __path__",
-      "flows-file" : "Flow-Datei: __path__",
+      "flows-file": "Flow-Datei: __path__",
-      "create" : "Neue __type__-Datei wird erstellt",
+      "create": "Neue __type__-Datei wird erstellt",
-      "empty" : "Vorhandene __type__-Datei ist leer",
+      "empty": "Vorhandene __type__-Datei ist leer",
-      "invalid" : "Vorhandene __type__ Datei ist ungültig (json)",
+      "invalid": "Vorhandene __type__-Datei enthält ungültigen JSON-Code",
-      "restore" : "__type__ Dateisicherung wird zurückgespeichert: __path__",
+      "restore": "Die __type__-Dateisicherung wird wiederhergestellt: __path__",
-      "restore-fail" : "Das Zurückschreiben der __type__ Dateisicherung ist fehlgeschlagen: __message__",
+      "restore-fail": "Die Wiederherstellung der '__type__'-Dateisicherung ist fehlgeschlagen: __message__",
-      "fsync-fail" : "Das Löschen der Datei __path__ auf die Platte ist fehlgeschlagen: __message__",
+      "fsync-fail": "Die Übertragung der Datei __path__ auf das Laufwerk ist fehlgeschlagen: __message__",
-      "projects" : {
+      "projects": {
-        "changing-project" : "Aktives Projekt wird festgelegt: __project__",
+        "changing-project": "Aktives Projekt wird festgelegt: __project__",
-        "active-project" : "Aktives Projekt: __project__",
+        "active-project": "Aktives Projekt: __project__",
-        "project-not-found" : "Projekt nicht gefunden: __project__",
+        "project-not-found": "Projekt nicht gefunden: __project__",
-        "no-active-project" : "Kein aktives Projekt: Standarddatei für DatenFlows verwenden",
+        "no-active-project": "Kein aktives Projekt: Es wird die Standarddatei für die Flows verwendet",
-        "disabled" : "Projekte inaktiviert: editorTheme.projects.enabled=false",
+        "disabled": "Projekte deaktiviert: editorTheme.projects.enabled=false",
-        "disabledNoFlag" : "Projekte inaktiviert: setze editorTheme.projects.enabled=true zum Aktivieren",
+        "disabledNoFlag": "Projekte deaktiviert: Setze editorTheme.projects.enabled=true zum Aktivieren",
-        "git-not-found" : "Projekte inaktiviert: Git-Befehl nicht gefunden",
+        "git-not-found": "Projekte deaktiviert: Git nicht gefunden",
-        "git-version-old" : "Projekte inaktiviert: git __version__ wird nicht unterstützt. Erfordert 2.x",
+        "git-version-old": "Projekte deaktiviert: Git __version__ wird nicht unterstützt. Erforderlich: V2.x",
-        "summary" : "Ein Node-RED-Projekt",
+        "summary": "Ein Node-RED-Projekt",
-        "readme" : "### Produktinfo\n\nDies ist die Datei README.md Ihres Projekts. Es hilft den Benutzern zu verstehen, was Ihr\nProjekt macht, wie man es verwendet und alles andere, was sie vielleicht wissen müssen."
+        "readme": "### Produktinfo\n\nDies ist die 'README.md'-Datei Ihres Projekts.\nSie hilft den Benutzern zu verstehen, was das Projekt macht,\nwie man es verwendet und enthält alles andere Wissenwerte dazu."
       }
     }
   },
-  "context" : {
+
-    "log-store-init" : "Kontextspeicher: '__name__' [ __info__]",
+  "context": {
-    "error-loading-module" : "Fehler beim Laden des Kontextspeichers: __message__",
+    "log-store-init": "Kontextspeicher: __name__ [__info__]",
-    "error-module-not-defined" : "Kontextspeicher '__storage__' fehlt 'Modul' -Option",
+    "error-loading-module": "Fehler beim Laden des Kontextspeichers: __message__",
-    "error-invalid-module-name" : "Ungültiger Kontextspeichername: '__name__'",
+    "error-loading-module2": "Fehler beim Laden des Kontextspeichers '__module__': __message__",
-    "error-invalid-default-module" : "Standardkontextspeicher unbekannt: '__storage__'",
+    "error-module-not-defined": "Beim Kontextspeicher '__storage__' fehlt die 'module'-Option",
-    "unknown-store" : "Unbekannter Kontextspeicher '__name__' angegeben. Standardspeicher wird verwendet.",
+    "error-invalid-module-name": "Ungültiger Kontextspeichername: __name__",
-    "localfilesystem" : {
+    "error-invalid-default-module": "Standardkontextspeicher unbekannt: __storage__",
-      "error-circular" : "Kontext __scope__ enthält einen kreisförmigen Verweis, der nicht persistent gespeichert werden kann.",
+    "unknown-store": "Unbekannter Kontextspeicher '__name__ ' angegeben. Standard-Kontextspeicher wird verwendet.",
-      "error-write" : "Fehler beim Schreiben des Kontextes: __message__"
+    "localfilesystem": {
+      "invalid-json": "Ungültiger JSON-Code in Kontextspeicher-Datei '__file__'",
+      "error-circular": "Der Kontext __scope__ enthält einen zirkulären Bezug, der nicht persistent gespeichert werden kann",
+      "error-write": "Fehler beim Schreiben des Kontextes: __message__"
     }
   }
+
 }