RubyGems - sn-collab-editor - Versions diffs - 0.1.6 → 0.1.7 - Mend

sn-collab-editor 0.1.6 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

checksums.yaml +4 -4
data/app/assets/javascripts/collab/cable.js +121 -11
data/app/assets/javascripts/collab/documents.js +142 -52
data/app/assets/stylesheets/collab/{application.css → application.css.scss} +31 -4
data/app/channels/edit_channel.rb +16 -10
data/app/controllers/collab/documents_controller.rb +2 -2
data/app/models/collab/document.rb +1 -0
data/app/models/collab/patch.rb +5 -0
data/app/views/collab/documents/show.html.erb +11 -4
data/app/views/layouts/collab/application.html.erb +5 -0
data/db/migrate/20170222133537_create_collab_documents.rb +8 -3
data/lib/collab/engine.rb +1 -2
data/lib/collab/version.rb +1 -1
data/vendor/assets/javascripts/TextPatcher.js +154 -0
data/vendor/assets/javascripts/chainpad.js +1588 -0
data/vendor/assets/javascripts/codemirror.js +9231 -0
data/vendor/assets/javascripts/markdown.js +816 -0
data/vendor/assets/stylesheets/codemirror.css +341 -0
metadata +9 -3

data/app/channels/edit_channel.rb CHANGED Viewed

@@ -12,21 +12,27 @@ class EditChannel < ApplicationCable::Channel
   def retrieve(data)
     doc = Collab::Document.find_by_uuid(data['doc_id'])
     ActionCable.server.broadcast("doc_#{doc.uuid}_#{params['client_id']}", {
-      :message => doc.content,
-      :iv => doc.iv,
-      :auth => doc.auth,
+      :patches => doc.patches,
       :client_id => data['client_id'],
-      :retrieve => true
-      })
+      :initial_retrieve => true
+    })
   end
   def post(data)
-    message = data['message']
     doc = Collab::Document.find_by_uuid(data['doc_id'])
-    doc.content = message
-    doc.iv = data["iv"]
-    doc.auth = data["auth"]
+    edit_token = data["edit_token"]
+    if edit_token != doc.edit_token
+      puts "Edit token not authorized, returning"
+      return
+    end
+    patch = doc.patches.create({
+      :content => data['content'],
+      :iv => data["iv"],
+      :auth => data["auth"]
+    })
     doc.save
-    EditChannel.broadcast_to(doc, {:message => message, :iv => data["iv"], :auth => data["auth"], :client_id => data['client_id']})
+    EditChannel.broadcast_to(doc, {:patch => patch, :client_id => data['client_id']})
   end
 end

data/app/controllers/collab/documents_controller.rb CHANGED Viewed

@@ -24,11 +24,11 @@ module Collab
     end
     def new
-      puts "\n\nCreating new document\n\n"
       @doc = Document.new
       @doc.uuid = SecureRandom.uuid
+      @doc.edit_token = Digest::SHA256.hexdigest(SecureRandom.random_bytes())[0,24]
       @doc.save
-      redirect_to(url)
+      redirect_to(url + "?et=#{@doc.edit_token}")
     end
   end

data/app/models/collab/document.rb CHANGED Viewed

@@ -1,4 +1,5 @@
 module Collab
   class Document < ApplicationRecord
+    has_many :patches
   end
 end

data/app/models/collab/patch.rb ADDED Viewed

@@ -0,0 +1,5 @@
+module Collab
+  class Patch < ApplicationRecord
+  end
+end

data/app/views/collab/documents/show.html.erb CHANGED Viewed

@@ -2,11 +2,18 @@
 <div id="wrapper">
   <% if @doc %>
-    <div id="url">
-      <strong>Sharing URL</strong>:
-      <span><%= @url %></span><span id="url-key"></span>
+    <div id="viewing-url-wrapper" class="url-wrapper">
+      <span class="label">Viewing URL</span>:
+      <a id="viewing-url" class="url" target="_blank"></a>
+    </div>
+    <div id="editing-url-wrapper" class="url-wrapper">
+      <span class="label">Editing URL</span>:
+      <a id="editing-url" class="url" target="_blank"></a>
     </div>
-    <textarea id="editor"></textarea>
+    <textarea id="editor" name="editor"></textarea>
   <% else %>
   <% end %>

data/app/views/layouts/collab/application.html.erb CHANGED Viewed

@@ -3,9 +3,14 @@
 <head>
   <title>Standard Notes Collaborative Editor</title>
   <%= stylesheet_link_tag    "collab/application", media: "all" %>
+  <%= stylesheet_link_tag "codemirror" %>
   <%= javascript_include_tag "collab/application" %>
   <%= javascript_include_tag "aes" %>
   <%= javascript_include_tag "hmac-sha256" %>
+  <%= javascript_include_tag "chainpad" %>
+  <%= javascript_include_tag "codemirror" %>
+  <%= javascript_include_tag "TextPatcher" %>
+  <%= javascript_include_tag "markdown" %>
   <%= csrf_meta_tags %>
 </head>
 <body>

data/db/migrate/20170222133537_create_collab_documents.rb CHANGED Viewed

@@ -1,11 +1,16 @@
 class CreateCollabDocuments < ActiveRecord::Migration[5.0]
   def change
     create_table :collab_documents do |t|
-      t.text :content
-      t.string :iv
-      t.string :auth
       t.string :uuid
+      t.string :edit_token
       t.timestamps
     end
+    create_table :collab_patches do |t|
+      t.text :content, :limit => 16.megabytes - 1
+      t.string :iv
+      t.string :auth
+      t.integer :document_id
+    end
   end
 end

data/lib/collab/engine.rb CHANGED Viewed

@@ -2,7 +2,6 @@ module Collab
   class Engine < ::Rails::Engine
     isolate_namespace Collab
-    # config.assets.paths << File.expand_path("../../../vendor/assets/javascripts", __FILE__)
-    config.assets.precompile += %w( aes.js hmac-sha256.js )
+    config.assets.precompile += %w( aes.js hmac-sha256.js chainpad.js codemirror.js codemirror.css TextPatcher markdown )
   end
 end

data/lib/collab/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Collab
-  VERSION = '0.1.6'
+  VERSION = '0.1.7'
 end

data/vendor/assets/javascripts/TextPatcher.js ADDED Viewed

@@ -0,0 +1,154 @@
+(function () {
+    var TextPatcher = {};
+/*  diff takes two strings, the old content, and the desired content
+    it returns the difference between these two strings in the form
+    of an 'Operation' (as defined in chainpad.js).
+    diff is purely functional.
+*/
+var diff = TextPatcher.diff = function (oldval, newval) {
+    // Strings are immutable and have reference equality. I think this test is O(1), so its worth doing.
+    if (oldval === newval) {
+        return;
+    }
+    var commonStart = 0;
+    while (oldval.charAt(commonStart) === newval.charAt(commonStart)) {
+        commonStart++;
+    }
+    var commonEnd = 0;
+    while (oldval.charAt(oldval.length - 1 - commonEnd) === newval.charAt(newval.length - 1 - commonEnd) &&
+        commonEnd + commonStart < oldval.length && commonEnd + commonStart < newval.length) {
+        commonEnd++;
+    }
+    var toRemove = 0;
+    var toInsert = '';
+    /*  throw some assertions in here before dropping patches into the realtime */
+    if (oldval.length !== commonStart + commonEnd) {
+        toRemove = oldval.length - commonStart - commonEnd;
+    }
+    if (newval.length !== commonStart + commonEnd) {
+        toInsert = newval.slice(commonStart, newval.length - commonEnd);
+    }
+    return {
+        type: 'Operation',
+        offset: commonStart,
+        toInsert: toInsert,
+        toRemove: toRemove
+    };
+};
+/*  patch accepts a realtime facade and an operation (which might be falsey)
+    it applies the operation to the realtime as components (remove/insert)
+    patch has no return value, and operates solely through side effects on
+    the realtime facade.
+*/
+var patch = TextPatcher.patch = function (ctx, op) {
+    if (!op) { return; }
+    if (ctx.patch) {
+        ctx.patch(op.offset, op.toRemove, op.toInsert);
+    } else {
+        console.log("chainpad.remove and chainpad.insert are deprecated. "+
+            "update your chainpad installation to the latest version.");
+        if (op.toRemove) { ctx.remove(op.offset, op.toRemove); }
+        if (op.toInsert) { ctx.insert(op.offset, op.toInsert); }
+    }
+};
+/*  format has the same signature as log, but doesn't log to the console
+    use it to get the pretty version of a diff */
+var format = TextPatcher.format = function (text, op) {
+    return op?{
+        insert: op.toInsert,
+        remove: text.slice(op.offset, op.offset + op.toRemove)
+    }: { insert: '', remove: '' };
+};
+/*  log accepts a string and an operation, and prints an object to the console
+    the object will display the content which is to be removed, and the content
+    which will be inserted in its place.
+    log is useful for debugging, but can otherwise be disabled.
+*/
+var log = TextPatcher.log = function (text, op) {
+    if (!op) { return; }
+    console.log(format(text, op));
+};
+/* applyChange takes:
+    ctx: the context (aka the realtime)
+    oldval: the old value
+    newval: the new value
+    it performs a diff on the two values, and generates patches
+    which are then passed into `ctx.remove` and `ctx.insert`.
+    Due to its reliance on patch, applyChange has side effects on the supplied
+    realtime facade.
+*/
+var applyChange = TextPatcher.applyChange = function(ctx, oldval, newval, logging) {
+    var op = diff(oldval, newval);
+    if (logging) { log(oldval, op); }
+    patch(ctx, op);
+};
+var transformCursor = TextPatcher.transformCursor = function (cursor, op) {
+    if (!op) { return cursor; }
+    var pos = op.offset;
+    var remove = op.toRemove;
+    var insert = op.toInsert.length;
+    if (typeof cursor === 'undefined') { return; }
+    if (typeof remove === 'number' && pos < cursor) {
+        cursor -= Math.min(remove, cursor - pos);
+    }
+    if (typeof insert === 'number' && pos < cursor) {
+        cursor += insert;
+    }
+    return cursor;
+};
+var create = TextPatcher.create = function(config) {
+    var ctx = config.realtime;
+    var logging = config.logging;
+    // initial state will always fail the !== check in genop.
+    // because nothing will equal this object
+    var content = {};
+    // *** remote -> local changes
+    ctx.onPatch(function(pos, length) {
+        content = ctx.getUserDoc();
+    });
+    // propogate()
+    return function (newContent, force) {
+        if (newContent !== content || force) {
+            applyChange(ctx, ctx.getUserDoc(), newContent, logging);
+            if (ctx.getUserDoc() !== newContent) {
+                console.log("Expected that: `ctx.getUserDoc() === newContent`!");
+            }
+            else { content = ctx.getUserDoc(); }
+            return true;
+        }
+        return false;
+    };
+};
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = TextPatcher;
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define(function () {
+            return TextPatcher;
+        });
+    } else {
+        window.TextPatcher = TextPatcher;
+    }
+}());

