@isothrum/editor 0.0.0-stage → 0.1.0

package/src/lib/tool/text/de.ts

@@ -0,0 +1,358 @@
+import type { EditorText } from "./en";
+
+export const de: EditorText = {
+  toolbar: {
+    blocks: { switch: "Switch", router: "Router", firewall: "Firewall", container: "Container", vm: "Virtuelle Maschine", mine: "Meine Geräte" },
+    kindsOf: (block) => `Arten: ${block}`,
+    devices: "Geräte",
+    hand: "Hand: Arbeitsfläche verschieben",
+    select: "Auswahl: auswählen, verschieben, löschen",
+    lan: "LAN",
+    lanTitle: "LAN / VLAN: ein Bereich; Maschinen darin erhalten dort eine Adresse",
+    switch: "Switch",
+    switchTitle: "Switch: Ports in VLANs und ein Trunk",
+    note: "Notiz",
+    noteTitle: "Notiz: Text, Kasten oder Ellipse, um das Lab zu erklären",
+    forget: (device) => `${device} vergessen`,
+    forgetLabel: (device) => `Gerät ${device} vergessen`,
+    undo: "Rückgängig",
+    undoTitle: "Rückgängig · Strg/⌘ Z",
+    redo: "Wiederholen",
+    redoTitle: "Wiederholen · Strg/⌘ Umschalt Z",
+  },
+  hints: {
+    lan: "Auf die Arbeitsfläche klicken, um ein LAN zu platzieren; Maschinen darin erhalten dort eine Adresse. Name oder Bereich doppelklicken, um sie zu bearbeiten.",
+    note: "Auf die Arbeitsfläche klicken, um eine Notiz zu platzieren, dann doppelklicken, um zu schreiben. Notizen bleiben im Editor, nicht in der isoloom.yml.",
+    place: (device) => `${device}: zum Platzieren auf die Arbeitsfläche klicken. Esc zum Abbrechen.`,
+    hand: "Ziehen, um die Arbeitsfläche zu verschieben. V drücken, um wieder auszuwählen.",
+    cable: "Von einem Punkt einer Maschine zu einer anderen ziehen, um sie zu verkabeln.",
+    select: "Auf der Arbeitsfläche ziehen, um mehrere Maschinen auszuwählen: Entf oder Strg/⌘ C, V, D. Leertaste halten, um die Arbeitsfläche zu verschieben.",
+  },
+  devices: {
+    router: { label: "Router", hint: "automatisch: seine Netze erreichen einander" },
+    "router-frr": { label: "Router (FRR)", hint: "FRRouting-Container zum Selbstkonfigurieren" },
+    firewall: { label: "Firewall", hint: "nftables auf Alpine" },
+    container: { label: "Linux-Container" },
+    web: { label: "Webserver", hint: "nginx, Port 80" },
+    database: { label: "Datenbank", hint: "PostgreSQL, Port 5432" },
+    desktop: { label: "Linux-Desktop", hint: "Xfce mit VNC: Rechtsklick, Bildschirm; Passwort vncpassword" },
+    "linux-vm": { label: "Linux-VM" },
+    "ubuntu-vm": { label: "Ubuntu-VM" },
+    "kali-vm": { label: "Kali-VM" },
+    "windows-vm": { label: "Windows-VM" },
+    workstation: { label: "Workstation", hint: "hier landet der Benutzer" },
+    "cisco-iol": { label: "Cisco-IOL-Router", hint: "IOS unter Linux, dein vrnetlab-Image" },
+    "cisco-iol-l2": { label: "Cisco-IOL-Switch", hint: "IOL-L2, dein vrnetlab-Image" },
+  },
+  myDevice: (what) => `eigenes Gerät: ${what}`,
+  myDeviceRouter: "automatischer Router",
+  status: {
+    loading: "Lädt…",
+    toFix: (count) => `${String(count)} zu beheben`,
+    valid: "Gültig",
+  },
+  run: {
+    autoStart: "Dieses Lab beim Öffnen der App starten",
+    autoStartNote: "Auf diesem Computer, wenn die App mit diesem Lab öffnet und es nicht schon läuft.",
+    statusTitle: (up, total) => `${String(up)} von ${String(total)} Maschinen laufen`,
+    probed: "Ports von den Maschinen gelesen",
+    inferred: "Ports nach dem Zustand der Maschinen (VMs werden nicht abgefragt)",
+    run: "Starten",
+    starting: "Startet…",
+    stop: "Stoppen",
+    stopping: "Stoppt…",
+    vmsTitle: "Ein Lab mit VMs läuft mit Vagrant (und VirtualBox oder libvirt): installiere es von vagrantup.com oder exportiere das Lab",
+    runVmsTitle: "Das Lab auf diesem Rechner ausführen (VMs mit Vagrant)",
+    startingVmsLog: "VMs werden mit vagrant up gestartet (beim ersten Mal werden ihre Boxen geladen: Minuten)…",
+    runTitle: "Das Lab auf diesem Rechner starten (Docker)",
+    startingLog: "Lab wird mit docker compose gestartet…",
+    window: "Auf diesem Rechner ausführen",
+    running: "Das Lab läuft. Ein LAN oder ein Kabel auswählen, um seinen Verkehr mitzuschneiden.",
+    stopped: "Das Lab ist gestoppt.",
+    noDocker:
+      "Docker antwortet nicht. Docker installieren und starten; unter Linux außerdem das eigene Konto zur Gruppe docker hinzufügen (sudo usermod -aG docker $USER, dann neu anmelden).",
+    noLiveCapture: (wireshark, dir) =>
+      `${
+        wireshark
+          ? "Wireshark kann mit diesem Konto nicht live mitschneiden: sudo usermod -aG wireshark $USER ausführen, dann neu anmelden. Bis dahin werden Mitschnitte"
+          : "Wireshark ist nicht installiert: Mitschnitte werden"
+      } als .pcap-Dateien unter ${dir} gespeichert.`,
+  },
+  capture: {
+    capturing: (network) => `Mitschnitt von ${network}`,
+    writingTo: "Schreibt nach",
+    live: "Live in Wireshark.",
+    stop: "Mitschnitt stoppen",
+    start: "Verkehr mitschneiden",
+    runFirst: "Das Lab starten, um seinen Verkehr mitzuschneiden.",
+  },
+  link: {
+    suspend: "Verbindung trennen",
+    resume: "Verbindung wiederherstellen",
+    suspendAll: "Alle Verbindungen trennen",
+    resumeAll: "Alle Verbindungen wiederherstellen",
+    cableSuspended: "Verbindung getrennt: nichts kommt durch.",
+    lanSuspended: (ports) => (ports === 1 ? "1 Verbindung getrennt." : `${String(ports)} Verbindungen getrennt.`),
+    runFirst: "Das Lab starten, um seine Verbindungen zu trennen.",
+  },
+  export: "Exportieren",
+  engineDidntLoad: (error) => `Die Engine wurde nicht geladen: ${error}`,
+  engineFailed: (error) => `Die Engine ist an diesem Lab gescheitert: ${error}`,
+  toasts: {
+    brokenLink: "Dieser Freigabelink ist beschädigt: Das Lab konnte nicht gelesen werden.",
+    openedShared: (lab) => `Geteiltes Lab „${lab}“ geöffnet. Rückgängig holt das vorherige zurück.`,
+    linkCopied: "Freigabelink kopiert: Wer ihn öffnet, erhält eine Kopie dieses Labs.",
+    copyPrompt: "Diesen Link kopieren, um das Lab zu teilen:",
+    savedDevice: (device) => `„${device}“ gespeichert: Es steht am Ende der Werkzeugleiste.`,
+    gns3Opened: (lab, machines, lans) =>
+      `„${lab}“ aus GNS3 geöffnet: ${String(machines)} ${machines === 1 ? "Maschine" : "Maschinen"}, ${String(lans)} ${lans === 1 ? "LAN" : "LANs"}.`,
+    undoBringsBack: "Rückgängig holt das vorherige Lab zurück.",
+    gns3Unreadable: "Dieses GNS3-Projekt konnte nicht gelesen werden.",
+  },
+  windows: {
+    machine: "Maschine",
+    lan: (lan) => `LAN ${lan}`,
+    cable: (a, b) => `Kabel ${a} ↔ ${b}`,
+    portOn: (machine) => `Port an ${machine}`,
+    cableNote: "Jedes Kabel ist ein eigenes kleines Netz (ein /29); die beiden Enden erhalten seine ersten zwei Adressen.",
+    removeCable: "Kabel entfernen",
+    conditions: {
+      title: "Leitungsbedingungen",
+      delay: "Verzögerung (ms, je Richtung)",
+      jitter: "Jitter (ms)",
+      loss: "Verlust (%)",
+      rate: "Bandbreite (Mbit/s)",
+      hint: "Eine langsame oder verlustbehaftete Leitung, mit tc netem an jedem Ende. Leer: keine.",
+      onLan: "Dieses Kabel bringt die Maschine ins LAN: Bedingungen am LAN einstellen.",
+      onVlan: "Bedingungen gelten für ein Kabel oder ein einfaches LAN, noch nicht für das VLAN eines Switches.",
+    },
+    selected: (count) => `${String(count)} ausgewählt`,
+    selection: (items, cables) =>
+      `${String(items)} ${items === 1 ? "Element" : "Elemente"}, ${String(cables)} Kabel. Eines davon ziehen, um alle zusammen zu verschieben.`,
+    deleteSelection: (count) => `${String(count)} löschen (Entf-Taste)`,
+    close: "Schließen",
+  },
+  lab: {
+    title: "Lab",
+    containers: "Container",
+    vms: "VMs",
+    lans: "LANs",
+    cables: "Kabel",
+    toFix: "Zu beheben",
+    valid: "Das Lab ist gültig: bereit zum Export.",
+    routing:
+      "Ein Router braucht seine eigene Weiterleitungskonfiguration: Jedes Kabel ist ein eigenes Netz, und nichts routet von selbst zwischen ihnen.",
+  },
+  menu: {
+    menu: "Menü",
+    example: "Beispiel-Lab laden",
+    vlanExample: "VLAN-Beispiel laden",
+    gns3: "GNS3-Projekt öffnen…",
+    gns3File: "GNS3-Projekt",
+    share: "Freigabelink kopieren",
+    fit: "An Bildschirm anpassen",
+    clear: "Arbeitsfläche leeren",
+    light: "Helles Design",
+    dark: "Dunkles Design",
+    style: "Stil",
+    styles: { sketch: "Skizze: handgezeichnet", business: "Business: klar und nüchtern" },
+    language: "Sprache",
+    about: "Über Isothrum",
+    blog: "Blog",
+  },
+  welcome: {
+    menuHint: "Beispiel, Design, Sprache…",
+    toolbarHint: "Ein Gerät wählen, dann auf die Arbeitsfläche klicken",
+    pitch: "Ein Netzwerk-Lab aus Containern und VMs zeichnen. Herunterladen, fertig zum Start mit Docker, Vagrant oder Terraform.",
+    example: "Beispiel-Lab laden",
+    how: "So funktioniert's",
+  },
+  inspector: {
+    name: "Name",
+    runsAs: "Läuft als",
+    automaticRouter: "Automatischer Router",
+    container: "Container (Docker)",
+    vm: "Virtuelle Maschine",
+    routerNote:
+      "Nichts zu konfigurieren: Die Netze, an denen er hängt (seine LANs, VLANs und Kabel), erreichen einander über den eigenen Router von Isoloom. Um das Routing selbst zu konfigurieren, ihn als Container (FRR) oder als VM betreiben.",
+    image: "Image",
+    keepRunning: "Laufen lassen",
+    applianceNote: "Cisco IOL läuft aus deinem eigenen Image: baue es mit",
+    ciscoOs: "Cisco-OS",
+    needsKvm: "Läuft in QEMU: der Docker-Host braucht /dev/kvm.",
+    dynamipsFirmware: (name: string) => `Dein 7200-IOS-Image in den Download legen: images/${name}.bin.`,
+    iosConfig: "IOS-Konfiguration",
+    iosConfigHint: "Ergänzt die Konfiguration, die Isothrum schreibt (Name, admin/admin über SSH, die Adresse jeder Schnittstelle). Gilt beim ersten Start.",
+    keepRunningHint: "Für ein Image ohne eigenen Dienst (Alpine, Ubuntu, Kali…): eine Maschine zum Arbeiten.",
+    os: "Betriebssystem",
+    provision: "Provisionierungsschritte (einer pro Zeile)",
+    ports: "Dienst-Ports",
+    access: "Der Benutzer landet auf dieser Maschine",
+    cables: "Kabel",
+    noCables: "Noch keine: von einem ihrer Punkte zu einer anderen Maschine ziehen.",
+    saveTitle: "Die Einrichtung dieser Maschine als Gerät in der Werkzeugleiste behalten, um sie erneut zu platzieren",
+    save: "Als Gerät speichern",
+    remove: "Maschine entfernen",
+  },
+  canvas: {
+    imageShort: "Image",
+    hosts: (n) => (n === 1 ? "1 Host" : `${String(n)} Hosts`),
+    roles: { router: "Router", firewall: "Firewall", workstation: "Arbeitsplatz", server: "Server", desktop: "Desktop", host: "Host" },
+    switchModel: (ports) => `Switch · ${String(ports)} Ports`,
+    live: {
+      up: "Läuft",
+      starting: "Startet",
+      unhealthy: "Fehlerhaft",
+      down: "Gestoppt",
+      portUp: "Verbindung aktiv",
+      portDown: "Verbindung unterbrochen",
+      portUnknown: "Unbekannt (gestoppt, oder der Port gehört zum Betriebssystem des Geräts)",
+      lanPorts: (up, total) => `${String(up)} von ${String(total)} Ports in diesem LAN aktiv`,
+      cable: { up: "Überträgt Verkehr", cut: "Getrennt: nichts kommt durch", down: "Unterbrochen: ein Ende ist gestoppt oder sein Port unterbrochen" },
+      cableShort: { cut: "getrennt", down: "unterbrochen" },
+    },
+    editTitle: (what) => `${what}: zum Bearbeiten doppelklicken`,
+    unnamed: "unbenannt",
+    machineName: "Maschinenname",
+    vm: "VM",
+    automatic: "Automatisch",
+    container: "Container",
+    access: "Zugang",
+    addressTitle: (network, fixed) => `${network}: doppelklicken, um diese Adresse festzulegen${fixed ? " (festgelegt)" : ""}`,
+    fixed: "festgelegt",
+    addressOn: (network) => `Adresse in ${network}`,
+    lanName: "LAN-Name",
+    addressBlock: "Adressbereich",
+    internetOnTitle: "Erreicht das Internet (klicken, um es zu sperren)",
+    internetOffTitle: "Kein Internet (klicken, um es zu erlauben)",
+    internetOn: "Internetzugang: an",
+    internetOff: "Internetzugang: aus",
+    showAreaTitle: "Bereich des LANs anzeigen",
+    hideAreaTitle: "Bereich des LANs ausblenden (das LAN bleibt: nur sein Rechteck verschwindet)",
+    showArea: "Bereich anzeigen",
+    hideArea: "Bereich ausblenden",
+    switchName: "Switch-Name",
+    port: (n) => `Port ${String(n)}`,
+    trunkPort: "Trunk-Port",
+    trunkCarries: (vlans) => `Trunk, trägt ${vlans}`,
+    noVlan: "kein VLAN",
+    clickToChange: "(klicken zum Ändern)",
+    vlanNumber: "VLAN-Nummer",
+    vlanBlock: "Adressbereich des VLANs",
+    remove: (what) => `${what} entfernen`,
+    routerName: "Router-Name",
+    portFree: (port) => `${port}: frei`,
+    textOnly: "Nur Text",
+    box: "Kasten",
+    ellipse: "Ellipse",
+    colors: { yellow: "gelb", red: "rot", blue: "blau", green: "grün", violet: "violett" },
+    color: (color) => `Farbe ${color}`,
+    write: "Zum Schreiben doppelklicken",
+    note: "Notiz",
+    noteName: "Notiz",
+  },
+  exportPanel: {
+    copy: "Kopieren",
+    copied: "Kopiert",
+    labName: "Lab-Name (der Name des Zips)",
+    fixFirst: "Vor dem Export das Lab korrigieren",
+    download: (lab) => `${lab}.zip herunterladen`,
+    onlySpec: "Nur isoloom.yml",
+    where: "Wo es läuft",
+    whereIntro: "Das Zip enthält einen Ordner pro Ziel. Entpacken und das passende starten.",
+    mixed:
+      "Dieses Lab mischt Container und VMs und läuft daher mit Vagrant. Nur Container (Docker, Kubernetes, eine Cloud-VM) oder nur VMs (Proxmox, Cloud-VMs) schalten weitere Ziele frei.",
+    install: "Isoloom startet jedes davon mit einem Befehl. Einmal installieren:",
+    files: (count) => `${String(count)} ${count === 1 ? "Datei" : "Dateien"}`,
+    downloadOnly: (target) => `Nur ${target} herunterladen (mit isoloom.yml)`,
+    downloadTarget: (target) => `${target} herunterladen`,
+    withIsoloom: "Mit Isoloom (stoppen mit isoloom down)",
+    withTool: "Oder direkt mit dem Werkzeug",
+    run: "Ausführen",
+    specIntro: "Das Lab als eine lesbare Datei, zum Ablegen in Git oder zum Bearbeiten von Hand.",
+    showSpec: "Datei anzeigen",
+    hideSpec: "Datei ausblenden",
+    containersAndVms: "Container und VMs",
+    dockerOnOneVm: "Docker auf einer VM",
+    oneVmPerMachine: "eine VM pro Maschine",
+  },
+  issues: {
+    vlanBlocks: (vlan, block, other, sw) => `${vlan} ist ${block} auf einem Switch und ${other} auf ${sw}.`,
+    areaBlock: (lan, block, switches) => `Der Bereich ${lan} ist ${block}, seine Switches sagen ${switches}.`,
+    noName: { machine: "Eine Maschine hat keinen Namen.", lan: "Ein LAN hat keinen Namen.", switch: "Ein Switch hat keinen Namen." },
+    sameName: {
+      machine: (name) => `Zwei Maschinen heißen „${name}“.`,
+      lan: (name) => `Zwei LANs heißen „${name}“.`,
+      switch: (name) => `Zwei Switches heißen „${name}“.`,
+    },
+    badPort: (machine, entry) => `„${entry}“ in den Ports von ${machine} ist kein Port: eine Zahl von 1 bis 65535, dann /udp, /http, /https oder /tls, wenn es nicht einfaches TCP ist.`,
+  },
+  gns3: {
+    notGns3: "Das ist kein GNS3-Projekt: die .gns3-Datei öffnen (in einem .gns3project ist es die oberste).",
+    noTopology: "Diese Datei enthält keine GNS3-Topologie.",
+    cisco: (node, kind) =>
+      `${node}: Ein Cisco-${kind}-Router wurde zu einem automatischen Router; seine IOS-Konfiguration wird nicht übernommen.`,
+    firewall: (node) => `${node}: Eine Firewall wurde zu einem automatischen Router (ihre Regeln werden nicht übernommen).`,
+    noEquivalent: (node, type) => `${node}: Der GNS3-Knoten „${type}“ hat keine Entsprechung; übersprungen.`,
+    noNodes: "Das Projekt hat keine Knoten.",
+  },
+  account: {
+    signIn: "Mit Cyber Auth anmelden",
+    signOut: "Abmelden",
+    signedInAs: (name: string) => `Angemeldet als ${name}`,
+  },
+  projects: {
+    save: "In meinen Projekten speichern",
+    saveAs: "Als neues Projekt speichern…",
+    openList: "Projekt öffnen…",
+    saveAsPrompt: "Name des neuen Projekts:",
+    windowTitle: "Meine Projekte",
+    loading: "Projekte werden geladen…",
+    none: "Noch kein Projekt: dieses Lab speichern, um eines anzulegen.",
+    open: "geöffnet",
+    openButton: "Öffnen",
+    delete: (name: string) => `${name} löschen`,
+    confirmDelete: (name: string) => `Das Projekt „${name}“ und seinen Verlauf löschen?`,
+    failed: (error: string) => `Projekte konnten nicht geladen werden: ${error}`,
+    history: (name: string) => `Frühere Versionen von ${name}`,
+    noVersions: "Noch keine frühere Version.",
+    restore: "Öffnen",
+    historyHint: "Eine Version zu öffnen legt sie auf die Arbeitsfläche: Rückgängig holt die aktuelle zurück, das nächste Speichern behält sie.",
+    opened: (name: string) => `„${name}“ geöffnet. Rückgängig holt das vorherige Lab zurück.`,
+    status: {
+      idle: (name: string) => `Projekt „${name}“`,
+      saving: (name: string) => `„${name}“ wird gespeichert…`,
+      saved: (name: string) => `In „${name}“ gespeichert`,
+      error: (name: string) => `„${name}“ konnte nicht gespeichert werden`,
+    },
+  },
+  machineRun: {
+    display: "Bildschirm (VNC)",
+    displayTitle: "Der Bildschirm der Maschine: ihr VNC-Server oder die Anzeige der VM",
+    displayOpened: (what) => `Geöffnet: ${what}`,
+    consoleHint: "Doppelklick auf eine Maschine öffnet ihre Konsole; Rechtsklick für Bildschirm und mehr.",
+    runFirst: "Das Lab starten, um seine Konsolen zu öffnen.",
+    running: "Läuft im Lab.",
+    stopped: "Gestoppt (der Rest des Labs läuft).",
+    unknown: "Nicht im laufenden Lab: das Lab neu starten, um sie hinzuzufügen.",
+    console: "Konsole",
+    restart: "Neu starten",
+    stop: "Stoppen",
+    start: "Starten",
+    snapshots: "Snapshots",
+    takeSnapshot: "Erstellen",
+    snapshotHint: "Die Maschine so speichern, wie sie ist (ihre Dateien, die gespeicherte Konfiguration eines Routers); nicht ihre Volumes",
+    snapshotPrompt: "Name des Snapshots (optional):",
+    noSnapshots: "Noch keine.",
+    restore: "Wiederherstellen",
+    inUse: "aktiv",
+    ownImage: "Zurück zum eigenen Image",
+    deleteSnapshot: (label: string) => `Snapshot ${label} löschen`,
+  },
+  update: {
+    available: (version: string) => `Isothrum ${version} ist verfügbar.`,
+    restart: "Neu starten zum Aktualisieren",
+    installing: "Wird aktualisiert…",
+    later: "Später",
+  },
+};