Merge branch 'gh-pages' of github.com:fiduswriter/diffDOM into no-for-each

Author: johanneswilm

README.md

@@ -17,59 +17,59 @@ Check http://fiduswriter.github.io/diffDOM for demo and tests.
 ## Usage
 
 Include the diffDOM.js file in your HTML like this:
-```
+```html
 <script src="diffDOM.js">
 ```
 
 Or like this in node/browserify:
-```
+```js
 var diffDOM = require("diff-dom");
 ```
 
 Then create an instance of diffDOM within the javascript code:
-```
+```js
 dd = new diffDOM();
 ```
 
-Now you can create a diff to get from dom elementA to dom elementB like this:
-```
+Now you can create a diff to get from dom `elementA` to dom `elementB` like this:
+```js
 diff = dd.diff(elementA, elementB);
 ```
 
 You can now apply this diff like this:
-```
+```js
 dd.apply(elementA, diff);
 ```
-Now elementA will have been changed to be structurally equal to elementB.
+Now `elementA` will have been changed to be structurally equal to `elementB`.
 
 ### Advanced uses
 
 #### Undo
 
 Continuing on from the previous example, you can also undo a diff, like this:
-```
+```js
 dd.undo(elementA, diff);
 ```
 Now elementA will be what it was like before applying the diff.
 
 #### Remote changes
 
-If you need to move diffs from one machine to another one, you will likely want to send the diffs through a websocket connection or as part of a form submit. In both cases you need to convert the diff to a json string.
+If you need to move diffs from one machine to another one, you will likely want to send the diffs through a websocket connection or as part of a form submit. In both cases you need to convert the diff to a json `string`.
 
 To convert a diff to a json string which you can send over the network, do:
-```
+```js
 diffJson = JSON.stringify(diff);
 ```
 
 On the receiving end you then need to unpack it like this:
-```
+```js
 diff = JSON.parse(diffJson);
 ```
 
 #### Error handling when patching/applying
 
-Sometimes one may try to patch an elment without knowing whether the patch actually will apply cleanly. This should not be a problem. If diffDOM determines that a patch cannot be executed, it will simple return false. Else it will return true:
-```
+Sometimes one may try to patch an elment without knowing whether the patch actually will apply cleanly. This should not be a problem. If diffDOM determines that a patch cannot be executed, it will simple return `false`. Else it will return `true`:
+```js
 result = dd.apply(element, diff);
 
 if (result) {
@@ -80,8 +80,8 @@ if (result) {
 ```
 #### Advanced merging of text node changes
 
-diffDOM does not include merging for changes to text nodes. However, it includes hooks so that you can add more advanced handling. Simple overwrite the textDiff function of the diffDOM instance. The functions TEXTDIFF and TEXTPATCH need to be defined in the code:
-```
+diffDOM does not include merging for changes to text nodes. However, it includes hooks so that you can add more advanced handling. Simple overwrite the `textDiff` function of the `diffDOM` instance. The functions TEXTDIFF and TEXTPATCH need to be defined in the code:
+```js
 dd = new diffDOM({
     textDiff: function (node, currentValue, expectedValue, newValue) {
         if (currentValue===expectedValue) {
@@ -101,7 +101,7 @@ dd = new diffDOM({
 
 diffDOM provides extension points before and after virtual and actual diffs, exposing some of the internals of the diff algorithm, and allowing you to make additional decisions based on that information.
 
-```
+```js
 dd = new diffDOM({
     preVirtualDiffApply: function (info) {
         console.log(info);
@@ -118,9 +118,9 @@ dd = new diffDOM({
   });
 ```
 
-Additionally, the _pre_ hooks allow you to shortcircuit the standard behaviour of the diff by returning 'true' from this callback. This will cause the diffApply functions to return prematurely, skipping their standard behaviour.
+Additionally, the _pre_ hooks allow you to shortcircuit the standard behaviour of the diff by returning `true` from this callback. This will cause the `diffApply` functions to return prematurely, skipping their standard behaviour.
 
-```
+```js
 dd = new diffDOM({
     // prevent removal of attributes
     preDiffApply: function (info) {
@@ -136,7 +136,7 @@ dd = new diffDOM({
 
 diffDOM also provides a way to filter outer diff
 
-```
+```js
 dd = new diffDOM({
     filterOuterDiff: function(t1, t2, diffs) {
         // can change current outer diffs by returning a new array,
@@ -152,7 +152,7 @@ dd = new diffDOM({
 #### Debugging
 
 For debugging you might want to set a max number of diff changes between two elements before diffDOM gives up. To allow for a maximum of 500 differences between elements when diffing, initialize diffDOM like this:
-```
+```js
 dd = new diffDOM({
     debug: true,
     diffcap: 500
@@ -163,7 +163,7 @@ dd = new diffDOM({
 
 For forms that have been filled out by a user in ways that have changed which value is associated with an input field or which options are checked/selected without
 the DOM having been updated, the values are diffed. For use cases in which no changes have been made to any of the form values, one may choose to skip diffing the values. To do this, hand `false` as a third configuration option to diffDOM:
-```
+```js
 dd = new diffDOM({
     valueDiffing: false
   });

diffDOM.js

@@ -1,4 +1,18 @@
-(function() {
+(function(root, factory) {
+    if (typeof exports !== 'undefined') {
+        if (typeof module !== 'undefined' && module.exports) {
+            exports = module.exports = factory();
+        } else {
+            exports.diffDOM = factory();
+        }
+    } else if (typeof define === 'function') {
+        // AMD loader
+        define(factory);
+    } else {
+        // `window` in the browser, or `exports` on the server
+        root.diffDOM = factory();
+    }
+})(this, function() {
     "use strict";
 
     var diffcount;
@@ -1416,14 +1430,5 @@
         }
     };
 
-    if (typeof exports !== 'undefined') {
-        if (typeof module !== 'undefined' && module.exports) {
-            exports = module.exports = diffDOM;
-        }
-        exports.diffDOM = diffDOM;
-    } else {
-        // `window` in the browser, or `exports` on the server
-        this.diffDOM = diffDOM;
-    }
-
-}.call(this));
+    return diffDOM;
+});