data/vendor/assets/javascripts/chainpad.js ADDED Viewed

@@ -0,0 +1,1588 @@
+(function(){
+var r=function(){var e="function"==typeof require&&require,r=function(i,o,u){o||(o=0);var n=r.resolve(i,o),t=r.m[o][n];if(!t&&e){if(t=e(n))return t}else if(t&&t.c&&(o=t.c,n=t.m,t=r.m[o][t.m],!t))throw new Error('failed to require "'+n+'" from '+o);if(!t)throw new Error('failed to require "'+i+'" from '+u);return t.exports||(t.exports={},t.call(t.exports,t,t.exports,r.relative(n,o))),t.exports};return r.resolve=function(e,n){var i=e,t=e+".js",o=e+"/index.js";return r.m[n][t]&&t?t:r.m[n][o]&&o?o:i},r.relative=function(e,t){return function(n){if("."!=n.charAt(0))return r(n,t,e);var o=e.split("/"),f=n.split("/");o.pop();for(var i=0;i<f.length;i++){var u=f[i];".."==u?o.pop():"."!=u&&o.push(u)}return r(o.join("/"),t,e)}},r}();r.m = [];
+r.m[0] = {
+"Patch.js": function(module, exports, require){
+/*
+ * Copyright 2014 XWiki SAS
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+var Common = require('./Common');
+var Operation = require('./Operation');
+var Sha = require('./SHA256');
+var Patch = module.exports;
+var create = Patch.create = function (parentHash) {
+    return {
+        type: 'Patch',
+        operations: [],
+        parentHash: parentHash,
+        isCheckpoint: false
+    };
+};
+var check = Patch.check = function (patch, docLength_opt) {
+    Common.assert(patch.type === 'Patch');
+    Common.assert(Array.isArray(patch.operations));
+    Common.assert(/^[0-9a-f]{64}$/.test(patch.parentHash));
+    for (var i = patch.operations.length - 1; i >= 0; i--) {
+        Operation.check(patch.operations[i], docLength_opt);
+        if (i > 0) {
+            Common.assert(!Operation.shouldMerge(patch.operations[i], patch.operations[i-1]));
+        }
+        if (typeof(docLength_opt) === 'number') {
+            docLength_opt += Operation.lengthChange(patch.operations[i]);
+        }
+    }
+    if (patch.isCheckpoint) {
+        Common.assert(patch.operations.length === 1);
+        Common.assert(patch.operations[0].offset === 0);
+        if (typeof(docLength_opt) === 'number') {
+            Common.assert(!docLength_opt || patch.operations[0].toRemove === docLength_opt);
+        }
+    }
+};
+var toObj = Patch.toObj = function (patch) {
+    if (Common.PARANOIA) { check(patch); }
+    var out = new Array(patch.operations.length+1);
+    var i;
+    for (i = 0; i < patch.operations.length; i++) {
+        out[i] = Operation.toObj(patch.operations[i]);
+    }
+    out[i] = patch.parentHash;
+    return out;
+};
+var fromObj = Patch.fromObj = function (obj) {
+    Common.assert(Array.isArray(obj) && obj.length > 0);
+    var patch = create();
+    var i;
+    for (i = 0; i < obj.length-1; i++) {
+        patch.operations[i] = Operation.fromObj(obj[i]);
+    }
+    patch.parentHash = obj[i];
+    if (Common.PARANOIA) { check(patch); }
+    return patch;
+};
+var hash = function (text) {
+    return Sha.hex_sha256(text);
+};
+var addOperation = Patch.addOperation = function (patch, op) {
+    if (Common.PARANOIA) {
+        check(patch);
+        Operation.check(op);
+    }
+    for (var i = 0; i < patch.operations.length; i++) {
+        if (Operation.shouldMerge(patch.operations[i], op)) {
+            op = Operation.merge(patch.operations[i], op);
+            patch.operations.splice(i,1);
+            if (op === null) {
+                //console.log("operations cancelled eachother");
+                return;
+            }
+            i--;
+        } else {
+            var out = Operation.rebase(patch.operations[i], op);
+            if (out === op) {
+                // op could not be rebased further, insert it here to keep the list ordered.
+                patch.operations.splice(i,0,op);
+                return;
+            } else {
+                op = out;
+                // op was rebased, try rebasing it against the next operation.
+            }
+        }
+    }
+    patch.operations.push(op);
+    if (Common.PARANOIA) { check(patch); }
+};
+var createCheckpoint = Patch.createCheckpoint =
+    function (parentContent, checkpointContent, parentContentHash_opt)
+{
+    var op = Operation.create(0, parentContent.length, checkpointContent);
+    if (Common.PARANOIA && parentContentHash_opt) {
+        Common.assert(parentContentHash_opt === hash(parentContent));
+    }
+    parentContentHash_opt = parentContentHash_opt || hash(parentContent);
+    var out = create(parentContentHash_opt);
+    addOperation(out, op);
+    out.isCheckpoint = true;
+    return out;
+};
+var clone = Patch.clone = function (patch) {
+    if (Common.PARANOIA) { check(patch); }
+    var out = create();
+    out.parentHash = patch.parentHash;
+    for (var i = 0; i < patch.operations.length; i++) {
+        out.operations[i] = Operation.clone(patch.operations[i]);
+    }
+    return out;
+};
+var merge = Patch.merge = function (oldPatch, newPatch) {
+    if (Common.PARANOIA) {
+        check(oldPatch);
+        check(newPatch);
+    }
+    if (oldPatch.isCheckpoint) {
+        Common.assert(newPatch.parentHash === oldPatch.parentHash);
+        if (newPatch.isCheckpoint) {
+            return create(oldPatch.parentHash)
+        }
+        return clone(newPatch);
+    } else if (newPatch.isCheckpoint) {
+        return clone(oldPatch);
+    }
+    oldPatch = clone(oldPatch);
+    for (var i = newPatch.operations.length-1; i >= 0; i--) {
+        addOperation(oldPatch, newPatch.operations[i]);
+    }
+    return oldPatch;
+};
+var apply = Patch.apply = function (patch, doc)
+{
+    if (Common.PARANOIA) {
+        check(patch);
+        Common.assert(typeof(doc) === 'string');
+        Common.assert(Sha.hex_sha256(doc) === patch.parentHash);
+    }
+    var newDoc = doc;
+    for (var i = patch.operations.length-1; i >= 0; i--) {
+        newDoc = Operation.apply(patch.operations[i], newDoc);
+    }
+    return newDoc;
+};
+var lengthChange = Patch.lengthChange = function (patch)
+{
+    if (Common.PARANOIA) { check(patch); }
+    var out = 0;
+    for (var i = 0; i < patch.operations.length; i++) {
+        out += Operation.lengthChange(patch.operations[i]);
+    }
+    return out;
+};
+var invert = Patch.invert = function (patch, doc)
+{
+    if (Common.PARANOIA) {
+        check(patch);
+        Common.assert(typeof(doc) === 'string');
+        Common.assert(Sha.hex_sha256(doc) === patch.parentHash);
+    }
+    var rpatch = create();
+    var newDoc = doc;
+    for (var i = patch.operations.length-1; i >= 0; i--) {
+        rpatch.operations[i] = Operation.invert(patch.operations[i], newDoc);
+        newDoc = Operation.apply(patch.operations[i], newDoc);
+    }
+    for (var i = rpatch.operations.length-1; i >= 0; i--) {
+        for (var j = i - 1; j >= 0; j--) {
+            rpatch.operations[i].offset += rpatch.operations[j].toRemove;
+            rpatch.operations[i].offset -= rpatch.operations[j].toInsert.length;
+        }
+    }
+    rpatch.parentHash = Sha.hex_sha256(newDoc);
+    rpatch.isCheckpoint = patch.isCheckpoint;
+    if (Common.PARANOIA) { check(rpatch); }
+    return rpatch;
+};
+var simplify = Patch.simplify = function (patch, doc, operationSimplify)
+{
+    if (Common.PARANOIA) {
+        check(patch);
+        Common.assert(typeof(doc) === 'string');
+        Common.assert(Sha.hex_sha256(doc) === patch.parentHash);
+    }
+    operationSimplify = operationSimplify || Operation.simplify;
+    var spatch = create(patch.parentHash);
+    var newDoc = doc;
+    var outOps = [];
+    var j = 0;
+    for (var i = patch.operations.length-1; i >= 0; i--) {
+        outOps[j] = operationSimplify(patch.operations[i], newDoc, Operation.simplify);
+        if (outOps[j]) {
+            newDoc = Operation.apply(outOps[j], newDoc);
+            j++;
+        }
+    }
+    spatch.operations = outOps.reverse();
+    if (!spatch.operations[0]) {
+        spatch.operations.shift();
+    }
+    if (Common.PARANOIA) {
+        check(spatch);
+    }
+    return spatch;
+};
+var equals = Patch.equals = function (patchA, patchB) {
+    if (patchA.operations.length !== patchB.operations.length) { return false; }
+    for (var i = 0; i < patchA.operations.length; i++) {
+        if (!Operation.equals(patchA.operations[i], patchB.operations[i])) { return false; }
+    }
+    return true;
+};
+var isCheckpointOp = function (op, text) {
+    return op.offset === 0 && op.toRemove === text.length && op.toInsert === text;
+};
+var transform = Patch.transform = function (origToTransform, transformBy, doc, transformFunction) {
+    if (Common.PARANOIA) {
+        check(origToTransform, doc.length);
+        check(transformBy, doc.length);
+        Common.assert(Sha.hex_sha256(doc) === origToTransform.parentHash);
+    }
+    Common.assert(origToTransform.parentHash === transformBy.parentHash);
+    var resultOfTransformBy = apply(transformBy, doc);
+    var toTransform = clone(origToTransform);
+    var text = doc;
+    for (var i = toTransform.operations.length-1; i >= 0; i--) {
+        if (isCheckpointOp(toTransform.operations[i], text)) { continue; }
+        for (var j = transformBy.operations.length-1; j >= 0; j--) {
+            if (isCheckpointOp(transformBy.operations[j], text)) { console.log('cpo'); continue; }
+            if (Common.DEBUG) {
+                console.log(
+                    ['TRANSFORM', text, toTransform.operations[i], transformBy.operations[j]]
+                );
+            }
+            try {
+                toTransform.operations[i] = Operation.transform(text,
+                                                                toTransform.operations[i],
+                                                                transformBy.operations[j],
+                                                                transformFunction);
+            } catch (e) {
+                console.error("The pluggable transform function threw an error, " +
+                    "failing operational transformation");
+                return create(Sha.hex_sha256(resultOfTransformBy));
+            }
+            if (!toTransform.operations[i]) {
+                break;
+            }
+        }
+        if (Common.PARANOIA && toTransform.operations[i]) {
+            Operation.check(toTransform.operations[i], resultOfTransformBy.length);
+        }
+    }
+    var out = create(transformBy.parentHash);
+    for (var i = toTransform.operations.length-1; i >= 0; i--) {
+        if (toTransform.operations[i]) {
+            addOperation(out, toTransform.operations[i]);
+        }
+    }
+    out.parentHash = Sha.hex_sha256(resultOfTransformBy);
+    if (Common.PARANOIA) {
+        check(out, resultOfTransformBy.length);
+    }
+    return out;
+};
+var random = Patch.random = function (doc, opCount) {
+    Common.assert(typeof(doc) === 'string');
+    opCount = opCount || (Math.floor(Math.random() * 30) + 1);
+    var patch = create(Sha.hex_sha256(doc));
+    var docLength = doc.length;
+    while (opCount-- > 0) {
+        var op = Operation.random(docLength);
+        docLength += Operation.lengthChange(op);
+        addOperation(patch, op);
+    }
+    check(patch);
+    return patch;
+};
+},
+"SHA256.js": function(module, exports, require){
+/* A JavaScript implementation of the Secure Hash Algorithm, SHA-256
+ * Version 0.3 Copyright Angel Marin 2003-2004 - http://anmar.eu.org/
+ * Distributed under the BSD License
+ * Some bits taken from Paul Johnston's SHA-1 implementation
+ */
+(function () {
+    var chrsz = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode  */
+    function safe_add (x, y) {
+        var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+        var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+        return (msw << 16) | (lsw & 0xFFFF);
+    }
+    function S (X, n) {return ( X >>> n ) | (X << (32 - n));}
+    function R (X, n) {return ( X >>> n );}
+    function Ch(x, y, z) {return ((x & y) ^ ((~x) & z));}
+    function Maj(x, y, z) {return ((x & y) ^ (x & z) ^ (y & z));}
+    function Sigma0256(x) {return (S(x, 2) ^ S(x, 13) ^ S(x, 22));}
+    function Sigma1256(x) {return (S(x, 6) ^ S(x, 11) ^ S(x, 25));}
+    function Gamma0256(x) {return (S(x, 7) ^ S(x, 18) ^ R(x, 3));}
+    function Gamma1256(x) {return (S(x, 17) ^ S(x, 19) ^ R(x, 10));}
+    function newArray (n) {
+        var a = [];
+        for (;n>0;n--) {
+            a.push(undefined);
+        }
+        return a;
+    }
+    function core_sha256 (m, l) {
+        var K = [0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,0xE49B69C1,0xEFBE4786,0xFC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x6CA6351,0x14292967,0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2];
+        var HASH = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19];
+        var W = newArray(64);
+        var a, b, c, d, e, f, g, h, i, j;
+        var T1, T2;
+        /* append padding */
+        m[l >> 5] |= 0x80 << (24 - l % 32);
+        m[((l + 64 >> 9) << 4) + 15] = l;
+        for ( var i = 0; i<m.length; i+=16 ) {
+            a = HASH[0]; b = HASH[1]; c = HASH[2]; d = HASH[3];
+            e = HASH[4]; f = HASH[5]; g = HASH[6]; h = HASH[7];
+            for ( var j = 0; j<64; j++) {
+                if (j < 16) {
+                    W[j] = m[j + i];
+                } else {
+                    W[j] = safe_add(safe_add(safe_add(Gamma1256(
+                        W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);
+                }
+                T1 = safe_add(safe_add(safe_add(
+                    safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);
+                T2 = safe_add(Sigma0256(a), Maj(a, b, c));
+                h = g; g = f; f = e; e = safe_add(d, T1);
+                d = c; c = b; b = a; a = safe_add(T1, T2);
+            }
+            HASH[0] = safe_add(a, HASH[0]); HASH[1] = safe_add(b, HASH[1]);
+            HASH[2] = safe_add(c, HASH[2]); HASH[3] = safe_add(d, HASH[3]);
+            HASH[4] = safe_add(e, HASH[4]); HASH[5] = safe_add(f, HASH[5]);
+            HASH[6] = safe_add(g, HASH[6]); HASH[7] = safe_add(h, HASH[7]);
+        }
+        return HASH;
+    }
+    function str2binb (str) {
+        var bin = Array();
+        var mask = (1 << chrsz) - 1;
+        for(var i = 0; i < str.length * chrsz; i += chrsz)
+            bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (24 - i%32);
+        return bin;
+    }
+    function binb2hex (binarray) {
+        var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
+        var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+        var str = "";
+        for (var i = 0; i < binarray.length * 4; i++) {
+            str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
+                hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
+        }
+        return str;
+    }
+    function hex_sha256(s){
+        return binb2hex(core_sha256(str2binb(s),s.length * chrsz));
+    }
+    module.exports.hex_sha256 = hex_sha256;
+}());
+},
+"Common.js": function(module, exports, require){
+/*
+ * Copyright 2014 XWiki SAS
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+var DEBUG = module.exports.debug =
+    (typeof(localStorage) !== 'undefined' && localStorage['ChainPad_DEBUG']);
+var PARANOIA = module.exports.PARANOIA =
+    (typeof(localStorage) !== 'undefined' && localStorage['ChainPad_PARANOIA']);
+/* Good testing but slooooooooooow */
+var VALIDATE_ENTIRE_CHAIN_EACH_MSG = module.exports.VALIDATE_ENTIRE_CHAIN_EACH_MSG =
+    (typeof(localStorage) !== 'undefined' && localStorage['ChainPad_VALIDATE_ENTIRE_CHAIN_EACH_MSG']);
+/* throw errors over non-compliant messages which would otherwise be treated as invalid */
+var TESTING = module.exports.TESTING =
+    (typeof(localStorage) !== 'undefined' && localStorage['ChainPad_TESTING']);
+var assert = module.exports.assert = function (expr) {
+    if (!expr) { throw new Error("Failed assertion"); }
+};
+var isUint = module.exports.isUint = function (integer) {
+    return (typeof(integer) === 'number') &&
+        (Math.floor(integer) === integer) &&
+        (integer >= 0);
+};
+var randomASCII = module.exports.randomASCII = function (length) {
+    var content = [];
+    for (var i = 0; i < length; i++) {
+        content[i] = String.fromCharCode( Math.floor(Math.random()*256) % 57 + 65 );
+    }
+    return content.join('');
+};
+var strcmp = module.exports.strcmp = function (a, b) {
+    if (PARANOIA && typeof(a) !== 'string') { throw new Error(); }
+    if (PARANOIA && typeof(b) !== 'string') { throw new Error(); }
+    return ( (a === b) ? 0 : ( (a > b) ? 1 : -1 ) );
+}
+},
+"Message.js": function(module, exports, require){
+/*
+ * Copyright 2014 XWiki SAS
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+var Common = require('./Common');
+var Operation = require('./Operation');
+var Patch = require('./Patch');
+var Sha = require('./SHA256');
+var Message = module.exports;
+var REGISTER     = Message.REGISTER     = 0;
+var REGISTER_ACK = Message.REGISTER_ACK = 1;
+var PATCH        = Message.PATCH        = 2;
+var DISCONNECT   = Message.DISCONNECT   = 3;
+var CHECKPOINT   = Message.CHECKPOINT   = 4;
+var check = Message.check = function(msg) {
+    Common.assert(msg.type === 'Message');
+    if (msg.messageType === PATCH || msg.messageType === CHECKPOINT) {
+        Patch.check(msg.content);
+        Common.assert(typeof(msg.lastMsgHash) === 'string');
+    } else {
+        throw new Error("invalid message type [" + msg.messageType + "]");
+    }
+};
+var create = Message.create = function (type, content, lastMsgHash) {
+    var msg = {
+        type: 'Message',
+        messageType: type,
+        content: content,
+        lastMsgHash: lastMsgHash
+    };
+    if (Common.PARANOIA) { check(msg); }
+    return msg;
+};
+var toString = Message.toString = function (msg) {
+    if (Common.PARANOIA) { check(msg); }
+    if (msg.messageType === PATCH || msg.messageType === CHECKPOINT) {
+        return JSON.stringify([msg.messageType, Patch.toObj(msg.content), msg.lastMsgHash]);
+    } else {
+        throw new Error();
+    }
+};
+var discardBencode = function (msg, arr) {
+    var len = msg.substring(0,msg.indexOf(':'));
+    msg = msg.substring(len.length+1);
+    var value = msg.substring(0,Number(len));
+    msg = msg.substring(value.length);
+    if (arr) { arr.push(value); }
+    return msg;
+};
+var fromString = Message.fromString = function (str) {
+    var m = JSON.parse(str);
+    if (m[0] !== CHECKPOINT && m[0] !== PATCH) { throw new Error("invalid message type " + m[0]); }
+    var msg = create(m[0], Patch.fromObj(m[1]), m[2]);
+    if (m[0] === CHECKPOINT) { msg.content.isCheckpoint = true; }
+    return msg;
+};
+var hashOf = Message.hashOf = function (msg) {
+    if (Common.PARANOIA) { check(msg); }
+    var hash = Sha.hex_sha256(toString(msg));
+    return hash;
+};
+},
+"ChainPad.js": function(module, exports, require){
+/*
+ * Copyright 2014 XWiki SAS
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+var Common = module.exports.Common = require('./Common');
+var Operation = module.exports.Operation = require('./Operation');
+var Patch = module.exports.Patch = require('./Patch');
+var Message = module.exports.Message = require('./Message');
+var Sha = module.exports.Sha = require('./SHA256');
+var ChainPad = {};
+// hex_sha256('')
+var EMPTY_STR_HASH = module.exports.EMPTY_STR_HASH =
+    'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+var ZERO = '0000000000000000000000000000000000000000000000000000000000000000';
+// Default number of patches between checkpoints (patches older than this will be pruned)
+// default for realtime.config.checkpointInterval
+var DEFAULT_CHECKPOINT_INTERVAL = 50;
+// Default number of milliseconds to wait before syncing to the server
+var DEFAULT_AVERAGE_SYNC_MILLISECONDS = 300;
+// By default, we allow checkpoints at any place but if this is set true, we will blow up on chains
+// which have checkpoints not where we expect them to be.
+var DEFAULT_STRICT_CHECKPOINT_VALIDATION = false;
+var enterChainPad = function (realtime, func) {
+    return function () {
+        if (realtime.failed) { return; }
+        func.apply(null, arguments);
+    };
+};
+var debug = function (realtime, msg) {
+    if (realtime.logLevel > 0) {
+        console.log("[" + realtime.userName + "]  " + msg);
+    }
+};
+var warn = function (realtime, msg) {
+    if (realtime.logLevel > 0) {
+        console.error("[" + realtime.userName + "]  " + msg);
+    }
+};
+var schedule = function (realtime, func, timeout) {
+    if (realtime.aborted) { return; }
+    if (!timeout) {
+        timeout = Math.floor(Math.random() * 2 * realtime.config.avgSyncMilliseconds);
+    }
+    var to = setTimeout(enterChainPad(realtime, function () {
+        realtime.schedules.splice(realtime.schedules.indexOf(to), 1);
+        func();
+    }), timeout);
+    realtime.schedules.push(to);
+    return to;
+};
+var unschedule = function (realtime, schedule) {
+    var index = realtime.schedules.indexOf(schedule);
+    if (index > -1) {
+        realtime.schedules.splice(index, 1);
+    }
+    clearTimeout(schedule);
+};
+var onMessage = function (realtime, message, callback) {
+    if (!realtime.messageHandlers.length) {
+        callback("no onMessage() handler registered");
+    }
+    for (var i = 0; i < realtime.messageHandlers.length; i++) {
+        realtime.messageHandlers[i](message, function () {
+            callback.apply(null, arguments);
+            callback = function () { };
+        });
+    }
+};
+var sendMessage = function (realtime, msg, callback) {
+    var strMsg = Message.toString(msg);
+    onMessage(realtime, strMsg, function (err) {
+        if (err) {
+            debug(realtime, "Posting to server failed [" + err + "]");
+            realtime.pending = null;
+        } else {
+            var pending = realtime.pending;
+            realtime.pending = null;
+            Common.assert(pending.hash === msg.hashOf);
+            handleMessage(realtime, strMsg, true);
+            pending.callback();
+        }
+    });
+    msg.hashOf = msg.hashOf || Message.hashOf(msg);
+    var timeout = schedule(realtime, function () {
+        debug(realtime, "Failed to send message [" + msg.hashOf + "] to server");
+        sync(realtime);
+    }, 10000 + (Math.random() * 5000));
+    if (realtime.pending) { throw new Error("there is already a pending message"); }
+    realtime.pending = {
+        hash: msg.hashOf,
+        callback: function () {
+            unschedule(realtime, timeout);
+            realtime.syncSchedule = schedule(realtime, function () { sync(realtime); }, 0);
+            callback();
+        }
+    };
+    if (Common.PARANOIA) { check(realtime); }
+};
+var sync = function (realtime) {
+    if (Common.PARANOIA) { check(realtime); }
+    if (realtime.syncSchedule && !realtime.pending) {
+        unschedule(realtime, realtime.syncSchedule);
+        realtime.syncSchedule = null;
+    } else {
+        //debug(realtime, "already syncing...");
+        // we're currently waiting on something from the server.
+        return;
+    }
+    realtime.uncommitted = Patch.simplify(
+        realtime.uncommitted, realtime.authDoc, realtime.config.operationSimplify);
+    if (realtime.uncommitted.operations.length === 0) {
+        //debug(realtime, "No data to sync to the server, sleeping");
+        realtime.syncSchedule = schedule(realtime, function () { sync(realtime); });
+        return;
+    }
+    if (((parentCount(realtime, realtime.best) + 1) % realtime.config.checkpointInterval) === 0) {
+        var best = realtime.best;
+        debug(realtime, "Sending checkpoint");
+        var cpp = Patch.createCheckpoint(realtime.authDoc,
+                                         realtime.authDoc,
+                                         realtime.best.content.inverseOf.parentHash);
+        var cp = Message.create(Message.CHECKPOINT, cpp, realtime.best.hashOf);
+        sendMessage(realtime, cp, function () {
+            debug(realtime, "Checkpoint sent and accepted");
+        });
+        return;
+    }
+    var msg;
+    if (realtime.setContentPatch) {
+        msg = realtime.setContentPatch;
+    } else {
+        msg = Message.create(Message.PATCH, realtime.uncommitted, realtime.best.hashOf);
+    }
+    sendMessage(realtime, msg, function () {
+        //debug(realtime, "patch sent");
+        if (realtime.setContentPatch) {
+            debug(realtime, "initial Ack received [" + msg.hashOf + "]");
+            realtime.setContentPatch = null;
+        }
+    });
+};
+var storeMessage = function (realtime, msg) {
+    Common.assert(msg.lastMsgHash);
+    Common.assert(msg.hashOf);
+    realtime.messages[msg.hashOf] = msg;
+    (realtime.messagesByParent[msg.lastMsgHash] =
+        realtime.messagesByParent[msg.lastMsgHash] || []).push(msg);
+};
+var forgetMessage = function (realtime, msg) {
+    Common.assert(msg.lastMsgHash);
+    Common.assert(msg.hashOf);
+    delete realtime.messages[msg.hashOf];
+    var list = realtime.messagesByParent[msg.lastMsgHash];
+    Common.assert(list.indexOf(msg) > -1);
+    list.splice(list.indexOf(msg), 1);
+    if (list.length === 0) {
+        delete realtime.messagesByParent[msg.lastMsgHash];
+    }
+    var children = realtime.messagesByParent[msg.hashOf];
+    if (children) {
+        for (var i = 0; i < children.length; i++) {
+            delete children[i].parent;
+        }
+    }
+};
+var create = ChainPad.create = function (config) {
+    config = config || {};
+    var initialState = config.initialState || '';
+    config.checkpointInterval = config.checkpointInterval || DEFAULT_CHECKPOINT_INTERVAL;
+    config.avgSyncMilliseconds = config.avgSyncMilliseconds || DEFAULT_AVERAGE_SYNC_MILLISECONDS;
+    config.strictCheckpointValidation =
+        config.strictCheckpointValidation || DEFAULT_STRICT_CHECKPOINT_VALIDATION;
+    var realtime = {
+        type: 'ChainPad',
+        authDoc: '',
+        config: config,
+        logLevel: (typeof(config.logLevel) === 'number') ? config.logLevel : 1,
+        /** A patch representing all uncommitted work. */
+        uncommitted: null,
+        uncommittedDocLength: initialState.length,
+        patchHandlers: [],
+        changeHandlers: [],
+        messageHandlers: [],
+        schedules: [],
+        aborted: false,
+        syncSchedule: null,
+        registered: false,
+        // this is only used if PARANOIA is enabled.
+        userInterfaceContent: undefined,
+        // If we want to set the content to a particular thing, this patch will be sent across the
+        // wire. If the patch is not accepted we will not try to recover it. This is used for
+        // setting initial state.
+        setContentPatch: null,
+        failed: false,
+        // hash and callback for previously send patch, currently in flight.
+        pending: null,
+        messages: {},
+        messagesByParent: {},
+        rootMessage: null,
+        onSettle: [],
+        userName: config.userName || 'anonymous',
+    };
+    var zeroPatch = Patch.create(EMPTY_STR_HASH);
+    zeroPatch.inverseOf = Patch.invert(zeroPatch, '');
+    zeroPatch.inverseOf.inverseOf = zeroPatch;
+    var zeroMsg = Message.create(Message.PATCH, zeroPatch, ZERO);
+    zeroMsg.hashOf = Message.hashOf(zeroMsg);
+    zeroMsg.parentCount = 0;
+    zeroMsg.isInitialMessage = true;
+    storeMessage(realtime, zeroMsg);
+    realtime.rootMessage = zeroMsg;
+    realtime.best = zeroMsg;
+    if (initialState !== '') {
+        var initPatch = Patch.create(EMPTY_STR_HASH);
+        Patch.addOperation(initPatch, Operation.create(0, 0, initialState));
+        initPatch.inverseOf = Patch.invert(initPatch, '');
+        initPatch.inverseOf.inverseOf = initPatch;
+        var initMsg = Message.create(Message.PATCH, initPatch, zeroMsg.hashOf);
+        initMsg.hashOf = Message.hashOf(initMsg);
+        initMsg.isInitialMessage = true;
+        storeMessage(realtime, initMsg);
+        realtime.best = initMsg;
+        realtime.authDoc = initialState;
+        realtime.setContentPatch = initMsg;
+    }
+    realtime.uncommitted = Patch.create(realtime.best.content.inverseOf.parentHash);
+    if (Common.PARANOIA) {
+        realtime.userInterfaceContent = initialState;
+    }
+    return realtime;
+};
+var getParent = function (realtime, message) {
+    return message.parent = message.parent || realtime.messages[message.lastMsgHash];
+};
+var check = ChainPad.check = function(realtime) {
+    Common.assert(realtime.type === 'ChainPad');
+    Common.assert(typeof(realtime.authDoc) === 'string');
+    Patch.check(realtime.uncommitted, realtime.authDoc.length);
+    var uiDoc = Patch.apply(realtime.uncommitted, realtime.authDoc);
+    if (uiDoc.length !== realtime.uncommittedDocLength) {
+        Common.assert(0);
+    }
+    if (realtime.userInterfaceContent !== '') {
+        Common.assert(uiDoc === realtime.userInterfaceContent);
+    }
+    if (!Common.VALIDATE_ENTIRE_CHAIN_EACH_MSG) { return; }
+    var doc = realtime.authDoc;
+    var patchMsg = realtime.best;
+    Common.assert(patchMsg.content.inverseOf.parentHash === realtime.uncommitted.parentHash);
+    var patches = [];
+    do {
+        patches.push(patchMsg);
+        doc = Patch.apply(patchMsg.content.inverseOf, doc);
+    } while ((patchMsg = getParent(realtime, patchMsg)));
+    Common.assert(doc === '');
+    while ((patchMsg = patches.pop())) {
+        doc = Patch.apply(patchMsg.content, doc);
+    }
+    Common.assert(doc === realtime.authDoc);
+};
+var doOperation = ChainPad.doOperation = function (realtime, op) {
+    if (Common.PARANOIA) {
+        check(realtime);
+        realtime.userInterfaceContent = Operation.apply(op, realtime.userInterfaceContent);
+    }
+    Operation.check(op, realtime.uncommittedDocLength);
+    Patch.addOperation(realtime.uncommitted, op);
+    realtime.uncommittedDocLength += Operation.lengthChange(op);
+};
+var doPatch = ChainPad.doPatch = function (realtime, patch) {
+    if (Common.PARANOIA) {
+        check(realtime);
+        Common.assert(Patch.invert(realtime.uncommitted).parentHash === patch.parentHash);
+        realtime.userInterfaceContent = Patch.apply(patch, realtime.userInterfaceContent);
+    }
+    Patch.check(patch, realtime.uncommittedDocLength);
+    realtime.uncommitted = Patch.merge(realtime.uncommitted, patch);
+    realtime.uncommittedDocLength += Patch.lengthChange(patch);
+};
+var isAncestorOf = function (realtime, ancestor, decendent) {
+    if (!decendent || !ancestor) { return false; }
+    if (ancestor === decendent) { return true; }
+    return isAncestorOf(realtime, ancestor, getParent(realtime, decendent));
+};
+var parentCount = function (realtime, message) {
+    if (typeof(message.parentCount) !== 'number') {
+        message.parentCount = parentCount(realtime, getParent(realtime, message)) + 1;
+    }
+    return message.parentCount;
+};
+var applyPatch = function (realtime, isFromMe, patch) {
+    Common.assert(patch);
+    Common.assert(patch.inverseOf);
+    if (isFromMe) {
+        // Case 1: We're applying a patch which we originally created (yay our work was accepted)
+        //         We will merge the inverse of the patch with our uncommitted work in order that
+        //         we do not try to commit that work over again.
+        // Case 2: We're reverting a patch which had originally come from us, a.k.a. we're applying
+        //         the inverse of that patch.
+        //
+        // In either scenario, we want to apply the inverse of the patch we are applying, to the
+        // uncommitted work. Whatever we "add" to the authDoc we "remove" from the uncommittedWork.
+        //
+        Common.assert(patch.parentHash === realtime.uncommitted.parentHash);
+        realtime.uncommitted = Patch.merge(patch.inverseOf, realtime.uncommitted);
+    } else {
+        // It's someone else's patch which was received, we need to *transform* out uncommitted
+        // work over their patch in order to preserve intent as much as possible.
+        realtime.uncommitted =
+            Patch.transform(
+                realtime.uncommitted, patch, realtime.authDoc, realtime.config.transformFunction);
+    }
+    realtime.uncommitted.parentHash = patch.inverseOf.parentHash;
+    realtime.authDoc = Patch.apply(patch, realtime.authDoc);
+    if (Common.PARANOIA) {
+        Common.assert(realtime.uncommitted.parentHash === patch.inverseOf.parentHash);
+        Common.assert(Sha.hex_sha256(realtime.authDoc) === realtime.uncommitted.parentHash);
+        realtime.userInterfaceContent = Patch.apply(realtime.uncommitted, realtime.authDoc);
+    }
+};
+var revertPatch = function (realtime, isFromMe, patch) {
+    applyPatch(realtime, isFromMe, patch.inverseOf);
+};
+var getBestChild = function (realtime, msg) {
+    var best = msg;
+    (realtime.messagesByParent[msg.hashOf] || []).forEach(function (child) {
+        Common.assert(child.lastMsgHash === msg.hashOf);
+        child = getBestChild(realtime, child);
+        if (parentCount(realtime, child) > parentCount(realtime, best)) { best = child; }
+    });
+    return best;
+};
+var pushUIPatch = function (realtime, patch) {
+    if (patch.operations.length) {
+        // push the uncommittedPatch out to the user interface.
+        for (var i = 0; i < realtime.patchHandlers.length; i++) {
+            realtime.patchHandlers[i](patch);
+        }
+        for (var i = 0; i < realtime.changeHandlers.length; i++) {
+            for (var j = patch.operations.length - 1; j >= 0; j--) {
+                var op = patch.operations[j];
+                realtime.changeHandlers[i](op.offset, op.toRemove, op.toInsert);
+            }
+        }
+    }
+};
+var validContent = function (realtime, contentGetter) {
+    if (!realtime.config.validateContent) { return true; }
+    try {
+        return realtime.config.validateContent(contentGetter());
+    } catch (e) {
+        warn(realtime, "Error in content validator [" + e.stack + "]");
+    }
+    return false;
+};
+var handleMessage = ChainPad.handleMessage = function (realtime, msgStr, isFromMe) {
+    if (Common.PARANOIA) { check(realtime); }
+    var msg = Message.fromString(msgStr);
+    if (msg.messageType !== Message.PATCH && msg.messageType !== Message.CHECKPOINT) {
+        debug(realtime, "unrecognized message type " + msg.messageType);
+        return;
+    }
+    msg.hashOf = Message.hashOf(msg);
+    if (Common.DEBUG) { debug(realtime, JSON.stringify([msg.hashOf, msg.content.operations])); }
+    if (realtime.messages[msg.hashOf]) {
+        if (realtime.setContentPatch && realtime.setContentPatch.hashOf === msg.hashOf) {
+            // We got the initial state patch, channel already has a pad, no need to send it.
+            realtime.setContentPatch = null;
+        } else {
+            debug(realtime, "Patch [" + msg.hashOf + "] is already known");
+        }
+        if (Common.PARANOIA) { check(realtime); }
+        return;
+    }
+    if (msg.content.isCheckpoint &&
+        !validContent(realtime, function () { return msg.content.operations[0].toInsert }))
+    {
+        // If it's not a checkpoint, we verify it later on...
+        debug(realtime, "Checkpoint [" + msg.hashOf + "] failed content validation");
+        return;
+    }
+    storeMessage(realtime, msg);
+    if (!isAncestorOf(realtime, realtime.rootMessage, msg)) {
+        if (msg.content.isCheckpoint && realtime.best.isInitialMessage) {
+            // We're starting with a trucated chain from a checkpoint, we will adopt this
+            // as the root message and go with it...
+            var userDoc = Patch.apply(realtime.uncommitted, realtime.authDoc);
+            Common.assert(!Common.PARANOIA || realtime.userInterfaceContent === userDoc);
+            var fixUserDocPatch = Patch.invert(realtime.uncommitted, realtime.authDoc);
+            Patch.addOperation(fixUserDocPatch,
+                Operation.create(0, realtime.authDoc.length, msg.content.operations[0].toInsert));
+            fixUserDocPatch =
+                Patch.simplify(fixUserDocPatch, userDoc, realtime.config.operationSimplify);
+            msg.parentCount = 0;
+            realtime.rootMessage = realtime.best = msg;
+            realtime.authDoc = msg.content.operations[0].toInsert;
+            realtime.uncommitted = Patch.create(Sha.hex_sha256(realtime.authDoc));
+            realtime.uncommittedDocLength = realtime.authDoc.length;
+            pushUIPatch(realtime, fixUserDocPatch);
+            if (Common.PARANOIA) { realtime.userInterfaceContent = realtime.authDoc; }
+            return;
+        } else {
+            // we'll probably find the missing parent later.
+            debug(realtime, "Patch [" + msg.hashOf + "] not connected to root");
+            if (Common.PARANOIA) { check(realtime); }
+            return;
+        }
+    }
+    // of this message fills in a hole in the chain which makes another patch better, swap to the
+    // best child of this patch since longest chain always wins.
+    msg = getBestChild(realtime, msg);
+    msg.isFromMe = isFromMe;
+    var patch = msg.content;
+    // Find the ancestor of this patch which is in the main chain, reverting as necessary
+    var toRevert = [];
+    var commonAncestor = realtime.best;
+    if (!isAncestorOf(realtime, realtime.best, msg)) {
+        var pcBest = parentCount(realtime, realtime.best);
+        var pcMsg = parentCount(realtime, msg);
+        if (pcBest < pcMsg
+          || (pcBest === pcMsg
+            && Common.strcmp(realtime.best.hashOf, msg.hashOf) > 0))
+        {
+            // switch chains
+            while (commonAncestor && !isAncestorOf(realtime, commonAncestor, msg)) {
+                toRevert.push(commonAncestor);
+                commonAncestor = getParent(realtime, commonAncestor);
+            }
+            Common.assert(commonAncestor);
+            debug(realtime, "Patch [" + msg.hashOf + "] better than best chain, switching");
+        } else {
+            debug(realtime, "Patch [" + msg.hashOf + "] chain is [" + pcMsg + "] best chain is [" +
+                pcBest + "]");
+            if (Common.PARANOIA) { check(realtime); }
+            return;
+        }
+    }
+    // Find the parents of this patch which are not in the main chain.
+    var toApply = [];
+    var current = msg;
+    do {
+        toApply.unshift(current);
+        current = getParent(realtime, current);
+        Common.assert(current);
+    } while (current !== commonAncestor);
+    var authDocAtTimeOfPatch = realtime.authDoc;
+    for (var i = 0; i < toRevert.length; i++) {
+        Common.assert(typeof(toRevert[i].content.inverseOf) !== 'undefined');
+        authDocAtTimeOfPatch = Patch.apply(toRevert[i].content.inverseOf, authDocAtTimeOfPatch);
+    }
+    // toApply.length-1 because we do not want to apply the new patch.
+    for (var i = 0; i < toApply.length-1; i++) {
+        if (typeof(toApply[i].content.inverseOf) === 'undefined') {
+            toApply[i].content.inverseOf = Patch.invert(toApply[i].content, authDocAtTimeOfPatch);
+            toApply[i].content.inverseOf.inverseOf = toApply[i].content;
+        }
+        authDocAtTimeOfPatch = Patch.apply(toApply[i].content, authDocAtTimeOfPatch);
+    }
+    if (Sha.hex_sha256(authDocAtTimeOfPatch) !== patch.parentHash) {
+        debug(realtime, "patch [" + msg.hashOf + "] parentHash is not valid");
+        if (Common.PARANOIA) { check(realtime); }
+        if (Common.TESTING) { throw new Error(); }
+        forgetMessage(realtime, msg);
+        return;
+    }
+    if (patch.isCheckpoint) {
+        // Ok, we have a checkpoint patch.
+        // If the chain length is not equal to checkpointInterval then this patch is invalid.
+        var i = 0;
+        var checkpointP;
+        for (var m = getParent(realtime, msg); m; m = getParent(realtime, m)) {
+            if (m.content.isCheckpoint) {
+                if (checkpointP) {
+                    checkpointP = m;
+                    break;
+                }
+                checkpointP = m;
+            }
+        }
+        if (checkpointP && checkpointP !== realtime.rootMessage) {
+            var point = parentCount(realtime, checkpointP);
+            if (realtime.config.strictCheckpointValidation &&
+                (point % realtime.config.checkpointInterval) !== 0)
+            {
+                debug(realtime, "checkpoint [" + msg.hashOf + "] at invalid point [" + point + "]");
+                if (Common.PARANOIA) { check(realtime); }
+                if (Common.TESTING) { throw new Error(); }
+                forgetMessage(realtime, msg);
+                return;
+            }
+            // Time to prune some old messages from the chain
+            debug(realtime, "checkpoint [" + msg.hashOf + "]");
+            for (var m = getParent(realtime, checkpointP); m; m = getParent(realtime, m)) {
+                debug(realtime, "pruning [" + m.hashOf + "]");
+                forgetMessage(realtime, m);
+            }
+            realtime.rootMessage = checkpointP;
+        }
+    } else {
+        var simplePatch =
+            Patch.simplify(patch, authDocAtTimeOfPatch, realtime.config.operationSimplify);
+        if (!Patch.equals(simplePatch, patch)) {
+            debug(realtime, "patch [" + msg.hashOf + "] can be simplified");
+            if (Common.PARANOIA) { check(realtime); }
+            if (Common.TESTING) { throw new Error(); }
+            forgetMessage(realtime, msg);
+            return;
+        }
+        if (!validContent(realtime,
+            function () { return Patch.apply(patch, authDocAtTimeOfPatch); }))
+        {
+            debug(realtime, "Patch [" + msg.hashOf + "] failed content validation");
+            return;
+        }
+    }
+    patch.inverseOf = Patch.invert(patch, authDocAtTimeOfPatch);
+    patch.inverseOf.inverseOf = patch;
+    realtime.uncommitted = Patch.simplify(
+        realtime.uncommitted, realtime.authDoc, realtime.config.operationSimplify);
+    var oldUserInterfaceContent = Patch.apply(realtime.uncommitted, realtime.authDoc);
+    if (Common.PARANOIA) {
+        Common.assert(oldUserInterfaceContent === realtime.userInterfaceContent);
+    }
+    // Derive the patch for the user's uncommitted work
+    var uncommittedPatch = Patch.invert(realtime.uncommitted, realtime.authDoc);
+    for (var i = 0; i < toRevert.length; i++) {
+        debug(realtime, "reverting [" + toRevert[i].hashOf + "]");
+        if (toRevert[i].isFromMe) { debug(realtime, "reverting patch 'from me' [" + JSON.stringify(toRevert[i].content.operations) + "]"); }
+        uncommittedPatch = Patch.merge(uncommittedPatch, toRevert[i].content.inverseOf);
+        revertPatch(realtime, toRevert[i].isFromMe, toRevert[i].content);
+    }
+    for (var i = 0; i < toApply.length; i++) {
+        debug(realtime, "applying [" + toApply[i].hashOf + "]");
+        uncommittedPatch = Patch.merge(uncommittedPatch, toApply[i].content);
+        applyPatch(realtime, toApply[i].isFromMe, toApply[i].content);
+    }
+    uncommittedPatch = Patch.merge(uncommittedPatch, realtime.uncommitted);
+    uncommittedPatch = Patch.simplify(
+        uncommittedPatch, oldUserInterfaceContent, realtime.config.operationSimplify);
+    realtime.uncommittedDocLength += Patch.lengthChange(uncommittedPatch);
+    realtime.best = msg;
+    if (Common.PARANOIA) {
+        // apply the uncommittedPatch to the userInterface content.
+        var newUserInterfaceContent = Patch.apply(uncommittedPatch, oldUserInterfaceContent);
+        Common.assert(realtime.userInterfaceContent.length === realtime.uncommittedDocLength);
+        Common.assert(newUserInterfaceContent === realtime.userInterfaceContent);
+    }
+    pushUIPatch(realtime, uncommittedPatch);
+    if (!uncommittedPatch.operations.length) {
+        var onSettle = realtime.onSettle;
+        realtime.onSettle = [];
+        onSettle.forEach(function (handler) { handler(); });
+    }
+    if (Common.PARANOIA) { check(realtime); }
+};
+var getDepthOfState = function (content, minDepth, realtime) {
+    Common.assert(typeof(content) === 'string');
+    // minimum depth is an optional argument which defaults to zero
+    var minDepth = minDepth || 0;
+    if (minDepth === 0 && realtime.authDoc === content) {
+        return 0;
+    }
+    var hash = Sha.hex_sha256(content);
+    var patchMsg = realtime.best;
+    var depth = 0;
+    do {
+        if (depth < minDepth) {
+            // you haven't exceeded the minimum depth
+        } else {
+            //console.log("Exceeded minimum depth");
+            // you *have* exceeded the minimum depth
+            if (patchMsg.content.parentHash === hash) {
+                // you found it!
+                return depth + 1;
+            }
+        }
+        depth++;
+    } while ((patchMsg = getParent(realtime, patchMsg)));
+    return -1;
+};
+module.exports.create = function (conf) {
+    var realtime = ChainPad.create(conf);
+    var out = {
+        onPatch: enterChainPad(realtime, function (handler) {
+            Common.assert(typeof(handler) === 'function');
+            realtime.patchHandlers.push(handler);
+        }),
+        patch: enterChainPad(realtime, function (patch, x, y) {
+            if (typeof(patch) === 'number') {
+                // Actually they meant to call realtime.change()
+                out.change(patch, x, y);
+                return;
+            }
+            doPatch(realtime, patch);
+        }),
+        onChange: enterChainPad(realtime, function (handler) {
+            Common.assert(typeof(handler) === 'function');
+            realtime.changeHandlers.push(handler);
+        }),
+        change: enterChainPad(realtime, function (offset, count, chars) {
+            if (count === 0 && chars === '') { return; }
+            doOperation(realtime, Operation.create(offset, count, chars));
+        }),
+        onMessage: enterChainPad(realtime, function (handler) {
+            Common.assert(typeof(handler) === 'function');
+            realtime.messageHandlers.push(handler);
+        }),
+        message: enterChainPad(realtime, function (message) {
+            handleMessage(realtime, message, false);
+        }),
+        start: enterChainPad(realtime, function () {
+            if (realtime.syncSchedule) { unschedule(realtime, realtime.syncSchedule); }
+            realtime.syncSchedule = schedule(realtime, function () { sync(realtime); });
+        }),
+        abort: enterChainPad(realtime, function () {
+            realtime.aborted = true;
+            realtime.schedules.forEach(function (s) { clearTimeout(s) });
+        }),
+        sync: enterChainPad(realtime, function () { sync(realtime); }),
+        getAuthDoc: function () { return realtime.authDoc; },
+        getUserDoc: function () { return Patch.apply(realtime.uncommitted, realtime.authDoc); },
+        getDepthOfState: function (content, minDepth) {
+            return getDepthOfState(content, minDepth, realtime);
+        },
+        onSettle: function (handler) {
+            realtime.onSettle.push(handler);
+        },
+    };
+    return out;
+};
+},
+"Operation.js": function(module, exports, require){
+/*
+ * Copyright 2014 XWiki SAS
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+var Common = require('./Common');
+var Operation = module.exports;
+var check = Operation.check = function (op, docLength_opt) {
+    Common.assert(op.type === 'Operation');
+    Common.assert(Common.isUint(op.offset));
+    Common.assert(Common.isUint(op.toRemove));
+    Common.assert(typeof(op.toInsert) === 'string');
+    Common.assert(op.toRemove > 0 || op.toInsert.length > 0);
+    Common.assert(typeof(docLength_opt) !== 'number' || op.offset + op.toRemove <= docLength_opt);
+};
+var create = Operation.create = function (offset, toRemove, toInsert) {
+    var out = {
+        type: 'Operation',
+        offset: offset || 0,
+        toRemove: toRemove || 0,
+        toInsert: toInsert || '',
+    };
+    if (Common.PARANOIA) { check(out); }
+    return out;
+};
+var toObj = Operation.toObj = function (op) {
+    if (Common.PARANOIA) { check(op); }
+    return [op.offset,op.toRemove,op.toInsert];
+};
+var fromObj = Operation.fromObj = function (obj) {
+    Common.assert(Array.isArray(obj) && obj.length === 3);
+    return create(obj[0], obj[1], obj[2]);
+};
+var clone = Operation.clone = function (op) {
+    return create(op.offset, op.toRemove, op.toInsert);
+};
+/**
+ * @param op the operation to apply.
+ * @param doc the content to apply the operation on
+ */
+var apply = Operation.apply = function (op, doc)
+{
+    if (Common.PARANOIA) {
+        check(op);
+        Common.assert(typeof(doc) === 'string');
+        Common.assert(op.offset + op.toRemove <= doc.length);
+    }
+    return doc.substring(0,op.offset) + op.toInsert + doc.substring(op.offset + op.toRemove);
+};
+var invert = Operation.invert = function (op, doc) {
+    if (Common.PARANOIA) {
+        check(op);
+        Common.assert(typeof(doc) === 'string');
+        Common.assert(op.offset + op.toRemove <= doc.length);
+    }
+    var rop = clone(op);
+    rop.toInsert = doc.substring(op.offset, op.offset + op.toRemove);
+    rop.toRemove = op.toInsert.length;
+    return rop;
+};
+var simplify = Operation.simplify = function (op, doc) {
+    if (Common.PARANOIA) {
+        check(op);
+        Common.assert(typeof(doc) === 'string');
+        Common.assert(op.offset + op.toRemove <= doc.length);
+    }
+    var rop = invert(op, doc);
+    op = clone(op);
+    var minLen = Math.min(op.toInsert.length, rop.toInsert.length);
+    var i;
+    for (i = 0; i < minLen && rop.toInsert[i] === op.toInsert[i]; i++) ;
+    op.offset += i;
+    op.toRemove -= i;
+    op.toInsert = op.toInsert.substring(i);
+    rop.toInsert = rop.toInsert.substring(i);
+    if (rop.toInsert.length === op.toInsert.length) {
+        for (i = rop.toInsert.length-1; i >= 0 && rop.toInsert[i] === op.toInsert[i]; i--) ;
+        op.toInsert = op.toInsert.substring(0, i+1);
+        op.toRemove = i+1;
+    }
+    if (op.toRemove === 0 && op.toInsert.length === 0) { return null; }
+    return op;
+};
+var equals = Operation.equals = function (opA, opB) {
+    return (opA.toRemove === opB.toRemove
+        && opA.toInsert === opB.toInsert
+        && opA.offset === opB.offset);
+};
+var lengthChange = Operation.lengthChange = function (op)
+{
+    if (Common.PARANOIA) { check(op); }
+    return op.toInsert.length - op.toRemove;
+};
+/*
+ * @return the merged operation OR null if the result of the merger is a noop.
+ */
+var merge = Operation.merge = function (oldOpOrig, newOpOrig) {
+    if (Common.PARANOIA) {
+        check(newOpOrig);
+        check(oldOpOrig);
+    }
+    var newOp = clone(newOpOrig);
+    var oldOp = clone(oldOpOrig);
+    var offsetDiff = newOp.offset - oldOp.offset;
+    if (newOp.toRemove > 0) {
+        var origOldInsert = oldOp.toInsert;
+        oldOp.toInsert = (
+             oldOp.toInsert.substring(0,offsetDiff)
+           + oldOp.toInsert.substring(offsetDiff + newOp.toRemove)
+        );
+        newOp.toRemove -= (origOldInsert.length - oldOp.toInsert.length);
+        if (newOp.toRemove < 0) { newOp.toRemove = 0; }
+        oldOp.toRemove += newOp.toRemove;
+        newOp.toRemove = 0;
+    }
+    if (offsetDiff < 0) {
+        oldOp.offset += offsetDiff;
+        oldOp.toInsert = newOp.toInsert + oldOp.toInsert;
+    } else if (oldOp.toInsert.length === offsetDiff) {
+        oldOp.toInsert = oldOp.toInsert + newOp.toInsert;
+    } else if (oldOp.toInsert.length > offsetDiff) {
+        oldOp.toInsert = (
+            oldOp.toInsert.substring(0,offsetDiff)
+          + newOp.toInsert
+          + oldOp.toInsert.substring(offsetDiff)
+        );
+    } else {
+        throw new Error("should never happen\n" +
+                        JSON.stringify([oldOpOrig,newOpOrig], null, '  '));
+    }
+    if (oldOp.toInsert === '' && oldOp.toRemove === 0) {
+        return null;
+    }
+    if (Common.PARANOIA) { check(oldOp); }
+    return oldOp;
+};
+/**
+ * If the new operation deletes what the old op inserted or inserts content in the middle of
+ * the old op's content or if they abbut one another, they should be merged.
+ */
+var shouldMerge = Operation.shouldMerge = function (oldOp, newOp) {
+    if (Common.PARANOIA) {
+        check(oldOp);
+        check(newOp);
+    }
+    if (newOp.offset < oldOp.offset) {
+        return (oldOp.offset <= (newOp.offset + newOp.toRemove));
+    } else {
+        return (newOp.offset <= (oldOp.offset + oldOp.toInsert.length));
+    }
+};
+/**
+ * Rebase newOp against oldOp.
+ *
+ * @param oldOp the eariler operation to have happened.
+ * @param newOp the later operation to have happened (in time).
+ * @return either the untouched newOp if it need not be rebased,
+ *                the rebased clone of newOp if it needs rebasing, or
+ *                null if newOp and oldOp must be merged.
+ */
+var rebase = Operation.rebase = function (oldOp, newOp) {
+    if (Common.PARANOIA) {
+        check(oldOp);
+        check(newOp);
+    }
+    if (newOp.offset < oldOp.offset) { return newOp; }
+    newOp = clone(newOp);
+    newOp.offset += oldOp.toRemove;
+    newOp.offset -= oldOp.toInsert.length;
+    return newOp;
+};
+/**
+ * this is a lossy and dirty algorithm, everything else is nice but transformation
+ * has to be lossy because both operations have the same base and they diverge.
+ * This could be made nicer and/or tailored to a specific data type.
+ *
+ * @param toTransform the operation which is converted *MUTATED*.
+ * @param transformBy an existing operation which also has the same base.
+ * @return toTransform *or* null if the result is a no-op.
+ */
+var transform0 = Operation.transform0 = function (text, toTransformOrig, transformByOrig) {
+    // Cloning the original transformations makes this algorithm such that it
+    // **DOES NOT MUTATE ANYMORE**
+    var toTransform = Operation.clone(toTransformOrig);
+    var transformBy = Operation.clone(transformByOrig);
+    if (toTransform.offset > transformBy.offset) {
+        if (toTransform.offset > transformBy.offset + transformBy.toRemove) {
+            // simple rebase
+            toTransform.offset -= transformBy.toRemove;
+            toTransform.offset += transformBy.toInsert.length;
+            return toTransform;
+        }
+        // goto the end, anything you deleted that they also deleted should be skipped.
+        var newOffset = transformBy.offset + transformBy.toInsert.length;
+        toTransform.toRemove = 0; //-= (newOffset - toTransform.offset);
+        if (toTransform.toRemove < 0) { toTransform.toRemove = 0; }
+        toTransform.offset = newOffset;
+        if (toTransform.toInsert.length === 0 && toTransform.toRemove === 0) {
+            return null;
+        }
+        return toTransform;
+    }
+    if (toTransform.offset + toTransform.toRemove < transformBy.offset) {
+        return toTransform;
+    }
+    toTransform.toRemove = transformBy.offset - toTransform.offset;
+    if (toTransform.toInsert.length === 0 && toTransform.toRemove === 0) {
+        return null;
+    }
+    return toTransform;
+};
+/**
+ * @param toTransform the operation which is converted
+ * @param transformBy an existing operation which also has the same base.
+ * @return a modified clone of toTransform *or* toTransform itself if no change was made.
+ */
+var transform = Operation.transform = function (text, toTransform, transformBy, transformFunction) {
+    if (Common.PARANOIA) {
+        check(toTransform);
+        check(transformBy);
+    }
+    transformFunction = transformFunction || transform0;
+    toTransform = clone(toTransform);
+    var result = transformFunction(text, toTransform, transformBy);
+    if (Common.PARANOIA && result) { check(result); }
+    return result;
+};
+/** Used for testing. */
+var random = Operation.random = function (docLength) {
+    Common.assert(Common.isUint(docLength));
+    var offset = Math.floor(Math.random() * 100000000 % docLength) || 0;
+    var toRemove = Math.floor(Math.random() * 100000000 % (docLength - offset)) || 0;
+    var toInsert = '';
+    do {
+        var toInsert = Common.randomASCII(Math.floor(Math.random() * 20));
+    } while (toRemove === 0 && toInsert === '');
+    return create(offset, toRemove, toInsert);
+};
+}
+};
+ChainPad = r("ChainPad.js");}());