(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] = { "json.sortify": {"c":1,"m":"dist/JSON.sortify.js"}, "Diff.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; var Operation = require('./Operation'); var Common = require('./Common'); /*:: import type { Operation_t } from './Operation'; */ var DEFAULT_BLOCKSIZE = module.exports.DEFAULT_BLOCKSIZE = 8; var hashScan = function (str, blockSize) { var out = {}; for (var i = 0; i + blockSize <= str.length; i++) { var slice = str.slice(i, i + blockSize); (out[slice] = out[slice] || []).push(i); } return out; }; // return true if two segments do not overlap, else false var isCompatible = function (m1, m2) { if (m1.oldIndex < m2.oldIndex) { if (m1.oldIndex + m1.length > m2.oldIndex) { return false; } if (m1.newIndex + m1.length > m2.newIndex) { return false; } } else if (m2.oldIndex < m1.oldIndex) { if (m2.oldIndex + m2.length > m1.oldIndex) { return false; } if (m2.newIndex + m2.length > m1.newIndex) { return false; } } else { return false; } return true; }; var scoreMatch = function (m) { return (m.length * 2) - m.oldIndex - m.newIndex; }; /* iterate backwards through and array, splicing out indices to remove the indices to remove MUST be in ascending order otherwise this could remove the wrong values operates strictly via side-effects */ var removeAscendingIndices = function (A, toRemove) { if (!toRemove.length) { return; } for (var j = toRemove.length - 1; j > -1; j--) { A.splice(toRemove[j], 1); } }; /* given a candidate match and the list of pending matches evaluate whether the candidate conflicts with existing matches if the candidate is determined to be a worse match than existing matches return false otherwise return the list of candidates which should be replaced returns either: false => the candidate is incompatible, and its conflicts are more valuable empty array => truthy, but there is nothing to remove (no conflicts) array => conflicting elements to replace with the candidate */ var listInferiorCandidates = function (current, pending) { var score_m = scoreMatch(current); var score_rest = 0; var toRemove = []; var l = pending.length; for (var i = 0; i < l; i++) { if (isCompatible(current, pending[i])) { continue; } toRemove.push(i); score_rest += scoreMatch(pending[i]); if (score_rest > score_m) { return false; } } return toRemove; }; /* called with all the matches, including the common start and common end, if they exist... A: Common start (should not be replaced) B: potential operations B': satisfactory set of operations C: Common end (should not be replaced) this implementation does not do anything special to protect A and C it is believed that the way matches are produced, they should not be removed. */ var reduceMatches = function (matches) { // ascending sort matches.sort(function (a, b) { return (a.oldIndex + a.newIndex) - (b.oldIndex + b.newIndex); }); var out = []; var l_m = matches.length; var toRemove; for (var i = 0; i < l_m; i++) { toRemove = listInferiorCandidates(matches[i], out); if (toRemove) { removeAscendingIndices(out, toRemove); out.push(matches[i]); } } return out; }; var resolve = function (str, hash, blockSize) { var matches = []; var candidates = []; // do the same thing as was done in hashscan, but for the new string // look for commonalities between new and old data for (var i = 0; i + blockSize <= str.length; i++) { var slice = str.slice(i, i + blockSize); var instances = (hash[slice] || []).slice(0); for (var j = candidates.length - 1; j >= 0; j--) { var c = candidates[j]; var ii = instances.indexOf(c.oldIndex + c.length - blockSize + 1); if (ii > -1) { c.length++; instances.splice(ii, 1); } else { // We're pushing all of the candidates as "matches" and then we're going to sort them // by length and pull out only ones which are non-intersecting because the result // of this function needs to be a set of sequencial non-intersecting matches. matches.push(candidates[j]); //if (candidates.length === 1) { matches.push(candidates[j]); } candidates.splice(j, 1); } } for (var k = 0; k < instances.length; k++) { candidates.push({ newIndex: i, oldIndex: instances[k], length: blockSize }); } //console.log(JSON.stringify(candidates)); } // Normally we would only take one candidate, since they're equal value we just pick one and // use it. However since we need all possible candidates which we will feed to our reduce // function in order to get a list of sequencial non-intersecting matches. // like concat, but destructive Array.prototype.push.apply(matches, candidates); //if (candidates[0]) { matches.push(candidates[0]); } return matches; }; var matchesToOps = function (oldS, newS, matches) { // ascending sort matches.sort(function (a, b) { return a.oldIndex - b.oldIndex; }); var oldI = 0; var newI = 0; var out = []; for (var i = 0; i < matches.length; i++) { var m = matches[i]; out.push(Operation.create(oldI, m.oldIndex - oldI, newS.slice(newI, m.newIndex))); oldI = m.oldIndex + m.length; newI = m.newIndex + m.length; } out.push(Operation.create(oldI, oldS.length - oldI, newS.slice(newI))); // does not check ops if (Common.PARANOIA) { out.forEach(function (op) { if (!op.toRemove || !op.toInsert) { return; } try { Operation.check(op); } catch (e) { console.log('\nINVALID OPERATION'); console.log(oldS); console.log(newS); //console.log(m); console.log('\nMATCHES'); console.log(matches); console.log('\nOPS'); console.log(out); throw e; } }); } return out.filter(function (x) { return x.toRemove || x.toInsert; }); }; var getCommonBeginning = function (oldS, newS) { var commonStart = 0; // This could be Math.min ? var limit = oldS.length < newS.length ? oldS.length : newS.length; while (oldS.charAt(commonStart) === newS.charAt(commonStart) && commonStart < limit) { commonStart++; } return { newIndex: 0, oldIndex: 0, length: commonStart }; }; var getCommonEnd = function (oldS, newS, commonBeginning) { var oldEnd = oldS.length - 1; var newEnd = newS.length - 1; var limit = Math.min(oldEnd, newEnd) - commonBeginning; var commonEnd = 0; while (oldS.charAt(oldEnd) === newS.charAt(newEnd) && limit >= 0) { oldEnd--; newEnd--; commonEnd++; limit--; } return { newIndex: newEnd + 1, oldIndex: oldEnd + 1, length: commonEnd }; }; module.exports.diff = function ( oldS /*:string*/, newS /*:string*/, blockSize /*:?number*/ ) /*:Array<Operation_t>*/ { blockSize = blockSize || DEFAULT_BLOCKSIZE; var cb = getCommonBeginning(oldS, newS); if (cb.length === oldS.length && oldS.length === newS.length) { return []; } var ce = getCommonEnd(oldS, newS, cb.length); var oldST = oldS; var newST = newS; if (ce.length) { oldST = oldST.slice(0, ce.oldIndex+1); newST = newST.slice(0, ce.newIndex+1); } if (cb.length) { oldST = oldST.slice(cb.length); newST = newST.slice(cb.length); } var matches = resolve(newST, hashScan(oldST, blockSize), blockSize); if (cb.length) { for (var i = 0; i < matches.length; i++) { matches[i].oldIndex += cb.length; matches[i].newIndex += cb.length; } matches.push(cb); } if (ce.length) { matches.push(ce); } var reduced = reduceMatches(matches); var ops = matchesToOps(oldS, newS, reduced); // HERE produced operation with negative toRemove if (Operation.applyMulti(ops, oldS) !== newS) { // use 'self' instead of 'window' for node and webworkers var x = (typeof(global) !== 'undefined'? global: self).ChainPad_Diff_DEBUG = { oldS: oldS, newS: newS, matches: matches, reduced: reduced, ops: ops }; console.log(x); console.log("diff did not make a sane patch, check window.ChainPad_Diff_DEBUG"); ops = matchesToOps(oldS, newS, [cb, ce]); if (Operation.applyMulti(ops, oldS) !== newS) { throw new Error("diff is unrecoverable"); } } return ops; }; }, "Patch.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; var Common = require('./Common'); var Operation = require('./Operation'); var Sha = require('./sha256'); var Patch = module.exports; /*:: import type { Operation_t, Operation_Packed_t, Operation_Simplify_t, Operation_Transform_t } from './Operation'; import type { Sha256_t } from './sha256'; export type Patch_t = { type: 'Patch', operations: Array<Operation_t>, parentHash: Sha256_t, isCheckpoint: boolean, mut: { inverseOf: ?Patch_t, } }; export type Patch_Packed_t = Array<Operation_Packed_t|Sha256_t>; export type Patch_Transform_t = ( toTransform:Array<Operation_t>, transformBy:Array<Operation_t>, state0:string ) => Array<Operation_t>; */ var create = Patch.create = function (parentHash /*:Sha256_t*/, isCheckpoint /*:?boolean*/) { var out = Object.freeze({ type: 'Patch', operations: [], parentHash: parentHash, isCheckpoint: !!isCheckpoint, mut: { inverseOf: undefined } }); if (isCheckpoint) { out.mut.inverseOf = out; } return out; }; var check = Patch.check = function (patch /*:any*/, docLength_opt /*:?number*/) /*:Patch_t*/ { 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); } } return patch; }; Patch.toObj = function (patch /*:Patch_t*/) { if (Common.PARANOIA) { check(patch); } var out /*:Array<Operation_Packed_t|Sha256_t>*/ = 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; }; Patch.fromObj = function (obj /*:Patch_Packed_t*/, isCheckpoint /*:?boolean*/) { Common.assert(Array.isArray(obj) && obj.length > 0); var patch = create(Sha.check(obj[obj.length-1]), isCheckpoint); var i; for (i = 0; i < obj.length-1; i++) { patch.operations[i] = Operation.fromObj(obj[i]); } if (Common.PARANOIA) { check(patch); } return patch; }; var hash = function (text) { return Sha.hex_sha256(text); }; var addOperation = Patch.addOperation = function (patch /*:Patch_t*/, op /*:Operation_t*/) { if (Common.PARANOIA) { check(patch); Operation.check(op); } for (var i = 0; i < patch.operations.length; i++) { if (Operation.shouldMerge(patch.operations[i], op)) { var maybeOp = Operation.merge(patch.operations[i], op); patch.operations.splice(i,1); if (maybeOp === null) { return; } op = maybeOp; 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); } }; Patch.createCheckpoint = function ( parentContent /*:string*/, checkpointContent /*:string*/, parentContentHash_opt /*:?string*/) { 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, true); out.operations[0] = op; return out; }; var clone = Patch.clone = function (patch /*:Patch_t*/) { if (Common.PARANOIA) { check(patch); } var out = create(patch.parentHash, patch.isCheckpoint); for (var i = 0; i < patch.operations.length; i++) { out.operations[i] = patch.operations[i]; } return out; }; Patch.merge = function (oldPatch /*:Patch_t*/, newPatch /*:Patch_t*/) { 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; }; Patch.apply = function (patch /*:Patch_t*/, doc /*:string*/) { 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; }; Patch.lengthChange = function (patch /*:Patch_t*/) { 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; }; Patch.invert = function (patch /*:Patch_t*/, doc /*:string*/) { if (Common.PARANOIA) { check(patch); Common.assert(typeof(doc) === 'string'); Common.assert(Sha.hex_sha256(doc) === patch.parentHash); } var newDoc = doc; var operations = new Array(patch.operations.length); for (var i = patch.operations.length-1; i >= 0; i--) { operations[i] = Operation.invert(patch.operations[i], newDoc); newDoc = Operation.apply(patch.operations[i], newDoc); } var opOffsets = new Array(patch.operations.length); (function () { for (var i = operations.length-1; i >= 0; i--) { opOffsets[i] = operations[i].offset; for (var j = i - 1; j >= 0; j--) { opOffsets[i] += operations[j].toRemove - operations[j].toInsert.length; } } }()); var rpatch = create(Sha.hex_sha256(newDoc), patch.isCheckpoint); rpatch.operations.splice(0, rpatch.operations.length); for (var j = 0; j < operations.length; j++) { rpatch.operations[j] = Operation.create(opOffsets[j], operations[j].toRemove, operations[j].toInsert); } if (Common.PARANOIA) { check(rpatch); } return rpatch; }; Patch.simplify = function ( patch /*:Patch_t*/, doc /*:string*/, operationSimplify /*:Operation_Simplify_t*/ ) { if (Common.PARANOIA) { check(patch); Common.assert(typeof(doc) === 'string'); Common.assert(Sha.hex_sha256(doc) === patch.parentHash); } var spatch = create(patch.parentHash); var newDoc = doc; var outOps = []; var j = 0; for (var i = patch.operations.length-1; i >= 0; i--) { var outOp = operationSimplify(patch.operations[i], newDoc, Operation.simplify); if (outOp) { newDoc = Operation.apply(outOp, newDoc); outOps[j++] = outOp; } } Array.prototype.push.apply(spatch.operations, outOps.reverse()); if (!spatch.operations[0]) { spatch.operations.shift(); } if (Common.PARANOIA) { check(spatch); } return spatch; }; Patch.equals = function (patchA /*:Patch_t*/, patchB /*:Patch_t*/) { 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; }; Patch.transform = function ( toTransform /*:Patch_t*/, transformBy /*:Patch_t*/, doc /*:string*/, patchTransformer /*:Patch_Transform_t*/ ) { if (Common.PARANOIA) { check(toTransform, doc.length); check(transformBy, doc.length); if (Sha.hex_sha256(doc) !== toTransform.parentHash) { throw new Error("wrong hash"); } } if (toTransform.parentHash !== transformBy.parentHash) { throw new Error(); } var afterTransformBy = Patch.apply(transformBy, doc); var out = create(transformBy.mut.inverseOf ? transformBy.mut.inverseOf.parentHash : Sha.hex_sha256(afterTransformBy), toTransform.isCheckpoint ); if (transformBy.operations.length === 0) { return clone(toTransform); } if (toTransform.operations.length === 0) { if (toTransform.isCheckpoint) { throw new Error(); } return out; } if (toTransform.isCheckpoint || (toTransform.operations.length === 1 && isCheckpointOp(toTransform.operations[0], doc))) { throw new Error("Attempting to transform a checkpoint, this should not happen"); } if (transformBy.operations.length === 1 && isCheckpointOp(transformBy.operations[0], doc)) { if (!transformBy.isCheckpoint) { throw new Error(); } return toTransform; } if (transformBy.isCheckpoint) { throw new Error(); } var ops = patchTransformer(toTransform.operations, transformBy.operations, doc); Array.prototype.push.apply(out.operations, ops); if (Common.PARANOIA) { check(out, afterTransformBy.length); } return out; }; Patch.random = function (doc /*:string*/, opCount /*:?number*/) { 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; }; Object.freeze(module.exports); }, "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){ /*@flow*/ /* globals localStorage, window */ /* * 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/>. */ "use strict"; module.exports.global = (function () { if (typeof(self) !== 'undefined') { return self; } if (typeof(global) !== 'undefined') { return global; } if (typeof(window) !== 'undefined') { return window; } throw new Error("no self, nor global, nor window"); }()); var cfg = function (name) { if (typeof(localStorage) !== 'undefined' && localStorage[name]) { return localStorage[name]; } // flow thinks global may be undefined return module.exports.global[name]; }; var PARANOIA = module.exports.PARANOIA = cfg("ChainPad_PARANOIA"); /* Good testing but slooooooooooow */ module.exports.VALIDATE_ENTIRE_CHAIN_EACH_MSG = cfg("ChainPad_VALIDATE_ENTIRE_CHAIN_EACH_MSG"); /* throw errors over non-compliant messages which would otherwise be treated as invalid */ module.exports.TESTING = cfg("ChainPad_TESTING"); module.exports.assert = function (expr /*:any*/) { if (!expr) { throw new Error("Failed assertion"); } }; module.exports.isUint = function (integer /*:number*/) { return (typeof(integer) === 'number') && (Math.floor(integer) === integer) && (integer >= 0); }; module.exports.randomASCII = function (length /*:number*/) { var content = []; for (var i = 0; i < length; i++) { content[i] = String.fromCharCode( Math.floor(Math.random()*256) % 57 + 65 ); } return content.join(''); }; module.exports.strcmp = function (a /*:string*/, b /*:string*/) { if (PARANOIA && typeof(a) !== 'string') { throw new Error(); } if (PARANOIA && typeof(b) !== 'string') { throw new Error(); } return ( (a === b) ? 0 : ( (a > b) ? 1 : -1 ) ); }; Object.freeze(module.exports); }, "sha256.js": function(module, exports, require){ /*@flow*/ /* * 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 asm_sha256 = require('./sha256/exports.js'); var old = require('./SHA256.js'); var Common = require('./Common'); /*:: export type Sha256_t = string; */ var brokenTextEncode = function (str) { var out = new Uint8Array(str.length); for (var i = 0; i < str.length; i++) { out[i] = str.charCodeAt(i) & 0xff; } return out; }; module.exports.check = function (hex /*:any*/) /*:Sha256_t*/ { if (typeof(hex) !== 'string') { throw new Error(); } if (!/[a-f0-9]{64}/.test(hex)) { throw new Error(); } return hex; }; module.exports.hex_sha256 = function (d /*:string*/) /*:Sha256_t*/ { d = d+''; var ret = asm_sha256.hex(brokenTextEncode(d)); if (Common.PARANOIA) { var oldHash = old.hex_sha256(d); if (oldHash !== ret) { try { throw new Error(); } catch (e) { console.log({ hashErr: e, badHash: d, asmHasher: asm_sha256.hex, oldHasher: old.hex_sha256 }); } return oldHash; } } return ret; }; Object.freeze(module.exports); }, "Message.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; var Common = require('./Common'); //var Operation = require('./Operation'); var Patch = require('./Patch'); var Sha = require('./sha256'); var Message = module.exports; var PATCH = Message.PATCH = 2; var CHECKPOINT = Message.CHECKPOINT = 4; /*:: import type { Sha256_t } from './sha256' import type { Patch_t } from './Patch' export type Message_Type_t = 2 | 4; export type Message_Status_t = 'accepted'|'initial_state'|'duplicate'|'failed_content_validation'| 'can_be_simplified'|'checkpoint_wrong_parentcount'|'parent_hash_invalid'|'unhandled'; export type Message_t = { type: 'Message', messageType: Message_Type_t, content: Patch_t, lastMsgHash: Sha256_t, hashOf: Sha256_t, mut: { parentCount: ?number, isInitialMessage: boolean, parent: ?Message_t, isFromMe: boolean, recvOrder: number, status: Message_Status_t } } */ var check = Message.check = function(msg /*:any*/) /*:Message_t*/ { Common.assert(msg.type === 'Message'); Common.assert(msg.messageType === PATCH || msg.messageType === CHECKPOINT); Patch.check(msg.content); Common.assert(typeof(msg.lastMsgHash) === 'string'); return msg; }; var DUMMY_HASH /*:Sha256_t*/ = ""; var create = Message.create = function ( type /*:Message_Type_t*/, content /*:Patch_t*/, lastMsgHash /*:Sha256_t*/) /*:Message_t*/ { var msg = { type: 'Message', messageType: type, content: content, lastMsgHash: lastMsgHash, hashOf: DUMMY_HASH, mut: { parentCount: undefined, isInitialMessage: false, isFromMe: false, parent: undefined, recvOrder: -1, status: "unhandled" } }; msg.hashOf = hashOf(msg); if (Common.PARANOIA) { check(msg); } return Object.freeze(msg); }; // $FlowFixMe doesn't like the toString() var toString = Message.toStr = Message.toString = function (msg /*:Message_t*/) { if (Common.PARANOIA) { check(msg); } if (msg.messageType === PATCH || msg.messageType === CHECKPOINT) { if (!msg.content) { throw new Error(); } return JSON.stringify([msg.messageType, Patch.toObj(msg.content), msg.lastMsgHash]); } else { throw new Error(); } }; Message.fromString = function (str /*:string*/) /*:Message_t*/ { 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[0] === CHECKPOINT)), m[2]); return Object.freeze(msg); }; var hashOf = Message.hashOf = function (msg /*:Message_t*/) { if (Common.PARANOIA) { check(msg); } var hash = Sha.hex_sha256(toString(msg)); return hash; }; Object.freeze(module.exports); }, "ChainPad.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; 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 Diff = module.exports.Diff = require('./Diff'); var TextTransformer = module.exports.TextTransformer = require('./transform/TextTransformer'); module.exports.NaiveJSONTransformer = require('./transform/NaiveJSONTransformer'); module.exports.SmartJSONTransformer = require('./transform/SmartJSONTransformer'); // 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 debug = function (realtime, msg) { if (realtime.logLevel > 1) { 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(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 /*:(?string)=>void*/) { if (!realtime.messageHandlers.length) { callback("no onMessage() handler registered"); } try { realtime.messageHandlers.forEach(function (handler) { handler(message, function () { callback.apply(null, arguments); callback = function () { }; }); }); } catch (e) { callback(e.stack); } }; var sendMessage = function (realtime, msg, callback, timeSent) { var strMsg = Message.toStr(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; if (!pending) { throw new Error(); } Common.assert(pending.hash === msg.hashOf); if (handleMessage(realtime, strMsg, true)) { realtime.timeOfLastSuccess = +new Date(); realtime.lag = +new Date() - pending.timeSent; } else { debug(realtime, "Our message [" + msg.hashOf + "] failed validation"); } pending.callback(); } }); var timeout = schedule(realtime, function () { debug(realtime, "Failed to send message [" + msg.hashOf + "] to server"); var pending = realtime.pending; if (pending) { //var timeSent = pending.timeSent; realtime.pending = null; realtime.syncSchedule = -1; } sync(realtime, 0); if (!pending) { throw new Error("INTERNAL ERROR: Message timed out but no realtime.pending"); } }, 10000 + (Math.random() * 5000)); if (realtime.pending) { throw new Error("there is already a pending message"); } if (realtime.timeOfLastSuccess === -1) { realtime.timeOfLastSuccess = +new Date(); } realtime.pending = { hash: msg.hashOf, timeSent: timeSent || +new Date(), callback: function () { unschedule(realtime, timeout); realtime.syncSchedule = schedule(realtime, function () { sync(realtime); }, 0); callback(); } }; if (Common.PARANOIA) { check(realtime); } }; var settle = function (realtime) { var onSettle = realtime.onSettle; realtime.onSettle = []; onSettle.forEach(function (handler) { try { handler(); } catch (e) { warn(realtime, "Error in onSettle handler [" + e.stack + "]"); } }); }; var inversePatch = function (patch) { if (!patch.mut.inverseOf) { throw new Error(); } return patch.mut.inverseOf; }; var sync = function (realtime, timeSent) { 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"); settle(realtime); realtime.timeOfLastSuccess = +new Date(); realtime.syncSchedule = schedule(realtime, function () { sync(realtime); }); return; } var pc = parentCount(realtime, realtime.best) + 1; if ((pc % realtime.config.checkpointInterval) === 0) { var best = realtime.best; debug(realtime, "Sending checkpoint (interval [" + realtime.config.checkpointInterval + "]) patch no [" + pc + "]"); debug(realtime, parentCount(realtime, realtime.best)); if (!best || !best.content || !inversePatch(best.content)) { throw new Error(); } var cpp = Patch.createCheckpoint(realtime.authDoc, realtime.authDoc, inversePatch(best.content).parentHash); var cp = Message.create(Message.CHECKPOINT, cpp, best.hashOf); sendMessage(realtime, cp, function () { debug(realtime, "Checkpoint sent and accepted"); }, timeSent); 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; } }, timeSent); }; 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); msg.mut.status = "accepted"; }; var forgetMessage = function (realtime, msg, reason) { Common.assert(msg.lastMsgHash); Common.assert(msg.hashOf); if (reason) { msg.mut.status = reason; realtime.rejectedBlocks.push(msg); } 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].mut.parent; } } }; var create = function (config) { var zeroPatch = Patch.create(EMPTY_STR_HASH); mkInverse(zeroPatch, ''); var zeroMsg = Message.create(Message.PATCH, zeroPatch, ZERO); zeroMsg.mut.parentCount = 0; zeroMsg.mut.isInitialMessage = true; var best = zeroMsg; var initMsg; if (config.initialState !== '') { var initPatch = Patch.create(EMPTY_STR_HASH); Patch.addOperation(initPatch, Operation.create(0, 0, config.initialState)); mkInverse(initPatch, ''); initMsg = Message.create(Message.PATCH, initPatch, zeroMsg.hashOf); initMsg.mut.isInitialMessage = true; best = initMsg; } var realtime = { type: 'ChainPad', authDoc: config.initialState, config: config, logLevel: config.logLevel, /** A patch representing all uncommitted work. */ uncommitted: Patch.create(inversePatch(best.content).parentHash), patchHandlers: [], changeHandlers: [], messageHandlers: [], schedules: [], aborted: false, syncSchedule: -2, // this is only used if PARANOIA is enabled. userInterfaceContent: config.initialState, // 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: initMsg, // hash and callback for previously send patch, currently in flight. pending: undefined, messages: {}, messagesByParent: {}, rootMessage: zeroMsg, onSettle: [], userName: config.userName, best: best, lag: 0, timeOfLastSuccess: -1, // Incremented every time a message comes in, valid or invalid, used to number messages. recvCounter: 0, // All of the messages which were discarded because they were faulty rejectedBlocks: [] }; storeMessage(realtime, zeroMsg); if (initMsg) { storeMessage(realtime, initMsg); } return realtime; }; var getParent = function (realtime, message) { var parent = message.mut.parent = message.mut.parent || realtime.messages[message.lastMsgHash]; return parent; }; var 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); Common.assert(uiDoc.length === uncommittedDocLength(realtime)); 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(inversePatch(patchMsg.content).parentHash === realtime.uncommitted.parentHash); var patches = []; do { patches.push(patchMsg); doc = Patch.apply(inversePatch(patchMsg.content), doc); } while ((patchMsg = getParent(realtime, patchMsg))); if (realtime.rootMessage.content.isCheckpoint) { if (doc !== realtime.rootMessage.content.operations[0].toInsert) { throw new Error(); } } else if (doc !== '') { throw new Error(); } while ((patchMsg = patches.pop())) { doc = Patch.apply(patchMsg.content, doc); } Common.assert(doc === realtime.authDoc); }; var uncommittedDocLength = function (realtime) { return realtime.authDoc.length + Patch.lengthChange(realtime.uncommitted); }; var doOperation = function (realtime, op) { if (Common.PARANOIA) { check(realtime); realtime.userInterfaceContent = Operation.apply(op, realtime.userInterfaceContent); } Operation.check(op, uncommittedDocLength(realtime)); Patch.addOperation(realtime.uncommitted, op); }; var doPatch = function (realtime, patch) { if (Common.PARANOIA) { check(realtime); Common.assert(Patch.invert(realtime.uncommitted, realtime.authDoc).parentHash === patch.parentHash); realtime.userInterfaceContent = Patch.apply(patch, realtime.userInterfaceContent); } Patch.check(patch, uncommittedDocLength(realtime)); realtime.uncommitted = Patch.merge(realtime.uncommitted, patch); }; var isAncestorOf = function (realtime, ancestor, decendent) { if (!ancestor) { return false; } for (;;) { if (!decendent) { return false; } if (ancestor === decendent) { return true; } decendent = getParent(realtime, decendent); } }; var parentCount = function (realtime, message) { if (typeof(message.mut.parentCount) === 'number') { return message.mut.parentCount; } var msgs = []; for (; (typeof(message.mut.parentCount) !== 'number'); message = getParent(realtime, message)) { if (!message) { if (message === realtime.rootMessage) { throw new Error("root message does not have parent count"); } throw new Error("parentCount called on unlinked message"); } msgs.unshift(message); } var pc = message.mut.parentCount; for (var i = 0; i < msgs.length; i++) { msgs[i].mut.parentCount = ++pc; } return pc; }; var applyPatch = function (realtime, isFromMe, patch) { Common.assert(patch); var newAuthDoc; 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(inversePatch(patch), 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. //debug(realtime, "Transforming patch " + JSON.stringify(realtime.uncommitted.operations)); realtime.uncommitted = Patch.transform( realtime.uncommitted, patch, realtime.authDoc, realtime.config.patchTransformer ); //debug(realtime, "By " + JSON.stringify(patch.operations) + // "\nResult " + JSON.stringify(realtime.uncommitted.operations)); if (realtime.config.validateContent) { newAuthDoc = Patch.apply(patch, realtime.authDoc); var userDoc = Patch.apply(realtime.uncommitted, newAuthDoc); if (!realtime.config.validateContent(userDoc)) { warn(realtime, "Transformed patch is not valid"); // big hammer realtime.uncommitted = Patch.create(Sha.hex_sha256(realtime.authDoc)); } } } Common.assert(realtime.uncommitted.parentHash === inversePatch(patch).parentHash); realtime.authDoc = newAuthDoc || Patch.apply(patch, realtime.authDoc); if (Common.PARANOIA) { Common.assert(realtime.uncommitted.parentHash === inversePatch(patch).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, inversePatch(patch)); }; 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) { return; } // push the uncommittedPatch out to the user interface. realtime.patchHandlers.forEach(function (handler) { handler(patch); }); realtime.changeHandlers.forEach(function (handler) { patch.operations.forEach(function (op) { handler(op.offset, op.toRemove, op.toInsert); }); }); }; var validContent = function (realtime, contentGetter) { try { return realtime.config.validateContent(contentGetter()); } catch (e) { warn(realtime, "Error in content validator [" + e.stack + "]"); } return false; }; var forEachParent = function (realtime, patch, callback) { for (var m = getParent(realtime, patch); m; m = getParent(realtime, m)) { if (callback(m) === false) { return; } } }; var mkInverse = function (patch, content) { if (patch.mut.inverseOf) { return; } var inverse = patch.mut.inverseOf = Patch.invert(patch, content); inverse.mut.inverseOf = patch; }; var handleMessage = function (realtime, msgStr, isFromMe) { if (Common.PARANOIA) { check(realtime); } var msg = Message.fromString(msgStr); msg.mut.recvOrder = realtime.recvCounter++; 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 { msg.mut.status = "duplicate"; realtime.rejectedBlocks.push(msg); if (msg.content.isCheckpoint) { debug(realtime, "[" + (isFromMe ? "our" : "their") + "] Checkpoint [" + msg.hashOf + "] is already known"); return true; } 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"); msg.mut.status = "failed_content_validation"; realtime.rejectedBlocks.push(msg); return; } storeMessage(realtime, msg); if (!isAncestorOf(realtime, realtime.rootMessage, msg)) { if (msg.content.isCheckpoint && realtime.best.mut.isInitialMessage) { // We're starting with a trucated chain from a checkpoint, we will adopt this // as the root message and go with it... debug(realtime, 'applying checkpoint [' + msg.hashOf + ']'); 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.mut.parentCount = 0; realtime.rootMessage = realtime.best = msg; realtime.authDoc = msg.content.operations[0].toInsert; realtime.uncommitted = Patch.create(Sha.hex_sha256(realtime.authDoc)); pushUIPatch(realtime, fixUserDocPatch); if (Common.PARANOIA) { realtime.userInterfaceContent = realtime.authDoc; } return true; } else { // we'll probably find the missing parent later. debug(realtime, "Patch [" + msg.hashOf + "] not connected to root (parent: [" + msg.lastMsgHash + "])"); 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.mut.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 true; } } // 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; toRevert.forEach(function (tr) { authDocAtTimeOfPatch = Patch.apply(inversePatch(tr.content), authDocAtTimeOfPatch); }); toApply.forEach(function (ta, i) { // toApply.length-1 because we do not want to apply the new patch. if (i === toApply.length - 1) { return; } mkInverse(ta.content, authDocAtTimeOfPatch); authDocAtTimeOfPatch = Patch.apply(ta.content, authDocAtTimeOfPatch); }); var headAtTimeOfPatch = realtime.best; if (toApply.length > 1) { headAtTimeOfPatch = toApply[toApply.length-2]; Common.assert(headAtTimeOfPatch); } else if (toRevert.length) { headAtTimeOfPatch = getParent(realtime, toRevert[toRevert.length-1]); Common.assert(headAtTimeOfPatch); } Common.assert(inversePatch(headAtTimeOfPatch.content).parentHash); Common.assert(!Common.PARANOIA || inversePatch(headAtTimeOfPatch.content).parentHash === Sha.hex_sha256(authDocAtTimeOfPatch)); if (inversePatch(headAtTimeOfPatch.content).parentHash !== 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, "parent_hash_invalid"); return; } if (patch.isCheckpoint && realtime.config.noPrune) { // do nothing, just fall through } else if (patch.isCheckpoint) { // Ok, we have a checkpoint patch. // If the chain length is not equal to checkpointInterval then this patch is invalid. var checkpointP; forEachParent(realtime, msg, function (m) { if (m.content.isCheckpoint) { if (checkpointP) { checkpointP = m; return false; } 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, "checkpoint_wrong_parentcount"); return; } // Time to prune some old messages from the chain debug(realtime, "checkpoint [" + msg.hashOf + "]"); forEachParent(realtime, checkpointP, function (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, "can_be_simplified"); return; } if (!validContent(realtime, function () { return Patch.apply(patch, authDocAtTimeOfPatch); })) { debug(realtime, "Patch [" + msg.hashOf + "] failed content validation"); return; } } mkInverse(patch, authDocAtTimeOfPatch); 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); toRevert.forEach(function (tr) { debug(realtime, "reverting [" + tr.hashOf + "]"); if (tr.mut.isFromMe) { debug(realtime, "reverting patch 'from me' [" + JSON.stringify(tr.content.operations) + "]"); } uncommittedPatch = Patch.merge(uncommittedPatch, inversePatch(tr.content)); revertPatch(realtime, tr.mut.isFromMe, tr.content); }); toApply.forEach(function (ta) { debug(realtime, "applying [" + ta.hashOf + "]"); uncommittedPatch = Patch.merge(uncommittedPatch, ta.content); applyPatch(realtime, ta.mut.isFromMe, ta.content); }); uncommittedPatch = Patch.merge(uncommittedPatch, realtime.uncommitted); uncommittedPatch = Patch.simplify( uncommittedPatch, oldUserInterfaceContent, realtime.config.operationSimplify); realtime.best = msg; if (Common.PARANOIA) { // apply the uncommittedPatch to the userInterface content. var newUserInterfaceContent = Patch.apply(uncommittedPatch, oldUserInterfaceContent); Common.assert(realtime.userInterfaceContent.length === uncommittedDocLength(realtime)); Common.assert(newUserInterfaceContent === realtime.userInterfaceContent); } pushUIPatch(realtime, uncommittedPatch); if (!realtime.uncommitted.operations.length) { settle(realtime); } if (Common.PARANOIA) { check(realtime); } return true; }; var getDepthOfState = function (content, minDepth, realtime) { Common.assert(typeof(content) === 'string'); // minimum depth is an optional argument which defaults to zero 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; }; var getContentAtState = function (realtime, msg, previousDoc) { var patches = [ msg ]; var doc = previousDoc || ''; if (!previousDoc) { while (patches[0] !== realtime.rootMessage) { var parent = getParent(realtime, patches[0]); if (!parent) { return { error: 'not connected to root', doc: undefined }; } patches.unshift(parent); } if (realtime.rootMessage.content.operations.length) { Common.assert(realtime.rootMessage.content.operations.length === 1); doc = realtime.rootMessage.content.operations[0].toInsert; } } for (var i = previousDoc?0:1; i < patches.length; i++) { doc = Patch.apply(patches[i].content, doc); } return { error: undefined, doc: doc }; }; /*:: import type { Message_Status_t } from './Message.js'; export type ChainPad_BlockContent_t = { error: ?string, doc: ?string }; export type ChainPad_Block_t = { type: 'Block', hashOf: string, lastMsgHash: string, isCheckpoint: boolean, status: Message_Status_t, recvOrder: number, parentCount: number, getParent: ()=>?ChainPad_Block_t, getChildren: ()=>Array<ChainPad_Block_t>, getContent: (?string)=>{ error: ?string, doc: ?string }, getPatch: ()=>Patch_t, getInversePatch: ()=>Patch_t, equals: (?ChainPad_Block_t, ?any)=>boolean }; */ var wrapMessage = function (realtime, msg) /*:ChainPad_Block_t*/ { var pc = -1; try { pc = parentCount(realtime, msg); } catch (e) { } return Object.freeze({ type: 'Block', hashOf: msg.hashOf, lastMsgHash: msg.lastMsgHash, isCheckpoint: !!msg.content.isCheckpoint, status: msg.mut.status, recvOrder: msg.mut.recvOrder, parentCount: pc, getParent: function () { var parentMsg = getParent(realtime, msg); if (parentMsg) { return wrapMessage(realtime, parentMsg); } }, getChildren: function () { return (realtime.messagesByParent[msg.hashOf] || []).map(function (x) { return wrapMessage(realtime, x); }); }, getContent: function (previous) { return getContentAtState(realtime, msg, previous); }, getPatch: function () { return Patch.clone(msg.content); }, getInversePatch: function () { return Patch.clone(inversePatch(msg.content)); }, equals: function (block, msgOpt) { if (msgOpt) { return msg === msgOpt; } if (!block || typeof(block) !== 'object' || block.type !== 'Block') { return false; } return block.equals(block, msg); } }); }; var mkConfig = function (config) { config = config || {}; if (config.transformFunction) { throw new Error("chainpad config transformFunction is nolonger used"); } return Object.freeze({ initialState: config.initialState || '', checkpointInterval: config.checkpointInterval || DEFAULT_CHECKPOINT_INTERVAL, avgSyncMilliseconds: config.avgSyncMilliseconds || DEFAULT_AVERAGE_SYNC_MILLISECONDS, strictCheckpointValidation: config.strictCheckpointValidation || DEFAULT_STRICT_CHECKPOINT_VALIDATION, operationSimplify: config.operationSimplify || Operation.simplify, logLevel: (typeof(config.logLevel) === 'number') ? config.logLevel : 2, noPrune: config.noPrune, patchTransformer: config.patchTransformer || TextTransformer, userName: config.userName || 'anonymous', validateContent: config.validateContent || function (x) { x = x; return true; }, diffFunction: config.diffFunction || function (strA, strB /*:string*/) { return Diff.diff(strA, strB, config.diffBlockSize); }, }); }; /*:: import type { Operation_Transform_t } from './Operation'; import type { Operation_Simplify_t } from './Operation'; import type { Operation_t } from './Operation'; import type { Patch_t } from './Patch'; import type { Patch_Transform_t } from './Patch'; export type ChainPad_Config_t = { initialState?: string, checkpointInterval?: number, avgSyncMilliseconds?: number, validateContent?: (string)=>boolean, strictCheckpointValidation?: boolean, patchTransformer?: Patch_Transform_t, operationSimplify?: Operation_Simplify_t, logLevel?: number, userName?: string, noPrune?: boolean, diffFunction?: (string, string)=>Array<Operation_t>, diffBlockSize?: number }; */ module.exports.create = function (conf /*:ChainPad_Config_t*/) { var realtime = create(mkConfig(conf)); var out = { onPatch: function (handler /*:(Patch_t)=>void*/) { Common.assert(typeof(handler) === 'function'); realtime.patchHandlers.push(handler); }, patch: function (patch /*:Patch_t|number*/, x /*:?number*/, y /*:?string*/) { if (typeof(patch) === 'number') { // Actually they meant to call realtime.change() if (typeof(x) !== 'number' || typeof(y) !== 'string') { throw new Error(); } out.change(patch, x, y); return; } doPatch(realtime, patch); }, onChange: function (handler /*:(number, number, string)=>void*/) { Common.assert(typeof(handler) === 'function'); realtime.changeHandlers.push(handler); }, change: function (offset /*:number*/, count /*:number*/, chars /*:string*/) { if (count === 0 && chars === '') { return; } doOperation(realtime, Operation.create(offset, count, chars)); }, contentUpdate: function (newContent /*:string*/) { var ops = realtime.config.diffFunction(realtime.authDoc, newContent); var uncommitted = Patch.create(realtime.uncommitted.parentHash); Array.prototype.push.apply(uncommitted.operations, ops); realtime.uncommitted = uncommitted; }, onMessage: function (handler /*:(string, ()=>void)=>void*/) { Common.assert(typeof(handler) === 'function'); realtime.messageHandlers.push(handler); }, message: function (message /*:string*/) { handleMessage(realtime, message, false); }, /// Control functions start: function () { realtime.aborted = false; if (realtime.syncSchedule) { unschedule(realtime, realtime.syncSchedule); } realtime.pending = null; realtime.syncSchedule = schedule(realtime, function () { sync(realtime); }); }, abort: function () { realtime.aborted = true; realtime.schedules.forEach(function (s) { clearTimeout(s); }); }, sync: function () { sync(realtime); }, getAuthDoc: function () { return realtime.authDoc; }, getUserDoc: function () { return Patch.apply(realtime.uncommitted, realtime.authDoc); }, getDepthOfState: function (content /*:string*/, minDepth /*:?number*/) { return getDepthOfState(content, minDepth, realtime); }, onSettle: function (handler /*:()=>void*/) { Common.assert(typeof(handler) === 'function'); realtime.onSettle.push(handler); }, getAuthBlock: function () { return wrapMessage(realtime, realtime.best); }, getBlockForHash: function (hash /*:string*/) { Common.assert(typeof(hash) === 'string'); var msg = realtime.messages[hash]; if (msg) { return wrapMessage(realtime, msg); } }, getBlockHashes: function () { return Object.keys(realtime.messages); }, getRootBlock: function () { return wrapMessage(realtime, realtime.rootMessage); }, getRejectedBlock: function (number /*:number*/) { var msg = realtime.rejectedBlocks[number]; return msg ? wrapMessage(realtime, msg) : undefined; }, getLag: function () { var isPending = !!realtime.pending; var lag = realtime.lag; if (realtime.pending) { lag = +new Date() - realtime.timeOfLastSuccess; } return { pending: isPending, lag: lag, active: (!realtime.aborted && realtime.syncSchedule !== -2) }; }, _: undefined }; out._ = realtime; return Object.freeze(out); }; Object.freeze(module.exports); }, "Operation.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; var Common = require('./Common'); var Operation = module.exports; /*:: export type Operation_t = { type: 'Operation', offset: number, toRemove: number, toInsert: string }; export type Operation_Packed_t = [number, number, string]; export type Operation_Simplify_t = (Operation_t, string, typeof(Operation.simplify))=>?Operation_t; export type Operation_Transform_t = (string, Operation_t, Operation_t)=>?Operation_t; */ var check = Operation.check = function (op /*:any*/, docLength_opt /*:?number*/) /*:Operation_t*/ { Common.assert(op.type === 'Operation'); if (!Common.isUint(op.offset)) { throw new Error(); } if (!Common.isUint(op.toRemove)) { throw new Error(); } if (typeof(op.toInsert) !== 'string') { throw new Error(); } if (op.toRemove < 1 && op.toInsert.length < 1) { throw new Error(); } Common.assert(typeof(docLength_opt) !== 'number' || op.offset + op.toRemove <= docLength_opt); return op; }; var create = Operation.create = function ( offset /*:?number*/, toRemove /*:?number*/, toInsert /*:?string*/) { var out = { type: 'Operation', offset: offset || 0, toRemove: toRemove || 0, toInsert: toInsert || '', }; if (Common.PARANOIA) { check(out); } return Object.freeze(out); }; Operation.toObj = function (op /*:Operation_t*/) { if (Common.PARANOIA) { check(op); } return [op.offset,op.toRemove,op.toInsert]; }; // Allow any as input because we assert its type internally.. Operation.fromObj = function (obj /*:any*/) { Common.assert(Array.isArray(obj) && obj.length === 3); return create(obj[0], obj[1], obj[2]); }; /** * @param op the operation to apply. * @param doc the content to apply the operation on */ var apply = Operation.apply = function (op /*:Operation_t*/, doc /*:string*/) { if (Common.PARANOIA) { Common.assert(typeof(doc) === 'string'); check(op, doc.length); } return doc.substring(0,op.offset) + op.toInsert + doc.substring(op.offset + op.toRemove); }; Operation.applyMulti = function (ops /*:Array<Operation_t>*/, doc /*:string*/) { for (var i = ops.length - 1; i >= 0; i--) { doc = apply(ops[i], doc); } return doc; }; var invert = Operation.invert = function (op /*:Operation_t*/, doc /*:string*/) { if (Common.PARANOIA) { check(op); Common.assert(typeof(doc) === 'string'); Common.assert(op.offset + op.toRemove <= doc.length); } return create( op.offset, op.toInsert.length, doc.substring(op.offset, op.offset + op.toRemove) ); }; // see http://unicode.org/faq/utf_bom.html#utf16-7 var surrogatePattern = /[\uD800-\uDBFF]|[\uDC00-\uDFFF]/; var hasSurrogate = Operation.hasSurrogate = function(str /*:string*/) { return surrogatePattern.test(str); }; /** * ATTENTION: This function is not just a neat way to make patches smaller, it's * actually part of the ChainPad consensus rules, so if you have a clever * idea to make it a bit faster, it is going to cause ChainPad to reject * old patches, which means when you go to load the history of a pad, you're * sunk. * tl;dr can't touch this */ Operation.simplify = function (op /*:Operation_t*/, doc /*:string*/) { if (Common.PARANOIA) { check(op); Common.assert(typeof(doc) === 'string'); Common.assert(op.offset + op.toRemove <= doc.length); } var rop = invert(op, doc); var minLen = Math.min(op.toInsert.length, rop.toInsert.length); var i = 0; while (i < minLen && rop.toInsert[i] === op.toInsert[i]) { if (hasSurrogate(rop.toInsert[i]) || hasSurrogate(op.toInsert[i])) { if (op.toInsert[i + 1] === rop.toInsert[i + 1]) { i++; } else { break; } } i++; } var opOffset = op.offset + i; var opToRemove = op.toRemove - i; var opToInsert = op.toInsert.substring(i); var ropToInsert = rop.toInsert.substring(i); if (ropToInsert.length === opToInsert.length) { for (i = ropToInsert.length-1; i >= 0 && ropToInsert[i] === opToInsert[i]; i--) ; opToInsert = opToInsert.substring(0, i+1); opToRemove = i+1; } if (opToRemove === 0 && opToInsert.length === 0) { return null; } return create(opOffset, opToRemove, opToInsert); }; Operation.equals = function (opA /*:Operation_t*/, opB /*:Operation_t*/) { return (opA.toRemove === opB.toRemove && opA.toInsert === opB.toInsert && opA.offset === opB.offset); }; Operation.lengthChange = function (op /*:Operation_t*/) { 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. */ Operation.merge = function (oldOpOrig /*:Operation_t*/, newOpOrig /*:Operation_t*/) { if (Common.PARANOIA) { check(newOpOrig); check(oldOpOrig); } var oldOp_offset = oldOpOrig.offset; var oldOp_toRemove = oldOpOrig.toRemove; var oldOp_toInsert = oldOpOrig.toInsert; var newOp_offset = newOpOrig.offset; var newOp_toRemove = newOpOrig.toRemove; var newOp_toInsert = newOpOrig.toInsert; 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; } return create(oldOp_offset, oldOp_toRemove, oldOp_toInsert); }; /** * 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. */ Operation.shouldMerge = function (oldOp /*:Operation_t*/, newOp /*:Operation_t*/) { 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. */ Operation.rebase = function (oldOp /*:Operation_t*/, newOp /*:Operation_t*/) { if (Common.PARANOIA) { check(oldOp); check(newOp); } if (newOp.offset < oldOp.offset) { return newOp; } return create( newOp.offset + oldOp.toRemove - oldOp.toInsert.length, newOp.toRemove, newOp.toInsert ); }; /** Used for testing. */ Operation.random = function (docLength /*:number*/) { 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 { toInsert = Common.randomASCII(Math.floor(Math.random() * 20)); } while (toRemove === 0 && toInsert === ''); return create(offset, toRemove, toInsert); }; Object.freeze(module.exports); }, "sha256/hash.js": function(module, exports, require){ var Utils = require('./utils.js'); function hash_reset () { this.result = null; this.pos = 0; this.len = 0; this.asm.reset(); return this; } function hash_process ( data ) { if ( this.result !== null ) throw new IllegalStateError("state must be reset before processing new data"); if ( Utils.is_string(data) ) data = Utils.string_to_bytes(data); if ( Utils.is_buffer(data) ) data = new Uint8Array(data); if ( !Utils.is_bytes(data) ) throw new TypeError("data isn't of expected type"); var asm = this.asm, heap = this.heap, hpos = this.pos, hlen = this.len, dpos = 0, dlen = data.length, wlen = 0; while ( dlen > 0 ) { wlen = Utils._heap_write( heap, hpos+hlen, data, dpos, dlen ); hlen += wlen; dpos += wlen; dlen -= wlen; wlen = asm.process( hpos, hlen ); hpos += wlen; hlen -= wlen; if ( !hlen ) hpos = 0; } this.pos = hpos; this.len = hlen; return this; } function hash_finish () { if ( this.result !== null ) throw new IllegalStateError("state must be reset before processing new data"); this.asm.finish( this.pos, this.len, 0 ); this.result = new Uint8Array(this.HASH_SIZE); this.result.set( this.heap.subarray( 0, this.HASH_SIZE ) ); this.pos = 0; this.len = 0; return this; } module.exports.hash_reset = hash_reset; module.exports.hash_process = hash_process; module.exports.hash_finish = hash_finish; }, "sha256/utils.js": function(module, exports, require){ //var FloatArray = global.Float64Array || global.Float32Array; // make PhantomJS happy var string_to_bytes = module.exports.string_to_bytes = function( str, utf8 ) { utf8 = !!utf8; var len = str.length, bytes = new Uint8Array( utf8 ? 4*len : len ); for ( var i = 0, j = 0; i < len; i++ ) { var c = str.charCodeAt(i); if ( utf8 && 0xd800 <= c && c <= 0xdbff ) { if ( ++i >= len ) throw new Error( "Malformed string, low surrogate expected at position " + i ); c = ( (c ^ 0xd800) << 10 ) | 0x10000 | ( str.charCodeAt(i) ^ 0xdc00 ); } else if ( !utf8 && c >>> 8 ) { throw new Error("Wide characters are not allowed."); } if ( !utf8 || c <= 0x7f ) { bytes[j++] = c; } else if ( c <= 0x7ff ) { bytes[j++] = 0xc0 | (c >> 6); bytes[j++] = 0x80 | (c & 0x3f); } else if ( c <= 0xffff ) { bytes[j++] = 0xe0 | (c >> 12); bytes[j++] = 0x80 | (c >> 6 & 0x3f); bytes[j++] = 0x80 | (c & 0x3f); } else { bytes[j++] = 0xf0 | (c >> 18); bytes[j++] = 0x80 | (c >> 12 & 0x3f); bytes[j++] = 0x80 | (c >> 6 & 0x3f); bytes[j++] = 0x80 | (c & 0x3f); } } return bytes.subarray(0, j); }; var hex_to_bytes = module.exports.hex_to_bytes = function( str ) { var len = str.length; if ( len & 1 ) { str = '0'+str; len++; } var bytes = new Uint8Array(len>>1); for ( var i = 0; i < len; i += 2 ) { bytes[i>>1] = parseInt( str.substr( i, 2), 16 ); } return bytes; }; var base64_to_bytes = module.exports.base64_to_bytes = function( str ) { return string_to_bytes( atob( str ) ); }; var bytes_to_string = module.exports.bytes_to_string = function( bytes, utf8 ) { utf8 = !!utf8; var len = bytes.length, chars = new Array(len); for ( var i = 0, j = 0; i < len; i++ ) { var b = bytes[i]; if ( !utf8 || b < 128 ) { chars[j++] = b; } else if ( b >= 192 && b < 224 && i+1 < len ) { chars[j++] = ( (b & 0x1f) << 6 ) | (bytes[++i] & 0x3f); } else if ( b >= 224 && b < 240 && i+2 < len ) { chars[j++] = ( (b & 0xf) << 12 ) | ( (bytes[++i] & 0x3f) << 6 ) | (bytes[++i] & 0x3f); } else if ( b >= 240 && b < 248 && i+3 < len ) { var c = ( (b & 7) << 18 ) | ( (bytes[++i] & 0x3f) << 12 ) | ( (bytes[++i] & 0x3f) << 6 ) | (bytes[++i] & 0x3f); if ( c <= 0xffff ) { chars[j++] = c; } else { c ^= 0x10000; chars[j++] = 0xd800 | (c >> 10); chars[j++] = 0xdc00 | (c & 0x3ff); } } else { throw new Error("Malformed UTF8 character at byte offset " + i); } } var str = '', bs = 16384; for ( var _i = 0; _i < j; _i += bs ) { str += String.fromCharCode.apply( String, chars.slice( _i, _i+bs <= j ? _i+bs : j ) ); } return str; }; var bytes_to_hex = module.exports.bytes_to_hex = function( arr ) { var str = ''; for ( var i = 0; i < arr.length; i++ ) { var h = ( arr[i] & 0xff ).toString(16); if ( h.length < 2 ) str += '0'; str += h; } return str; }; var bytes_to_base64 = module.exports.bytes_to_base64 = function( arr ) { return btoa( bytes_to_string(arr) ); }; var pow2_ceil = module.exports.pow2_ceil = function( a ) { a -= 1; a |= a >>> 1; a |= a >>> 2; a |= a >>> 4; a |= a >>> 8; a |= a >>> 16; a += 1; return a; }; var is_number = module.exports.is_number = function( a ) { return ( typeof a === 'number' ); }; var is_string = module.exports.is_string = function( a ) { return ( typeof a === 'string' ); }; var is_buffer = module.exports.is_buffer = function( a ) { return ( a instanceof ArrayBuffer ); }; var is_bytes = module.exports.is_bytes = function( a ) { return ( a instanceof Uint8Array ); }; var is_typed_array = module.exports.is_typed_array = function( a ) { return ( a instanceof Int8Array ) || ( a instanceof Uint8Array ) || ( a instanceof Int16Array ) || ( a instanceof Uint16Array ) || ( a instanceof Int32Array ) || ( a instanceof Uint32Array ) || ( a instanceof Float32Array ) || ( a instanceof Float64Array ); }; var _heap_init = module.exports._heap_init = function( constructor, options ) { var heap = options.heap, size = heap ? heap.byteLength : options.heapSize || 65536; if ( size & 0xfff || size <= 0 ) throw new Error("heap size must be a positive integer and a multiple of 4096"); heap = heap || new constructor( new ArrayBuffer(size) ); return heap; }; var _heap_write = module.exports._heap_write = function( heap, hpos, data, dpos, dlen ) { var hlen = heap.length - hpos, wlen = ( hlen < dlen ) ? hlen : dlen; heap.set( data.subarray( dpos, dpos+wlen ), hpos ); return wlen; }; }, "sha256/sha256.js": function(module, exports, require){ var Utils = require('./utils.js'); var Hash = require('./hash.js'); var Asm = require('./sha256.asm.js'); var _sha256_block_size = 64, _sha256_hash_size = 32; function sha256_constructor ( options ) { options = options || {}; this.heap = Utils._heap_init( Uint8Array, options ); this.asm = options.asm || Asm.sha256_asm( { Uint8Array: Uint8Array }, null, this.heap.buffer ); this.BLOCK_SIZE = _sha256_block_size; this.HASH_SIZE = _sha256_hash_size; this.reset(); } sha256_constructor.BLOCK_SIZE = _sha256_block_size; sha256_constructor.HASH_SIZE = _sha256_hash_size; var sha256_prototype = sha256_constructor.prototype; sha256_prototype.reset = Hash.hash_reset; sha256_prototype.process = Hash.hash_process; sha256_prototype.finish = Hash.hash_finish; var sha256_instance = null; function get_sha256_instance () { if ( sha256_instance === null ) sha256_instance = new sha256_constructor( { heapSize: 0x100000 } ); return sha256_instance; } module.exports.get_sha256_instance = get_sha256_instance; module.exports.sha256_constructor = sha256_constructor; }, "sha256/exports.js": function(module, exports, require){ var Sha256 = require('./sha256.js'); var Utils = require('./utils.js'); /** * SHA256 exports */ function sha256_bytes ( data ) { if ( data === undefined ) throw new SyntaxError("data required"); return Sha256.get_sha256_instance().reset().process(data).finish().result; } function sha256_hex ( data ) { var result = sha256_bytes(data); return Utils.bytes_to_hex(result); } function sha256_base64 ( data ) { var result = sha256_bytes(data); return Utils.bytes_to_base64(result); } Sha256.sha256_constructor.bytes = sha256_bytes; Sha256.sha256_constructor.hex = sha256_hex; Sha256.sha256_constructor.base64 = sha256_base64; //exports.SHA256 = sha256_constructor; module.exports = Sha256.sha256_constructor; }, "sha256/sha256.asm.js": function(module, exports, require){ module.exports.sha256_asm = function sha256_asm ( stdlib, foreign, buffer ) { "use asm"; // SHA256 state var H0 = 0, H1 = 0, H2 = 0, H3 = 0, H4 = 0, H5 = 0, H6 = 0, H7 = 0, TOTAL0 = 0, TOTAL1 = 0; // HMAC state var I0 = 0, I1 = 0, I2 = 0, I3 = 0, I4 = 0, I5 = 0, I6 = 0, I7 = 0, O0 = 0, O1 = 0, O2 = 0, O3 = 0, O4 = 0, O5 = 0, O6 = 0, O7 = 0; // I/O buffer var HEAP = new stdlib.Uint8Array(buffer); function _core ( w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15 ) { w0 = w0|0; w1 = w1|0; w2 = w2|0; w3 = w3|0; w4 = w4|0; w5 = w5|0; w6 = w6|0; w7 = w7|0; w8 = w8|0; w9 = w9|0; w10 = w10|0; w11 = w11|0; w12 = w12|0; w13 = w13|0; w14 = w14|0; w15 = w15|0; var a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, t = 0; a = H0; b = H1; c = H2; d = H3; e = H4; f = H5; g = H6; h = H7; // 0 t = ( w0 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x428a2f98 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 1 t = ( w1 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x71374491 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 2 t = ( w2 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xb5c0fbcf )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 3 t = ( w3 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xe9b5dba5 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 4 t = ( w4 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x3956c25b )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 5 t = ( w5 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x59f111f1 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 6 t = ( w6 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x923f82a4 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 7 t = ( w7 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xab1c5ed5 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 8 t = ( w8 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xd807aa98 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 9 t = ( w9 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x12835b01 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 10 t = ( w10 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x243185be )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 11 t = ( w11 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x550c7dc3 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 12 t = ( w12 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x72be5d74 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 13 t = ( w13 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x80deb1fe )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 14 t = ( w14 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x9bdc06a7 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 15 t = ( w15 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xc19bf174 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 16 w0 = t = ( ( w1>>>7 ^ w1>>>18 ^ w1>>>3 ^ w1<<25 ^ w1<<14 ) + ( w14>>>17 ^ w14>>>19 ^ w14>>>10 ^ w14<<15 ^ w14<<13 ) + w0 + w9 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xe49b69c1 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 17 w1 = t = ( ( w2>>>7 ^ w2>>>18 ^ w2>>>3 ^ w2<<25 ^ w2<<14 ) + ( w15>>>17 ^ w15>>>19 ^ w15>>>10 ^ w15<<15 ^ w15<<13 ) + w1 + w10 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xefbe4786 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 18 w2 = t = ( ( w3>>>7 ^ w3>>>18 ^ w3>>>3 ^ w3<<25 ^ w3<<14 ) + ( w0>>>17 ^ w0>>>19 ^ w0>>>10 ^ w0<<15 ^ w0<<13 ) + w2 + w11 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x0fc19dc6 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 19 w3 = t = ( ( w4>>>7 ^ w4>>>18 ^ w4>>>3 ^ w4<<25 ^ w4<<14 ) + ( w1>>>17 ^ w1>>>19 ^ w1>>>10 ^ w1<<15 ^ w1<<13 ) + w3 + w12 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x240ca1cc )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 20 w4 = t = ( ( w5>>>7 ^ w5>>>18 ^ w5>>>3 ^ w5<<25 ^ w5<<14 ) + ( w2>>>17 ^ w2>>>19 ^ w2>>>10 ^ w2<<15 ^ w2<<13 ) + w4 + w13 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x2de92c6f )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 21 w5 = t = ( ( w6>>>7 ^ w6>>>18 ^ w6>>>3 ^ w6<<25 ^ w6<<14 ) + ( w3>>>17 ^ w3>>>19 ^ w3>>>10 ^ w3<<15 ^ w3<<13 ) + w5 + w14 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x4a7484aa )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 22 w6 = t = ( ( w7>>>7 ^ w7>>>18 ^ w7>>>3 ^ w7<<25 ^ w7<<14 ) + ( w4>>>17 ^ w4>>>19 ^ w4>>>10 ^ w4<<15 ^ w4<<13 ) + w6 + w15 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x5cb0a9dc )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 23 w7 = t = ( ( w8>>>7 ^ w8>>>18 ^ w8>>>3 ^ w8<<25 ^ w8<<14 ) + ( w5>>>17 ^ w5>>>19 ^ w5>>>10 ^ w5<<15 ^ w5<<13 ) + w7 + w0 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x76f988da )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 24 w8 = t = ( ( w9>>>7 ^ w9>>>18 ^ w9>>>3 ^ w9<<25 ^ w9<<14 ) + ( w6>>>17 ^ w6>>>19 ^ w6>>>10 ^ w6<<15 ^ w6<<13 ) + w8 + w1 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x983e5152 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 25 w9 = t = ( ( w10>>>7 ^ w10>>>18 ^ w10>>>3 ^ w10<<25 ^ w10<<14 ) + ( w7>>>17 ^ w7>>>19 ^ w7>>>10 ^ w7<<15 ^ w7<<13 ) + w9 + w2 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xa831c66d )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 26 w10 = t = ( ( w11>>>7 ^ w11>>>18 ^ w11>>>3 ^ w11<<25 ^ w11<<14 ) + ( w8>>>17 ^ w8>>>19 ^ w8>>>10 ^ w8<<15 ^ w8<<13 ) + w10 + w3 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xb00327c8 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 27 w11 = t = ( ( w12>>>7 ^ w12>>>18 ^ w12>>>3 ^ w12<<25 ^ w12<<14 ) + ( w9>>>17 ^ w9>>>19 ^ w9>>>10 ^ w9<<15 ^ w9<<13 ) + w11 + w4 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xbf597fc7 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 28 w12 = t = ( ( w13>>>7 ^ w13>>>18 ^ w13>>>3 ^ w13<<25 ^ w13<<14 ) + ( w10>>>17 ^ w10>>>19 ^ w10>>>10 ^ w10<<15 ^ w10<<13 ) + w12 + w5 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xc6e00bf3 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 29 w13 = t = ( ( w14>>>7 ^ w14>>>18 ^ w14>>>3 ^ w14<<25 ^ w14<<14 ) + ( w11>>>17 ^ w11>>>19 ^ w11>>>10 ^ w11<<15 ^ w11<<13 ) + w13 + w6 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xd5a79147 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 30 w14 = t = ( ( w15>>>7 ^ w15>>>18 ^ w15>>>3 ^ w15<<25 ^ w15<<14 ) + ( w12>>>17 ^ w12>>>19 ^ w12>>>10 ^ w12<<15 ^ w12<<13 ) + w14 + w7 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x06ca6351 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 31 w15 = t = ( ( w0>>>7 ^ w0>>>18 ^ w0>>>3 ^ w0<<25 ^ w0<<14 ) + ( w13>>>17 ^ w13>>>19 ^ w13>>>10 ^ w13<<15 ^ w13<<13 ) + w15 + w8 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x14292967 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 32 w0 = t = ( ( w1>>>7 ^ w1>>>18 ^ w1>>>3 ^ w1<<25 ^ w1<<14 ) + ( w14>>>17 ^ w14>>>19 ^ w14>>>10 ^ w14<<15 ^ w14<<13 ) + w0 + w9 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x27b70a85 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 33 w1 = t = ( ( w2>>>7 ^ w2>>>18 ^ w2>>>3 ^ w2<<25 ^ w2<<14 ) + ( w15>>>17 ^ w15>>>19 ^ w15>>>10 ^ w15<<15 ^ w15<<13 ) + w1 + w10 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x2e1b2138 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 34 w2 = t = ( ( w3>>>7 ^ w3>>>18 ^ w3>>>3 ^ w3<<25 ^ w3<<14 ) + ( w0>>>17 ^ w0>>>19 ^ w0>>>10 ^ w0<<15 ^ w0<<13 ) + w2 + w11 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x4d2c6dfc )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 35 w3 = t = ( ( w4>>>7 ^ w4>>>18 ^ w4>>>3 ^ w4<<25 ^ w4<<14 ) + ( w1>>>17 ^ w1>>>19 ^ w1>>>10 ^ w1<<15 ^ w1<<13 ) + w3 + w12 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x53380d13 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 36 w4 = t = ( ( w5>>>7 ^ w5>>>18 ^ w5>>>3 ^ w5<<25 ^ w5<<14 ) + ( w2>>>17 ^ w2>>>19 ^ w2>>>10 ^ w2<<15 ^ w2<<13 ) + w4 + w13 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x650a7354 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 37 w5 = t = ( ( w6>>>7 ^ w6>>>18 ^ w6>>>3 ^ w6<<25 ^ w6<<14 ) + ( w3>>>17 ^ w3>>>19 ^ w3>>>10 ^ w3<<15 ^ w3<<13 ) + w5 + w14 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x766a0abb )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 38 w6 = t = ( ( w7>>>7 ^ w7>>>18 ^ w7>>>3 ^ w7<<25 ^ w7<<14 ) + ( w4>>>17 ^ w4>>>19 ^ w4>>>10 ^ w4<<15 ^ w4<<13 ) + w6 + w15 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x81c2c92e )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 39 w7 = t = ( ( w8>>>7 ^ w8>>>18 ^ w8>>>3 ^ w8<<25 ^ w8<<14 ) + ( w5>>>17 ^ w5>>>19 ^ w5>>>10 ^ w5<<15 ^ w5<<13 ) + w7 + w0 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x92722c85 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 40 w8 = t = ( ( w9>>>7 ^ w9>>>18 ^ w9>>>3 ^ w9<<25 ^ w9<<14 ) + ( w6>>>17 ^ w6>>>19 ^ w6>>>10 ^ w6<<15 ^ w6<<13 ) + w8 + w1 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xa2bfe8a1 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 41 w9 = t = ( ( w10>>>7 ^ w10>>>18 ^ w10>>>3 ^ w10<<25 ^ w10<<14 ) + ( w7>>>17 ^ w7>>>19 ^ w7>>>10 ^ w7<<15 ^ w7<<13 ) + w9 + w2 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xa81a664b )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 42 w10 = t = ( ( w11>>>7 ^ w11>>>18 ^ w11>>>3 ^ w11<<25 ^ w11<<14 ) + ( w8>>>17 ^ w8>>>19 ^ w8>>>10 ^ w8<<15 ^ w8<<13 ) + w10 + w3 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xc24b8b70 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 43 w11 = t = ( ( w12>>>7 ^ w12>>>18 ^ w12>>>3 ^ w12<<25 ^ w12<<14 ) + ( w9>>>17 ^ w9>>>19 ^ w9>>>10 ^ w9<<15 ^ w9<<13 ) + w11 + w4 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xc76c51a3 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 44 w12 = t = ( ( w13>>>7 ^ w13>>>18 ^ w13>>>3 ^ w13<<25 ^ w13<<14 ) + ( w10>>>17 ^ w10>>>19 ^ w10>>>10 ^ w10<<15 ^ w10<<13 ) + w12 + w5 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xd192e819 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 45 w13 = t = ( ( w14>>>7 ^ w14>>>18 ^ w14>>>3 ^ w14<<25 ^ w14<<14 ) + ( w11>>>17 ^ w11>>>19 ^ w11>>>10 ^ w11<<15 ^ w11<<13 ) + w13 + w6 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xd6990624 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 46 w14 = t = ( ( w15>>>7 ^ w15>>>18 ^ w15>>>3 ^ w15<<25 ^ w15<<14 ) + ( w12>>>17 ^ w12>>>19 ^ w12>>>10 ^ w12<<15 ^ w12<<13 ) + w14 + w7 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xf40e3585 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 47 w15 = t = ( ( w0>>>7 ^ w0>>>18 ^ w0>>>3 ^ w0<<25 ^ w0<<14 ) + ( w13>>>17 ^ w13>>>19 ^ w13>>>10 ^ w13<<15 ^ w13<<13 ) + w15 + w8 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x106aa070 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 48 w0 = t = ( ( w1>>>7 ^ w1>>>18 ^ w1>>>3 ^ w1<<25 ^ w1<<14 ) + ( w14>>>17 ^ w14>>>19 ^ w14>>>10 ^ w14<<15 ^ w14<<13 ) + w0 + w9 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x19a4c116 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 49 w1 = t = ( ( w2>>>7 ^ w2>>>18 ^ w2>>>3 ^ w2<<25 ^ w2<<14 ) + ( w15>>>17 ^ w15>>>19 ^ w15>>>10 ^ w15<<15 ^ w15<<13 ) + w1 + w10 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x1e376c08 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 50 w2 = t = ( ( w3>>>7 ^ w3>>>18 ^ w3>>>3 ^ w3<<25 ^ w3<<14 ) + ( w0>>>17 ^ w0>>>19 ^ w0>>>10 ^ w0<<15 ^ w0<<13 ) + w2 + w11 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x2748774c )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 51 w3 = t = ( ( w4>>>7 ^ w4>>>18 ^ w4>>>3 ^ w4<<25 ^ w4<<14 ) + ( w1>>>17 ^ w1>>>19 ^ w1>>>10 ^ w1<<15 ^ w1<<13 ) + w3 + w12 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x34b0bcb5 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 52 w4 = t = ( ( w5>>>7 ^ w5>>>18 ^ w5>>>3 ^ w5<<25 ^ w5<<14 ) + ( w2>>>17 ^ w2>>>19 ^ w2>>>10 ^ w2<<15 ^ w2<<13 ) + w4 + w13 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x391c0cb3 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 53 w5 = t = ( ( w6>>>7 ^ w6>>>18 ^ w6>>>3 ^ w6<<25 ^ w6<<14 ) + ( w3>>>17 ^ w3>>>19 ^ w3>>>10 ^ w3<<15 ^ w3<<13 ) + w5 + w14 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x4ed8aa4a )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 54 w6 = t = ( ( w7>>>7 ^ w7>>>18 ^ w7>>>3 ^ w7<<25 ^ w7<<14 ) + ( w4>>>17 ^ w4>>>19 ^ w4>>>10 ^ w4<<15 ^ w4<<13 ) + w6 + w15 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x5b9cca4f )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 55 w7 = t = ( ( w8>>>7 ^ w8>>>18 ^ w8>>>3 ^ w8<<25 ^ w8<<14 ) + ( w5>>>17 ^ w5>>>19 ^ w5>>>10 ^ w5<<15 ^ w5<<13 ) + w7 + w0 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x682e6ff3 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 56 w8 = t = ( ( w9>>>7 ^ w9>>>18 ^ w9>>>3 ^ w9<<25 ^ w9<<14 ) + ( w6>>>17 ^ w6>>>19 ^ w6>>>10 ^ w6<<15 ^ w6<<13 ) + w8 + w1 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x748f82ee )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 57 w9 = t = ( ( w10>>>7 ^ w10>>>18 ^ w10>>>3 ^ w10<<25 ^ w10<<14 ) + ( w7>>>17 ^ w7>>>19 ^ w7>>>10 ^ w7<<15 ^ w7<<13 ) + w9 + w2 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x78a5636f )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 58 w10 = t = ( ( w11>>>7 ^ w11>>>18 ^ w11>>>3 ^ w11<<25 ^ w11<<14 ) + ( w8>>>17 ^ w8>>>19 ^ w8>>>10 ^ w8<<15 ^ w8<<13 ) + w10 + w3 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x84c87814 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 59 w11 = t = ( ( w12>>>7 ^ w12>>>18 ^ w12>>>3 ^ w12<<25 ^ w12<<14 ) + ( w9>>>17 ^ w9>>>19 ^ w9>>>10 ^ w9<<15 ^ w9<<13 ) + w11 + w4 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x8cc70208 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 60 w12 = t = ( ( w13>>>7 ^ w13>>>18 ^ w13>>>3 ^ w13<<25 ^ w13<<14 ) + ( w10>>>17 ^ w10>>>19 ^ w10>>>10 ^ w10<<15 ^ w10<<13 ) + w12 + w5 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0x90befffa )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 61 w13 = t = ( ( w14>>>7 ^ w14>>>18 ^ w14>>>3 ^ w14<<25 ^ w14<<14 ) + ( w11>>>17 ^ w11>>>19 ^ w11>>>10 ^ w11<<15 ^ w11<<13 ) + w13 + w6 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xa4506ceb )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 62 w14 = t = ( ( w15>>>7 ^ w15>>>18 ^ w15>>>3 ^ w15<<25 ^ w15<<14 ) + ( w12>>>17 ^ w12>>>19 ^ w12>>>10 ^ w12<<15 ^ w12<<13 ) + w14 + w7 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xbef9a3f7 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; // 63 w15 = t = ( ( w0>>>7 ^ w0>>>18 ^ w0>>>3 ^ w0<<25 ^ w0<<14 ) + ( w13>>>17 ^ w13>>>19 ^ w13>>>10 ^ w13<<15 ^ w13<<13 ) + w15 + w8 )|0; t = ( t + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) + ( g ^ e & (f^g) ) + 0xc67178f2 )|0; h = g; g = f; f = e; e = ( d + t )|0; d = c; c = b; b = a; a = ( t + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0; H0 = ( H0 + a )|0; H1 = ( H1 + b )|0; H2 = ( H2 + c )|0; H3 = ( H3 + d )|0; H4 = ( H4 + e )|0; H5 = ( H5 + f )|0; H6 = ( H6 + g )|0; H7 = ( H7 + h )|0; } function _core_heap ( offset ) { offset = offset|0; _core( HEAP[offset|0]<<24 | HEAP[offset|1]<<16 | HEAP[offset|2]<<8 | HEAP[offset|3], HEAP[offset|4]<<24 | HEAP[offset|5]<<16 | HEAP[offset|6]<<8 | HEAP[offset|7], HEAP[offset|8]<<24 | HEAP[offset|9]<<16 | HEAP[offset|10]<<8 | HEAP[offset|11], HEAP[offset|12]<<24 | HEAP[offset|13]<<16 | HEAP[offset|14]<<8 | HEAP[offset|15], HEAP[offset|16]<<24 | HEAP[offset|17]<<16 | HEAP[offset|18]<<8 | HEAP[offset|19], HEAP[offset|20]<<24 | HEAP[offset|21]<<16 | HEAP[offset|22]<<8 | HEAP[offset|23], HEAP[offset|24]<<24 | HEAP[offset|25]<<16 | HEAP[offset|26]<<8 | HEAP[offset|27], HEAP[offset|28]<<24 | HEAP[offset|29]<<16 | HEAP[offset|30]<<8 | HEAP[offset|31], HEAP[offset|32]<<24 | HEAP[offset|33]<<16 | HEAP[offset|34]<<8 | HEAP[offset|35], HEAP[offset|36]<<24 | HEAP[offset|37]<<16 | HEAP[offset|38]<<8 | HEAP[offset|39], HEAP[offset|40]<<24 | HEAP[offset|41]<<16 | HEAP[offset|42]<<8 | HEAP[offset|43], HEAP[offset|44]<<24 | HEAP[offset|45]<<16 | HEAP[offset|46]<<8 | HEAP[offset|47], HEAP[offset|48]<<24 | HEAP[offset|49]<<16 | HEAP[offset|50]<<8 | HEAP[offset|51], HEAP[offset|52]<<24 | HEAP[offset|53]<<16 | HEAP[offset|54]<<8 | HEAP[offset|55], HEAP[offset|56]<<24 | HEAP[offset|57]<<16 | HEAP[offset|58]<<8 | HEAP[offset|59], HEAP[offset|60]<<24 | HEAP[offset|61]<<16 | HEAP[offset|62]<<8 | HEAP[offset|63] ); } // offset — multiple of 32 function _state_to_heap ( output ) { output = output|0; HEAP[output|0] = H0>>>24; HEAP[output|1] = H0>>>16&255; HEAP[output|2] = H0>>>8&255; HEAP[output|3] = H0&255; HEAP[output|4] = H1>>>24; HEAP[output|5] = H1>>>16&255; HEAP[output|6] = H1>>>8&255; HEAP[output|7] = H1&255; HEAP[output|8] = H2>>>24; HEAP[output|9] = H2>>>16&255; HEAP[output|10] = H2>>>8&255; HEAP[output|11] = H2&255; HEAP[output|12] = H3>>>24; HEAP[output|13] = H3>>>16&255; HEAP[output|14] = H3>>>8&255; HEAP[output|15] = H3&255; HEAP[output|16] = H4>>>24; HEAP[output|17] = H4>>>16&255; HEAP[output|18] = H4>>>8&255; HEAP[output|19] = H4&255; HEAP[output|20] = H5>>>24; HEAP[output|21] = H5>>>16&255; HEAP[output|22] = H5>>>8&255; HEAP[output|23] = H5&255; HEAP[output|24] = H6>>>24; HEAP[output|25] = H6>>>16&255; HEAP[output|26] = H6>>>8&255; HEAP[output|27] = H6&255; HEAP[output|28] = H7>>>24; HEAP[output|29] = H7>>>16&255; HEAP[output|30] = H7>>>8&255; HEAP[output|31] = H7&255; } function reset () { H0 = 0x6a09e667; H1 = 0xbb67ae85; H2 = 0x3c6ef372; H3 = 0xa54ff53a; H4 = 0x510e527f; H5 = 0x9b05688c; H6 = 0x1f83d9ab; H7 = 0x5be0cd19; TOTAL0 = TOTAL1 = 0; } function init ( h0, h1, h2, h3, h4, h5, h6, h7, total0, total1 ) { h0 = h0|0; h1 = h1|0; h2 = h2|0; h3 = h3|0; h4 = h4|0; h5 = h5|0; h6 = h6|0; h7 = h7|0; total0 = total0|0; total1 = total1|0; H0 = h0; H1 = h1; H2 = h2; H3 = h3; H4 = h4; H5 = h5; H6 = h6; H7 = h7; TOTAL0 = total0; TOTAL1 = total1; } // offset — multiple of 64 function process ( offset, length ) { offset = offset|0; length = length|0; var hashed = 0; if ( offset & 63 ) return -1; while ( (length|0) >= 64 ) { _core_heap(offset); offset = ( offset + 64 )|0; length = ( length - 64 )|0; hashed = ( hashed + 64 )|0; } TOTAL0 = ( TOTAL0 + hashed )|0; if ( TOTAL0>>>0 < hashed>>>0 ) TOTAL1 = ( TOTAL1 + 1 )|0; return hashed|0; } // offset — multiple of 64 // output — multiple of 32 function finish ( offset, length, output ) { offset = offset|0; length = length|0; output = output|0; var hashed = 0, i = 0; if ( offset & 63 ) return -1; if ( ~output ) if ( output & 31 ) return -1; if ( (length|0) >= 64 ) { hashed = process( offset, length )|0; if ( (hashed|0) == -1 ) return -1; offset = ( offset + hashed )|0; length = ( length - hashed )|0; } hashed = ( hashed + length )|0; TOTAL0 = ( TOTAL0 + length )|0; if ( TOTAL0>>>0 < length>>>0 ) TOTAL1 = ( TOTAL1 + 1 )|0; HEAP[offset|length] = 0x80; if ( (length|0) >= 56 ) { for ( i = (length+1)|0; (i|0) < 64; i = (i+1)|0 ) HEAP[offset|i] = 0x00; _core_heap(offset); length = 0; HEAP[offset|0] = 0; } for ( i = (length+1)|0; (i|0) < 59; i = (i+1)|0 ) HEAP[offset|i] = 0; HEAP[offset|56] = TOTAL1>>>21&255; HEAP[offset|57] = TOTAL1>>>13&255; HEAP[offset|58] = TOTAL1>>>5&255; HEAP[offset|59] = TOTAL1<<3&255 | TOTAL0>>>29; HEAP[offset|60] = TOTAL0>>>21&255; HEAP[offset|61] = TOTAL0>>>13&255; HEAP[offset|62] = TOTAL0>>>5&255; HEAP[offset|63] = TOTAL0<<3&255; _core_heap(offset); if ( ~output ) _state_to_heap(output); return hashed|0; } function hmac_reset () { H0 = I0; H1 = I1; H2 = I2; H3 = I3; H4 = I4; H5 = I5; H6 = I6; H7 = I7; TOTAL0 = 64; TOTAL1 = 0; } function _hmac_opad () { H0 = O0; H1 = O1; H2 = O2; H3 = O3; H4 = O4; H5 = O5; H6 = O6; H7 = O7; TOTAL0 = 64; TOTAL1 = 0; } function hmac_init ( p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ) { p0 = p0|0; p1 = p1|0; p2 = p2|0; p3 = p3|0; p4 = p4|0; p5 = p5|0; p6 = p6|0; p7 = p7|0; p8 = p8|0; p9 = p9|0; p10 = p10|0; p11 = p11|0; p12 = p12|0; p13 = p13|0; p14 = p14|0; p15 = p15|0; // opad reset(); _core( p0 ^ 0x5c5c5c5c, p1 ^ 0x5c5c5c5c, p2 ^ 0x5c5c5c5c, p3 ^ 0x5c5c5c5c, p4 ^ 0x5c5c5c5c, p5 ^ 0x5c5c5c5c, p6 ^ 0x5c5c5c5c, p7 ^ 0x5c5c5c5c, p8 ^ 0x5c5c5c5c, p9 ^ 0x5c5c5c5c, p10 ^ 0x5c5c5c5c, p11 ^ 0x5c5c5c5c, p12 ^ 0x5c5c5c5c, p13 ^ 0x5c5c5c5c, p14 ^ 0x5c5c5c5c, p15 ^ 0x5c5c5c5c ); O0 = H0; O1 = H1; O2 = H2; O3 = H3; O4 = H4; O5 = H5; O6 = H6; O7 = H7; // ipad reset(); _core( p0 ^ 0x36363636, p1 ^ 0x36363636, p2 ^ 0x36363636, p3 ^ 0x36363636, p4 ^ 0x36363636, p5 ^ 0x36363636, p6 ^ 0x36363636, p7 ^ 0x36363636, p8 ^ 0x36363636, p9 ^ 0x36363636, p10 ^ 0x36363636, p11 ^ 0x36363636, p12 ^ 0x36363636, p13 ^ 0x36363636, p14 ^ 0x36363636, p15 ^ 0x36363636 ); I0 = H0; I1 = H1; I2 = H2; I3 = H3; I4 = H4; I5 = H5; I6 = H6; I7 = H7; TOTAL0 = 64; TOTAL1 = 0; } // offset — multiple of 64 // output — multiple of 32 function hmac_finish ( offset, length, output ) { offset = offset|0; length = length|0; output = output|0; var t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, hashed = 0; if ( offset & 63 ) return -1; if ( ~output ) if ( output & 31 ) return -1; hashed = finish( offset, length, -1 )|0; t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4, t5 = H5, t6 = H6, t7 = H7; _hmac_opad(); _core( t0, t1, t2, t3, t4, t5, t6, t7, 0x80000000, 0, 0, 0, 0, 0, 0, 768 ); if ( ~output ) _state_to_heap(output); return hashed|0; } // salt is assumed to be already processed // offset — multiple of 64 // output — multiple of 32 function pbkdf2_generate_block ( offset, length, block, count, output ) { offset = offset|0; length = length|0; block = block|0; count = count|0; output = output|0; var h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0, h5 = 0, h6 = 0, h7 = 0, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0; if ( offset & 63 ) return -1; if ( ~output ) if ( output & 31 ) return -1; // pad block number into heap // FIXME probable OOB write HEAP[(offset+length)|0] = block>>>24; HEAP[(offset+length+1)|0] = block>>>16&255; HEAP[(offset+length+2)|0] = block>>>8&255; HEAP[(offset+length+3)|0] = block&255; // finish first iteration hmac_finish( offset, (length+4)|0, -1 )|0; h0 = t0 = H0, h1 = t1 = H1, h2 = t2 = H2, h3 = t3 = H3, h4 = t4 = H4, h5 = t5 = H5, h6 = t6 = H6, h7 = t7 = H7; count = (count-1)|0; // perform the rest iterations while ( (count|0) > 0 ) { hmac_reset(); _core( t0, t1, t2, t3, t4, t5, t6, t7, 0x80000000, 0, 0, 0, 0, 0, 0, 768 ); t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4, t5 = H5, t6 = H6, t7 = H7; _hmac_opad(); _core( t0, t1, t2, t3, t4, t5, t6, t7, 0x80000000, 0, 0, 0, 0, 0, 0, 768 ); t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4, t5 = H5, t6 = H6, t7 = H7; h0 = h0 ^ H0; h1 = h1 ^ H1; h2 = h2 ^ H2; h3 = h3 ^ H3; h4 = h4 ^ H4; h5 = h5 ^ H5; h6 = h6 ^ H6; h7 = h7 ^ H7; count = (count-1)|0; } H0 = h0; H1 = h1; H2 = h2; H3 = h3; H4 = h4; H5 = h5; H6 = h6; H7 = h7; if ( ~output ) _state_to_heap(output); return 0; } return { // SHA256 reset: reset, init: init, process: process, finish: finish, // HMAC-SHA256 hmac_reset: hmac_reset, hmac_init: hmac_init, hmac_finish: hmac_finish, // PBKDF2-HMAC-SHA256 pbkdf2_generate_block: pbkdf2_generate_block } } }, "transform/TextTransformer.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; /*:: import type { Operation_t } from '../Operation' */ var Operation = require('../Operation'); var Common = require('../Common'); var transformOp0 = function ( toTransform /*:Operation_t*/, transformBy /*:Operation_t*/) { if (toTransform.offset > transformBy.offset) { if (toTransform.offset > transformBy.offset + transformBy.toRemove) { // simple rebase return Operation.create( toTransform.offset - transformBy.toRemove + transformBy.toInsert.length, toTransform.toRemove, toTransform.toInsert ); } var newToRemove = toTransform.toRemove - (transformBy.offset + transformBy.toRemove - toTransform.offset); if (newToRemove < 0) { newToRemove = 0; } if (newToRemove === 0 && toTransform.toInsert.length === 0) { return null; } return Operation.create( transformBy.offset + transformBy.toInsert.length, newToRemove, toTransform.toInsert ); } // they don't touch, yay if (toTransform.offset + toTransform.toRemove < transformBy.offset) { return toTransform; } // Truncate what will be deleted... var _newToRemove = transformBy.offset - toTransform.offset; if (_newToRemove === 0 && toTransform.toInsert.length === 0) { return null; } return Operation.create(toTransform.offset, _newToRemove, toTransform.toInsert); }; var transformOp = function ( toTransform /*:Operation_t*/, transformBy /*:Operation_t*/) { if (Common.PARANOIA) { Operation.check(toTransform); Operation.check(transformBy); } var result = transformOp0(toTransform, transformBy); if (Common.PARANOIA && result) { Operation.check(result); } return result; }; module.exports = function ( opsToTransform /*:Array<Operation_t>*/, opsTransformBy /*:Array<Operation_t>*/, doc /*:string*/ ) /*:Array<Operation_t>*/ { var resultOfTransformBy = doc; var i; for (i = opsTransformBy.length - 1; i >= 0; i--) { resultOfTransformBy = Operation.apply(opsTransformBy[i], resultOfTransformBy); } var out = []; for (i = opsToTransform.length - 1; i >= 0; i--) { var tti = opsToTransform[i]; for (var j = opsTransformBy.length - 1; j >= 0; j--) { try { tti = transformOp(tti, opsTransformBy[j]); } catch (e) { console.error("The pluggable transform function threw an error, " + "failing operational transformation"); console.error(e.stack); return []; } if (!tti) { break; } } if (tti) { if (Common.PARANOIA) { Operation.check(tti, resultOfTransformBy.length); } out.unshift(tti); } } return out; }; }, "transform/SmartJSONTransformer.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; var Sortify = require('json.sortify'); var Diff = require('../Diff'); //var Patch = require('../Patch'); var Operation = require('../Operation'); var TextTransformer = require('./TextTransformer'); //var Sha = require('../sha256'); /*:: import type { Operation_t } from '../Operation'; */ var isArray = function (obj) { return Object.prototype.toString.call(obj)==='[object Array]'; }; /* Arrays and nulls both register as 'object' when using native typeof we need to distinguish them as their own types, so use this instead. */ var type = function (dat) { return dat === null? 'null': isArray(dat)?'array': typeof(dat); }; var find = function (map, path) { var l = path.length; for (var i = 0; i < l; i++) { if (typeof(map[path[i]]) === 'undefined') { return; } map = map[path[i]]; } return map; }; var clone = function (val) { return JSON.parse(JSON.stringify(val)); }; var deepEqual = function (A /*:any*/, B /*:any*/) { var t_A = type(A); var t_B = type(B); if (t_A !== t_B) { return false; } if (t_A === 'object') { var k_A = Object.keys(A); var k_B = Object.keys(B); return k_A.length === k_B.length && !k_A.some(function (a) { return !deepEqual(A[a], B[a]); }) && !k_B.some(function (b) { return !(b in A); }); } else if (t_A === 'array') { return A.length === B.length && !A.some(function (a, i) { return !deepEqual(a, B[i]); }); } else { return A === B; } }; /*:: export type SmartJSONTransformer_Replace_t = { type: 'replace', path: Array<string|number>, value: any, prev: any }; export type SmartJSONTransformer_Splice_t = { type: 'splice', path: Array<string|number>, value: any, offset: number, removals: number }; export type SmartJSONTransformer_Remove_t = { type: 'remove', path: Array<string|number>, value: any }; export type SmartJSONTransformer_Operation_t = SmartJSONTransformer_Replace_t | SmartJSONTransformer_Splice_t | SmartJSONTransformer_Remove_t; */ var operation = function (type, path, value, prev, other) /*:SmartJSONTransformer_Operation_t*/ { if (type === 'replace') { return ({ type: 'replace', path: path, value: value, prev: prev, } /*:SmartJSONTransformer_Replace_t*/); } else if (type === 'splice') { if (typeof(prev) !== 'number') { throw new Error(); } if (typeof(other) !== 'number') { throw new Error(); } return ({ type: 'splice', path: path, value: value, offset: prev, removals: other } /*:SmartJSONTransformer_Splice_t*/); } else if (type !== 'remove') { throw new Error('expected a removal'); } // if it's not a replace or splice, it's a 'remove' return ({ type: 'remove', path: path, value: value, } /*:SmartJSONTransformer_Remove_t*/); }; var replace = function (ops, path, to, from) { ops.push(operation('replace', path, to, from)); }; var remove = function (ops, path, val) { ops.push(operation('remove', path, val)); }; // HERE var splice = function (ops, path, value, offset, removals) { ops.push(operation('splice', path, value, offset, removals)); }; /* all of A's path is at the beginning of B roughly: B.indexOf(A) === 0 */ var pathOverlaps = function (A /*:Array<string|number>*/, B /*:Array<string|number>*/) { return !A.some(function (a, i) { return a !== B[i]; }); }; // OT Case #1 replace->replace ✔ // OT Case #2 replace->remove ✔ // OT Case #3 replace->splice ✔ // OT Case #4 remove->replace ✔ // OT Case #5 remove->remove ✔ // OT Case #6 remove->splice ✔ // OT Case #7 splice->replace ✔ // OT Case #8 splice->remove ✔ // OT Case #9 splice->splice ✔ var CASES = (function () { var types = ['replace', 'remove', 'splice']; var matrix = {}; var i = 1; types.forEach(function (a) { matrix[a] = {}; return types.forEach(function (b) { matrix[a][b] = i++; }); }); return matrix; }()); // A and B are lists of operations which result from calling diff var resolve = function (A /*:any*/, B /*:any*/, arbiter /*:?function*/) { if (!(type(A) === 'array' && type(B) === 'array')) { throw new Error("[resolve] expected two arrays"); } /* OVERVIEW * B * 1. filter removals at identical paths * */ B = B.filter(function (b) { // if A removed part of the tree you were working on... if (A.some(function (a) { if (a.type === 'remove') { if (pathOverlaps(a.path, b.path)) { if (b.path.length - a.path.length > 1) { return true; } } } })) { // this is weird... FIXME return false; } /* remove operations which would no longer make sense for instance, if a replaces an array with a string, that would invalidate a splice operation at that path */ if (b.type === 'splice' && A.some(function (a) { if (a.type === 'splice' && pathOverlaps(a.path, b.path)) { if (a.path.length - b.path.length < 0) { if (!a.removals) { return; } var start = a.offset; var end = a.offset + a.removals; for (;start < end; start++) { if (start === b.path[a.path.length]) { /* if (typeof(arbiter) === 'function' && deepEqual(a.path, b.path) && a.value.length === 1 && b.value.length === 1 && typeof(a.value[0]) === 'string' && typeof(b.value[0]) === 'string') { console.log('strings'); return arbiter(a, b, CASES.splice.splice); } */ // b is a descendant of a removal return true; } } } } })) { return false; } if (!A.some(function (a) { return b.type === 'remove' && deepEqual(a.path, b.path); })) { return true; } }) .filter(function (b) { // let A win conflicts over b if no arbiter is supplied here // Arbiter is required here return !A.some(function (a) { if (b.type === 'replace' && a.type === 'replace') { // remove any operations which return true if (deepEqual(a.path, b.path)) { if (typeof(a.value) === 'string' && typeof(b.value) === 'string') { if (arbiter && a.prev === b.prev && a.value !== b.value) { return arbiter(a, b, CASES.replace.replace); } return true; } return true; } } }); }) .map(function (b) { // if a splice in A modifies the path to b // update b's path to reflect that A.forEach(function (a) { if (a.type === 'splice') { // TODO // what if a.path == b.path // what if a removes elements (splice) and b also removes elements // (generally we merge these two together but it is probably best to allow the api customer to decide via a "strategy") // Note that A might be removing *and* inserting because a splice is roughly equivilent to a ChainPad Operation // Consult Transform0 :) // resolve insertion overlaps array.push conflicts // iterate over A such that each overlapping splice // adjusts the path/offset of b if (deepEqual(a.path, b.path)) { if (b.type === 'splice') { // what if the splice is a removal? b.offset += (a.value.length - a.removals); // if both A and B are removing the same thing // be careful } else { // adjust the path of b to account for the splice // TODO } return; } if (pathOverlaps(a.path, b.path)) { // TODO validate that this isn't an off-by-one error var pos = a.path.length; if (typeof(b.path[pos]) === 'number' && a.offset <= b.path[pos]) { // FIXME a.value is undefined b.path[pos] += (a.value.length - a.removals); } } } }); return b; }); return B; }; // A, B, f, path, ops var objects = function (A, B, path, ops) { var Akeys = Object.keys(A); var Bkeys = Object.keys(B); Bkeys.forEach(function (b) { var t_b = type(B[b]); var old = A[b]; var nextPath = path.concat(b); if (Akeys.indexOf(b) === -1) { // there was an insertion // mind the fallthrough behaviour if (t_b === 'undefined') { throw new Error("undefined type has key. this shouldn't happen?"); } if (old) { throw new Error("no such key existed in b, so 'old' should be falsey"); } replace(ops, nextPath, B[b], old); return; } // else the key already existed var t_a = type(old); if (t_a !== t_b) { // its type changed! console.log("type changed from [%s] to [%s]", t_a, t_b); // type changes always mean a change happened if (t_b === 'undefined') { throw new Error("first pass should never reveal undefined keys"); } replace(ops, nextPath, B[b], old); return; } if (t_a === 'object') { // it's an object objects(A[b], B[b], nextPath, ops); } else if (t_a === 'array') { // it's an array arrays(A[b], B[b], nextPath, ops); } else if (A[b] !== B[b]) { // it's not an array or object, so we can do === comparison replace(ops, nextPath, B[b], old); } }); Akeys.forEach(function (a) { // the key was deleted if (Bkeys.indexOf(a) === -1 || type(B[a]) === 'undefined') { remove(ops, path.concat(a), A[a]); } }); }; var arrayShallowEquality = function (A, B) { if (A.length !== B.length) { return false; } for (var i = 0; i < A.length; i++) { if (type(A[i]) !== type(B[i])) { return false; } } return true; }; // When an element in an array (number, string, bool) is changed, instead of a replace we // will do a splice(offset, [element], 1) var arrays = function (A_orig, B, path, ops) { var A = A_orig.slice(0); // shallow clone if (A.length === 0) { // A is zero length, this is going to be easy... splice(ops, path, B, 0, 0); } else if (arrayShallowEquality(A, B)) { // This is a relatively simple case, the elements in A and B are all of the same type and if // that type happens to be a primitive type, they are also equal. // This means no change will be needed at the level of this array, only it's children. A.forEach(function (a, i) { var b = B[i]; if (b === a) { return; } var old = a; var nextPath = path.concat(i); var t_a = type(a); switch (t_a) { case 'undefined': throw new Error('existing key had type `undefined`. this should never happen'); case 'object': objects(a, b, nextPath, ops); break; case 'array': arrays(a, b, nextPath, ops); break; default: //console.log('replace: ' + t_a); //splice(ops, path, [b], i, 1); replace(ops, nextPath, b, old); } }); } else { // Something was changed in the length of the array or one of the primitives so we're going // to make an actual change to this array, not only it's children. var commonStart = 0; var commonEnd = 0; while (commonStart < A.length && deepEqual(A[commonStart], B[commonStart])) { commonStart++; } while (deepEqual(A[A.length - 1 - commonEnd], B[B.length - 1 - commonEnd]) && commonEnd + commonStart < A.length && commonEnd + commonStart < B.length) { commonEnd++; } var toRemove = A.length - commonStart - commonEnd; var toInsert = []; if (B.length !== commonStart + commonEnd) { toInsert = B.slice(commonStart, B.length - commonEnd); } splice(ops, path, toInsert, commonStart, toRemove); } }; var diff = function (A, B) { var ops = []; var t_A = type(A); var t_B = type(B); if (t_A !== t_B) { throw new Error("Can't merge two objects of differing types"); } if (t_B === 'array') { arrays(A, B, [], ops); } else if (t_B === 'object') { objects(A, B, [], ops); } else { throw new Error("unsupported datatype" + t_B); } return ops; }; var applyOp = function (O, op /*:SmartJSONTransformer_Operation_t*/) { var path; var key; var result; switch (op.type) { case "replace": key = op.path[op.path.length -1]; path = op.path.slice(0, op.path.length - 1); var parent = find(O, path); if (!parent) { throw new Error("cannot apply change to non-existent element"); } parent[key] = op.value; break; case "splice": var found = find(O, op.path); if (!found) { console.error("[applyOp] expected path [%s] to exist in object", op.path.join(',')); throw new Error("Path did not exist"); } if (type(found) !== 'array') { throw new Error("Can't splice non-array"); } Array.prototype.splice.apply(found, [op.offset, op.removals].concat(op.value)); break; case "remove": key = op.path[op.path.length -1]; path = op.path.slice(0, op.path.length - 1); result = find(O, path); if (typeof(result) !== 'undefined') { delete result[key]; } break; default: throw new Error('unsupported operation type'); } }; var patch = function (O, ops) { ops.forEach(function (op) { applyOp(O, op); }); return O; }; ///// // We mutate b in this function // Our operation is p_b and the other person's operation is p_a. // If we return true here, it means our operation will die off. var arbiter = function (p_a, p_b, c) { if (p_a.prev !== p_b.prev) { throw new Error("Parent values don't match!"); } if (c === CASES.splice.splice) { // We and the other person are both pushing strings to an array so // we'll just accept both of them into the array. console.log(p_a); console.log(p_b); console.log('\n\n\n\n\n\n\n\n\n'); // TODO: do we really want to kill off our operation in this case ? return true; } var o = p_a.prev; var ops_a = Diff.diff(o, p_a.value); var ops_b = Diff.diff(o, p_b.value); /* given the parent text, the op to transform, and the incoming op return a transformed operation which takes the incoming op into account */ var ops_x = TextTransformer(ops_b, ops_a, o); /* Apply the incoming operation to the parent text */ var x2 = Operation.applyMulti(ops_a, o); /* Apply the transformed operation to the result of the incoming op */ var x3 = Operation.applyMulti(ops_x, x2); p_b.value = x3; }; module.exports = function ( opsToTransform /*:Array<Operation_t>*/, opsTransformBy /*:Array<Operation_t>*/, s_orig /*:string*/ ) /*:Array<Operation_t>*/ { var o_orig = JSON.parse(s_orig); var s_transformBy = Operation.applyMulti(opsTransformBy, s_orig); var o_transformBy = JSON.parse(s_transformBy); // try whole patch at a time, see how it goes... var s_toTransform = Operation.applyMulti(opsToTransform, s_orig); var o_toTransform = JSON.parse(s_toTransform); try { var diffTTF = diff(o_orig, o_toTransform); var diffTFB = diff(o_orig, o_transformBy); var newDiffTTF = resolve(diffTFB, diffTTF, arbiter); // mutates orig patch(o_orig, diffTFB); patch(o_orig, newDiffTTF); var result = Sortify(o_orig); var ret = Diff.diff(s_transformBy, result); return ret; } catch (err) { console.error(err); // FIXME Path did not exist... } return []; }; module.exports._ = { clone: clone, pathOverlaps: pathOverlaps, deepEqual: deepEqual, diff: diff, resolve: resolve, patch: patch, }; }, "transform/NaiveJSONTransformer.js": function(module, exports, require){ /*@flow*/ /* * 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/>. */ "use strict"; var TextTransformer = require('./TextTransformer'); //var ChainPad = require('../ChainPad'); var Operation = require('../Operation'); var Common = require('../Common'); /*:: import type { Operation_t } from '../Operation'; */ module.exports = function ( opsToTransform /*:Array<Operation_t>*/, opsTransformBy /*:Array<Operation_t>*/, text /*:string*/ ) /*:Array<Operation_t>*/ { var DEBUG = Common.global.REALTIME_DEBUG = Common.global.REALTIME_DEBUG || {}; var resultOps, text2, text3; try { // text = O (mutual common ancestor) // toTransform = A (your own operation) // transformBy = B (the incoming operation) // threeway merge (0, A, B) resultOps = TextTransformer(opsToTransform, opsTransformBy, text); text2 = Operation.applyMulti(opsTransformBy, text); text3 = Operation.applyMulti(resultOps, text2); try { JSON.parse(text3); return resultOps; } catch (e) { console.error(e); DEBUG.ot_parseError = { type: 'resultParseError', resultOps: resultOps, toTransform: opsToTransform, transformBy: opsTransformBy, text1: text, text2: text2, text3: text3, error: e }; console.log('Debugging info available at `window.REALTIME_DEBUG.ot_parseError`'); } } catch (x) { console.error(x); DEBUG.ot_applyError = { type: 'resultParseError', resultOps: resultOps, toTransform: opsToTransform, transformBy: opsTransformBy, text1: text, text2: text2, text3: text3, error: x }; console.log('Debugging info available at `window.REALTIME_DEBUG.ot_applyError`'); } // return an empty patch in case we can't do anything else return []; }; } }; r.m[1] = { "dist/JSON.sortify.js": function(module, exports, require){ "use strict";(function(factory){if(typeof module!=="undefined"&&module.exports)module.exports=factory();else if(typeof define=="function"&&typeof define.amd=="object")define("json.sortify",factory);else JSON.sortify=factory()})(function(){ /*! * Copyright 2015-2017 Thomas Rosenau * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */"use strict";var sortKeys=function sortKeys(o){if(Array.isArray(o)){return o.map(sortKeys)}else if(o instanceof Object){var _ret=function(){var numeric=[];var nonNumeric=[];Object.keys(o).forEach(function(key){if(/^(0|[1-9][0-9]*)$/.test(key)){numeric.push(+key)}else {nonNumeric.push(key)}});return {v:numeric.sort(function(a,b){return a-b}).concat(nonNumeric.sort()).reduce(function(result,key){result[key]=sortKeys(o[key]);return result},{})}}();if(typeof _ret==="object")return _ret.v}return o};var jsonStringify=JSON.stringify.bind(JSON);var sortify=function sortify(value,replacer,space){var nativeJson=jsonStringify(value,replacer,0);if(!nativeJson||nativeJson[0]!=="{"&&nativeJson[0]!=="["){return nativeJson}var cleanObj=JSON.parse(nativeJson);return jsonStringify(sortKeys(cleanObj),null,space)};return sortify}); } }; function umd(n,f){"object"==typeof exports&&(module.exports=n),"function"==typeof define&&define.amd&&define(function(){return n});var e;"undefined"!=typeof window?e=window:"undefined"!=typeof global?e=global:"undefined"!=typeof self&&(e=self),e[f]=n}umd(r("ChainPad.js"), "ChainPad");}());