Correcting some Typos in lang/de

content/lang/de/about/browser-support.md

@@ -5,7 +5,7 @@ permalink: '/about/browser-support'
 
 # Browserunterstützung
 
-Prect untersützt moderne Browser (Chrome, Firefox, Safari, Edge) und IE9+. Es sollte in IE7 sowie IE8 funktionieren, setzt allerdings einige Polyfiller voraus. Wenn es beabsichtigt ist, Preact zu benutzen und diese älteren Browser zu untersützen, wird empfohlen, einen Polyfiller wie zum Beispiel [es5-shim] oder [babel-polyfill] zu verwenden.
+Preact untersützt moderne Browser (Chrome, Firefox, Safari, Edge) und IE9+. Es sollte in IE7 sowie IE8 funktionieren, setzt allerdings einige Polyfiller voraus. Wenn es beabsichtigt ist, Preact zu benutzen und diese älteren Browser zu unterstützen, wird empfohlen, einen Polyfiller wie zum Beispiel [es5-shim] oder [babel-polyfill] zu verwenden.
 
 <center>
     <a href="https://saucelabs.com/u/preact">

content/lang/de/about/demos-examples.md

@@ -76,10 +76,10 @@ Preact + Redux-Beispielprojekt, das eine einfache To-Do-Liste implementiert.
 [GitHub-Projekt](https://github.com/developit/preact-redux-example)
 
 **[Preact Without Babel](https://github.com/developit/preact-without-babel)** :horse:  
-Wie man Preact gänzlich ohne Babes, ES2015 oder JSX benutzt.
+Wie man Preact gänzlich ohne Babel, ES2015 oder JSX benutzt.
 
 **[preact-minimal](https://github.com/aganglada/preact-minimal)** :rocket:  
-Kleine Preact-Struktur mit allen nötigen Werkzeugen um direkt mit seinem Projekt zu Starten.
+Kleine Preact-Struktur mit allen nötigen Werkzeugen um direkt mit seinem Projekt zu starten.
 
 
 ## Codepens
@@ -90,7 +90,7 @@ Kleine Preact-Struktur mit allen nötigen Werkzeugen um direkt mit seinem Projek
 - [Simple Uhr](http://jsfiddle.net/developit/u9m5x0L7/embedded/result,js/) _(@ JSFiddle)_
 - [3D + ThreeJS](http://codepen.io/developit/pen/PPMNjd?editors=0010) _(@ CodePen)_
 
-## Vorlage
+## Vorlagen
 
 :zap: [**JSFiddle Template**](https://jsfiddle.net/developit/rs6zrh5f/embedded/result/)
 

content/lang/de/about/libraries-addons.md

@@ -25,7 +25,7 @@ Eine Auswahl an Modulen, die nahtlos mit Preact funktionieren.
 - :bookmark_tabs: [**preact-markup**](https://git.io/preact-markup): HTML & eigene Elemente als JSX & Komponenten rendern
 - :satellite: [**preact-portal**](https://git.io/preact-portal): Rendern von Preact-Komponenten im (Welt-)Raum :milky_way:
 - :pencil: [**preact-richtextarea**](https://git.io/preact-richtextarea): Simple HTML-Editor-Komponente
-- :bookmark: [**preact-token-input**](https://github.com/developit/preact-token-input): Textfeld, dass Eingabe für Zwecke wie z.B. Tags in Tokens übersetzt
+- :bookmark: [**preact-token-input**](https://github.com/developit/preact-token-input): Textfeld, das Eingabe für Zwecke wie z.B. Tags in Tokens übersetzt
 - :card_index: [**preact-virtual-list**](https://github.com/developit/preact-virtual-list): Listen mit Millionen Reihen einfach rendern([demo](https://jsfiddle.net/developit/qqan9pdo/))
 - :triangular_ruler: [**preact-layout**](https://download.github.io/preact-layout/): Kleine und simple Layout-Bibliothek
 - :construction_worker: [**preact-helmet**](https://github.com/download/preact-helmet): Ein Dokumentenkopf-Manager für Preact
@@ -35,7 +35,7 @@ Eine Auswahl an Modulen, die nahtlos mit Preact funktionieren.
 
 - :thought_balloon: [**preact-socrates**](https://github.com/matthewmueller/preact-socrates): Preact-Plugin für [Socrates](http://github.com/matthewmueller/socrates)
 - :rowboat: [**preact-flyd**](https://github.com/xialvjun/preact-flyd): [flyd](https://github.com/paldepind/flyd) FRP-Streams in Preact + JSX benutzen
-- :speech_balloon: [**preact-i18nline**](https://github.com/download/preact-i18nline): Das  [i18n-js](https://github.com/everydayhero/i18n-js)-Ökosystem mit Preact mithilfe von  [i18nline](https://github.com/download/i18nline) integrieren.
+- :speech_balloon: [**preact-i18nline**](https://github.com/download/preact-i18nline): Das  [i18n-js](https://github.com/everydayhero/i18n-js)-Ökosystem mit Preact mithilfe von [i18nline](https://github.com/download/i18nline) integrieren.
 
 
 ### GUI Toolkits

content/lang/de/about/project-goals.md

@@ -12,7 +12,7 @@ Preact zielt darauf ab, Leistung aufgrund folgender Ziele zu liefern:
 - **Leistung:** Schnell und effizient rendern
 - **Größe:** Leichtigkeit und kleine Größe _(ungefähr 3.5kb)_
 - **Effizienz:** Effektive Speichernutzung _(Wiederverwendung, GC-Müll verhindern)_
-- **Verständlichkeit:** Die Grundlagen des Codes zu Verstehen sollte nicht länger als ein paar Stunden dauern
+- **Verständlichkeit:** Die Grundlagen des Codes zu verstehen sollte nicht länger als ein paar Stunden dauern
 - **Kompatibilität:** Preact zielt darauf ab, _Kompatibilität im großen Rahmen_ mit der React API zu erreichen. [preact-compat] versucht, die größtmögliche Kompatibilität mit React zu erzielen.
 
 ## Nicht-Ziele

content/lang/de/guide/api-reference.md

@@ -11,7 +11,7 @@ permalink: '/guide/api-reference'
 
 ### `Component.render(props, state)`
 
-Die `render()`-Funktion ist voraussetzend für alle Komponenten. Sie kann die props und states der Komponente inspizieren und sollte ein Preact-Element oder `null` zurückgeben.
+Die `render()`-Funktion ist Voraussetzung für alle Komponenten. Sie kann die props und states der Komponente inspizieren und sollte ein Preact-Element oder `null` zurückgeben.
 
 ```jsx
 import { Component } from 'preact';
@@ -34,8 +34,8 @@ Preact ruft die nachfolgenden Lebenszyklusmethoden auf, falls sie für eine Komp
 
 | Lebenszyklusmethoden        | Wann sie aufgerufen wird                             				 |
 |-----------------------------|--------------------------------------------------------------|
-| `componentWillMount`        | bevor die Komponente an das DOM eingehanden wird					   |
-| `componentDidMount`         | nachdem die Komponente an das DOM eingehanden wird 					 |
+| `componentWillMount`        | bevor die Komponente in DOM eingebunden wird					   |
+| `componentDidMount`         | nachdem die Komponente in DOM eingebunden wurde 					 |
 | `componentWillUnmount`      | vor dem Entfernen vom  DOM	                      					 |
 | `componentWillReceiveProps` | bevor neue props angenommen werden                 					 |
 | `shouldComponentUpdate`     | vor `render()`. `false` ausgeben, um Rendern zu überspringen |

content/lang/de/guide/differences-to-react.md

@@ -12,7 +12,7 @@ Preact ist nicht darauf ausgelegt, jede einzelne Funktion von React zu übernehm
 
 ## Versionenkompatibilität
 
-Für Preact und [preact-compat] gilt: Versionenkompatibilit wird gegen die _aktuellen_ und _vorherigen_ Hauptveröffentlichungen von React gemessen. Wenn neue Funktionen vom React-Team angekündigt werden, werden sie, sollten sie mit den [Projektziele]n im Hinterkopf nutzvoll sein, zu Preacts Kern hinzugefügt. Dies ist ein recht demokratischer Prozess, der von sich konstant entwickelnden Diskussionen und Entscheidungen der Masse gezeichnet ist. Er lebt von Issues und Pull Requests.
+Für Preact und [preact-compat] gilt: Versionenkompatibilität wird mit den _aktuellen_ und _vorherigen_ Hauptveröffentlichungen von React verglichen. Wenn neue Funktionen vom React-Team angekündigt werden sie, sollten sie mit den [Projektziele]n im Hinterkopf nützlich sein, zu Preacts Kern hinzugefügt. Dies ist ein recht demokratischer Prozess, der von sich konstant entwickelnden Diskussionen und Entscheidungen der Masse gezeichnet ist. Er lebt von Issues und Pull Requests.
 
 > Daher ist von React `0.14.x` und `15.x` gemeint, wenn auf der Website oder in der Dokumentation von Kompatibilität oder Vergleichen die Rede ist.
 
@@ -28,11 +28,11 @@ Für Preact und [preact-compat] gilt: Versionenkompatibilit wird gegen die _aktu
 - [Contexts]: Support for `context` was added in Preact [3.0].
     - _Kontext ist eine experimentelle React-Funktion, wurde aber von anderen Bibliotheken adoptiert._
 - [Refs]: Support for function refs was added in Preact in [4.0]. String refs are supported in `preact-compat`.
-    - _Refs bieten einen weg, gerenderte Elemente und Child-Komponenten zu rendern._
+    - _Refs bieten einen Weg, gerenderte Elemente und Child-Komponenten zu rendern._
 - Virtual DOM Diffing
     - _Quasi unabdingbar - Preacts Differenzierung ist simpel, aber effektiv und **[extrem](http://developit.github.io/js-repaint-perfs/) [schnell](https://localvoid.github.io/uibench/)**._
 - `h()`, eine mehr generalisierte Version von `React.createElement`
-- _Diese Idee hieß ursprünglich [hyperscript] und war weit über das React-Ökosystem hinaus wertvoll, daher bewirbt Preact den originalen Standart. ([Lies: warum `h()`?](http://jasonformat.com/wtf-is-jsx))_
+- _Diese Idee hieß ursprünglich [hyperscript] und war weit über das React-Ökosystem hinaus wertvoll, daher bewirbt Preact den originalen Standard. ([Lies: warum `h()`?](http://jasonformat.com/wtf-is-jsx))_
 - _Außerdem ist lesbarer: `h('a', { href:'/' }, h('span', null, 'Home'))`_
 
 
@@ -50,10 +50,10 @@ Preact fügt durchaus vereinzelt nützliche Funktionen hinzu, die von dem Schaff
 ## Was fehlt?
 
 - [PropType] Validierung: Nicht jeder benutzt PropTypes, daher gehören sie nicht Preacts Kern an.
-    - _**PropTypes sind vollständig durch** [preact-compat] **unterstützt**, können aber auchmaniell verwendet werden._
+    - _**PropTypes sind vollständig durch** [preact-compat] **unterstützt**, können aber auch manuell verwendet werden._
 - [Children]: Nicht notwendig in Preact, da `props.children` _immer ein Array_ ist.
     - _`React.Children` ist vollständig in [preact-compat] unterstützt._
-- Synthetisch Ereignisse: Preacts Ziel in der Browserunterstützung setzt diesen zusätzlichen Mehraufwand nicht vorraus.
+- Synthetische Ereignisse: Preacts Ziel in der Browserunterstützung setzt diesen zusätzlichen Mehraufwand nicht vorraus.
     - _Preact nutzt das native `addEventListener` des Browsers für Ereignishandhabung. Unter [GlobalEventHandlers] ist eine vollständige Liste an DOM Ereignishandhabungen zu finden._
     - _Eine vollständige Ereignisimplementierung würde mehr Wartung, Leistungseinbußen und eine größere API bedeuten._
 
@@ -63,7 +63,7 @@ Preact fügt durchaus vereinzelt nützliche Funktionen hinzu, die von dem Schaff
 Preact und React haben einige feinere Unteschiede:
 
 
-- `render()` akzeptiert ein drittes Argument, welches der Grundknoten zu _replace_ ist, andernfalls fügt es es hinzu. Dies könnte sich in einer zukünftigen Version ein wenig ändern, vermutlich durch automatische Erkennung der Angemessenheit eines Ersatzrenders mithilfe einer Inspizierung des Grundknoten.
+- `render()` akzeptiert ein drittes Argument, welches der Grundknoten zu _replace_ ist, andernfalls fügt es es hinzu. Dies könnte sich in einer zukünftigen Version ein wenig ändern, vermutlich durch automatische Erkennung der Angemessenheit eines Ersatzrenders mithilfe einer Inspizierung des Grundknotens.
 - Komponenten implementieren `contextTypes` oder `childContextTypes` nicht. Children empfangen alle `context`-Einträge von `getChildContext()`.
 
 [Projektziele]: /about/project-goals

content/lang/de/guide/extending-component.md

@@ -9,7 +9,7 @@ Es besteht die Möglichkeit, dass manche Projekte eine Komponente mit zusätzlic
 
 Der Stellenwert von Vererbung in JavaScript ist umstritten, wenn man allerdings eine eigene "Basisklasse" erstellen will, von der alle anderen Komponenten erben, ist Preact genau richtig.
 
-Möglicherweise ist das Erstellen von automatischen Verbindungen zu Stores/Reducers in einer Flux-ähnlichen Architektur gewünsht. Vielleicht mag man es auch, Eigentums-basierte Mixins hinzuzufügen, damit es sich mehr wie `React.createClass` anfühlt _(Anmerkung: der [@`bind` decorator](https://github.com/developit/decko#bind) ist bevorzugt)_.
+Möglicherweise ist das Erstellen von automatischen Verbindungen zu Stores/Reducers in einer Flux-ähnlichen Architektur gewünscht. Vielleicht mag man es auch, Eigentums-basierte Mixins hinzuzufügen, damit es sich mehr wie `React.createClass` anfühlt _(Anmerkung: der [@`bind` decorator](https://github.com/developit/decko#bind) ist bevorzugt)_.
 
 In jedem Fall ist die Klassenvererbbarkeit aus ES2015 anwendbar, um Preacts `Component`-Klasse zu erweitern:
 
@@ -64,4 +64,4 @@ class MixedComponent extends Component {
 
 ---
 
-> **Fußnote:** Man sollte anmerken, dass Vererbung einen in zerbrechliche parent-child-Beziehungen sperren können. Wenn man auf eine Programmieraufgabe, die adequat mit Vererbung gelöst werden kann, gibt es oftmals einen funktionaleren Weg um das gleiche Ziel zu erreichen, das das Erstellen einer solchen Beziehung unnötig macht.
+> **Fußnote:** Man sollte anmerken, dass Vererbung einen in zerbrechliche parent-child-Beziehungen sperren können. Wenn man auf eine Programmieraufgabe, die adäquat mit Vererbung gelöst werden kann, gibt es oftmals einen funktionaleren Weg um das gleiche Ziel zu erreichen, das das Erstellen einer solchen Beziehung unnötig macht.

content/lang/de/guide/external-dom-mutations.md

@@ -8,7 +8,7 @@ permalink: '/guide/external-dom-mutations'
 
 ## Übersicht
 
-Manchmal ist es nötig, mit Drittanbieterbibliotheken zu arbeiten, die erwarten, frei im DOM mutieren zu können, in einem Stadium zu verharren oder überhaupt gar keine Komponentengrenzen zu haben. Es gibt viele großartige UI-Toolkits oder wiederverwendbare Elemente, die so funktionieren. In Preact, ähnlich wie in React, setzt das Arbeiten mit diesen Bibliotheken voraus, dass man dem Rendering oder der Differenzierungsalgorithmus des Virtual DOM befield, keine externen DOM-Mutationen, die innerhalb einer gegebenen Komponente (oder dem DOM-Element, dass es repräsentiert), _zückgängig_ zu machen.
+Manchmal ist es nötig, mit Drittanbieterbibliotheken zu arbeiten, die erwarten, frei im DOM mutieren zu können, in einem Stadium zu verharren oder überhaupt gar keine Komponentengrenzen zu haben. Es gibt viele großartige UI-Toolkits oder wiederverwendbare Elemente, die so funktionieren. In Preact, ähnlich wie in React, setzt das Arbeiten mit diesen Bibliotheken voraus, dass man dem Rendering oder dem Differenzierungsalgorithmus des Virtual DOM befiehlt, keine externen DOM-Mutationen, die innerhalb einer gegebenen Komponente (oder dem DOM-Element, dass es repräsentiert), _zückgänglich_ zu machen.
 
 
 ## Technik
@@ -36,7 +36,7 @@ Mit diesem Lebenszyklus an Ort und Stelle und der Anweisung an Preact, die Kompo
 
 ## Beispielsdurchlauf
 
-Hier wird beispielhaft gezeigt, wie das Rerendern einer Komponente "ausgeschaltet" wird. Es muss beachtet wirden, dass `render()` immer noch im Zuge von Erstellung und Mounten der Komponente aufgerufen ist, damit seine ursprüngliche DOM-Struktur generiert werden kann.
+Hier wird beispielhaft gezeigt, wie das Rerendern einer Komponente "ausgeschaltet" wird. Es muss beachtet werden, dass `render()` immer noch im Zuge von Erstellung und Mounten der Komponente aufgerufen ist, damit seine ursprüngliche DOM-Struktur generiert werden kann.
 
 ```js
 class Beispiel extends Component {
@@ -50,7 +50,7 @@ class Beispiel extends Component {
   }
 
   componentDidMount() {
-    // jetzt gemounted, kann das DOM frei modifizieren:
+    // jetzt gemounted, kann das DOM frei modifiziert werden:
     let thing = document.createElement('maybe-a-custom-element');
     this.base.appendChild(thing);
   }

content/lang/de/guide/forms.md

@@ -15,14 +15,14 @@ Eingabemasken funktionieren in Preact fast genauso wie in React, allerdings gibt
 
 Reacts Dokumentation zu ["Kontrollierten" Komponenten](https://facebook.github.io/react/docs/forms.html#controlled-components) und ["Unkontrollierten" Komponenten](https://facebook.github.io/react/docs/forms.html#uncontrolled-components) ist ungemein nützlich, wenn man verstehen möchte, wie man HTML-Eingabemasken mit bidirektionalem Datenfluss benutzt und sich diese im Kontext eines komponentenbasierten DOM-Renderer, welche normalerweise unidirektionale Datenflüsse haben, zu Nutze macht.
 
-Generell sollte man versuchen, immer _Kontrollierte_ Komponenten zu verwenden. Trotzdem kann es beim Erstellen von unabhängigen Komponenten oder umschließenden Drittanbieter-UI-Bibliotheken sehr nützelich sein, die Komponente einfach als Mount-Punkt für Non-Preact-Funktionalitäten zu verwenden. In diesen Fällen sind _Unkontrollierte_ Komponenten genau richtig für die Aufgabe.
+Generell sollte man versuchen, immer _Kontrollierte_ Komponenten zu verwenden. Trotzdem kann es beim Erstellen von unabhängigen Komponenten oder umschließenden Drittanbieter-UI-Bibliotheken sehr nützlich sein, die Komponente einfach als Mount-Punkt für Non-Preact-Funktionalitäten zu verwenden. In diesen Fällen sind _Unkontrollierte_ Komponenten genau richtig für die Aufgabe.
 
 
 ## Kontrollbox & Radio Buttons
 
-Kontrollboxe und Radio Buttons (`<input type="checkbox|radio">`) kann anfänglich für Verwirrung sorgen, wenn man kontrollierte Eingabemasken erstellt. Dies ist damit zu begründen, dass man in einer unkontrollieren Umgebung normalerweise dem Browser erlauben würden, eine Kontrollbox oder einen Radio Button für uns "umzuschalten" oder "anzukreuzen", auf Änderungsereignisse zu warten und auf den neuen Wert zu reagieren. Allerdings geht diese Technik nicht sonderlich gut in ein Weltbild über, in dem da UI immer wieder automatisch als Reaktion auf state- und prop-Änderungen aktualisiert wird.
+Kontrollboxen und Radio Buttons (`<input type="checkbox|radio">`) können anfänglich für Verwirrung sorgen, wenn man kontrollierte Eingabemasken erstellt. Das liegt daran, dass man in einer unkontrollieren Umgebung normalerweise dem Browser erlauben würden, eine Kontrollbox oder einen Radio Button für uns "umzuschalten" oder "anzukreuzen", auf Änderungsereignisse zu warten und auf den neuen Wert zu reagieren. Allerdings funktioniert diese Technik nicht sonderlich gut in einem Szenario, in dem das UI immer wieder automatisch als Reaktion auf state- und prop-Änderungen aktualisiert wird.
 
-> **Durchlauf:** Man geht davon aus, dass wir auf ein "Änderungs"ereignis einer Kontrollbox warten, welches ausgelöst wird, wenn die Kontrollbox ausgewählt oder aufgehoben wird. Der Änderungsereignis-Handler wird ein Wert in `state` dem neuen Wert, der von der Kontrollbox empfangen wird, zugeordnet. Dies löst das Neurendern der Komponente aus, was den Wert der Kontrollbox dem Wert von state neu zuordnen wird. Das ist allerdings unnötig, das wir gerade beim DOM einen Wert angefragt haben, ihm dann aber das Neurendern mit dem gewünschten Wert befohlen haben.
+> **Durchlauf:** Nehmen wir an, dass wir auf ein "Änderungs"ereignis einer Kontrollbox warten, welches ausgelöst wird, wenn die Kontrollbox ausgewählt oder aufgehoben wird. Der Änderungsereignis-Handler wird ein Wert in `state` dem neuen Wert, der von der Kontrollbox empfangen wird, zugeordnet. Dies löst das Neurendern der Komponente aus, was den Wert der Kontrollbox dem Wert von state neu zuordnen wird. Das ist allerdings unnötig, da wir gerade beim DOM einen Wert angefragt haben, ihm dann aber das Neurendern mit dem gewünschten Wert befohlen haben.
 
 Man sollte also anstatt auf ein `change`-Ereignis auf ein `click`-Ereignis warten, welches bei jedem Click des Nutzers auf die Kontrollbox _oder ein assoziiertes `<label>`_ ausgelöst wird. Kontrollboxen schalten lediglich zwischen Boolean `true` und `false` hin und her, daher bewirkt ein Klick auf die Kontrollbox oder das Label nichts anderes als eine Invertierung des aktuellen Stadiums, das Auslösen einer Neurenderung und das Setzen des gewünschten Wertes innerhalb der Kontrollbox.