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" : {
-    "tip0" : "Sie können die ausgewählten Nodes oder Verbindungen mit {{ core:delete-selection }} entfernen.",
-    "tip1" : "Suche nach Nodes mit {{ core:search }}",
-    "tip2" : "{{ core:toggle-sidebar }} schaltet die Ansicht dieser Seitenleiste ein.",
-    "tip3" : "Sie können Ihre Palette von Nodes 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.",
-    "tip5" : "Aktiviert oder inaktiviert diese Tipps von der Option in den Einstellungen",
-    "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",
-    "tip7" : "Wenn Sie einen Node auf eine Verbindung ziehen, wird er in die Verbindung eingefügt.",
-    "tip8" : "Die ausgewählten Nodes exportieren oder die aktuelle Registerkarte mit {{ core:show-export-dialog }}",
-    "tip9" : "Importieren Sie einen Flow, indem Sie sein JSON in den Editor ziehen oder mit {{ 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.",
-    "tip11" : "Die Registerkarte \"Info\" mit {{ core:show-info-tab }} oder der Registerkarte \"Debug\" mit {{ core:show-debug-tab }} anzeigen",
-    "tip12" : "[ctrl] [Klicken] in den Arbeitsbereich, um den Schnellhinzufügedialog zu öffnen.",
-    "tip13" : "Halten Sie [ctrl] gedrückt, wenn Sie auf einem Node-Anschluss klicken, um eine Schnellverbindung zu aktivieren.",
-    "tip14" : "Halten Sie [Umschalt] gedrückt, wenn Sie auf einen Node klicken, um auch alle verbundenen Nodes 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.",
-    "tip16" : "Indexzungen wechseln mit {{ core:show-previous-tab }} und {{ core:show-next-tab }}",
-    "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.",
-    "tip18" : "Durch Drücken von {{ core:edit-selected-node }} wird der erste Node in der aktuellen Auswahl bearbeitet."
+    "info": {
+        "tip0": "Sie können die ausgewählten Nodes oder Verbindungen mit {{ core:delete-selection }} entfernen",
+        "tip1": "Sie können nach Nodes mit  {{ core:search }} suchen",
+        "tip2": "{{ core:toggle-sidebar }} blendet die Seitenleiste ein/aus",
+        "tip3": "Sie können Ihre Node-Palette mit {{ core:manage-palette }} verwalten",
+        "tip4": "Ihre Flow-Konfigurationsnodes werden in der Seitenleiste angezeigt, die über das Menü oder mit {{ core:show-config-tab }} angezeigt werden kann",
+        "tip5": "Aktiviere oder deaktiviere diese Tipps in den Benutzereinstellungen",
+        "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 ein Node auf eine Verbindung ziehen, wird es in die Verbindung eingefügt",
+        "tip8": "Sie können die ausgewählten Nodes oder den aktuellen Flow-Tab mit {{ core:show-export-dialog }} exportieren",
+        "tip9": "Sie können einen Flow importieren, indem Sie sein JSON in den Editor ziehen oder mittels {{ core:show-import-dialog }}",
+        "tip10": "Halten Sie [Shift] beim [Klicken] auf ein Node gedrückt, um auch alle verbundenen Nodes mit zu verschieben",
+        "tip11": "Sie können den Tab 'Info' mit {{ core:show-info-tab }} oder den Tab 'Debug' mit {{ core:show-debug-tab }} anzeigen lassen",
+        "tip12": "Halten Sie [Strg] beim [Klicken] in den Arbeitsbereich gedrückt, um den Schnellhinzufügedialog öffnen",
+        "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 [Shift] beim [Klicken] auf ein Node gedrückt, um auch alle verbundenen Nodes mit auszuwählen",
+        "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": "Sie können die Flow-Tabs mit {{ core:show-previous-tab }} und {{ core:show-next-tab }} wechseln",
+        "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": "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" : {
-    "args" : "arg",
-    "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."
+    "$string": {
+        "args": "arg[, prettify]",
+        "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" : {
-    "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."
+    "$length": {
+        "args": "str",
+        "desc": "Gibt die Zeichenanzahl von `str` zurück. Es wird ein Fehler ausgelöst, wenn `str` keine Zeichenfolge ist."
     },
-  "$substring" : {
-    "args" : "str, start [, länge]",
-    "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."
+    "$substring": {
+        "args": "str, start [, length]",
+        "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" : {
-    "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."
+    "$substringBefore": {
+        "args": "str, chars",
+        "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" : {
-    "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."
+    "$substringAfter": {
+        "args": "str, chars",
+        "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" : {
-    "args" : "str",
-    "desc" : "Gibt eine Zeichenfolge mit allen Zeichen von `str` zurück, die in Großbuchstaben konvertiert werden."
+    "$uppercase": {
+        "args": "str",
+        "desc": "Gibt veränderten `str` zurück, bei dem allen Zeichen in Großbuchstaben umgewandelt wurden."
     },
-  "$lowercase" : {
-    "args" : "str",
-    "desc" : "Gibt eine Zeichenfolge mit allen Zeichen von `str` in Kleinbuchstaben zurück."
+    "$lowercase": {
+        "args": "str",
+        "desc": "Gibt veränderten `str` zurück, bei dem allen Zeichen in Kleinbuchstaben umgewandelt wurden."
     },
-  "$trim" : {
-    "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."
+    "$trim": {
+        "args": "[str]",
+        "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" : {
-    "args" : "str, Muster",
-    "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."
+    "$contains": {
+        "args": "str, pattern",
+        "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" : {
-    "args" : "str [, Trennzeichen] [, Grenzwert]",
-    "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."
+    "$split": {
+        "args": "str [, separator] [, limit]",
+        "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" : {
-    "args" : "array [, Trennzeichen]",
-    "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."
+    "$join": {
+        "args": "array [, separator]",
+        "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" : {
-    "args" : "str, Muster [, Grenzwert]",
-    "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."
+    "$match": {
+        "args": "str, pattern [, limit]",
+        "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" : {
-    "args" : "str, Muster, Ersatz [, Grenzwert]",
-    "desc" : "Findet Vorkommen von `Muster` in `str` und ersetzt sie durch `Ersatz`.\n\nDer optionale Parameter 'Grenzwert' ist die maximale Anzahl an Ersetzungen."
+    "$replace": {
+        "args": "str, pattern, replacement [, limit]",
+        "desc": "Findet Vorkommen von `pattern` in `str` und ersetzt sie durch `replacement`.\n\nDer optionale Parameter `limit` ist die maximale Anzahl an Ersetzungen."
     },
-  "$now" : {
-    "args" : "",
-    "desc" : "Generiert einen Zeitstempel im ISO-8601-kompatiblen Format und gibt sie als Zeichenfolge zurück."
+    "$now": {
+        "args": "",
+        "desc": "Generiert einen Zeitstempel im ISO-8601-kompatiblen Format und gibt sie als Zeichenfolge zurück."
     },
-  "$base64encode" : {
-    "args" : "Zeichenfolge",
-    "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."
+    "$base64encode": {
+        "args": "str",
+        "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" : {
-    "args" : "Zeichenfolge",
-    "desc" : "Konvertiert die Basis-64-codierten Byte in eine Zeichenfolge unter Verwendung einer UTF-8-Unicode-Codepage."
+    "$base64decode": {
+        "args": "str",
+        "desc": "Konvertiert den Basis-64-codierten `str` in eine Zeichenfolge unter Verwendung einer UTF-8-Unicode-Codepage."
     },
-  "$number" : {
-    "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."
+    "$number": {
+        "args": "arg",
+        "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" : {
-    "args" : "Anzahl",
-    "desc" : "Gibt den absoluten Wert des Parameters 'Zahl' zurück."
+    "$abs": {
+        "args": "number",
+        "desc": "Gibt den absoluten Wert von `number` zurück."
     },
-  "$floor" : {
-    "args" : "Anzahl",
-    "desc" : "Gibt den Wert von 'Zahl' auf die nächste ganze Zahl zurück, die kleiner oder gleich 'Zahl' ist."
+    "$floor": {
+        "args": "number",
+        "desc": "Gibt `number` abgerundet auf die nächste ganze Zahl zurück, die kleiner oder gleich `number` ist."
     },
-  "$ceil" : {
-    "args" : "Anzahl",
-    "desc" : "Gibt den Wert von 'Zahl' auf die nächste ganze Zahl zurück, die größer oder gleich 'Zahl' ist."
+    "$ceil": {
+        "args": "number",
+        "desc": "Gibt `number` aufgerundet auf die nächste ganze Zahl zurück, die größer oder gleich `number` ist."
     },
-  "$round" : {
-    "args" : "Zahl [, Genauigkeit]",
-    "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."
+    "$round": {
+        "args": "number [, precision]",
+        "desc": "Gibt `number` gerundet auf die Anzahl der Nachkommastellen zurück, welche durch den optionalen Parameter `precision` vorgegeben ist."
     },
-  "$power" : {
-    "args" : "Basis, Exponent",
-    "desc" : "Gibt den Wert von `Basis` potenziert mit `Exponent` zurück."
+    "$power": {
+        "args": "base, exponent",
+        "desc": "Gibt `base` potenziert mit `exponent` zurück."
     },
-  "$sqrt" : {
-    "args" : "Zahl",
-    "desc" : "Gibt die Quadratwurzel des Werts des Parameters 'Zahl' zurück."
+    "$sqrt": {
+        "args": "number",
+        "desc": "Gibt die Quadratwurzel von `number` zurück."
     },
-  "$random" : {
-    "args" : "",
-    "desc" : "Gibt eine Pseudozufallszahl größer-gleich null und kleiner als eins zurück."
+    "$random": {
+        "args": "",
+        "desc": "Gibt eine Pseudozufallszahl größer-gleich null und kleiner als eins zurück."
     },
-  "$millis" : {
-    "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."
+    "$millis": {
+        "args": "",
+        "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" : {
-    "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."
+    "$sum": {
+        "args": "array",
+        "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" : {
-    "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."
+    "$max": {
+        "args": "array",
+        "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" : {
-    "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."
+    "$min": {
+        "args": "array",
+        "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" : {
-    "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."
+    "$average": {
+        "args": "array",
+        "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" : {
-    "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 `"
+    "$boolean": {
+        "args": "arg",
+        "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" : {
-    "args" : "arg",
-    "desc" : "Gibt den Booleschen Wert NOT für das Argument zurück. `arg` wird zuerst in einen Booleschen Wert umgesetzt."
+    "$not": {
+        "args": "arg",
+        "desc": "Gibt den invertierten booleschen Wert von `arg` zurück. `arg` wird zuerst in einen booleschen Wert umgesetzt."
     },
-  "$exists" : {
-    "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)."
+    "$exists": {
+        "args": "arg",
+        "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" : {
-    "args" : "Array",
-    "desc" : "Gibt die Anzahl der Elemente in dem Array zurück."
+    "$count": {
+        "args": "array",
+        "desc": "Gibt die Anzahl der Elemente in dem Array `array` zurück."
     },
-  "$append" : {
-    "args" : "Array, Array",
-    "desc" : "Hängen Sie zwei Arrays an."
+    "$append": {
+        "args": "array, array",
+        "desc": "Verkettet zwei Arrays miteinander."
     },
-  "$sort" : {
-    "args" : "array [, Funktion]",
-    "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."
+    "$sort": {
+        "args": "array [, function]",
+        "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" : {
-    "args" : "Array",
-    "desc" : "Gibt ein Array zurück, das alle Werte aus dem Parameter 'array' enthält, aber in umgekehrter Reihenfolge."
+    "$reverse": {
+        "args": "array",
+        "desc": "Gibt ein Array zurück, das alle Elemente vom `array` in umgekehrter Reihenfolge enthält."
     },
-  "$shuffle" : {
-    "args" : "Array",
-    "desc" : "Gibt ein Array zurück, das alle Werte aus dem Parameter ` array ` enthält, aber in zufälliger Reihenfolge geschattiert ist."
+    "$shuffle": {
+        "args": "array",
+        "desc": "Gibt ein Array zurück, das alle Elemente vom `array` in zufälliger Reihenfolge enthält."
     },
-  "$zip" : {
-    "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."
+    "$zip": {
+        "args": "array, ...",
+        "desc": "Gibt ein gepacktes (geziptes) Array zurück, das gruppierte Arrays der Elemente von `array1` ... `arrayN` aus Index 0, 1, 2 ... enthält."
     },
-  "$keys" : {
-    "args" : "Objekt",
-    "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."
+    "$keys": {
+        "args": "object",
+        "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" : {
-    "args" : "Objekt, Schlüssel",
-    "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."
+    "$lookup": {
+        "args": "object, key",
+        "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" : {
-    "args" : "Objekt",
-    "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."
+    "$spread": {
+        "args": "object",
+        "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" : {
-    "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."
+    "$merge": {
+        "args": "array<object>",
+        "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" : {
-    "args" : "Objekt, Funktion",
-    "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]]) `"
+    "$sift": {
+        "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 `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" : {
-    "args" : "Objekt, Funktion",
-    "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."
+    "$each": {
+        "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."
     },
-  "$map" : {
-    "args" : "Array, Funktion",
-    "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]]) `"
+    "$map": {
+        "args": "array, function",
+        "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" : {
-    "args" : "Array, Funktion",
-    "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]]) `"
+    "$filter": {
+        "args": "array, function",
+        "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" : {
-    "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."
+    "$reduce": {
+        "args": "array, function [, init]",
+        "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" : {
-    "args" : "Zeichenfolge [, Zeichenfolge]",
-    "desc" : "Ruft eine Flusskontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ \"Node-RED\"."
+    "$flowContext": {
+        "args": "str [, str]",
+        "desc": "Ruft eine Flow-Kontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ `Node-RED`."
     },
-  "$globalContext" : {
-    "args" : "Zeichenfolge [, Zeichenfolge]",
-    "desc" : "Ruft eine globale Kontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ \"Node-RED\"."
+    "$globalContext": {
+        "args": "str [, str]",
+        "desc": "Ruft eine globale Kontexteigenschaft ab.\n\nDies ist eine definierte Funktion vom Typ `Node-RED`."
     },
-  "$pad" : {
-    "args" : "string, 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."
+    "$pad": {
+        "args": "str, width [, char]",
+        "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" : {
-    "args" : "Anzahl",
-    "desc" : "Konvertieren Sie eine Zahl, die Millisekunden seit der Unix-Epoche (1. Januar 1970 (UTC)) enthält in eine Zeitangabe im ISO 8601-Format."
+    "$fromMillis": {
+        "args": "number",
+        "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" : {
-    "args" : "Zahl, Bild [, Optionen]",
-    "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."
+    "$formatNumber": {
+        "args": "number, picture [, options]",
+        "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" : {
-    "args" : "Zahl [, 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."
+    "$formatBase": {
+        "args": "number [, radix]",
+        "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" : {
-    "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."
+    "$toMillis": {
+        "args": "timestamp",
+        "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" : {
-    "args" : "arg",
-    "desc" : "Gibt den Wert einer Umgebungsvariablen zurück.\n\nDies ist eine definierte Funktion vom Typ \"Node-RED\"."
+    "$env": {
+        "args": "arg",
+        "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. 
-    Bei den Nutzdaten kann es sich um eine Vielzahl von Typen handeln, einschließlich Zeichenfolgen, JavaScript-Objekte oder die aktuelle Zeit. </p>
-    <h3> Ausgaben </h3>
+    <p>Injektion einer Nachricht manuell oder in regelmäßigen Intervallen in einen Flow.
+       Bei den Nutzdaten (Payload) der Nachricht kann es sich um eine Vielzahl von Typen handeln,
+       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>
-        <dd> Die konfigurierten Nutzdaten der Nachricht. </dd>
-        <dt class="optional"> Topic  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Eine optionale Eigenschaft, die im Node konfiguriert werden kann. </dd>
+        <dt>payload<span class="property-type">Verschiedene Typen</span></dt>
+        <dd>Eingestellte Nutzdaten (Payload) der Nachricht</dd>
+        <dt class="optional">topic<span class="property-type">string</span></dt>
+        <dd>Optional nutzbare Nachrichten-Eigenschaft</dd>
     </dl>
-    <h3> Details </h3>
-    <p> Der Inject-Node kann einen Flow mit einem bestimmten Nutzdatenwert starten.
-    Der Standard-Payload ist die aktuelle Zeit als Zeitstempel seit dem 1. Januar 1970 in Millisekunden. </p>
-    <p> Der Node unterstützt auch die Injektion von Zeichenfolgen, Zahlen, Boolescher Daten, JavaScript-Objekten oder flow/globalen Kontextwerten. </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> Er kann auch so konfiguriert werden, dass er jedes Mal, wenn der Flow gestartet wird einen Wert injiziert. </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> <b> Hinweis </b>: Die Optionen  <i> "Intervall zwischen den Zeiten" </i>  und  <i> "Zu einem bestimmten Zeitpunkt" </i>  verwenden das Standardcron-System.
-    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.
-    Wenn Sie alle 20 Minuten ab sofort verwenden möchten, verwenden Sie die Option  <i> "interval" </i> . </p>
-    <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>
+    <h3>Details</h3>
+    <p>Der <span style="background-color:Gainsboro">inject</span>-Node kann einen Flow mit einstellbaren Nutzdaten (Payload) starten.
+       Der voreingestellte Payload ist die aktuelle Zeit als Zeitstempel in Millisekunden
+       seit Beginn der Unix-Zeitrechnung (1. Januar 1970 UTC).</p>
+    <p>Der Node unterstützt auch die Injektion von Zeichenfolgen, Zahlenwerten, Booleschen Werten,
+       JavaScript-Objekten oder Flow-lokalen oder globalen Kontextwerten.</p>
+    <p>Der Node wird normalerweise manuell ausgelöst, indem im Editor auf seine Schaltfläche geklickt wird.
+       Er kann auch in regelmäßigen Intervallen oder nach einem Zeitplan injizieren.</p>
+    <p>Er kann auch so eingestellt werden, dass er jedes Mal einen Wert injiziert, wenn der Flow gestartet wird.</p>
+    <p>Das maximal einstellbare Intervall beträgt etwa 596 Stunden bzw. 24 Tage.
+       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 
-    optional im Laufzeitprotokoll an. Standardmäßig wird  <code>msg.payload</code> angezeigt. </p>
-  <h3> Details </h3>
-  <p> Die Registerkarte "Debug" bietet eine strukturierte Sicht der Nachrichten an 
-    wodurch die ihre Struktur leichter zu verstehen ist. </p>
-  <p> JavaScript-Objekte und -Arrays können nach Bedarf ausgeblendet und eingeblendet werden. 
-    Bufferobjekte können, wenn möglich, als Rohdaten oder als Zeichenfolge angezeigt werden. </p>
-  <p> Neben jeder Nachricht enthält die Registerkarte "Debug" Informationen über den Zeitpunkt, 
-    zu dem die Nachricht empfangen wurde, den Node, der sie gesendet hat, und den Typ der Nachricht.
-    Wenn Sie auf die ID des Quellen-Nodes klicken, wird dieser Node innerhalb des Arbeitsbereichs angezeigt. </p>
-  <p> Die Schaltfläche auf dem Node kann verwendet werden, um die Ausgabe zu aktivieren oder zu inaktivieren.
-    Es wird empfohlen, alle Debug-Nodes, die nicht verwendet werden, zu inaktivieren oder zu entfernen. </p>
-  <p> Der Node kann auch so konfiguriert werden, dass er alle Nachrichten an das Laufzeitprotokoll sendet,
-    oder dass er kurze (32 Zeichen) an den Statustext unter dem Debug-Node sendet. </p>
+    <p>Anzeige ausgewählter Nachrichten wahlweise im Debug-Tab, als Node-Status und in der Systemkonsole.
+       Standardmäßig wird <code>msg.payload</code> angezeigt.</p>
+    <h3>Details</h3>
+    <p>Der Debug-Tab zeigt ein strukturiertes Protokoll der empfangenen Nachrichten an,
+       wodurch die ihre Struktur leichter zu verstehen ist.</p>
+    <p>JavaScript-Objekte und -Arrays können nach Bedarf ein- und ausgeblendet werden.
+       Binäre Puffer-Objekte (buffer objects) können nach Möglichkeit als Rohdaten oder als Zeichenfolge (string) angezeigt werden.</p>
+    <p>Neben der eigentlichen Nachricht werden im Debug-Tab auch der Empfangszeitpunkt,
+       der empfangende <span style="background-color:Gainsboro">debug</span>-Node, sowie Name und Typ der Nachricht protokolliert.
+       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 des <span style="background-color:Gainsboro">debug</span>-Nodes kann verwendet werden, um die Debug-Ausgabe ein- und auszuschalten.
+       Es ist empfehlenswert, alle nicht verwendeten <span style="background-color:Gainsboro">debug</span>-Nodes zu deaktivieren oder gleich zu entfernen.</p>
+    <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
+       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>
-    <h3> Ausgaben </h3>
+    <p>Abfang von Fehlern von Nodes im selben Flow-Tab.</p>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt> error.message <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> die Fehlernachricht. </dd>
-        <dt> error.source.id  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Die ID des Nodes, der den Fehler ausgelöst hat. </dd>
-        <dt> error.source.type  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Der Typ des Nodes, der den Fehler ausgelöst hat. </dd>
-        <dt> error.source.name  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Der Name des Nodes (falls festgelegt), der den Fehler ausgelöst hat. </dd>
+        <dt>error.message<span class="property-type">string</span></dt>
+        <dd>Fehlermeldung</dd>
+        <dt>error.source.id<span class="property-type">string</span></dt>
+        <dd>ID des fehlerauslösenden Nodes</dd>
+        <dt>error.source.type<span class="property-type">string</span></dt>
+        <dd>Typ des fehlerauslösenden Nodes</dd>
+        <dt>error.source.name<span class="property-type">string</span></dt>
+        <dd>Name des fehlerauslösenden Nodes (falls festgelegt)</dd>
     </dl>
-    <h3> Details </h3>
-    <p> Wenn ein Node bei der Verarbeitung einer Nachricht einen Fehler auslöst, wird der Flow in der Regel
-       angehalten. Dieser Node kann verwendet werden, um diese Fehler abzufangen und sie mit einem
-       dedizierten Flow zu bearbeiten. </p>
-    <p> Der Node fängt standardmäßig Fehler ab, die von einem beliebigen Node auf derselben Registerkarte ausgelöst werden. Alternativ
-   kann er an einen bestimmten Node gebunden werden. </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 Fehlerabfang-Node
-       innerhalb des Subflows abgefangen. Wenn keine vorhanden sind, wird zu dem Tab geleitet, 
-       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>
+    <h3>Details</h3>
+    <p>Wenn ein Node bei der Verarbeitung einer Nachricht einen Fehler verursacht, wird der Flow in der Regel angehalten.
+       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>
+    <p>Der Node fängt standardmäßig die Fehler aller Nodes im selben Flow ab.
+       Alternativ kann er auch an bestimmte Nodes 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 in einem Subflow ausgelöst wird, wird der Fehler von einem <span style="background-color:Gainsboro">catch</span>-Node
+       innerhalb des Subflows abgefangen.
+       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>
+    <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>
-    <h3> Ausgaben </h3>
+    <p>Berichten von Statusnachrichten anderer Nodes im selben Flow.</p>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt> status.text  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Statustext </dd>
-        <dt> status.source.type  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Der Typ des Nodes, der den Status gemeldet hat </dd>
-        <dt> status.source.id  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Die ID des Nodes, der den Status gemeldet hat. </dd>
-        <dt> status.source.name  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Der Name des Nodes (falls gesetzt), der den Status gemeldet hat. </dd>
+        <dt>status.text<span class="property-type">string</span></dt>
+        <dd>Statustext</dd>
+        <dt>status.source.type<span class="property-type">string</span></dt>
+        <dd>Typ des statusmeldenden Nodes</dd>
+        <dt>status.source.id<span class="property-type">string</span></dt>
+        <dd>ID des statusmeldenden Nodes</dd>
+        <dt>status.source.name<span class="property-type">string</span></dt>
+        <dd>Name des statusmeldenden Nodes (falls festgelegt)</dd>
     </dl>
-    <h3> Details </h3>
-   <p> Dieser Node erzeugt keine <code>Nutzdaten</code>. </p>
-   <p> Standardmäßig meldet der Node den Status für alle Node auf derselben Registerkarte.
-   Er kann so konfiguriert werden, dass der Status für einzelne Nodes selektiv gemeldet wird. </p>
+    <h3>Details</h3>
+    <p>Dieser Node erzeugt keine Nutzdaten (Payload).</p>
+    <p>Der Node meldet standardmäßig den Status aller Nodes im selben Flow.
+       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>
-   <h3> Details </h3>
-   <p> Der Node kann mit jedem beliebigen  <code>Link-out</code> Node auf einer beliebigen Registerkarte verbunden werden.
-      Sobald sie verbunden sind, verhalten sie sich so, als wären sie direkt verbunden. </p>
-   <p> Die Verbindungen zwischen Verknüpfungs-Node werden nur angezeigt, wenn ein Verknüpfungs-Node ausgewählt ist.
-      Wenn Verbindungen zu anderen Registerkarten vorhanden sind, wird ein virtueller Node angezeigt, auf den geklickt werden kann,
-      um zur entsprechenden Registerkarte zu springen. </p>
-   <p> <b> Hinweis:  </b> Links können nicht in einem Subflow erstellt oder aus einem Subflow heraus erstellt werden. </p>
+    <p>Erstellung virtueller Verbindungen (Links) zwischen Flows.</p>
+    <h3>Details</h3>
+    <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 verlinkt sind, verhalten sie sich so, als wären sie direkt miteinander verbunden.</p>
+    <p>Die Links zwischen Link-Nodes werden nur angezeigt, wenn ein Link-Node ausgewählt ist.
+       Wenn Links zu anderen Flow-Tabs vorhanden sind, werden virtuelle Link-Nodes als Gegenparts angezeigt,
+       über die durch Klicken zum entsprechenden Flow-Tab gesprungen werden kann.</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>
-   <h3> Details </h3>
-   <p> Der Node kann mit jedem beliebigen  <code>Link-out</code> Node auf einer beliebigen Registerkarte verbunden werden.
-      Sobald sie verbunden sind, verhalten sie sich so, als wären sie direkt verbunden. </p>
-   <p> Die Verbindungen zwischen Verknüpfungs-Node werden nur angezeigt, wenn ein Verknüpfungs-Node ausgewählt ist.
-      Wenn Verbindungen zu anderen Registerkarten vorhanden sind, wird ein virtueller Node angezeigt, auf den geklickt werden kann,
-      um zur entsprechenden Registerkarte zu springen. </p>
-   <p> <b> Hinweis:  </b> Links können nicht in einem Subflow erstellt oder aus einem Subflow heraus erstellt werden. </p>
+    <p>Erstellung virtueller Verbindungen (Links) zwischen Flows.</p>
+    <h3>Details</h3>
+    <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 verlinkt sind, verhalten sie sich so, als wären sie direkt miteinander verbunden.</p>
+    <p>Die Links zwischen Link-Nodes werden nur angezeigt, wenn ein Link-Node ausgewählt ist.
+       Wenn Links zu anderen Flow-Tabs vorhanden sind, werden virtuelle Link-Nodes als Gegenparts angezeigt,
+       über die durch Klicken zum entsprechenden Flow-Tab gesprungen werden kann.</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>
+    <p>Das Textfeld des Nodes verwendet den Markdown-Syntax.
+       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 
-      aber der Flow wird nicht starten bis der vermisste 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
-      oder verwenden Sie <b>npm install &lt;module&gt;</b> um die vermissten Module zu installieren. 
-      Starten Sie danach Node-RED neu und importieren Sie die Node erneut.</p>
-    <p>Es ist möglich, dass der Nodetyp 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>
-    <p>Andernfalls kontaktieren Sie den Author des Flows um Informationen über den vermissten Nodetyp zu bekommen.</p>
+    <p><i>Wenn Sie den Node in diesem Zustand übernehmen (Deploy), wird die Konfiguration beibehalten,
+       aber der Flow wird erst gestartet, wenn der fehlende Node-Typ installiert ist.</i></p>
+    <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 fehlenden Module zu installieren.
+       Starten Sie danach Node-RED neu und importieren Sie die Nodes erneut.</p>
+    <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 Fehlermeldungen in Bezug auf den vermissten Node-Typ.</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> Die Nachrichten werden 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> Die Funktion wird erwartet, dass ein Nachrichtenobjekt (oder mehrere Nachrichtenobjekte) zurückgegeben werden, kann aber
-     auch nichts zurückzugeben, um einen Flow zu stoppen. </p>
-  <h3> Details </h3>
-  <p> Siehe  <a target="_blank" href="http://nodered.org/docs/writing-functions.html"> Onlinedokumentation </a> 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 Node inm Flow weitergeben möchte
-    oder kann  <code>node.send (msg)</code> aufrufen. </p>
-  <p> Es kann Folgendes zurückgeben/senden: </p>
+    <p>JavaScript-Funktion zur Weiterverarbeitung eingehender Nachrichten.</p>
+    <p>Die empfangenen Nachrichten werden der Funktion als JavaScript-Objekt mit dem Namen <code>msg</code> übergeben.</p>
+    <p>Per Konvention enthält die <code>msg.payload</code>-Eigenschaft die eigentliche Nachricht.</p>
+    <p>Von der Funktion wird erwartet, dass sie ein (oder mehrere) Nachrichtenobjekt(e) zurückgibt.
+       Es kann aber auch nichts zurückgeben werden, um einen Flow zu stoppen.</p>
+    <p>In den <b>Start</b>-Tab kann Code eingetragen werden, der beim Node-Start ausgeführt wird.
+       In den <b>Stopp</b>-Tab kann Code eingetragen werden, der beim Node-Stopp ausgeführt wird.</p>
+    <p>Wenn ein promise-Objekt aus dem Start-Code zurückgegeben wird,
+       beginnt danach die reguläre Verarbeitung der Eingangsnachrichten.</p>
+    <h3>Details</h3>
+    <p>Siehe  <a target="_blank" href="http://nodered.org/docs/writing-functions.html">Onlinedokumentation</a>
+       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 Array von Nachrichtenobjekten, die an Nodes übergeben werden, die mit den entsprechenden Ausgaben verbunden sind </li>
+        <li>Ein einzelnes Nachrichtenobjekt, das an Nodes am ersten Ausgang übergeben wird</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> Wenn null zurückgegeben wird, entweder durch sich selbst oder als Element des Arrays, wird die Nachricht nicht 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>
+    <p><b>Hinweis:</b> Der Start-Code wird nur während der Initialisierung des Nodes ausgeführt.
+       Wenn <code>node.send</code> im Start-Code aufgerufen wird, können nachfolgende Nodes die Nachricht möglicherweise nicht empfangen.</p>
+    <p>Wenn ein Element des Arrays selbst ein Array von Nachrichten ist, werden mehrere Nachrichten an den entsprechenden Ausgang gesendet.</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.warn (" Warning")</code> </li>
-        <li> <code>node.error ("Error")</code> </li>
+        <li><code>node.log("Protokollnachricht")</code></li>
+        <li><code>node.warn("Warnmeldungstext")</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:
-  Übergeben Sie <code>msg</code> als zweites Argument an <code>node.error</code>:</p>
-  <pre>node.error ("Error" ,msg);</pre>
-  <h4> Auf Node-Informationen zugreifen </h4>
-  <p> Im Funktionsblock können die ID und der Name des Nodes mit den folgenden Eigenschaften referenziert werden: </p>
+    <p>Der <span style="background-color:Gainsboro">catch</span>-Node kann auch zur Bearbeitung von Fehlern verwendet werden.
+       Er wird aufgerufen, indem <code>msg</code> als zweites Argument an <code>node.error</code> übergeben wird:</p>
+    <pre>node.error("Fehlermeldungstext" ,msg);</pre>
+    <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>
     <ul>
-      <li> <code>node.id</code> - ID des Nodes </li>
-      <li> <code>node.name</code> - Name des Nodes </li>
+        <li><code>node.id</code> - ID des Nodes</li>
+        <li><code>node.name</code> - Name des Nodes</li>
     </ul>
-  <h4> Umgebungsvariablen verwenden </h4>
-  <p> Auf Umgebungsvariablen kann mit  <code>env.get ("MY_ENV_VAR")</code> zugegriffen werden. </p>
+    <h4>Umgebungsvariablen verwenden</h4>
+    <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
-        und leitet die Nachricht an die entsprechenden Ausgänge der übereinstimmenden Regeln weiter.</p>
-    <p>Optional kann der Node so eingestellt werden, dass er die Auswertung von Regeln einstellt,
-        sobald er eine passende Regel findet.</p>
-    <p>Die Regeln können anhand einer einzelnen Nachrichteneigenschaft, 
-        einer Flow- oder globalen Kontext-Eigenschaft oder dem Ergebniss eines JSONata-Ausdrucks ausgewertet werden.</p>
+    <p>Bei Eingang einer Nachricht wertet der Node einstellbare Regeln aus und
+       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 nach der ersten erfüllten Regel beendet.</p>
+    <p>Die Regeln können anhand einer einzelnen Nachrichteneigenschaft, einer Flow- oder globalen Kontext-Eigenschaft oder
+       anhand dem Ergebnis 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>Sequence</b> Regeln können auf Nachrichtenfolgen verwendet werden, 
-            wie sie beispielsweise durch den Split-Node erzeugt werden.</li>
-        <li>Es kann ein JSONata <b>Expression</b> bereitgestellt werden, 
-            der anhand der gesamten Nachricht bewertet wird und eine Übereinstimmung erzeugt, 
-            wenn der Ausdruck einen wahren Wert zurückgibt.</li>
-        <li>Eine <b>Andernfalls</b> Regel kann verwendet werden, um eine Übereinstimmung herzustellen, 
-            wenn keine der vorhergehenden Regeln übereinstimmt.</li>
+        <li><b>value rules:</b> Regeln werden hinsichtlich einer eingestellten Eigenschaft ausgewertet</li>
+        <li><b>sequence rules:</b> Regeln beziehen sich auf Nachrichtensequenzen,
+            wie sie beispielsweise durch den <span style="background-color:Gainsboro">split</span>-Node erzeugt werden</li>
+        <li>Ein <b>JSONata-Ausdruck</b> kann die gesamte Eingangsnachricht auswerten und einen <code>true</code>-Wert zurückliefern,
+            um eine Regelerfüllung zu signalisieren</li>
+        <li>Die <b>ansonsten</b>-Regel wird angewendet, wenn keine vorhergehende Regel ü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
-         oder Objekte, die keine Eigenschaften haben aber nicht für <code>null</code> oder <code>undefiniert</code>.</p>
-    <h4>Behandlung von Nachrichtenfolgen</h4>
-    <p>Standardmäßig ändert der Node nicht  die Eigenschaft <code>msg.parts</code> 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>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,
+       sowie für Objekte, bei denen auf die Anzahl der Eigenschaften geprüft wird.
+       Die Regel ist niemals erfült, wenn die Eigenschaft einen <code>boolean</code>-, <code>null</code>- oder <code>undefined</code>-Wert hat.
+    <h4>Behandlung von Nachrichtensequenzen</h4>
+    <p>Standardmäßig ändert der Node nicht die <code>msg.parts</code>-Eigenschaft für Nachrichten, die Teil einer Sequenz sind.</p>
+    <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>Der Node kann mehrere Regeln angeben, die in der Reihenfolge ihrer Definition angewendet werden.</p>
+    <p>Setzen, Ändern, Löschen oder Verschieben von Eigenschaften einer Nachricht, eines Flow- oder eines globalen Kontextes.</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 
-        oder aus einer bestehenden Nachricht oder einer Kontext-Eigenschaft übernommen werden.</dd>
+        <dd>Setzen einer Eigenschaft.
+            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, 
-        kann die Eigenschaft "Ersetzen mit" sogenante Capture groups beinhalten, z.B. <code>$1</code>. 
-        Ersetzen ändert den Typ nur, wenn eine vollständige Übereinstimmung vorliegt.</dd>
-    <dt>Löschen</dt>
-    <dd>Löscht eine Eigenschaft.</dd>
+        <dd>Suchen und Ersetzen von Teilen einer Eigenschaft.
+            Wenn reguläre Ausdrücke verwendet werden, kann auch durch sogenannte Capture Groups ersetzt werden, z. B. <code>$1</code>.
+            Beim Ersetzen wird der Typ nur geändert, wenn eine vollständige Übereinstimmung vorliegt.</dd>
+        <dt>Lösche</dt>
+        <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 
-        <a href="http://jsonata.org/" target="_new">JSONata</a>.
-    </p>
+    <!-- <p>Der Typ "expression" verwendet die Abfrage- und Ausdruckssprache <a href="http://jsonata.org/" target="_new">JSONata</a>.</p> -->
+    <!-- was ist mit "expression" gemeint?!? vermutlich nicht mehr aktuell -->
 </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>
-    <h3>Eingaben</h3>
+    <p>Umskalierung eines Zahlenwertes auf einen anderen Wertebereich.</p>
+    <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>
-        <dd>Der Wert, der dem neuen Bereich zugeordnet ist.</dd>
+        <dt>payload<span class="property-type">number</span></dt>
+        <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>
-    <p><i>Skalieren und begrenzen auf den Zielbereich</i> bedeutet, 
-        dass das Ergebnis niemals außerhalb des im Ergebnisbereich angegebenen Bereichs liegt.</p>
-    <p><Skalieren und Umhüllen innerhalb des Zielbereichs</i> bedeutet, 
-        dass das Ergebnis innerhalb des Ergebnisbereichs umgepackt wird.</p>
+       Standardmäßig ist das Ergebnis nicht auf Ausgangswertebereich beschränkt.</p>
+    <p><i>Skalierung und Begrenzung</i> bedeutet,
+       dass das Ergebnis niemals außerhalb des Ausgangswertebereich liegt.</p>
+    <p><i>Skalieren und Begrenzung mit Überlauf</i> bedeutet,
+       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>
-  <h3> Eingaben </h3>
+    <p>Festlegen einer Eigenschaft anhand einer Vorlage (template).</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-      <dt> msg  <span class="property-type"> Objekt </span> </dt>
-      <dd> Ein msg Objekt, das Informationen zum Füllen der Vorlage enthält. </dd>
-      <dt class="optional"> template  <span class="property-type">Zeichenfolge</span> </dt>
-      <dd> Eine Schablone, die aus msg.payload gefüllt werden soll. Falls es nicht in der Editieranzeige konfiguriert ist, kann 
-       kann es als Eigenschaft von msg gesetzt werden. </dd>
+        <dt>msg<span class="property-type">object</span></dt>
+        <dd>msg-Objekt mit Informationen zum Befüllen der Vorlage</dd>
+        <dt class="optional">template<span class="property-type">string</span></dt>
+        <dd>Mit msg.payload zu befüllende Vorlage.
+            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>
-      <dd> Eine Nachricht die durch Verbindung der konfigurierten Vorlage mit den Eigenschaften aus der eingehenden Nachricht gebildet wird. </dd>
+        <dt>msg<span class="property-type">object</span></dt>
+        <dd>Nachricht auf Basis der Vorlage und gefüllt mit Eigenschaften aus der eingehenden Nachricht</dd>
     </dl>
-  <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>
-  Format, das kann aber bei Bedarf ausgeschaltet werden. </p>
-  <p> Beispiel: Wenn eine Vorlage von:
-  <pre> Hallo {{payload.name}}. Heute ist {{date}} </pre>
-  <p> eine Nachricht empfangt, die folgendes enthält:
-  <pre>{
+    <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>-Format,
+      was aber bei Bedarf ausgeschaltet werden kann.</p>
+    <p>Beispiel: Wenn die Vorlage</p>
+    <pre>Hallo {{payload.name}}. Heute ist {{date}}</pre>
+    <p>die Nachricht</p>
+    <pre>
+{
   date: "Montag",
   payload: {
     name: "Fred"
   }
-}</pre>
-  <p> wird die resultierende Nachrich wie folgt sein:
-  <pre> Hallo Fred. Heute ist Montag </pre>
-  <p> Es ist möglich, eine Eigenschaft aus dem Flowkontext oder dem globalen Kontext zu verwenden. 
-    Verwenden Sie einfach  <code>{{flow.name}}</code>  oder
-  <code>{{global.name}}</code> oder für den persistenten Speicher <code>store</code> verwenden <code>{{flow[store].name}}</code> oder
-  <code>{{global[store].name}}</code>.
-  <p> <b>Hinweis: </b> Standardmäßig wird <i>mustache</i> alle HTML-Entitäten in den Werten die es ersetzt mit Escape behandeln.
-     Um dies zu verhindern, verwenden Sie <code>{{{triple}}}</code> Klammern.
-
+}
+    </pre>
+    <p>empfängt, wird die resultierende Ausgangsnachricht wie folgt sein:</p>
+    <pre>Hallo Fred. Heute ist Montag</pre>
+    <p>Es ist möglich, eine Eigenschaft aus dem Flowkontext oder dem globalen Kontext zu verwenden,
+       indem <code>{{flow.name}}</code> oder <code>{{global.name}}</code> verwendet wird.
+       Oder für den persistenten Speicher <code>store</code> kann <code>{{flow[store].name}}</code> oder
+       <code>{{global[store].name}}</code> verwendet werden.
+    <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>
-    <h3> Eingaben </h3>
+    <p>Verzögerung von Nachrichten oder Begrenzung ihrer Durchlaufrate.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional"> delay  <span class="property-type"> Zahl </span> </dt>
-        <dd> Legt die Verzögerung (in Millisekunden) fest, die auf die Nachricht angewendet werden soll. Dies
-            Option gilt nur, wenn der Node so konfiguriert ist, dass er Nachrichten zulässt,
-            die das konfigurierte Standardverzögerungsintervall überschreiben. </dd>
-            <dt class="optional"> zurücksetzen </dt>
-            <dd> Wenn für die empfangene Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist, werden alle
-                ausstehende Nachrichten gelöscht, die vom Node noch gehalten werden. </dd>
-            <dt class="optional"> Flush </dt>
-            <dd> Wenn für die empfangene Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist, werden alle
-                ausstehende Nachrichten, die vom noch Node gehalten werden, sofort gesendet. </dd>
+        <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.
+            Zur Nutzung dieser Option muss <i>Verzög. mit msg.delay überschreibbar</i> aktiviert sein.</dd>
+        <dt class="optional">reset</dt>
+        <dd>Wenn bei der empfangenen Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist,
+            werden alle im Node gepufferten Nachrichten gelöscht</dd>
+        <dt class="optional">flush</dt>
+        <dd>Wenn bei der empfangenen Nachricht diese Eigenschaft auf einen beliebigen Wert gesetzt ist,
+            werden alle im Node gepufferten Nachrichten sofort gesendet</dd>
     </dl>
-    <h3> Details </h3>
-    <p> Wenn das Verzögerungsintervall für die Verzögerung von Nachrichten konfiguriert ist, kann es sich um einen festen Wert,
-        einen Zufallswert innerhalb eines Bereichs oder einen dynamisch für jede Nachricht festgelegten Wert handeln. </p>
-    <p> Bei der Konfiguration von Begrenzungen werden die Nachrichten über den konfigurierten Zeitraum verteilt. 
-        Der Status zeigt die Anzahl der Nachrichten an, die sich derzeit in der Warteschlange befinden. 
-        Zwíschenzeitlich entreffende Nachrichten können gegebenenfalls verworfen werden.</p>
-    </p>
-    <p> Die Ratenbegrenzung kann auf alle Nachrichten angewendet werden
-        oder sie werden gemäß des Wertes von <code>msg.topic</code> gruppiert. 
-        Bei der Gruppierung werden zwíschenzeitlich eintreffende Nachrichten automatisch gelöscht. 
-        In jedes Zeitintervall kann der Node entweder die aktuellste Nachricht für alle Themen
-        oder die neueste Nachricht für das nächste Topic freigeben.
-    </p>
+    <h3>Details</h3>
+    <p>Wenn Verzögerung als Nachrichtenaktion eingestellt ist, kann die Verzögerungszeit ein fixer Wert,
+       ein Zufallswert innerhalb eines Bereichs oder ein für jede Nachricht dynamisch vorgebbarer Wert handeln.</p>
+    <p>Bei Begrenzung auf Nachrichtenrate werden die Nachrichten über den eingestellten Zeitraum verteilt.
+       Der Status zeigt die Anzahl der sich aktuell in der Warteschlange befindlichen Nachrichten an.
+       Zwischenzeitlich eintreffende Nachrichten können optional beim Eintreffen verworfen werden.</p>
+    <p>Die Ratenbegrenzung kann auf alle Nachrichten angewendet werden oder
+       die Nachrichten werden anhand des <code>msg.topic</code>-Wertes gruppiert.
+       Bei der Gruppierung werden zwischenzeitlich eintreffende Nachrichten automatisch gelöscht.
+       In jedem Zeitintervall werden die neuesten Nachricht entweder für alle oder
+       für das nächste Thema (Topic) in der Reihe gesendet.</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 , 
-        sofern der Trigger nicht verlängert oder zurückgesetzt wird. </p>
-
-    <h3> Eingaben </h3>
+    <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>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional"> reset </dt>
-        <dd> Wenn eine Nachricht mit dieser Eigenschaft empfangen wird, wird jeder aktuelle Zeitlimit oder Wiederholung 
-            zrückgesetzt und es wird keine Nachricht ausgelöst. </dd>
+        <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.
+            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>
-    <p> Dieser Node kann verwendet werden, um ein Zeitlimit in einem Flow zu erstellen. Wenn er eine Nachricht empfängt, wird
-        standardmäßig wird eine Nachricht mit einer <code>payload</code> von <code>1</code> versandt.
-        Anschließend wartet er 250 ms, bevor er eine zweite Nachricht mit einer <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>
-    <p> Die Nutzdaten jeder gesendeten Nachricht können für eine Vielzahl von Werten konfiguriert werden, 
-        einschließlich der Option, nichts zu senden. Wenn Sie beispielsweise die Anfangsnachricht auf <i>nichts</i> setzen und
-        Auswahl der Option zum Erweitern des Zeitgebers mit jeder empfangenen Nachricht dann wird der Node als Überwachungszeitgeber agieren
-        und nur dann eine Nachricht senden, wenn innerhalb des konfigurierten Erweiterungszeitraums keine Nachricht empfangen wird. </p>
-    <p> Wenn der Node auf den Typ  <i>Zeichenfolge</i>  gesetzt ist, unterstützt der Node die Syntax der Mustache-Vorlage. </p>
-    <p> Wenn der Node eine Nachricht mit einer Eigenschaft  <code>reset</code>  oder einer <code>payload</code> die mit dem Wert in der
-        Node-Konfiguration übereinstimmt, wird jede beliebige Zeitlimitüberschreitung oder Wiederholung gelöscht,
-        die sich derzeit in Bearbeitung befindet und es wird keine Nachricht ausgelöst. </p>
-    <p> Der Node kann so konfiguriert werden, dass er eine Nachricht in einem regulären Intervall sendet,
-        bis er durch eine empfangene Nachricht zurückgesetzt wird. </p>
-    <p> Optional kann der Node so konfiguriert werden, dass er Nachrichten für jedes <code>msg.topic</code> als separate Datenströme behandelt. </p>
+    <h3>Details</h3>
+    <p>Dieser Node kann verwendet werden, um ein Zeitlimit in einem Flow zu erstellen.
+       Bei Empfang einer Nachricht wird standardmäßig eine Nachricht mit einem <code>payload</code> von <code>1</code> versendet.
+       Optional wird nach einer einstellbaren Wartezeit (standardmäßig 250 ms) eine zweite Nachricht
+       mit einem <code>payload</code> von <code>0</code> sendet.
+       Dies kann beispielsweise zum Blinken einer LED verwendet werden, die an einen GPIO-Pin des Raspberry Pi angeschlossen ist.</p>
+    <p>Als Nutzdaten (Payload) jeder zu sendenen Nachricht können eine Vielzahl von Werten eingestellt werden inklusive der Option,
+       überhaupt nicht zu senden.
+       Wenn beispielsweise die erste Ausgnagsnachricht auf <i>nichts</i> gesetzt und die Option
+       <i>Verzögerung verlängern bei Eingang neuer Nachrichten</i> aktiviert ist,
+       agiert der Node als Überwachungszeitgeber (Watchdog-Timer).
+       Er sendet hier nur dann eine Nachricht, wenn innerhalb der eingestellten Verzögerungszeit keine Nachricht empfangen wird.</p>
+    <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>
+    <p>Wenn eine Nachricht mit der <code>reset</code> oder <code>payload</code>-Eigenschaft gleich dem konfigurierten Wert empfangen wird,
+       wird eine laufende Verzögerung oder Wiederholung rückgesetzt und keine Nachricht gesendet.</p>
+    <p>Der Node kann auch so eingestellt werden, dass er eine Nachricht normal in den vorgegebenen Intervallen sendet,
+       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> Der Node kann so konfiguriert werden, dass er entweder wartet, bis der Befehl abgeschlossen ist,
-        oder die Ausgabe so sendet 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>
-
-    <h3> Eingaben </h3>
+    <p>Ausführung eines Systembefehls und Rückgabe seiner Ausgabe.</p>
+    <p>Der Node kann so eingestellt werden, dass er entweder bis zum Befehlabschluss wartet (exec) oder
+       die Ausgabe sogleich sendet (spawn), wie der Befehl sie generiert.</p>
+    <p>Der auszuführende Befehl kann im Node eingestellt und/oder
+       über die empfangene Nachricht übergeben werden.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt class="optional">payload<span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> wird an den ausgeführten Befehl angehängt  </dd>
-        <dt class="optional"> kill  <span class="property-type"> Zeichenfolge </span> </dt>
-        <dd> Der Typ des Kill-Signals, das einen vorhandenen exec-Node-Prozess gesendet wird. </dd>
-        <dt class="optional"> pid  <span class="property-type"> Zahl|Zeichenfolge </span> </dt>
-        <dd> Die Prozess-ID eines vorhandenen exec-Node-Prozesses, der beendet werden soll. </dd>
+        <dt class="optional">payload<span class="property-type">string</span></dt>
+        <dd>Wird an auszuführenden Befehl angehängt, sofern im Node aktiviert</dd>
+        <dt class="optional">kill<span class="property-type">string</span></dt>
+        <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">number | string</span></dt>
+        <dd>Prozess-ID des zu beendenden <span style="background-color:Gainsboro">exec</span>-Node-Prozesses</dd>
     </dl>
-
-    <h3> Ausgaben </h3>
+    <h3>Ausgangsdaten</h3>
     <ol class="node-ports">
-        <li> Standardausgabe
+        <li>Standardausgabe (stdout)
             <dl class="message-properties">
-                <dt> payload  <span class="property-type"> Zeichenfolge </span> </dt>
-                <dd> die Standardausgabe des Befehls. </dd>
+                <dt>payload<span class="property-type">string</span></dt>
+                <dd>Standardausgabe des Befehls</dd>
             </dl>
             <dl class="message-properties">
-                <dt> rc  <span class="property-type"> Objekt </span> </dt>
-                <dd> Eine Kopie des Rückkehrcodeobjekts (auch an Port 3 verfügbar) - nur im Ausführungsmodus verfügbar </dd>
+                <dt>rc<span class="property-type">object</span></dt>
+                <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>
-                <dd> Standardfehlerausgabe des Befehls. </dd>
+                <dt>payload<span class="property-type">string</span></dt>
+                <dd>Standardfehlerausgabe des Befehls</dd>
             </dl>
             <dl class="message-properties">
-                <dt> rc  <span class="property-type"> Objekt </span> </dt>
-                <dd> Eine Kopie des Rückkehrcodeobjekts (auch an Port 3 verfügbar) - nur im Ausführungsmodus verfügbar </dd>
+                <dt>rc<span class="property-type">object</span></dt>
+                <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>
-                <dd> ein Objekt, das den Rückkehrcode und gegebenfals <code>Nachricht</code>,  <code>Signal</code> Eigenschaften enthält. </dd>
+                <dt>payload<span class="property-type">object</span></dt>
+                <dd>Objekt mit dem Rückgabe-Code und gegebenenfalls <code>message</code> oder <code>signal</code>-Eigenschaften</dd>
             </dl>
         </li>
     </ol>
-    <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
-    gibt dessen Ausgabe zurück. Ein erfolgreicher Befehl sollte z. B. den Rückkehrcode  <code>{ code: 0 }</code> haben. </p>
-    <p> Optional kann stattdessen <code>spawn</code> verwendet werden, wodurch die Ausgaben von Standardausgabe und Standardfehler zurückgegeben werden während
-    der Befehl ausgeführt wird, in der Regel Zeile für Zeile. Nach Abschluss des Befehles gibt sie ein Objekt 
-    am 3. Port zurück. Ein erfolgreicher Befehl sollte z. B.  <code>{ code: 0 }</code> zurückgeben. </p>
-    <p> Fehler können zusätzliche Informationen über den dritten Port als <code>msg.payload</code> zurückgeben, 
-        z. B. eine <code>message</code> Zeichenfolge oder <code>Signal</code> zeichenfolge. </p>
-    <p> Der Befehl, der ausgeführt wird, ist innerhalb des Nodes definiert, mit einer Option zum Anhängen von  <code> msg.payload </code>
-        und einer weiteren Gruppe von Parametern. </p>
-    <p> Befehle oder Parameter mit Leerzeichen müssen in Anführungszeichen eingeschlossen werden: <code> "Dies ist ein einzelner Parameter" </code> </p>
-    <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
-    falls es sich um einen  <i>Buffer</i> handelt. </p>
-    <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>
-    <h4> Prozesse beenden </h4>
-    <p> Wird <code>msg.kill</code>  gesendet, wird ein einzelner aktiver Prozess beendet. <code>msg.kill</code>  sollte eine Zeichenfolge sein, die
-    Der Typ des Signals, der gesendet werden soll, z. B.  <code>SIGINT</code>,  <code>SIGQUIT</code>  oder  <code>SIGHUP</code>.
-    Der Standardwert ist  <code>SIGTERM</code> , wenn er auf eine leere Zeichenfolge gesetzt ist. </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>
-    <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> 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>
+    <h3>Details</h3>
+    <p>Standardmäßig wartet der zur Befehlsausführung genutzte Systemaufruf <code>exec</code>,
+       bis die Ausführung abgeschlossen ist, und gibt anschließend dessen Ausgaben zurück.
+       Ein erfolgreich ausgeführter Befehl sollte z. B. den Rückgabe-Code <code>{ code: 0 }</code> haben.</p>
+    <p>Optional kann stattdessen <code>spawn</code> verwendet werden, wodurch die Standardausgabe und Standardfehlerausgabe
+       bereits während der Befehlsausführung in der Regel Zeile für Zeile rückgegeben werden.
+       Nach Befehlsabschluss wird ein Objekt am 3. Port ausgegeben.
+       Ein erfolgreich ausgeführter Befehl sollte z. B. <code>{ code: 0 }</code> zurückgeben.</p>
+    <p>Fehler können zusätzliche Informationen über den dritten Port als <code>msg.payload</code> zurückgeben,
+       z. B. eine <code>message</code>- oder <code>signal</code>-Zeichenfolge.</p>
+    <p>Der auszuführende Befehl wird innerhalb des Nodes mit der Option zum Anhängen von
+       <code>msg.payload</code> und weiteren Parametern definiert.</p>
+    <p>Befehle oder Parameter mit Leerzeichen sollten in Anführungszeichen eingeschlossen werden,
+       z. B. <code>"Dies ist ein einzelner Parameter"</code></p>
+    <p>Die zurückgegebenen Daten (Payload) sind in der Regel eine <i>Zeichenfolge (string)</i>,
+       außer es werden nicht UTF-8-Zeichen wie bei einem <i>binären Puffer (buffer)</i> erkannt.</p>
+    <p>Bei einem aktiven Node werden Status und die PID angezeigt.
+       Änderungen können mittels <span style="background-color:Gainsboro">status</span>-Node gelesen werden.</p>
+    <h4>Prozesse beenden</h4>
+    <p>Durch Senden von <code>msg.kill</code> wird ein einzelner aktiver Prozess beendet.
+       <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>
-   <h3> Ausgaben </h3>
+    <p>Verbindungsherstellung zu einem MQTT-Broker und Abonnement von Topic-Nachrichten.</p>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-      <dt> payload  <span class="property-type"> Zeichenfolge | Buffer </span> </dt>
-      <dd> eine Zeichenfolge, sofern sie nicht als binärer Buffer erkannt wird. </dd>
-      <dt> topic  <span class="property-type"> Zeichenfolge </span> </dt>
-      <dd> Das MQTT-Topic verwendet <code>/</code> als Trennzeichen für die Hierarchie. </dd>
-      <dt> qos  <span class="property-type"> Zahl </span>  </dt>
-      <dd> 0: fire und forget 1: mindestens einmal 2: einmal und nur einmal. </dd>
-      <dt> retain  <span class="property-type"> boolean </span> </dt>
-      <dd> true gibt an, dass die Nachricht retained wurde und älter sein kann. </dd>
+        <dt>payload<span class="property-type">string | buffer</span></dt>
+        <dd>Zeichenfolge, sofern sie nicht als binärer Puffer (buffer) erkannt wurde</dd>
+        <dt>topic<span class="property-type">string</span></dt>
+        <dd>MQTT-Topic mit / (Schrägstrich) als Hierarchie-Trennzeichen</dd>
+        <dt>qos<span class="property-type">number</span></dt>
+        <dd>QoS (Quality of Service)<br/>
+            0: Einmal gesendet ohne Empfangsgarantie (fire und forget)<br/>
+            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>
-   Das Subscribete Topic kann MQTT-Platzhalterzeichen, + für eine Ebene, # für mehrere Ebenen umfassen. </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>
-   <p> Mehrere MQTT-Nodes (in oder out) können bei Bedarf dieselbe Brokerverbindung nutzen. </p>
+    <h3>Details</h3>
+    <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.
+       Eine neue Verbindung wird durch Klicken auf das Stiftsymbol erstellt.</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>
-    <h3>Eingaben</h3>
+    <p>Verbindungsherstellung zu einem MQTT-Broker und publizieren von Topic-Nachrichten.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-       <dt>payload <span class="property-type">Zeichenfolge | Buffer</span></dt>
-       <dd>die meisten Benutzer präferieren einfach Textnachrichten aber es können auch binäre Buffer publiziert werden.</dd>
-       <dt class="optional">topic <span class="property-type">string</span></dt>
-       <dd> Das MQTT-Topic zu dem publiziert wird. Es verwendet <code>/</code> als Trennzeichen für die Hierarchie.</dd>
-
-       <dt class="optional">qos <span class="property-type">number</span></dt>
-       <dd>0: fire und forget 1: mindestens einmal 2: einmal und nur einmal. Default 0.</dd>
-
-       <dt class="optional">retain <span class="property-type">boolean</span></dt>
-       <dd>Wenn dieser Wert auf <code>true</code> gesetzt ist, wird die Nachricht auf dem Broker gehalten. Default false.</dd>
+        <dt>payload<span class="property-type">string | buffer</span></dt>
+        <dd>Zu publiziernde Nutzdaten.<br/>
+            Wenn nicht gesetzt wird keine Nachricht gesendet.
+            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>
+        <dd>MQTT-Topic mit / (Schrägstrich) als Hierarchie-Trennzeichen</dd>
+        <dt class="optional">qos<span class="property-type">number</span></dt>
+        <dd>QoS (Quality of Service)<br/>
+            0: Einmal gesendet ohne Empfangsgarantie (fire und forget)<br/>
+            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.
-      Wenn er ein Objekt enthält, wird es in eine JSON-Zeichenfolge konvertiert, bevor es gesendet wird.
-      Wenn er einen binären Buffer enthält, wird die Nachricht unverändert veröffentlicht. </p>
-      <p> Das verwendete Topic kann im Node konfiguriert werden oder, falls es leer gelassen wird,
-      durch <code>msg.topic</code> festgelegt werden. </p>
-      <p> Ebenso können die QoS- und retain-Werte im Node konfiguriert werden oder, falls vorhanden,
-      durch <code>msg.qos</code> bzw. <code>msg.retain</code> festgelegt werden. 
-      Sie können eine zuvor auf einem Topic auf dem Broker retainte Nachricht löschen,
-      indem eine leere Nachricht an dieses Topic gesendet wird und die Markierung 'retain' gesetzt ist.</p>
+    <p><code>msg.payload</code> wird als Nutzdaten (Payload) der zu publizierenden Nachricht verwendet.
+       Wenn es ein Objekt enthält, wird es vorm Senden in eine JSON-Zeichenfolge (string) konvertiert.
+       Wenn es einen binären Puffer (buffer) enthält, wird die Nachricht unverändert gesendet.</p>
+    <p>Das Topic kann im Node eingestellt werden oder, falls leer gelassen,
+       durch <code>msg.topic</code> vorgegeben werden.</p>
+    <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> vorgegeben werden.
+       Um ein beim Broker vorgehaltenes Topic zu löschen,
+       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>
-    <p>Mehrere MQTT-Nodes (in oder out) können bei Bedarf dieselbe Brokerverbindung nutzen.</p>
+       Eine neue Verbindung wird durch Klicken auf das Stiftsymbol erstellt.</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> Diese Konfiguration erstellt eine Verbindung zu einem Broker, die anschließend von den 
-      Nodes <code>MQTT In</code> und <code>MQTT Out</code> verwendet werden. </p>
-   <p> Der Node generiert eine beliebige Client-ID, falls sie nicht definiert ist und der Node für die Verwendung
-      einer bereinigten Sitzung (Clean Session) konfiguriert ist. Wenn eine Client-ID festgelegt ist, 
-      muss sie für den Broker, zu dem Sie eine Verbindung herstellen, eindeutig sein. </p>
-   <h3> Nachricht bei Verbindungsaufbau </h3>
-   <p> Dies ist eine Nachricht, die vom Broker in dem konfigurierten Topic veröffentlicht wird, wenn die Verbindung hergestellt wurde. </p>
-   <h3> Nachricht bei Verbindungsbeendigung </h3>
-   <p> Dies ist eine Nachricht, die vom Broker in dem konfigurierten Topic veröffentlicht wird, wenn die Verbindung normal geschlossen wird -
-      entweder durch erneute Implementierung des Nodes oder durch Herunterfahren von Node-RED. </p>
-   <h3> Nachricht bei unerwarteter Verbindungsbeendigung</h3>
-   <p> Dies ist eine Nachricht, die vom Broker in dem konfigurierten Topic veröffentlicht wird,
-      wenn die Verbindung unerwartet geschlossen wird 
-   <h3> WebSockets </h3>
-   <p> Der Node kann für die Verwendung einer WebSocket-Verbindung konfiguriert werden.
-      Dazu wird im Server-Feld eine vollständigen URI für die Verbindung angegeben. Beispiel: </p>
-   <pre> ws://example.com:4000/mqtt </pre>
+    <p>Konfiguration der Verbindung zu einem MQTT-Broker.</p>
+    <p>Diese Konfiguration erstellt eine einzelne Verbindung zu einem Broker,
+       welche anschließend von den <span style="background-color:Gainsboro">mqtt&nbsp;in</span>- und
+       <span style="background-color:Gainsboro">mqtt out</span>-Nodes verwendet werden.</p>
+    <p>Der Node generiert eine beliebige Client-ID, falls sie nicht vorgegeben ist und der
+       Node eine bereinigte Sitzung (clean session) verwenden soll.
+       Wenn eine Client-ID vorgegeben wird, muss sie für den Broker eindeutig sein, zu dem die Verbindung hergestellt werden soll.</p>
+    <h3>Nachricht bei Verbindungsaufbau</h3>
+    <p>Diese Nachricht wird vom Broker mit dem eingestellten Topic publiziert, wenn die Verbindung hergestellt wurde.</p>
+    <h3>Nachricht vor Verbindungsabbau</h3>
+    <p>Diese Nachricht wird vom Broker mit dem eingestellten Topic publiziert, bevor die Verbindung normal abgebaut wird,
+       egal ob durch erneute Übernahme (deploy) des Nodes oder durch Herunterfahren von Node-RED.</p>
+    <h3>Nachricht bei unerwarteten Verbindungsabbruch</h3>
+    <p>Diese Nachricht wird vom Broker mit dem eingestellten Topic veröffentlicht,
+       wenn die Verbindung unerwartet abgebrochen ist.</p>
+    <h3>WebSockets</h3>
+    <p>Der Node kann für die Verwendung einer WebSocket-Verbindung eingestellt werden.
+       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>
-    <h3>Outputs</h3>
+    <p>Erstellung eines HTTP-Endpunktes zur Erzeugung von Web-Diensten.</p>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <dt>Nutzdaten</dt>
-        <dd>Für eine GET-Anforderung ist ein Objekt mit beliebigen Parametern der Abfragezeichenfolge oder der 
-            Hauptteil (Body) der HTTP-Anforderung enthalten</dd>
-        <dt>req<span class="property-type">Objekt</span></dt>
-        <dd>Ein HTTP Anforderungsobjekt. Dieses Objekt enthält mehrere Eigenschaften, 
-            die Informationen zu der Anforderung bereitstellen.
+        <dt>payload</dt>
+        <dd>Für eine GET-Anforderung enthält es ein Objekt aller Abfrage-Parameter (query string parameters).
+            Ansonsten enthält es den Hauptteil (Body) der HTTP-Anforderung.</dd>
+        <dt>req<span class="property-type">object</span></dt>
+        <dd>HTTP Anforderungsobjekt.<br/>
+            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>headers</code> - ein Objekt, dass den HTTP Header enthält.</li>
-             <li><code>query</code> - ein Objekt, dass die Anfrage Parameter enthält.</li>
-             <li><code>params</code> - ein Objekt, dass die Routing Parameter enthält</li>
-             <li><code>cookies</code> - ein Objekt, dass die Cookies der Anfrage enthät..</li>
-             <li><code>files</code> - wenn die Funktion aktieviert ist, enthält dieses Objekt alle Dateien, 
-                die mit der POST-Anforderung gesendet wurden.</li>
+                <li><code>body</code>: Hauptteil der eingehenden Anforderung. Das Format hängt von der Anforderung ab.</li>
+                <li><code>headers</code>: Objekt mit HTTP-Request-Header</li>
+                <li><code>query</code>: Objekt mit Anfrage-Parametern (query string parameters)</li>
+                <li><code>params</code>: Objekt mit den Routing-Parametern</li>
+                <li><code>cookies</code>: Objekt mit den Cookies der Anfrage</li>
+                <li><code>files</code>: Objekt mit allen Dateien, die mit der POST-Anforderung gesendet wurden, sofern im Node aktiviert</li>
             </ul>
         </dd>
-        <dt>res<span class="property-type">Objekt</span></dt>
-        <dd>Ein HTTP-Antwortobjekt. Diese Eigenschaft sollte nicht direkt verwendet werden.
-            Der <code>HTTP Response</code> Node dokumentiert, wie auf eine Anforderung reagiert wird.
-            Diese Eigenschaft muss an die Nachricht angehängt bleiben, die an den Antwort-Node übergeben wird.</dd>
+        <dt>res<span class="property-type">object</span></dt>
+        <dd>HTTP-Antwortobjekt.<br/>
+            Diese Eigenschaft sollte nicht direkt verwendet werden.
+            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> 
-        zugegriffen werden. </p>
-    <p> Für Anforderungen, die einen Hauptteil enthalten, wie z.B. POST oder PUT, wird der Inhalt der 
+       Wenn benannte Parameter verwendet werden, kann auf ihren aktuellen Wert über <code>msg.req.params</code>
+       zugegriffen werden.</p>
+    <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.
-        Wenn zum Beispiel <code> application/json</code> erkannt wurde, die Darstellung in der JavaScript-Objekt Notation. </p>
-    <p> <b> Hinweis:</b> Dieser Node sendet keine Antwort an die Anforderung. Der Flow
-        muss einen code>HTTP Response</code> Node enthalten, um die Anforderung abzuschließen. </p>
+    <p>Wenn der Inhaltstyp der Anforderung ermittelt werden kann, wird der Hauptteil als passender Typ analysiert.
+       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 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>
-    <h3>Eingaben</h3>
+    <p>Senden von Antworten auf Anforderungen, die von einem <span style="background-color:Gainsboro">http&nbsp;in</span>-Node empfangen wurden.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">Zeichenfolge</span> </dt>
-        <dd>Der Hauptteil der Antwort.</dd>
-        <dt class="optional">statusCode<span class="property-type">Zahl</span> </dt>
-        <dd>Wenn festgelegt wird diese als Antwortstatuscode verwendet. Standardwert: 200. </dd>
-        <dt class="optional">Header<span class="property-type">Objekt</span> </dt>
-        <dd> Wenn festgelegt enthält es die HTTP-Header, die in die Antwort mit eingeschlossen werden sollen. </dd>
-        <dt class="optional">Cookies<span class="property-type">Objekt</span> </dt>
-        <dd> Wenn festgelegt kann es zum Setzen oder Löschen von Cookies verwendet werden. </dd>
+        <dt>payload<span class="property-type">string</span></dt>
+        <dd>Hauptteil (Body) der Antwort</dd>
+        <dt class="optional">statusCode<span class="property-type">number</span></dt>
+        <dd>Wenn gesetzt, wird diese als Antwort-Statuscode verwendet. Standardwert: 200</dd>
+        <dt class="optional">headers<span class="property-type">object</span></dt>
+        <dd>Wenn gesetzt, enthält es die HTTP-Header für die Antwort</dd>
+        <dt class="optional">cookies<span class="property-type">object</span></dt>
+        <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.
-        Wenn eine Eigenschaft innerhalb des Nodes festgelegt wird,
+    <p>Der <code>statusCode</code> und die <code>headers</code> können auch innerhalb des Node angegeben werden.
+       Wenn eine Eigenschaft innerhalb des Nodes angegeben ist,
        kann sie nicht durch die entsprechende Nachrichteneigenschaft überschrieben werden.</p>
-    <h4>Behandlung von Cookies</h4>
-    <p> Die Eigenschaft <code>Cookies</code> 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 
-    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
-    einem Wert von <code>nick</code> und der andere als <code>session</code> mit einem Wert von 
-    <code>1234</code> und einer festgelegten Ablaufzeit von 15 Minuten. </p>
+    <h4>Cookie-Behandlung</h4>
+    <p>Die <code>cookies</code>-Eigenschaft muss ein Objekt mit Name/Wert-Paaren sein.
+       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>
+    <p>Im folgenden Beispiel werden zwei Cookies festgelegt - einer mit dem Namen <code>name</code> und dem
+       Wert <code>nick</code> und der andere <code>session</code> mit dem Wert
+       <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>expires</code> -(Datum) Ablaufzeit in GMT. Wenn Sie keinen Wert angeben oder auf 0 setzen, wird ein Sitzungscookie erstellt. </li>
-    <li><code>maxAge</code> -(Zeichenfolge) Ablaufzeit in Bezug auf die aktuelle Zeit in Millisekunden </li>
-    <li><code>Pfad</code> -(String) Pfad für das Cookie. Standardwert: / </li>
-    <li><code>value</code> -(String) der Wert, der für das Cookie verwendet werden soll </li>
+        <li><code>domain</code>: Domänenname für das Cookie, angegeben als Zeichenfolge (string)</li>
+        <li><code>expires</code>: Ablaufzeit in GMT. Wenn nicht vorgeben oder Null (0), wird ein Sitzungscookie erstellt.</li>
+        <li><code>maxAge</code>: Ablaufzeit in Bezug auf die aktuelle Zeit in Millisekunden, angegeben als Zeichenfolge (string)</li>
+        <li><code>path</code>: Pfad für das Cookie. Standardwert: / (Schrägstrich), angegeben als Zeichenfolge (string)</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>
-
-    <h3>Eingaben</h3>
+    <p>Senden von HTTP-Anforderungen und Rückgabe der Antwort.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <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>
-        <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.
-            Muss einer von <code>GET</code>, <code>PUT</code>, <code>POST</code>, <code>PATCH</code> oder <code>DELETE</code> sein.</dd>
-        <dt class="optional">headers <span class="property-type">Objekt</span></dt>
-        <dd>Setzt die HTTP-Header der Anforderung.</dd>
-        <dt class="optional">cookies <span class="property-type">Objekt</span></dt>
-        <dd>Wenn gesetzt, kann es verwendet werden, um Cookies mit der Anforderung zu senden.</dd>
+        <dt class="optional">url<span class="property-type">string</span></dt>
+        <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>
+        <dd>Wenn nicht im Node eingestellt, setzt diese optionale Eigenschaft die HTTP-Methode der Anforderung
+            (<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">object</span></dt>
+        <dd>HTTP-Header der Anforderung</dd>
+        <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>
         <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. 
-            In der Standardeinstellung ist <code>true</code>.</dd>
+        <dd>Wenn auf <code>false</code> gesetzt, wird ein nachfolgendes Redirect (HTTP 301) verhindert.
+            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>
-        <dd>Der Hauptteil der Antwort. Der Node kann konfiguriert werden, um den Hauptteil als String zurückzugeben,
-            zu versuchen, ihn als JSON-String zu analysieren oder ihn als binären Buffer zu belassen.</dd>
-        <dt>statusCode <span class="property-type">Zahl</span></dt>
-        <dd>Der Statuscode der Antwort oder der Fehlercode, wenn die Anforderung nicht abgeschlossen werden konnte.</dd>
-        <dt>headers <span class="property-type">Objekt</span></dt>
-        <dd>Ein Objekt, das die HTTP-Header der Antwort enthält.</dd>
-        <dt>responseUrl <span class="property-type">String</span></dt>
+        <dt>payload<span class="property-type">string | object | buffer</span></dt>
+        <dd>Hauptteil der Antwort.<br/>
+            Der Node kann eingestellt werden, um den Hauptteil als String zurückzugeben,
+            zu versuchen, ihn als JSON-String zu analysieren oder ihn als binären Puffer (buffer) zu belassen.</dd>
+        <dt>statusCode<span class="property-type">number</span></dt>
+        <dd>Statuscode der Antwort oder der Fehlercode, wenn die Anforderung nicht abgeschlossen werden konnte</dd>
+        <dt>headers<span class="property-type">object</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>
-        <dd>Wenn die Antwort Cookies enthält, ist dieses Element ein Objekt von Namen/Wertpaaren für jedes Cookie.</dd>
+        <dt>responseCookies<span class="property-type">object</span></dt>
+        <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
-        <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. 
-        Wenn die URL beispielsweise auf <code>example.com/{{{topic}}}</code> gesetzt ist, 
+    <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.
+       Diese ermöglichen es, die URL aus den Werten der eingehenden Nachricht aufzubauen.
+       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>
-    <p><b>Note</b>: Wenn Node-RED hinter einem Proxy läuft, sollte die Umgebungsvariable <code>http_proxy=...</code> gesetzt 
-        und Node-RED neu gestartet werden, oder eine Proxy Konfiguration wird verwendet. 
-        Wenn die Proxy-Konfiguration verwendet wird, hat diese Konfiguration Vorrang vor der Umgebungsvariablen.</p>
-    <h4>Verwendung mehrerer HTTP-Anforderungs-Node</h4>
-    <p>Um mehr als einen dieser Node im gleichen Flow verwenden zu können,
-        ist Vorsicht bei der Verwendung der Eigenschaft <code>msg.headers</code> geboten 
-        Der erste Node setzt diese Eigenschaft mit  dem Antwortheader.
-        Der nächste Node verwendet dann diese Header für seine Anfrage - diese sind aber in der Regel nicht die Richtigen.
-        Wenn die Eigenschaft <code>msg.headers</code> zwischen den Nodes unverändert bleibt, wird sie vom zweiten Node ignoriert.
-        Um benutzerdefinierte Header festzulegen, sollte <code>msg.headers</code> zuerst gelöscht 
-        oder auf ein leeres Objekt gesetzt werden: <code>{}</code>.</p>
+       Die Verwendung von {{{...}} hindert Mustache am Escaping von Zeichen wie z. B. / & usw.</p>
+    <p><b>Hinweis:</b> Wenn Node-RED hinter einem Proxy läuft, sollte die Umgebungsvariable <code>http_proxy=...</code>
+       gesetzt und Node-RED neu gestartet werden.
+       Alternativ kann eine Proxy-Konfiguration verwendet werden, die dann Vorrang vor der Umgebungsvariable hat.</p>
+    <h4>Verwendung mehrerer HTTP-Anforderungs-Nodes</h4>
+    <p>Um mehr als einen dieser Nodes im gleichen Flow verwenden zu können,
+       ist Aufmerksamkeit bei der Verwendung der <code>msg.headers</code>-Eigenschaft gefordert.
+       Der erste Node setzt diese Eigenschaft mit dem Antwort-Header.
+       Der nächste Node verwendet dann diesen Header für seine Anfrage, was aber nicht die richtige Art und Weise ist.
+       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 oder
+       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>
-    <p>Alle von der Anforderung zurückgegebenen Cookies werden unter der Eigenschaft <code>responseCookies</code> zurückgegeben.</p>
+       oder es kann ein Objekt mit einer einzigen <code>value</code>-Eigenschaft sein.<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, 
-        sollte <code>msg.headers["content-type"]</code> auf <code>application/x-wwww-form-urlencoded</code> gesetzt werden.</p>
-
+    <p>Um die Anforderung als Formulardaten zu kodieren, sollte <code>msg.headers["content-type"]</code> auf
+       <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,
-        in diesem Fall wird er das JSON analysieren und das resultierende Objekt als gesamte Nachricht senden.</p>
+       Der Socket kann eingestellt werden, einen korrekt gebildeten JSON-Zeichenfolge (string) zu erwarten.
+       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>
-
-    <p>Wenn die an diesem Node ankommende Nachricht an einem WebSocket-Eingangs-Node begann,
+       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 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>
-    <p>Wenn eine Nachricht, die an einem WebSocket-Eingangsnoten gestartet wurde, an alle verbunden Clients gesendet werden soll,
-        muss die Eigenschaft <code>msg._session</code> innerhalb des Flow gelöscht werden.</p>
+       Andernfalls wird die Nachricht an alle verbundenen Clients gesendet.</p>
+    <p>Wenn eine von einem WebSocket-Eingangs-Node ausgehende Nachricht an alle verbundenen Clients gesendet werden soll,
+       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><b>Note: </b>Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+    <p>TCP-Eingang zur Verbindung mit einem entfernten TCP-Port oder Akzeptanz eingehender Verbindungen.</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 out">
-    <p>Bietet eine Auswahl an TCP-Ausgängen. Kann sich entweder mit einem entfernten TCP-Port verbinden,
-       eingehende Verbindungen akzeptieren oder auf Nachrichten antworten, die von einem TCP-In-Node empfangen werden.</p>
-       <p>Nur der Inhalt von <code>msg.payload</code> wird gesendet.</p>
-    <p>Wenn <code>msg.payload</code> einen String beinhaltet, die eine Base64-Kodierung von binären
-        Daten darstellt, wird die <code>Dekodiere Base64</codes> Option dazu führen, 
-        dass sie wieder in Binärdaten umgewandelt wird bevor sie verschickt werden.</p>
-    <p>Wenn <code>msg._session</code> nicht vorhanden ist, wird der Payload an <b>alle</b> alle verbundenen Clients gesendet.</p>
-    <p><b>Note: </b>Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+    <p>TCP-Ausgang zur Verbindung mit einem entfernten TCP-Port, Akzeptanz eingehender Verbindungen oder
+       Antwort auf Nachrichten, die von einem <b>tcp&nbsp;in</b>-Node empfangen werden.</p>
+    <p>Nur der <code>msg.payload</code>-Inhalt wird gesendet.</p>
+    <p>Wenn <code>msg.payload</code> einen String mit Base64-Kodierung von binären Daten beinhaltet,
+       bewirkt die Option <i>Base64-Nachricht dekodieren</i>,
+       dass sie vorm Senden wieder in Binärdaten umgewandelt wird.</p>
+    <p>Wenn <code>msg._session</code> nicht vorhanden ist,
+       werden die Nutzdaten (Payload) an <b>alle</b> verbundenen Clients gesendet.</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>Verbindet sich, sendet die "Anforderung" und liest die "Antwort". Der Node wartet entweder auf eine vorgegebene Anzahl von
-        Zeichen in einen festen Buffer, auf ein bestimmtes Zeichen oder einen festen Timeout ab der ersten Antwort,
-        bevor er die Verbindug schliesst und die Daten an den Flow zurück gibt. 
-        Alternativ hält der Node die Verbindung ständig offen. </p>
-    <p>Die Antwort wird in <code>msg.payload</code> als Buffer ausgegeben, so dass sie unter Umständen mit einer
-        <code> .toString()>/code> Funktion umgewandelt werden müssen.</p>
-    <p>Wenn <code>tcp host</code> oder <code>port</code> leer gelassen werden, 
-        müssen diese mit den Eigenschaften <code>msg.host</code> und <code>msg.port</code> übergeben werden.</p>
+    <p>Einfacher TCP-Anforderungs-Node zum
+       Senden von <code>msg.payload</code> an einen Server-TCP-Port und erwarten einer Antwort.</p>
+    <p>Der Node verbindet sich, sendet einen <i>request</i> (Anfrage) und liest den <i>response</i> (Antwort).
+       Er kann entweder eine vorgegebene Zeichenanzahl in einem festen Puffer abzählen,
+       auf ein passendes Zeichen zur Rückkehr reagieren, ein festes Zeitlimit ab der ersten Antwort abwarten und dann rückkehren,
+       endlos auf Daten warten oder sofort die Verbindug schliessen, ohne auf Antwort zu warten.</p>
+    <p>Die Antwort wird in <code>msg.payload</code> als binärer Puffer (buffer) ausgegeben,
+       sodass sie ggf. mit der <code>.toString()</code>-Funktion umgewandelt werden kann.</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
-        Buffer, Strings oder base64-kodierter String enthält. Multicast wird unterstützt.</p>
-    <p>Über die Eigenschaften <code>msg.ip</code> und <code>msg.port</code> kann auf die Werte der 
-    IP Addresse und des Ports zugegriffen werden, von dem die Nachtricht empfangen wurde.</p>
-    <p><b>Note</b>: Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+    <p>UDP-Eingangs-Node zur Erzeugung einer <code>msg.payload</code> mit Buffer, String oder base64-kodierten String.
+       Multicast wird unterstützt.</p>
+    <p>Über die Eigenschaften <code>msg.ip</code> und <code>msg.port</code> können IP-Addresse und Port vorgeben werden,
+       von dem die Nachtrichten empfangen werden.</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="udp out">
-    <p>Dieser Node sendet <code>msg.payload</code> an den angegebenen UDP-Host und Port. Multicast wird unterstützt.</p>
-    <p>Sie können <code>msg.ip</code> und <code>msg.port</code> verwenden, um die Zielwerte festzulegen, 
-        aber die statisch im Node konfigurierten Werte haben Vorrang.</p>
-    <p>Wenn Sie Broadcast auswählen, stellen Sie entweder die Adresse auf die lokale Broadcast-IP-Adresse 
-        oder versuchen Sie es mit 255.255.255.255, was die globale Broadcast-Adresse ist.</p>
-    <p><b>Note</b>: Auf einigen Systemen benötigen Sie möglicherweise Root- oder Administratorzugriff, um 
-        Ports unter 1024 und/oder Broadcast nutzen zu können.</p>
+    <p>UDP-Ausgangs-Node zum Senden von <code>msg.payload</code> an vorgegebenen UDP-Host und -Port.
+       Multicast wird unterstützt.</p>
+    <p>Über die Eigenschaften <code>msg.ip</code> und <code>msg.port</code> können IP-Addresse und Port vorgeben werden,
+       an den die Nachtrichten gesendet werden. Statisch im Node vorgebene Werte haben aber Vorrang.</p>
+    <p>Bei Verwendung von Broadcast sollte die Adresse auf die lokale Broadcast-IP-Adresse oder
+       auf 255.255.255.255 (globale Broadcast-Adresse) eingestellt werden.</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>
-    <h3>Eingaben</h3>
+    <p>Konvertierung zwischen einer CSV-formatierten Zeichenfolge (string) und ihrer JavaScript-Objektdarstellung in beide Richtungen.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | Array | String</span></dt>
-        <dd>Ein JavaScript Objekt, Array oder CSV String.</dd>
+        <dt>payload<span class="property-type">object | array | string</span></dt>
+        <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
-                es wird für jede Zeile ein JavaScript-Objekt mit Schlüssel/Wertpaaren erstellt. 
-                Der Node sendet dann entweder eine Nachricht für jede Zeile oder eine einzelne Nachricht mit einem Array von Objekten.</li>
-            <li>Wenn die Eingabe ein JavaScript-Objekt ist, wird versucht ein CSV-String zu erzeugen.</li>
-            <li>Wenn die Eingabe ein Array mit einfachen Werten ist, wird ein einzeiliger CSV-String erstellt.</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 Zeichenfolge (string) sind, wird versucht, sie als CSV zu analysieren (parse),
+                    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 CSV-Zeile oder
+                    eine einzige Nachricht mit einem Array von Objekten.</li>
+                <li>Wenn die Eingangsdaten ein JavaScript-Objekt sind, wird versucht, eine CSV-Zeichenfolge zu erzeugen</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 
-        Spaltennamen als Eigenschaftsname verwendet. Alternativ können die Spaltennamen auch aus der ersten Zeile des CSV übernommen werden.</p>
+    <p>Die Spaltenvorlage besteht aus der geordneten und durch Komma getrennten Liste der Spaltennamen.
+       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>Der Node kann eine mehrteilige Eingabe akzeptieren, solange die Eigenschaft <code>parts</code> korrekt gesetzt ist.</p>
-    <p>Wenn mehrere Nachrichten ausgeben werden, sind ihre <code>parts</code>-Eigenschaft festgelegt und sie bilden eine vollständige Nachrichtensequenz.</p>
-    <p><b>Note:</b> die Spaltenvorlage muss kommagetrennt sein - auch wenn für die Daten ein anderes Trennzeichen gewählt wird.</p>
+    <p>Wenn die Spaltenvorlage nicht vorgegeben ist, kann eine einfache, Komma getrennte Liste über
+       die <code>msg.columns</code>-Eigenschaft übergeben werden, um vorzugeben, was der Node extrahieren soll.
+       Wenn das nicht vorgegeben ist, werden alle Objekt-Eigenschaften in der Reihenfolge ausgegeben,
+       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>
-    <h3>Eingaben</h3>
+    <p>Extraktion von Elementen unter Verwendung eines CSS-Selektors aus einem HTML-Dokument, das sich in <code>msg.payload</code> befindet.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-    <dt>payload <span class="property-type">String</span></dt>
-    <dd>der html-String, aus der Elemente extrahiert werden sollen.</dd>
-    <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>
-</dl>
-    <h3>Ausgaben</h3>
+        <dt>payload<span class="property-type">string</span></dt>
+        <dd>HTML-Zeichenfolge (string), aus dem Elemente extrahiert werden sollen</dd>
+        <dt class="optional">select<span class="property-type">string</span></dt>
+        <dd>Sofern nicht im Node vorgegeben, kann der Selektor auch als <code>msg.select</code>-Eigenschaft übergeben werden</dd>
+    </dl>
+    <h3>Ausgangsdaten</h3>
     <dl class="message-properties">
-        <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
-            oder mehrere Nachrichten, die jeweils ein passendes Element enthalten. 
-            Wenn mehrere Nachrichten gesendet werden, haben sie auch <code>parts</code> gesetzt.</dd>
+        <dt>payload<span class="property-type">array | string</span></dt>
+        <dd>Das Ergebnis kann entweder eine einzelne Nachricht mit dem Array der passendes Elemente oder
+            mehrere Nachrichten mit je einem passenden Element sein.
+            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
-        <a href="https://github.com/fb55/CSSselect#user-content-supported-selectors" target="_blank">css-select Dokumentation</a> 
+    <p>Dieser Node unterstützt eine Kombination aus CSS- und jQuery-Selektoren.
+       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>
-    <h3>Eingaben</h3>
+    <p>Konvertierung zwischen JSON-Zeichenfolge (string) und JavaScript-Objektdarstellung in beide Richtungen.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
-        <dd>Ein JavaScript Objekt oder ein String.</dd>
-        <dt>schema<span class="property-type">Objekt</span></dt>
-        <dd>Ein optionales JSON Schema Objekt gegen das das JSON Objekt validiert wird.</dd>
+        <dt>payload<span class="property-type">object | string</span></dt>
+        <dd>JavaScript-Objekt oder JSON-Zeichenfolge (string)</dd>
+        <dt>schema<span class="property-type">object</span></dt>
+        <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 Eingabe ein JavaScript-Objekt ist, wird ein JSON-String erstellt. Der String kann optional gut formatiert werden.</li>
+                <li>Wenn die Eingangsdaten eine JSON-Zeichenfolge (string) darstellen, wird versucht sie in ein JavaScript-Objekt zu analysieren (parsen).</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>
-        <dd>Wenn die JSON-Schemavalidierung fehlschlägt, wird für den <code>Catch</code> Node eine <code>schemaError</code> Eigenschaft erstellt,
-            die ein Array von Fehlern enthält.</dd>
+        <dt>schemaError<span class="property-type">array</span></dt>
+        <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>
     </dl>
     <h3>Details</h3>
-    <p>Standardmäßig arbeitet der Node mit <code>msg.payload</code>, kann aber so konfiguriert werden, dass eine beliebige
-        Nachrichteneigenschaft konvertiert wird.</p>
-    <p>Der Node kann auch konfiguriert werden, um eine bestimmte Kodierung sicherzustellen, anstatt zwischen den beiden umzuschalten.
-        Dies kann z.B. mit dem <code>HTTP In</code> Node benutzt werden, um sicherzustellen, dass der Payload ein analysiertes Objekt ist,
-        auch wenn eine eingehende Anfrage seinen Inhaltstyp nicht korrekt eingestellt hat, damit der <code>HTTP In</code> Node
-        die Konvertierung durchführen kann.</p>
-    <p>Wenn der Node so konfiguriert ist, dass die Eigenschaft als String kodiert wird, und es einen String empfängt,
+    <p>Standardmäßig verarbeitet der Node <code>msg.payload</code>,
+       kann aber auch eine beliebige Nachrichteneigenschaft konvertieren.</p>
+    <p>Die Konvertierungsrichtung kann im Node auch vorgegeben werden, um eine bestimmte Ziel-Kodierung sicherzustellen.
+       Dies kann z. B. zusammen mit dem <span style="background-color:Gainsboro">http&nbsp;in</span>-Node benutzt werden, um sicherzustellen,
+       dass die Nutzdaten (Payload) ein analysiertes (parsed) Objekt ist,
+       auch wenn eine eingehende Anfrage seinen Inhaltstyp nicht korrekt eingestellt hat,
+       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>
-    <p>Für weitere Details über das JSON-Schema 
-        können Sie die <a href="http://json-schema.org/latest/json-schema-validation.html">Spezifikation</a> einsehen.</p>
+       Der Node prüft weder, ob die Zeichenfolge (string) ein gültiges JSON enthält, noch wird er ihn neu formatieren,
+       wenn die Format-Option ausgewählt ist.</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>
-    <h3>Eingaben</h3>
+    <p>Konvertierung zwischen XML-Zeichenfolge (string) und JavaScript-Objekt in beiden Richtungen.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
-        <dd>Ein JavaScript Objekt oder ein XML String.</dd>
-        <dt class="optional">options <span class="property-type">Objekt</span></dt>
-        <dd>This optional property can be used to pass in any of the options supported by the underlying
-            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>
-            for more information.</dd>
+        <dt>payload<span class="property-type">object | string</span></dt>
+        <dd>JavaScript-Objekt oder XML-Zeichenfolge (string)</dd>
+        <dt class="optional">options<span class="property-type">object</span></dt>
+        <dd>Optionale Eigenschaft zur Übergabe von Optionen an die Konvertier-Bibliothek von und zu XML.
+            Siehe <a href="https://github.com/Leonidas-from-XIV/node-xml2js/blob/master/README.md#options" target="_blank">xml2js Dokumente</a>
+            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 Eingabe ein JavaScript-Objekt ist, wird versucht ein XML-String zu erstellen.</li>
+                <li>Wenn die Eingangsdaten eine Zeichenfolge (string) sind,
+                    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. 
-        Jeder Textinhalt wird 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 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>
-    <h3>Eingaben</h3>
+    <p>Konvertierung zwischen YAML-formatierter Zeichenfolge (string) und JavaScript-Objekt-Darstellung in beide Richtungen.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String</span></dt>
-        <dd>Ein JavaScript Objekt oder ein YAML String.</dd>
+        <dt>payload<span class="property-type">object | string</span></dt>
+        <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 Eingabe ein JavaScript-Objekt ist, wird ein YAML-String erstellt.</li>
+                <li>Wenn die Eingangsdaten eine YAML-Zeichenfolge (string) sind, wird versucht daraus ein JavaScript-Objekt zu erzeugen.</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>
-
-    <h3>Eingaben</h3>
+    <p>Aufteilung einer Nachricht in Nachrichtensequenzen.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <dt>payload<span class="property-type">Objekt | String | Array | Buffer</span></dt>
-        <dd>Das Verhalten des Nodes wird durch den Typ der <code>msg.payload</code> bestimmt:
+        <dt>payload<span class="property-type">object | string | array | buffer</span></dt>
+        <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>),
-                    der Buffersequenz 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>Objekt</b> - es wird für jedes Schlüssel-Wert-Paar des Objekts eine Nachricht gesendet.</li>
+                <li><b>Zeichenfolge (string) / Binärer Puffer (buffer):</b> Die Nachricht wird anhand des vorgegebenen Zeichens (Standard: <code>\n</code>),
+                    der Buffer-Sequenz oder in feste Längen 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 (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>
-        <dd>Diese Eigenschaft enthält Informationen darüber, wie die Nachricht von der ursprünglichen Nachricht getrennt wurde. 
-            Wenn sie an einen Node <b>join</b> übergeben werden,
-            kann die Sequenz wieder zu einer einzigen Nachricht zusammengefasst werden. 
+        <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 abgeteilt wurde.
+            Bei Übergabe an ein <span style="background-color:Gainsboro">join</span>-Node kann die Sequenz wieder zu einer einzigen Nachricht zusammengeführt werden.
             Diese Eigenschaft hat die folgenden Eigenschaften:
             <ul>
-            <li><code>id</code> - ein Identifikator für die Gruppe der Nachrichten</li>
-            <li><code>index</code> - die Position innerhalb der Gruppep</li>
-            <li><code>count</code> - falls bekannt, die Gesamtzahl der Nachrichten in der Gruppe. Siehe dazu unten "Streaming-Modus".</li>
-            <li><code>type</code> - die Art der Nachricht - 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>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>len</code> - die Länge jeder Nachricht, wenn sie durch einen Wert fester Länge aufgeteilt wird.</li>
+                <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
+                <li><code>index</code>: Position innerhalb der Gruppe</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>: Nachrichtentyp string/array/object/buffer</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>: Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde (nur bei einem Objekt).
+                    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>
-    <p>Es verwendet die Eigenschaft <code>msg.parts</code>, um die einzelnen Teile einer Sequenz zu verfolgen.</p>
-    <h4>Streaming Modus</h4>
-    <p>Der Node kann auch zum Wiederaufbereiten eines Nachrichtenstroms verwendet werden.
-        So kann beispielsweise ein serielles Gerät, das <code><newline/code>-terminierte Befehle sendet, 
-        eine einzelne Nachricht mit einem Teilbefehl am Ende liefern. 
-        Im Streaming-Modus teilt dieser Node eine Nachricht auf und sendet jedes komplette Segment.
-        Befindet er sich am Ende eines Teilsegments, hält der Node es fest und wird es der nächsten empfangenen Nachricht voranstellen.
-    </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.
-        Das bedeutet, dass er nicht mit dem <b>join</b> Node im Automatikmodus verwendet werden kann.</p>
+       bevor die Sequenz mittels <span style="background-color:Gainsboro">join</span>-Node wieder zu einer einzigen Nachricht neu kombiniert wird.</p>
+    <p>Der Node verwendet die <code>msg.parts</code>-Eigenschaft, um die einzelnen Sequenzteile nachzuverfolgen.</p>
+    <h4>Streaming-Modus</h4>
+    <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,
+       eine Nachricht mit einem noch unvollständigen Befehl am Ende liefern.
+       Im Streaming-Modus teilt der Node die Nachricht in komplette Befehlsegmente auf.
+       Befindet sich am Nachrichtenende ein unvollständiges Befehlsegment,
+       so wird es im Node aufbewahrt und der nächsten empfangenen Nachricht vorangestellt.</p>
+    <p>In diesem Modus wird die <code>msg.parts.count</code>-Eigenschaft nicht gesetzt,
+       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>
-        <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>
-        <dt>manual</dt>
-        <dd>Die Sequenzen von Nachrichten können auf verschiedene Weise verknüpft werden.</dd>
-        <dt>Reihenfolge reduzieren</dt>
-        <dd>Einen Ausdruck auf alle Nachrichten in einer Sequenz anwenden, um sie auf eine einzige Nachricht zu reduzieren.</dd>
+        <dt>Automatisch</dt>
+        <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>Manuell</dt>
+        <dd>Die Nachrichtensequenzen können auf verschiedene Weisen verbunden werden</dd>
+        <dt>Sequenz reduzieren</dt>
+        <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>
-        <dd>Um automatisch einer Nachrichtensequenz beizutreten, sollten sie alle über diese Eigenschaft verfügen. 
-            Der Node <b>split</b> erzeugt diese Eigenschaft, sie kann aber manuell erstellt werden.
-            Es hat die folgenden Eigenschaften:
+        <dt class="optional">parts<span class="property-type">object</span></dt>
+            <dd>Zur automatischen Verbindung einer Nachrichtensequenz sollten alle über diese Eigenschaft verfügen.
+                Der <span style="background-color:Gainsboro">split</span>-Node erzeugt diese Eigenschaft, sie kann aber auch manuell erstellt werden.
+                Sie hat die folgenden Eigenschaften:
                 <ul>
-                    <li><code>id</code> - ein Identifikator für die Gruppe der Nachrichten</li>
-                    <li><code>index</code> - die Position innerhalb der Gruppep</li>
-                    <li><code>count</code> - fie Gesamtzahl der Nachrichten in der Gruppe.</li>
-                    <li><code>type</code> - die Art der Nachricht - 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>key</code> - für ein Objekt, den Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde.</li>
-                    <li><code>len</code> - die Länge jeder Nachricht, wenn sie durch einen Wert fester Länge aufgeteilt wird.</li>
+                <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
+                <li><code>index</code>: Position innerhalb 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>: Nachrichtentyp string/array/object/buffer</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>: Schlüssel der Eigenschaft, aus der diese Nachricht erstellt wurde (nur bei einem Objekt).
+                    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, 
-        wie die Sequenz verknüpft werden soll. 
-        Dies ermöglicht es ihm, die Aktion eines <b>split</b>-Nodes automatisch rückgängig zu machen.
-    </p>
+    <p>Der automatische Modus verwendet die <code>parts</code>-Eigenschaften der eingehenden Nachrichten,
+       um die Sequenz in richtiger Reihenfolge zu verknüpften.
+       Dies ermöglicht die Aufteilung des <span style="background-color:Gainsboro">split</span>-Nodes automatisch rückgängig zu machen.</p>
+
     <h4>Manueller Modus</h4>
-    <p>Wenn der Node für die Zusammenführung im manuellen Modus konfiguriert ist,
-        kann er Sequenzen von Nachrichten zu einer Reihe von verschiedenen Ergebnissen zusammenfügen:</p>
+    <p>Im manuellen Modus werden Nachrichtensequenzen auf verschiedenen Arten zusammengefügt:</p>
     <ul>
-        <li>ein <b>String </b> oder <b>Buffer</b> - erstellt durch Verbinden der ausgewählten Eigenschaft
-            jeder Nachricht mit den angegebenen Join-Zeichen oder dem angegebenen Buffer.</li>
-        <li>ein <b>Array</b> - erstellt durch Hinzufügen jeder ausgewählten Eigenschaft oder einer ganzen Nachricht zum Ausgangsarray.</li>
-        <li>ein <b>Schlüssel/Wert-Objekt</b> - erstellt durch Verwendung einer Eigenschaft jeder Nachricht, um den Schlüssel zu bestimmen, 
-            unter dem der gewünschte Wert gespeichert ist.</li>
-        <li>ein <b>zusammengefügtes Objekt</b> - erstellt durch Zusammenführen der Eigenschaft jeder Nachricht unter einem einzigen Objekt.</li>
+        <li><b>String</b> oder <b>Buffer</b>: Verbinden der ausgewählten Eigenschaft jeder Nachricht
+        mit den vorgegebenen Join-Zeichen oder -Buffer</li>
+        <li><b>Array</b>: Erstellung eines Ausgangsarrays durch Hinzufügen jeder ausgewählten Eigenschaft oder ganzer Nachrichten</li>
+        <li><b>Schlüssel/Wert-Objekt</b>: Erzeugung von Schlüssel und Wert aus Eigenschaft jeder Nachricht</li>
+        <li><b>Zusammengeführtes Objekt</b>: Erzeugung durch Zusammenführen der Eigenschaften jeder Nachricht als ein einziges Objekt</li>
     </ul>
-    <p>Die anderen Eigenschaften der Ausgangsnachricht werden aus der letzten empfangenen Nachricht entnommen, bevor das Ergebnis gesendet wird.</p>
-    <p>Mit <i>count</i> kann angegeben werden, wie viele Nachrichten vor dem Erzeugen der Ausgabemeldung empfangen werden sollen.
-        Bei Objektausgaben kann der Node nach Erreichen dieser Anzahl konfiguriert werden,
-        um für jede nachfolgende empfangene Nachricht eine Nachricht zu senden.</p>
-    <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>
-    <p>Wenn eine Nachricht mit der Eigenschaft <b>msg.complete</b> empfangen wird, wird die Ausgabemeldung finalisiert und gesendet.
+    <p>Die anderen Eigenschaften der Ausgangsnachricht werden von der zuletzt empfangenen Nachricht übernommen,
+       bevor das Ergebnis gesendet wird.</p>
+    <p>Mit <i>Anzahl</i> kann vorgegeben werden, wie viele Nachrichten vor dem Erzeugen der Ausgangsnadchricht empfangen werden sollen.
+       Bei Objektausgaben kann der Node nach Erreichen dieser Anzahl so eingestellt werden,
+       dass er bei jeder nachfolgenden empfangenen Nachricht eine weitere Nachricht sendet.</p>
+    <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>
-    <p>Wenn sie so konfiguriert sind, dass sie sich im Reduktionsmodus befinden, wird auf jede Nachricht in einer Sequenz ein Ausdruck angewendet 
-        und das Ergebnis zu einer einzigen Nachricht zusammengefasst.</p>
-
+    <h4>Modus Sequenz reduzieren</h4>
+    <p>In diesem Modus wird auf jede Nachricht einer Sequenz ein Ausdruck angewendet und
+       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>
-        <dt>Reduktionsausdruck</dt>
-        <dd>Ein 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.
-                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.
+        <dd>Anfangswert des akkumulierten Wertes (<code>$A</code>)</dd>
+        <dt>Reduktions-Ausdruck</dt>
+        <dd>JSONata-Ausdruck, der für jede Nachricht in der Sequenz aufgerufen wird.
+            Das Ergebnis wird als akkumulierter Wert an den nächsten Aufruf des Ausdrucks übergeben.
             Im Ausdruck können folgende spezielle Variablen verwendet werden:
             <ul>
-                <li><code>$A</code>: der kumulierte Wert, </li>
-                <li><code>$N</code>: Anzahl der Nachrichten in der Sequenz.</li>
+                <li><code>$A</code>: Akkumulierter Wert</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>Initial value</b>: <code>0</code></li>
-            <li><b>Fix-up expression</b>: <code>$A/$N</code></li>
+            <li><b>Reduktions-Ausdruck:</b> <code>$A+payload</code></li>
+            <li><b>Anfangswert:</b> <code>0</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>Wenn der Node konfiguriert ist, um die Nachrichteneigenschaft zu sortieren,
-        sortiert er Array-Daten, auf die von der angegebenen Nachrichteneigenschaft verwiesen wird.</p>
-    <p>Wenn der Node konfiguriert ist, um eine Folge von Nachrichten zu sortieren, ordnet er die Nachrichten neu.</p>
+    <p>Sortierung einer Nachrichteneigenschaft oder einer Nachrichtensequenz.</p>
+    <p>Der Node sortiert entweder das Array der vorgegebenen Nachrichteneigenschaft oder
+       die Reihenfolge einer Nachrichtensequenz neu.</p>
     <p>Die Sortierreihenfolge kann sein:</p>
     <ul>
-        <li><b>aufsteigend</b>,</li>
-        <li><b>absteigend</b>.</li>
+        <li><b>aufsteigend</b> oder</li>
+        <li><b>absteigend</b></li>
     </ul>
-    <p>Für Zahlen kann die numerische Reihenfolge durch ein Kontrollkästchen festgelegt werden.</p>
-    <p>Der Sortierschlüssel kann ein Elementwert oder ein JSONata-Ausdruck zum Sortieren des Eigenschaftswerts 
-        oder eine Nachrichteneigenschaft oder ein JSONata-Ausdruck zum 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.
-        Der Split-Node erzeugt diese Eigenschaft, kann aber manuell angelegt werden.  Es hat die folgenden Eigenschaften:</p>
+    <p>Für Zahlenwerte kann die numerische Sortierreihenfolge festgelegt werden.</p>
+    <p>Der Sortierschlüssel kann ein Elementwert oder ein JSONata-Ausdruck beim Sortieren einer Nachrichteneigenschaft
+       bzw. eine Nachrichteneigenschaft oder ein JSONata-Ausdruck beim Sortieren einer Nachrichtensequenz sein.<p>
+    <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.
+       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>index</code> - die Position innerhalb einer Gruppe</li>
-            <li><code>count</code> - die Anzahl von Nachrichten in einer Gruppe</li>
+            <li><code>id</code>: Identifikator der Nachrichten-Gruppe</li>
+            <li><code>index</code>: Position innerhalb der 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.
-        Standardmäßig ist die Anzahl der Nachrichten nicht begrenzt.
-        <ul>
-            <li>Es kann die Eigenschaft <code>nodeMessageBufferMaxLength</code> in der Datei <b>settings.js</b> gesetzt werden.</li>
-        </ul>
+    <p><b>Hinweis:</b> Dieser Node speichert intern Nachrichten um seine Aufgabe erfüllen zu können.
+       Um einen unerwarteten Speicherverbrauch zu vermeiden, kann die Anzahl der gespeicherten Nachrichten begrenzt werden.
+       Standardmäßig ist die Nachrichtenanzahl nicht begrenzt.
+       Mit der Laufzeiteinstellung <code>nodeMessageBufferMaxLength</code> kann begrenzt werden,
+       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>
-        <dd>Die Nachrichten werden zu Sequenzen einer bestimmten Länge gruppiert. Die Option <b>Überlappung</b>
-            gibt an, wie viele Nachrichten vom Ende einer Sequenz am Anfang der nächsten Sequenz wiederholt werden sollen.</dd>
+        <dt>Gruppierung anhand Nachrichtenanzahl</dt>
+        <dd>Die Nachrichten werden zu Sequenzen einer vorgegebenen Länge gruppiert.
+            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>
-        <dd>Gruppiert Nachrichten, die innerhalb des angegebenen Intervalls eingehen. Wenn keine Nachrichten 
-            innerhalb des Intervalls ankommen, kann der Node optional eine leere Nachricht senden.</dd>
+        <dt>Gruppierung anhand Zeitintervall</dt>
+        <dd>Gruppierung von Nachrichten, die innerhalb des vorgegebenen Intervalls eingehen.
+            Wenn keine Nachrichten innerhalb des Intervalls eingehen, kann der Node optional eine leere Nachricht senden.</dd>
 
-        <dt>Sequenzen verketten/dt>
-        <dd>Erzeugt eine Nachrichtensequenz durch die Verkettung eingehender Sequenzen. Jede Nachricht muss eine <code>msg.topic</code> 
-            und eine <code>msg.parts</code> Eigenschaft haben, um die Sequenz identifizieren zu können. 
-            Der Node ist mit einer Liste von <code>topic</code> konfiguriert,
-             mit der die Reihenfolge der Verkettung der Sequenzen definiert wird.</dd>
+        <dt>Verknüpfung von Sequenzen</dt>
+        <dd>Erzeugt eine Nachrichtensequenz durch die Verkettung eingehender Sequenzen.
+            Jede Nachricht muss eine <code>msg.topic</code>- und eine <code>msg.parts</code>-Eigenschaft haben,
+            damit die Sequenz identifiziert werden kann.
+            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
-        <code>nodeMessageBufferMaxLength</code> kann verwendet werden, um die Anzahl der Nachrichten zu begrenzen 
-        die vom Node gepuffert werden.</p>
+    <p>Dieser Node puffert Nachrichten intern, um sequenzübergreifend arbeiten zu können.
+       Mit der Laufzeiteinstellung <code>nodeMessageBufferMaxLength</code> kann begrenzt werden,
+       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.
-        Alternativ kann die Datei auch gelöscht werden.</p>
-    <h3>Eingaben</h3>
+    <p>Schreiben von <code>msg.payload</code> in eine Datei entweder hinzufügend oder ersetzend.
+       Alternativ Löschen der Datei.</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <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>
+        <dt class="optional">filename<span class="property-type">string</span></dt>
+        <dd>Sofern nicht im Node eingestellt, legt diese optionale Eigenschaft den Namen der zu aktualisierenden Datei fest</dd>
     </dl>
-    <h3>Ausgaben</h3>
-    <p>Nach Abschluss des Schreibvorgangs wird die Eingangsnachricht an den Ausgangsport gesendet.</p>
+    <h3>Ausgangsdaten</h3>
+    <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>
-    <p>Es kann konfiguriert werden, dass die gesamte Datei überschrieben wird und nicht angehängt wird. Zum Beispiel 
-        beim Schreiben von Binärdaten in eine Datei wie bei einem Bild, sollte diese Option verwendet werden 
-        und die Option, einen Zeilenumbruch anzuhängen, sollte deaktiviert sein.</p>
-    <p>Alternativ kann dieser Node konfiguriert werden, um die Datei zu löschen.</p>
+       Für eine optimale Leistung sollten feste Dateinamen verwendet werden.</p>
+    <p>Alternativ kann angegeben werden, dass die gesamte Datei überschrieben wird.
+       Zum Beispiel wird diese Option beim Schreiben von Binärdaten in eine Datei verwendet,
+       wo dann auch die Zeilenumbruch-Hinzufüge-Option deaktiviert sein sollte.</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>
-    <h3>Inputs</h3>
+    <p>Lesen von Dateiinhalt als Zeichenfolge (string) oder binären Puffer (buffer).</p>
+    <h3>Eingangsdaten</h3>
     <dl class="message-properties">
-        <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>
+        <dt class="optional">filename<span class="property-type">string</span></dt>
+        <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>
-        <dd>The contents of the file as either a string or binary buffer.</dd>
-        <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>
-        <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>
+        <dt>payload<span class="property-type">string | buffer</span></dt>
+        <dd>Dateiinhalt entweder als Zeichenfolge (string) oder binärer Puffer (buffer)</dd>
+        <dt class="optional">filename<span class="property-type">string</span></dt>
+        <dd>Sofern nicht im Node eingestellt, enthält diese optionale Eigenschaft den Namen der zu lesenden Datei</dd>
     </dl>
     <h3>Details</h3>
-    <p>The filename should be an absolute path, otherwise it will be relative to
-    the working directory of the Node-RED process.</p>
-    <p>On Windows, path separators may need to be escaped, for example: <code>\\Users\\myUser</code>.</p>
-    <p>Optionally, a text file can be split into lines, outputting one message per line, or a binary file
-    split into smaller buffer chunks - the chunk size being operating system dependant, but typically 64k (Linux/Mac) or 41k (Windows).</p>
-    <p>When split into multiple messages, each message will have a <code>parts</code>
-    property set, forming a complete message sequence.</p>
-    <h4>Legacy error handling</h4>
-    <p>Before Node-RED 0.17, if this node hit an error whilst reading the file, it would
-    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>
+    <p>Der Dateiname sollte ein absoluter Pfad sein.
+       Andernfalls wird er relativ zum Arbeitsverzeichnis des Node-RED-Prozesses angewandt.</p>
+    <p>Unter Windows müssen die Pfadtrenner (\) in Escape-Codes umgewandelt werden, z. B.: <code>\\Users\\myUser</code>.</p>
+    <p>Optional kann eine Textdatei in einzelne Zeilen mit jeweils eine Nachricht pro Zeile aufgeteilt werden.
+       Eine Binärdatei wird in kleine Teile in Größe abhängig vom Betriebssystem aufgeteilt,
+       aber typischerweise 64k (Linux/Mac) oder 41k (Windows).</p>
+    <p>Bei Aufteilung in mehrere Nachrichten besitzt jede eine <code>parts</code>-Eigenschaft,
+       welche eine komplette Nachrichten-Sequenz bildet.</p>
+    <p>Fehler sollten mittels <span style="background-color:Gainsboro">catch</span>-Nodes abgefangen und behandelt werden.</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>Es kann eine kommagetrennte Liste von Verzeichnissen und/oder Dateien eingeben werden. 
-      Es müssen Anführungszeichen "...." um alle Einträge gesetzt werden, die Leerzeichen enthalten.</p>
-    <p>Unter Windows muss in allen Verzeichnisnamen doppelte Backslashes \\\ 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, 
-      während eine stringifizierte Version der Ü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, 
-      normalerweise <i>file</i> oder <i>directory</i>, während <code>msg.size</code> die Dateigröße in Bytes enthält.</p>
-    <p>Natürlich ist unter Linux <i>alles</i> eine Datei und kann somit beobachtet werden...</p>
-    <p><b>Note: </b>Das Verzeichnis oder die Datei muss vorhanden sein, um beobachtet zu werden. Wenn die Datei
-      oder das Verzeichnis gelöscht wird, kann es nicht mehr überwacht werden, auch wenn es wieder neu erstellt wird.</p>
+    <p>Überwachung eines Verzeichnisses oder einer Datei auf Änderungen.</p>
+    <p>Es kann eine kommagetrennte Liste von Verzeichnissen und/oder Dateien angegeben werden.
+       Es müssen Anführungszeichen "..." um alle Leerzeichen enthaltenden Einträge gesetzt werden.</p>
+    <p>Unter Windows müssen in allen Verzeichnisnamen doppelte Schrägstriche \\ verwendet werden.</p>
+    <p>Der vollständige Dateiname der geänderten Datei wird in <code>msg.payload</code> und <code>msg.filename</code> gemeldet,
+       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> enthält den Typ des geänderten Elements, normalerweise <i>file</i> oder <i>directory</i>,
+       während <code>msg.size</code> die Dateigröße in Bytes enthält.</p>
+    <p>Natürlich ist unter Linux <i>alles</i> eine Datei und kann somit beobachtet werden ...</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>如果收到设置了<b>msg.reset</b>属性的消息，则部分收到的消息将被删除而不发送，同时重置消息列数。</p>
+    <p>如果收到设置了<code>msg.complete</code>属性的消息时发送输出消息并重置消息列数。</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>如果收到設置了<b>msg.reset</b>屬性的消息，則部分收到的消息將被刪除而不發送，同時重置消息列數。</p>
+    <p>如果收到設置了<code>msg.complete</code>屬性的消息時發送輸出消息並重置消息列數。</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" : {
-    "welcome" : "Willkommen bei Node-RED!",
-    "version" : "__component__ Version: __version__",
-    "unsupported_version" : "Nicht unterstützte Version von __component__. Erfordert: __requires__ Gefunden: __version__",
-    "paths" : {
-      "settings" : "Einstellungsdatei: __path__",
-      "httpStatic" : "HTTP-Statisch: __path__"
+  "runtime": {
+    "welcome": "Willkommen bei Node-RED!",
+    "version": "__component__ Version: __version__",
+    "unsupported_version": "Nicht unterstützte Version von __component__. Erforderlich: __requires__, jedoch gefunden: __version__",
+    "paths": {
+      "settings": "Einstellungsdatei: __path__",
+      "httpStatic": "HTTP-Statisch: __path__"
     }
   },
-  "server" : {
-    "loading" : "Paletten-Nodes werden geladen",
-    "palette-editor" : {
-      "disabled" : "Paletteneditor inaktiviert: Benutzereinstellungen",
-      "npm-not-found" : "Paletteneditor inaktiviert: Befehl 'npm' nicht gefunden"
+
+  "server": {
+    "loading": "Paletten-Nodes werden geladen",
+    "palette-editor": {
+      "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_plural" : "Fehler beim Registrieren von __count__ -Node-Typen",
-    "errors-help" : "Mit -v ausführen, um Details zu erfahren",
-    "missing-modules" : "Fehlende Node-Module:",
-    "node-version-mismatch" : "Das Node-Modul kann in dieser Version nicht geladen werden. Erfordert: __version__ ",
-    "type-already-registered" : "'__type__' bereits von Modul __module__ registriert",
-    "removing-modules" : "Module aus der Konfiguration entfernen",
-    "added-types" : "Hinzugefügte Node-Typen:",
-    "removed-types" : "Entfernte Node-Typen:",
-    "install" : {
-      "invalid" : "Ungültiger Modulname",
-      "installing" : "Modul wird installiert: __name__, Version: __version__",
-      "installed" : "Installiertes Modul: __name__",
-      "install-failed" : "Installation fehlgeschlagen",
-      "install-failed-long" : "Die Installation des Moduls __name__ ist fehlgeschlagen:",
-      "install-failed-not-found" : "Das Modul '$t(server.install.install-failed-long') wurde nicht gefunden.",
-      "upgrading" : "Modul wird aktualisiert: __name__ auf Version: __version__",
-      "upgraded" : "Erweitertes Modul: __name__. Neustart von Node-RED für die Verwendung der neuen Version",
-      "upgrade-failed-not-found" : "$t(server.install.install-failed-long) Version nicht gefunden",
-      "uninstalling" : "Modul wird deinstalliert: __name__",
-      "uninstall-failed" : "Deinstallation fehlgeschlagen",
-      "uninstall-failed-long" : "Das Deinstallieren des Moduls __name__ ist fehlgeschlagen:",
-      "uninstalled" : "Nicht installiertes Modul: __name__"
+    "errors": "Fehler beim Registrieren von __count__ Node-Type",
+    "errors_plural": "Fehler beim Registrieren von __count__ Node-Typen",
+    "errors-help": "Mit der Option -v ausführen, um weitere Details zu erfahren",
+    "missing-modules": "Fehlende Node-Module:",
+    "node-version-mismatch": "Das Node-Modul kann nicht in dieser Version geladen werden. Erforderlich: __version__",
+    "type-already-registered": "Der Typ '__type__' ist bereits von Modul '__module__' registriert",
+    "removing-modules": "Entferne Module aus der Konfiguration",
+    "added-types": "Hinzugefügte Node-Typen:",
+    "removed-types": "Entfernte Node-Typen:",
+    "install": {
+      "invalid": "Ungültiger Modulname",
+      "installing": "Modul wird installiert: __name__, Version: __version__",
+      "installed": "Installiertes Modul: __name__",
+      "install-failed": "Installation 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-name": "$t(server.install.install-failed-long). Ungültiger Modulname: __name__",
+      "install-failed-url": "$t(server.install.install-failed-long). Ungültige URL: __url__",
+      "upgrading": "Upgrade von Modul __name__ auf Version __version__ gestartet",
+      "upgraded": "Upgrade von Modul __name__ war erfolgreich. Neustart von Node-RED für die Verwendung der neuen Version erforderlich.",
+      "upgrade-failed-not-found": "Upgrade fehlgeschlagen. $t(server.install.install-failed-long). Version nicht gefunden.",
+      "uninstalling": "Das Modul __name__ wird deinstalliert",
+      "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.",
-    "port-in-use" : "Fehler: Port wird verwendet",
-    "uncaught-exception" : "Nicht abgefangene Ausnahmebedingung:",
-    "admin-ui-disabled" : "Administratorbenutzerschnittstelle inaktiviert",
-    "now-running" : "Server wird jetzt auf __listenpath__ ausgeführt.",
-    "failed-to-start" : "Starten des Servers fehlgeschlagen:",
-    "headless-mode" : "Ausführung im Headless-Modus",
-    "httpadminauth-deprecated" : "Die Verwendung von httpAdminAuth wird nicht weiter unterstützt. Verwenden Sie stattdessen adminAuth."
-  },
-  "api" : {
-    "flows" : {
-      "error-save" : "Fehler beim Speichern der Flows: __message__",
-      "error-reload" : "Fehler beim erneuten Laden von Flows: __message__"
-    },
-    "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:"
+    "unable-to-listen": "Überwachen (listen) von __listenpath__ nicht möglich",
+    "port-in-use": "Fehler: Port wird verwendet",
+    "uncaught-exception": "Nicht abgefangene Ausnahmebedingung:",
+    "admin-ui-disabled": "Administrator-Benutzeroberfläche deaktiv",
+    "now-running": "Server wird jetzt auf __listenpath__ ausgeführt",
+    "failed-to-start": "Starten des Servers fehlgeschlagen:",
+    "headless-mode": "Server läuft im Headless-Modus",
+    "httpadminauth-deprecated": "Die Verwendung von httpAdminAuth wird nicht weiter unterstützt. Verwenden Sie stattdessen adminAuth.",
+    "https": {
+      "refresh-interval": "Erneuerung der https-Einstellungen erfolgt alle __interval__ Stunden",
+      "settings-refreshed": "https-Einstellungen wurden erneuert",
+      "refresh-failed": "Erneuerung der https-Einstellungen fehlgeschlagen: __message__",
+      "nodejs-version": "httpsRefreshInterval erfordert Node.js 11 or later",
+      "function-required": "httpsRefreshInterval erfordert die https-Eigenschaft in Form einer Funktion"
     }
   },
-  "comms" : {
-    "error" : "Kommunikationskanalfehler: __message__",
-    "error-server" : "Kommunikationsserverfehler: __message__",
-    "error-send" : "Fehler beim Senden der Kommunikation: __message__"
+
+  "api": {
+    "flows": {
+      "error-save": "Fehler beim Speichern der Flows: __message__",
+      "error-reload": "Fehler beim erneuten Laden der Flows: __message__"
     },
-  "settings" : {
-    "user-not-available" : "Benutzereinstellungen können nicht gespeichert werden: __message__",
-    "not-available" : "Einstellungen nicht verfügbar",
-    "property-read-only" : "Eigenschaft '__prop__' ist schreibgeschützt"
+    "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 des Flows '__path__': __message__",
+      "error-save-flow": "Fehler beim Speichern des Flows '__path__': __message__"
     },
-  "nodes" : {
-    "credentials" : {
-      "error" : "Fehler beim Laden der Berechtigungsnachweise: __message__",
-      "error-saving" : "Fehler beim Speichern der Berechtigungsnachweise: __message__",
-      "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"
+    "nodes": {
+      "enabled": "Aktivierte Node-Typen:",
+      "disabled": "Deaktivierte Node-Typen:",
+      "error-enable": "Der Node konnte nicht aktiviert werden:"
+    }
   },
-    "flows" : {
-      "registered-missing" : "Fehlender Typ registriert: __type__",
-      "error" : "Fehler beim Laden von Flows: __message__",
-      "starting-modified-nodes" : "Modifizierte Nodes werden gestartet",
-      "starting-modified-flows" : "Modifizierte Flows werden gestartet",
-      "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:"
+
+  "comms": {
+    "error": "Kommunikationskanal-Fehler: __message__",
+    "error-server": "Kommunikationsserver-Fehler: __message__",
+    "error-send": "Kommunikationsende-Fehler: __message__"
   },
-    "flow" : {
-      "unknown-type" : "Unbekannter Typ: __type__",
-      "missing-types" : "Fehlende Typen",
-      "error-loop" : "Nachricht überschritt die maximale Anzahl der Wiederholungen"
+
+  "settings": {
+    "user-not-available": "Benutzereinstellungen konnten nicht gespeichert werden: __message__",
+    "not-available": "Einstellungen nicht verfügbar",
+    "property-read-only": "Die Eigenschaft '__prop__ 'ist schreibgeschützt"
   },
-    "index" : {
-      "unrecognised-id" : "Nicht erkannte ID: __id__",
-      "type-in-use" : "Typ in Verwendung: __msg__",
-      "unrecognised-module" : "Nicht erkannes Modul: __module__"
+
+  "nodes": {
+    "credentials": {
+      "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" : {
-      "localfilesystem" : {
-        "module-not-found" : "Modul '__module__' wurde nicht gefunden."
+    "flows": {
+      "safe-mode": "Die Flows sind gestoppt im abgesicherten Modus. Übernahme (Deploy) zum Starten.",
+      "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" : {
-      "forbidden-flow-name" : "Unzulässiger Flowname"
+
+  "storage": {
+    "index": {
+      "forbidden-flow-name": "Unzulässiger Flow-Name"
     },
-    "localfilesystem" : {
-      "user-dir" : "Benutzerverzeichnis: __path__",
-      "flows-file" : "Flow-Datei: __path__",
-      "create" : "Neue __type__-Datei wird erstellt",
-      "empty" : "Vorhandene __type__-Datei ist leer",
-      "invalid" : "Vorhandene __type__ Datei ist ungültig (json)",
-      "restore" : "__type__ Dateisicherung wird zurückgespeichert: __path__",
-      "restore-fail" : "Das Zurückschreiben der __type__ Dateisicherung ist fehlgeschlagen: __message__",
-      "fsync-fail" : "Das Löschen der Datei __path__ auf die Platte ist fehlgeschlagen: __message__",
-      "projects" : {
-        "changing-project" : "Aktives Projekt wird festgelegt: __project__",
-        "active-project" : "Aktives Projekt: __project__",
-        "project-not-found" : "Projekt nicht gefunden: __project__",
-        "no-active-project" : "Kein aktives Projekt: Standarddatei für DatenFlows verwenden",
-        "disabled" : "Projekte inaktiviert: editorTheme.projects.enabled=false",
-        "disabledNoFlag" : "Projekte inaktiviert: setze editorTheme.projects.enabled=true zum Aktivieren",
-        "git-not-found" : "Projekte inaktiviert: Git-Befehl nicht gefunden",
-        "git-version-old" : "Projekte inaktiviert: git __version__ wird nicht unterstützt. Erfordert 2.x",
-        "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."
+    "localfilesystem": {
+      "user-dir": "Benutzerverzeichnis: __path__",
+      "flows-file": "Flow-Datei: __path__",
+      "create": "Neue __type__-Datei wird erstellt",
+      "empty": "Vorhandene __type__-Datei ist leer",
+      "invalid": "Vorhandene __type__-Datei enthält ungültigen JSON-Code",
+      "restore": "Die __type__-Dateisicherung wird wiederhergestellt: __path__",
+      "restore-fail": "Die Wiederherstellung der '__type__'-Dateisicherung ist fehlgeschlagen: __message__",
+      "fsync-fail": "Die Übertragung der Datei __path__ auf das Laufwerk ist fehlgeschlagen: __message__",
+      "projects": {
+        "changing-project": "Aktives Projekt wird festgelegt: __project__",
+        "active-project": "Aktives Projekt: __project__",
+        "project-not-found": "Projekt nicht gefunden: __project__",
+        "no-active-project": "Kein aktives Projekt: Es wird die Standarddatei für die Flows verwendet",
+        "disabled": "Projekte deaktiviert: editorTheme.projects.enabled=false",
+        "disabledNoFlag": "Projekte deaktiviert: Setze editorTheme.projects.enabled=true zum Aktivieren",
+        "git-not-found": "Projekte deaktiviert: Git nicht gefunden",
+        "git-version-old": "Projekte deaktiviert: Git __version__ wird nicht unterstützt. Erforderlich: V2.x",
+        "summary": "Ein Node-RED-Projekt",
+        "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__]",
-    "error-loading-module" : "Fehler beim Laden des Kontextspeichers: __message__",
-    "error-module-not-defined" : "Kontextspeicher '__storage__' fehlt 'Modul' -Option",
-    "error-invalid-module-name" : "Ungültiger Kontextspeichername: '__name__'",
-    "error-invalid-default-module" : "Standardkontextspeicher unbekannt: '__storage__'",
-    "unknown-store" : "Unbekannter Kontextspeicher '__name__' angegeben. Standardspeicher wird verwendet.",
-    "localfilesystem" : {
-      "error-circular" : "Kontext __scope__ enthält einen kreisförmigen Verweis, der nicht persistent gespeichert werden kann.",
-      "error-write" : "Fehler beim Schreiben des Kontextes: __message__"
+
+  "context": {
+    "log-store-init": "Kontextspeicher: __name__ [__info__]",
+    "error-loading-module": "Fehler beim Laden des Kontextspeichers: __message__",
+    "error-loading-module2": "Fehler beim Laden des Kontextspeichers '__module__': __message__",
+    "error-module-not-defined": "Beim Kontextspeicher '__storage__' fehlt die 'module'-Option",
+    "error-invalid-module-name": "Ungültiger Kontextspeichername: __name__",
+    "error-invalid-default-module": "Standardkontextspeicher unbekannt: __storage__",
+    "unknown-store": "Unbekannter Kontextspeicher '__name__ ' angegeben. Standard-Kontextspeicher wird verwendet.",
+    "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__"
     }
   }
+
 }