update de book and contributor book

contributor-book/plugins.md

@@ -37,14 +37,14 @@ Let's create our project. For this example, we'll create a simple `len` command
 First off, we'll create our plugin:
 
 ```sh
-> cargo new nu_plugin_len
-> cd nu_plugin_len
+cargo new nu_plugin_len
+cd nu_plugin_len
 ```
 
 Next, we'll add `nu` to our project's dependencies.
 
 ```sh
-> cargo add nu-plugin nu-protocol
+cargo add nu-plugin nu-protocol
 ```
 
 The `Cargo.toml` file should now look something like the following.

de/book/3rdpartyprompts.md

@@ -22,7 +22,7 @@ Wenn [oh-my-posh](https://ohmyposh.dev/) verwendet werden soll, kann dies in wen
 3. Die Umgebungsvariable `PROMPT_COMMAND` durch hinzufügen der folgenden Zeile in `~/.config/nushell/config.nu` setzen. Den Style `M365Princess.omp.json` kann man entsprechend der [Demo](https://ohmyposh.dev/docs/themes) beliebig ändern .
 
 ```nu
-> $env.PROMPT_COMMAND = { oh-my-posh --config ~/.poshthemes/M365Princess.omp.json }
+$env.PROMPT_COMMAND = { oh-my-posh --config ~/.poshthemes/M365Princess.omp.json }
 ```
 
 ## Starship

de/book/aliases.md

@@ -5,19 +5,19 @@ Aliase in Nushell bieten eine einfache Möglichkeit, um Texte zur ersetzen. Dami
 Beispielsweise kann ein Alias namens `ll` definiert werden, der den längeren Befehl `ls -l` ersetzt:
 
 ```
-> alias ll = ls -l
+alias ll = ls -l
 ```
 
 Nun kann der Alias aufgerufen werden:
 
 ```
-> ll
+ll
 ```
 
 Wenn das getan wird, wirkt es, als sei `ls -l` aufgerufen worden. Das bietet auch die Möglichkeit weitere Parameter anzugeben. So kann auch geschrieben werden:
 
 ```
-> ll -a
+ll -a
 ```
 
 Das ist äquivalent zu `ls -l -a`. Deutlich kürzer.

de/book/coloring_and_theming.md

@@ -17,7 +17,7 @@ Tabellen Rahmen werden mit der Einstellung `table_mode` in der `config.nu` konfi
 Hier ein Beispiel:
 
 ```nu
-> $env.config = {
+$env.config = {
     table_mode: rounded
 }
 ```
@@ -273,7 +273,7 @@ Hier die aktuelle Liste von Primitiven Typen. Nicht alle davon sind konfigurierb
 Hier ein kleines Beispiel, wie diese Werte angewendet werden können.
 
 ```nu
-> let config = {
+let config = {
     color_config: {
         separator: purple
         leading_trailing_space_bg: "#ffffff"
@@ -298,7 +298,7 @@ Hier ein kleines Beispiel, wie diese Werte angewendet werden können.
 Hier ein anderes Beispiel, welches mehrere Farben Schreibweisen sowie Kommentare verwendet.
 
 ```nu
-> let config = {
+let config = {
     color_config: {
         separator: "#88b719" # Dies setzt nur die Vordergrundsfarbe wie in PR #486
         leading_trailing_space_bg: white # Dies setzt nur die Vordergrundsfarbe im ursprünglichen Stil
@@ -352,7 +352,7 @@ Hier die aktuelle Formen Liste.
 Hier ein kleines Beispiel wie Farben auf diese Teile angewendet werden. Was nicht spezifiziert wird, erhält die Standardfarbe.
 
 ```nu
-> $env.config = {
+$env.config = {
     color_config: {
         shape_garbage: { fg: "#FFFFFF" bg: "#FF0000" attr: b}
         shape_bool: green
@@ -375,13 +375,13 @@ Der Nushell Prompt ist konfigurierbar mit diesen Umgebungsvariablen:
 Beispiel: Für einen einfachen Prompt wäre folgendes mögllich. Hinweis `PROMPT_COMMAND` benötigt einen `block` wogegen die anderen einen `string` erwarten.
 
 ```nu
-> $env.PROMPT_COMMAND = { build-string (date now | format date '%m/%d/%Y %I:%M:%S%.3f') ': ' (pwd | path basename) }
+$env.PROMPT_COMMAND = { build-string (date now | format date '%m/%d/%Y %I:%M:%S%.3f') ': ' (pwd | path basename) }
 ```
 
 Soll der standard `PROMPT_INDICATOR` geändert werden, sieht das so aus.
 
 ```nu
-> $env.PROMPT_INDICATOR = "> "
+$env.PROMPT_INDICATOR = "> "
 ```
 
 Den Prompt einfärben wird duch den `block` `PROMPT_COMMAND` kontrolliert und individualisiert.

de/book/configuration.md

@@ -45,23 +45,23 @@ Um Nushell als Login-Shell zu verwenden, muss die `$env` Variable konfiguriert w
 Der komplette Satz an Umgebungsvariablen kann erzeugt werden, wenn Nu in einer anderen Shell, wie beispielsweise Bash, ausgeführt wird. In diese Nu-Sitzung kann ein Befehl wie der folgende verwendet werden, um `$env` zu setzen:
 
 ```
-> env | each { echo $"$env.($it.name) = '($it.raw)'" } | str join (char nl)
+env | each { echo $"$env.($it.name) = '($it.raw)'" } | str join (char nl)
 ```
 
 Das gibt Zeilen aus um `$env` in `env.nu` zu setzen - eine für jede Umgebungsvariable - inklusive der nötigen Werte.
 
 Als nächstes, muss auf manchen Distributionen sichergestellt werden, dass Nu in der Liste der Shells in /etc/shells ist:
 
 ```
-> cat /etc/shells
-# /etc/shells: valid login shells
-/bin/sh
-/bin/dash
-/bin/bash
-/bin/rbash
-/usr/bin/screen
-/usr/bin/fish
-/home/sophia/.cargo/bin/nu
+cat /etc/shells
+# => # /etc/shells: valid login shells
+# => /bin/sh
+# => /bin/dash
+# => /bin/bash
+# => /bin/rbash
+# => /usr/bin/screen
+# => /usr/bin/fish
+# => /home/sophia/.cargo/bin/nu
 ```
 
 Damit sollte es möglich sein, Nu als Login-Shell mit `chsh` festzulegen. Nach dem Ausloggen und erneutem Einloggen sollte Nu als Shell grüßen.

de/book/custom_commands.md

@@ -17,7 +17,7 @@ In dieser Definition, wird ein Befehl `greet` beschrieben, der einen Parameter `
 Um den obigen Befehl auszuführen wird er wie ein eingebauter Befehl aufgerufen:
 
 ```
-> greet "world"
+greet "world"
 ```
 
 Wenn das getan wird, wird eine Ausgabe erzeugt, die wie die der eingebauten Befehle aussieht:
@@ -48,7 +48,7 @@ def "str mycommand" [] {
 Jetzt kann der eigene Unterbefehl aufgerufen werden, als ob er ein eingebauter Befehl von `str` wäre:
 
 ```
-> str mycommand
+str mycommand
 ```
 
 ## Typen von Parametern
@@ -130,19 +130,19 @@ In der obigen Definition von `greet`, werden ein fester Parameter `name` und ein
 Das obige Beispiel kann wie folgt aufgerufen werden:
 
 ```
-> greet world --age 10
+greet world --age 10
 ```
 
 Oder:
 
 ```
-> greet --age 10 world
+greet --age 10 world
 ```
 
 Oder gleich ganz ohne Flag:
 
 ```
-> greet world
+greet world
 ```
 
 Flags können auch so definiert werden, dass es eine Kurzform gibt. Das erlaubt es sowohl eine kurze als auch eine einfach lesbare lange Flag für die selbe Aufgabe zu haben.
@@ -163,7 +163,7 @@ _Hinweis:_ Flags sind benannt nach der langen Form des Namens. Im obigen Beispie
 Nun kann diese neue Version von `greet` wie folgt aufgerufen werden:
 
 ```
-> greet -a 10 hello
+greet -a 10 hello
 ```
 
 ## Dokumentation für den eigenen Befehl

de/book/custom_completions.md

@@ -13,10 +13,10 @@ Dem Befehl, der die Vervollständigung bereitstellt, und die Verknüpfung mit de
 Hier ein Beispiel:
 
 ```
-> def tiere [] { ["katze", "hund", "aal" ] }
-> def my-command [tier: string@tiere] { print $tier }
->| my-command
-katze                 hund                 aal
+def tiere [] { ["katze", "hund", "aal" ] }
+def my-command [tier: string@tiere] { print $tier }
+| my-command
+# => katze                 hund                 aal
 ```
 
 In der ersten Zeile wird ein eigener Befehl erstellt, der eine Liste von drei verschiedenen Tieren zurückgibt.

de/book/environment.md

@@ -36,7 +36,7 @@ Umgebungsvariablen werden als Felder der Variable `$env` gesetzt.
 Um die Umgebungsvariable `FOO` zu setzen kann direkt der Wert zu `$env.FOO` zugewiesen werden.
 
 ```
-> $env.FOO = 'BAR'
+$env.FOO = 'BAR'
 ```
 
 Um zum Beispiel die `PATH` Variable zu ergänzen, wird folgendes eingegeben:
@@ -54,7 +54,7 @@ Wenn mehrere Umgebungsvariablen gesetzt werden sollen, so kann `load-env` eine g
 Diese besteht aus name/value Paaren, welche alle auf einmal geladen werden:
 
 ```
-> load-env { "BOB": "FOO", "JAY": "BAR" }
+load-env { "BOB": "FOO", "JAY": "BAR" }
 ```
 
 ### Einmalig verwendete Umgebungsvariablen
@@ -77,14 +77,14 @@ Wenn eine Umgebungsvariable gesetzt wird, ist sie nur in ihrem Gültigkeitsberei
 Hier ein kleines Beispiel um den Gültigkeitsbereich zu demonstrieren:
 
 ```
-> $env.FOO = "BAR"
-> do {
+$env.FOO = "BAR"
+do {
     $env.FOO = "BAZ"
     $env.FOO == "BAZ"
 }
-true
-> $env.FOO == "BAR"
-true
+# => true
+$env.FOO == "BAR"
+# => true
 ```
 
 ## Verzeichnis Wechsel
@@ -98,15 +98,15 @@ Dies wiederum folgt den gleichen Regeln wie das setzen anderer Umgebungsvariable
 Eine praktische Möglichkeit eine Umgebungsvariable einmalig zu setzen, ist inspiriert von Bash und anderen Shells:
 
 ```
-> FOO=BAR echo $env.FOO
-BAR
+FOO=BAR echo $env.FOO
+# => BAR
 ```
 
 Es kann auch [`with-env`](/commands/docs/with-env.md) verwendet werden um expliziter zu sein:
 
 ```
-> with-env { FOO: BAR } { echo $env.FOO }
-BAR
+with-env { FOO: BAR } { echo $env.FOO }
+# => BAR
 ```
 
 Der [`with-env`](/commands/docs/with-env.md) Befehl setzt die Umgebungsvariable temporär (hier wird die Variable "FOO" auf den Wert "BAR" gesetzt)
@@ -129,14 +129,14 @@ Wird sie jedoch mit [`def --env`](/commands/docs/def.md) anstatt [`def`](/comman
 (Gilt auch für `export def`, siehe [Modules (EN)](/book/modules.md))
 
 ```
-> def --env foo [] {
+def --env foo [] {
     $env.FOO = 'BAR'
 }
 
-> foo
+foo
 
-> $env.FOO
-BAR
+$env.FOO
+# => BAR
 ```
 
 ## Umgebungsvariablen konvertieren
@@ -166,26 +166,26 @@ $env.ENV_CONVERSIONS = {
 In einer Nushell Instanz gilt nun:
 
 ```
-> with-env { FOO : 'a-b-c' } { nu }  # runs Nushell with FOO env. var. set to 'a-b-c'
+with-env { FOO : 'a-b-c' } { nu }  # runs Nushell with FOO env. var. set to 'a-b-c'
 
-> $env.FOO
-  0   a
-  1   b
-  2   c
+$env.FOO
+# =>   0   a
+# =>   1   b
+# =>   2   c
 ```
 
 Wie zu sehen ist `$env.FOO` nun eine Liste in einer neuen Nushell Instanz mit der neuen config.
 Die Konvertierung kann auch manuell getestet werden mit:
 
 ```
-> do $env.ENV_CONVERSIONS.FOO.from_string 'a-b-c'
+do $env.ENV_CONVERSIONS.FOO.from_string 'a-b-c'
 ```
 
 Um die Konvertierun list -> string zu testen:
 
 ```
-> nu -c '$env.FOO'
-a-b-c
+nu -c '$env.FOO'
+# => a-b-c
 ```
 
 Weil `nu` selber ein externer Befehl ist, übersetzt Nushell die `[ a b c ]` Liste gemäss `ENV_CONVERSIONS.FOO.to_string` und übergibt sie dem `nu` Prozess.
@@ -208,21 +208,21 @@ Alle Umgebungsvariablen in env.nu und config.nu sind immer noch Strings solange
 Umgebungsvariablen können im aktuellen Gültigkeitsbereich entfernt werden via [`hide`](/commands/docs/hide.md):
 
 ```
-> $env.FOO = 'BAR'
-...
-> hide FOO
+$env.FOO = 'BAR'
+# => ...
+hide FOO
 ```
 
 Dieses Verstecken im Gültigkeitsbereich erlaubt es gleichzeitig temporär eine Variabel zu entfernen ohne dass man die höher gelegene Umgebung modifiziert wird:
 
 ```
-> $env.FOO = 'BAR'
-> do {
+$env.FOO = 'BAR'
+do {
     hide FOO
     # $env.FOO does not exist
   }
-> $env.FOO
-BAR
+$env.FOO
+# => BAR
 ```
 
 Mehr Informationen über Verstecken findet sich im Kapitel [Modules](/book/modules.md)

de/book/escaping.md

@@ -5,11 +5,11 @@ Nushell stellt einen identischen Satz an Befehlen für verschiedene Systeme zur
 Nushell Befehl:
 
 ```
-> ls
+ls
 ```
 
 Aufruf des Systembefehls:
 
 ```
-> ^ls
+^ls
 ```

de/book/hooks.md

@@ -89,12 +89,12 @@ Umgebungsvariablen im Hook **Block** werden in ähnlicher Weise wie [`def --env`
 Folgendes Beispiel zeigt dies:
 
 ```
-> $env.config = ($env.config | upsert hooks {
+$env.config = ($env.config | upsert hooks {
     pre_prompt: { $env.SPAM = "eggs" }
 })
 
-> $env.SPAM
-eggs
+$env.SPAM
+# => eggs
 ```
 
 Die Hookblöcke folgen ansonsten den allgemeinen Scoping-Regeln, d.h. Befehle, Aliase, etc., die innerhalb des Blocks definiert sind,
@@ -152,11 +152,11 @@ Dies funktioniert, als ob der String in den REPL eingeben und Enter gedrückt wi
 So kann der Hook aus dem vorherigen Abschnitt auch geschrieben werden als:
 
 ```
-> $env.config = ($env.config | upsert hooks {
+$env.config = ($env.config | upsert hooks {
     pre_prompt: '$env.SPAM = "eggs"'
 })
 
-> $env.SPAM
+$env.SPAM
 eggs
 ```
 Dieses Feature kann z.B. verwendet werden, um abhängig vom aktuellen Verzeichnis Definitionen einzubringen: