Latest repo

node_modules/quill-delta/test/delta/builder.js

@@ -0,0 +1,212 @@
+var Delta = require('../../lib/delta');
+
+
+describe('constructor', function () {
+  var ops = [
+    { insert: 'abc' },
+    { retain: 1, attributes: { color: 'red' } },
+    { delete: 4 },
+    { insert: 'def', attributes: { bold: true } },
+    { retain: 6 }
+  ];
+
+  it('empty', function () {
+    var delta = new Delta();
+    expect(delta).toBeDefined();
+    expect(delta.ops).toBeDefined();
+    expect(delta.ops.length).toEqual(0);
+  });
+
+  it('empty ops', function () {
+    var delta = new Delta().insert('').delete(0).retain(0);
+    expect(delta).toBeDefined();
+    expect(delta.ops).toBeDefined();
+    expect(delta.ops.length).toEqual(0);
+  });
+
+  it('array of ops', function () {
+    var delta = new Delta(ops);
+    expect(delta.ops).toEqual(ops);
+  });
+
+  it('delta in object form', function () {
+    var delta = new Delta({ ops: ops });
+    expect(delta.ops).toEqual(ops);
+  });
+
+  it('delta', function () {
+    var original = new Delta(ops);
+    var delta = new Delta(original);
+    expect(delta.ops).toEqual(original.ops);
+    expect(delta.ops).toEqual(ops);
+  });
+});
+
+describe('insert()', function () {
+  it('insert(text)', function () {
+    var delta = new Delta().insert('test');
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: 'test' });
+  });
+
+  it('insert(text, null)', function () {
+    var delta = new Delta().insert('test', null);
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: 'test' });
+  });
+
+  it('insert(embed)', function () {
+    var delta = new Delta().insert(1);
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: 1 });
+  });
+
+  it('insert(embed, attributes)', function () {
+    var obj = { url: 'http://quilljs.com', alt: 'Quill' };
+    var delta = new Delta().insert(1, obj);
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: 1, attributes: obj });
+  });
+
+  it('insert(embed) non-integer', function () {
+    var embed = { url: 'http://quilljs.com' };
+    var attr = { alt: 'Quill' };
+    var delta = new Delta().insert(embed, attr);
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: embed, attributes: attr });
+  });
+
+  it('insert(text, attributes)', function () {
+    var delta = new Delta().insert('test', { bold: true });
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: 'test', attributes: { bold: true } });
+  });
+
+  it('insert(text) after delete', function () {
+    var delta = new Delta().delete(1).insert('a');
+    var expected = new Delta().insert('a').delete(1);
+    expect(delta).toEqual(expected);
+  });
+
+  it('insert(text) after delete with merge', function () {
+    var delta = new Delta().insert('a').delete(1).insert('b');
+    var expected = new Delta().insert('ab').delete(1);
+    expect(delta).toEqual(expected);
+  });
+
+  it('insert(text) after delete no merge', function () {
+    var delta = new Delta().insert(1).delete(1).insert('a');
+    var expected = new Delta().insert(1).insert('a').delete(1);
+    expect(delta).toEqual(expected);
+  });
+
+  it('insert(text) after delete no merge', function () {
+    var delta = new Delta().insert(1).delete(1).insert('a');
+    var expected = new Delta().insert(1).insert('a').delete(1);
+    expect(delta).toEqual(expected);
+  });
+
+  it('insert(text, {})', function () {
+    var delta = new Delta().insert('a', {});
+    var expected = new Delta().insert('a');
+    expect(delta).toEqual(expected);
+  });
+});
+
+describe('delete()', function () {
+  it('delete(0)', function () {
+    var delta = new Delta().delete(0);
+    expect(delta.ops.length).toEqual(0);
+  });
+
+  it('delete(positive)', function () {
+    var delta = new Delta().delete(1);
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ delete: 1 });
+  });
+});
+
+describe('retain()', function () {
+  it('retain(0)', function () {
+    var delta = new Delta().retain(0);
+    expect(delta.ops.length).toEqual(0);
+  });
+
+  it('retain(length)', function () {
+    var delta = new Delta().retain(2);
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ retain: 2 });
+  });
+
+  it('retain(length, null)', function () {
+    var delta = new Delta().retain(2, null);
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ retain: 2 });
+  });
+
+  it('retain(length, attributes)', function () {
+    var delta = new Delta().retain(1, { bold: true });
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ retain: 1, attributes: { bold: true } });
+  });
+
+  it('retain(length, {})', function () {
+    var delta = new Delta().retain(2, {}).delete(1);    // Delete prevents chop
+    var expected = new Delta().retain(2).delete(1);
+    expect(delta).toEqual(expected);
+  });
+});
+
+describe('push()', function () {
+  it('push(op) into empty', function () {
+    var delta = new Delta();
+    delta.push({ insert: 'test' });
+    expect(delta.ops.length).toEqual(1);
+  });
+
+  it('push(op) consecutive delete', function () {
+    var delta = new Delta().delete(2);
+    delta.push({ delete: 3 });
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ delete: 5 });
+  });
+
+  it('push(op) consecutive text', function () {
+    var delta = new Delta().insert('a');
+    delta.push({ insert: 'b' });
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: 'ab' });
+  });
+
+  it('push(op) consecutive texts with matching attributes', function () {
+    var delta = new Delta().insert('a', { bold: true });
+    delta.push({ insert: 'b', attributes: { bold: true } });
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ insert: 'ab', attributes: { bold: true } });
+  });
+
+  it('push(op) consecutive retains with matching attributes', function () {
+    var delta = new Delta().retain(1, { bold: true });
+    delta.push({ retain: 3, attributes: { bold : true } });
+    expect(delta.ops.length).toEqual(1);
+    expect(delta.ops[0]).toEqual({ retain: 4, attributes: { bold: true } });
+  });
+
+  it('push(op) consecutive texts with mismatched attributes', function () {
+    var delta = new Delta().insert('a', { bold: true });
+    delta.push({ insert: 'b' });
+    expect(delta.ops.length).toEqual(2);
+  });
+
+  it('push(op) consecutive retains with mismatched attributes', function () {
+    var delta = new Delta().retain(1, { bold: true });
+    delta.push({ retain: 3 });
+    expect(delta.ops.length).toEqual(2);
+  });
+
+  it('push(op) consecutive embeds with matching attributes', function () {
+    var delta = new Delta().insert(1, { alt: 'Description' });
+    delta.push({ insert: { url: 'http://quilljs.com' }, attributes: { alt: 'Description' } });
+    expect(delta.ops.length).toEqual(2);
+  });
+});

node_modules/quill-delta/test/delta/compose.js

@@ -0,0 +1,195 @@
+var Delta = require('../../lib/delta');
+
+
+describe('compose()', function () {
+  it('insert + insert', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().insert('B');
+    var expected = new Delta().insert('B').insert('A');
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('insert + retain', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().retain(1, { bold: true, color: 'red', font: null });
+    var expected = new Delta().insert('A', { bold: true, color: 'red' });
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('insert + delete', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().delete(1);
+    var expected = new Delta();
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('delete + insert', function () {
+    var a = new Delta().delete(1);
+    var b = new Delta().insert('B');
+    var expected = new Delta().insert('B').delete(1);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('delete + retain', function () {
+    var a = new Delta().delete(1);
+    var b = new Delta().retain(1, { bold: true, color: 'red' });
+    var expected = new Delta().delete(1).retain(1, { bold: true, color: 'red' });
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('delete + delete', function () {
+    var a = new Delta().delete(1);
+    var b = new Delta().delete(1);
+    var expected = new Delta().delete(2);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain + insert', function () {
+    var a = new Delta().retain(1, { color: 'blue' });
+    var b = new Delta().insert('B');
+    var expected = new Delta().insert('B').retain(1, { color: 'blue' });
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain + retain', function () {
+    var a = new Delta().retain(1, { color: 'blue' });
+    var b = new Delta().retain(1, { bold: true, color: 'red', font: null });
+    var expected = new Delta().retain(1, { bold: true, color: 'red', font: null });
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain + delete', function () {
+    var a = new Delta().retain(1, { color: 'blue' });
+    var b = new Delta().delete(1);
+    var expected = new Delta().delete(1);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('insert in middle of text', function () {
+    var a = new Delta().insert('Hello');
+    var b = new Delta().retain(3).insert('X');
+    var expected = new Delta().insert('HelXlo');
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('insert and delete ordering', function () {
+    var a = new Delta().insert('Hello');
+    var b = new Delta().insert('Hello');
+    var insertFirst = new Delta().retain(3).insert('X').delete(1);
+    var deleteFirst = new Delta().retain(3).delete(1).insert('X');
+    var expected = new Delta().insert('HelXo');
+    expect(a.compose(insertFirst)).toEqual(expected);
+    expect(b.compose(deleteFirst)).toEqual(expected);
+  });
+
+  it('insert embed', function () {
+    var a = new Delta().insert(1, { src: 'http://quilljs.com/image.png' });
+    var b = new Delta().retain(1, { alt: 'logo' });
+    var expected = new Delta().insert(1, { src: 'http://quilljs.com/image.png', alt: 'logo' });
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('delete entire text', function () {
+    var a = new Delta().retain(4).insert('Hello');
+    var b = new Delta().delete(9);
+    var expected = new Delta().delete(4);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain more than length of text', function () {
+    var a = new Delta().insert('Hello');
+    var b = new Delta().retain(10);
+    var expected = new Delta().insert('Hello');
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain empty embed', function () {
+    var a = new Delta().insert(1);
+    var b = new Delta().retain(1);
+    var expected = new Delta().insert(1);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('remove all attributes', function () {
+    var a = new Delta().insert('A', { bold: true });
+    var b = new Delta().retain(1, { bold: null });
+    var expected = new Delta().insert('A');
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('remove all embed attributes', function () {
+    var a = new Delta().insert(2, { bold: true });
+    var b = new Delta().retain(1, { bold: null });
+    var expected = new Delta().insert(2);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('immutability', function () {
+    var attr1 = { bold: true };
+    var attr2 = { bold: true };
+    var a1 = new Delta().insert('Test', attr1);
+    var a2 = new Delta().insert('Test', attr1);
+    var b1 = new Delta().retain(1, { color: 'red' }).delete(2);
+    var b2 = new Delta().retain(1, { color: 'red' }).delete(2);
+    var expected = new Delta().insert('T', { color: 'red', bold: true }).insert('t', attr1);
+    expect(a1.compose(b1)).toEqual(expected);
+    expect(a1).toEqual(a2);
+    expect(b1).toEqual(b2);
+    expect(attr1).toEqual(attr2);
+  });
+
+  it('retain start optimization', function () {
+    var a = new Delta().insert('A', { bold: true })
+                       .insert('B')
+                       .insert('C', { bold: true })
+                       .delete(1);
+    var b = new Delta().retain(3).insert('D');
+    var expected = new Delta().insert('A', { bold: true })
+                              .insert('B')
+                              .insert('C', { bold: true })
+                              .insert('D')
+                              .delete(1);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain start optimization split', function () {
+    var a = new Delta().insert('A', { bold: true })
+                       .insert('B')
+                       .insert('C', { bold: true })
+                       .retain(5)
+                       .delete(1);
+    var b = new Delta().retain(4).insert('D');
+    var expected = new Delta().insert('A', { bold: true })
+                              .insert('B')
+                              .insert('C', { bold: true })
+                              .retain(1)
+                              .insert('D')
+                              .retain(4)
+                              .delete(1);
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain end optimization', function () {
+    var a = new Delta().insert('A', { bold: true })
+                       .insert('B')
+                       .insert('C', { bold: true });
+    var b = new Delta().delete(1);
+    var expected = new Delta().insert('B').insert('C', { bold: true })
+    expect(a.compose(b)).toEqual(expected);
+  });
+
+  it('retain end optimization join', function () {
+    var a = new Delta().insert('A', { bold: true })
+                       .insert('B')
+                       .insert('C', { bold: true })
+                       .insert('D')
+                       .insert('E', { bold: true })
+                       .insert('F')
+    var b = new Delta().retain(1).delete(1);
+    var expected = new Delta().insert('AC', { bold: true })
+                              .insert('D')
+                              .insert('E', { bold: true })
+                              .insert('F')
+    expect(a.compose(b)).toEqual(expected);
+  });
+});

node_modules/quill-delta/test/delta/diff.js

@@ -0,0 +1,136 @@
+var Delta = require('../../lib/delta');
+
+
+describe('diff()', function () {
+  it('insert', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().insert('AB');
+    var expected = new Delta().retain(1).insert('B');
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('delete', function () {
+    var a = new Delta().insert('AB');
+    var b = new Delta().insert('A');
+    var expected = new Delta().retain(1).delete(1);
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('retain', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().insert('A');
+    var expected = new Delta();
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('format', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().insert('A', { bold: true });
+    var expected = new Delta().retain(1, { bold: true });
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('object attributes', function () {
+    var a = new Delta().insert('A', { font: { family: 'Helvetica', size: '15px' } });
+    var b = new Delta().insert('A', { font: { family: 'Helvetica', size: '15px' } });
+    var expected = new Delta();
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('embed integer match', function () {
+    var a = new Delta().insert(1);
+    var b = new Delta().insert(1);
+    var expected = new Delta();
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('embed integer mismatch', function () {
+    var a = new Delta().insert(1);
+    var b = new Delta().insert(2);
+    var expected = new Delta().delete(1).insert(2);
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('embed object match', function () {
+    var a = new Delta().insert({ image: 'http://quilljs.com' });
+    var b = new Delta().insert({ image: 'http://quilljs.com' });
+    var expected = new Delta();
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('embed object mismatch', function () {
+    var a = new Delta().insert({ image: 'http://quilljs.com', alt: 'Overwrite' });
+    var b = new Delta().insert({ image: 'http://quilljs.com' });
+    var expected = new Delta().insert({ image: 'http://quilljs.com' }).delete(1);
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('embed object change', function () {
+    var embed = { image: 'http://quilljs.com' };
+    var a = new Delta().insert(embed);
+    embed.image = 'http://github.com';
+    var b = new Delta().insert(embed);
+    var expected = new Delta().insert({ image: 'http://github.com' }).delete(1);
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('embed false positive', function () {
+    var a = new Delta().insert(1);
+    var b = new Delta().insert(String.fromCharCode(0)); // Placeholder char for embed in diff()
+    var expected = new Delta().insert(String.fromCharCode(0)).delete(1);
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('error on non-documents', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().retain(1).insert('B');
+    expect(function () {
+      a.diff(b);
+    }).toThrow();
+    expect(function () {
+      b.diff(a);
+    }).toThrow();
+  });
+
+  it('inconvenient indexes', function () {
+    var a = new Delta().insert('12', { bold: true }).insert('34', { italic: true });
+    var b = new Delta().insert('123', { color: 'red' });
+    var expected = new Delta().retain(2, { bold: null, color: 'red' }).retain(1, { italic: null, color: 'red' }).delete(1);
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('combination', function () {
+    var a = new Delta().insert('Bad', { color: 'red' }).insert('cat', { color: 'blue' });
+    var b = new Delta().insert('Good', { bold: true }).insert('dog', { italic: true });
+    var expected = new Delta().insert('Good', { bold: true }).delete(2).retain(1, { italic: true, color: null }).delete(3).insert('og', { italic: true });
+    expect(a.diff(b)).toEqual(expected);
+  });
+
+  it('same document', function () {
+    var a = new Delta().insert('A').insert('B', { bold: true });
+    expected = new Delta();
+    expect(a.diff(a)).toEqual(expected);
+  });
+
+  it('immutability', function () {
+    var attr1 = { color: 'red' };
+    var attr2 = { color: 'red' };
+    var a1 = new Delta().insert('A', attr1);
+    var a2 = new Delta().insert('A', attr1);
+    var b1 = new Delta().insert('A', { bold: true }).insert('B');
+    var b2 = new Delta().insert('A', { bold: true }).insert('B');
+    var expected = new Delta().retain(1, { bold: true, color: null }).insert('B');
+    expect(a1.diff(b1)).toEqual(expected);
+    expect(a1).toEqual(a2);
+    expect(b2).toEqual(b2);
+    expect(attr1).toEqual(attr2);
+  });
+
+  it('non-document', function () {
+    var a = new Delta().insert('Test');
+    var b = new Delta().delete(4);
+    expect(function() {
+      a.diff(b);
+    }).toThrow(new Error('diff() called on non-document'));
+  });
+});

node_modules/quill-delta/test/delta/helpers.js

@@ -0,0 +1,204 @@
+var Delta = require('../../lib/delta');
+
+
+describe('helpers', function () {
+  describe('concat()', function () {
+    it('empty delta', function () {
+      var delta = new Delta().insert('Test');
+      var concat = new Delta();
+      var expected = new Delta().insert('Test');
+      expect(delta.concat(concat)).toEqual(expected);
+    });
+
+    it('unmergeable', function () {
+      var delta = new Delta().insert('Test');
+      var original = new Delta(JSON.parse(JSON.stringify(delta)));
+      var concat = new Delta().insert('!', { bold: true });
+      var expected = new Delta().insert('Test').insert('!', { bold: true });
+      expect(delta.concat(concat)).toEqual(expected);
+      expect(delta).toEqual(original);
+    });
+
+    it('mergeable', function () {
+      var delta = new Delta().insert('Test', { bold: true });
+      var original = new Delta(JSON.parse(JSON.stringify(delta)));
+      var concat = new Delta().insert('!', { bold: true }).insert('\n');
+      var expected = new Delta().insert('Test!', { bold: true }).insert('\n');
+      expect(delta.concat(concat)).toEqual(expected);
+      expect(delta).toEqual(original);
+    });
+  });
+
+  describe('chop()', function () {
+    it('retain', function () {
+      var delta = new Delta().insert('Test').retain(4);
+      var expected = new Delta().insert('Test');
+      expect(delta.chop()).toEqual(expected);
+    });
+
+    it('insert', function () {
+      var delta = new Delta().insert('Test');
+      var expected = new Delta().insert('Test');
+      expect(delta.chop()).toEqual(expected);
+    });
+
+    it('formatted retain', function () {
+      var delta = new Delta().insert('Test').retain(4, { bold: true });
+      var expected = new Delta().insert('Test').retain(4, { bold: true });
+      expect(delta.chop()).toEqual(expected);
+    })
+  });
+
+  describe('eachLine()', function () {
+    var spy = { predicate: function () {} };
+
+    beforeEach(function () {
+      spyOn(spy, 'predicate').and.callThrough();
+    });
+
+    it('expected', function () {
+      var delta = new Delta().insert('Hello\n\n')
+                             .insert('World', { bold: true })
+                             .insert({ image: 'octocat.png' })
+                             .insert('\n', { align: 'right' })
+                             .insert('!');
+      delta.eachLine(spy.predicate);
+      expect(spy.predicate.calls.count()).toEqual(4);
+      expect(spy.predicate.calls.argsFor(0)).toEqual([ new Delta().insert('Hello'), {}, 0 ]);
+      expect(spy.predicate.calls.argsFor(1)).toEqual([ new Delta(), {}, 1 ]);
+      expect(spy.predicate.calls.argsFor(2)).toEqual([
+        new Delta().insert('World', { bold: true }).insert({ image: 'octocat.png' }),
+        { align: 'right' },
+        2
+      ]);
+      expect(spy.predicate.calls.argsFor(3)).toEqual([ new Delta().insert('!'), {}, 3 ]);
+    });
+
+    it('trailing newline', function () {
+      var delta = new Delta().insert('Hello\nWorld!\n');
+      delta.eachLine(spy.predicate);
+      expect(spy.predicate.calls.count()).toEqual(2);
+      expect(spy.predicate.calls.argsFor(0)).toEqual([ new Delta().insert('Hello'), {}, 0 ]);
+      expect(spy.predicate.calls.argsFor(1)).toEqual([ new Delta().insert('World!'), {}, 1 ]);
+    });
+
+    it('non-document', function () {
+      var delta = new Delta().retain(1).delete(2);
+      delta.eachLine(spy.predicate);
+      expect(spy.predicate.calls.count()).toEqual(0);
+    });
+
+    it('early return', function () {
+      var delta = new Delta().insert('Hello\nNew\nWorld!');
+      var count = 0;
+      var spy = {
+        predicate: function() {
+          if (count === 1) return false;
+          count += 1;
+        }
+      };
+      spyOn(spy, 'predicate').and.callThrough();
+      delta.eachLine(spy.predicate);
+      expect(spy.predicate.calls.count()).toEqual(2);
+    });
+  });
+
+  describe('iteration', function () {
+    beforeEach(function() {
+      this.delta = new Delta().insert('Hello').insert({ image: true }).insert('World!');
+    });
+
+    it('filter()', function () {
+      var arr = this.delta.filter(function (op) {
+        return typeof op.insert === 'string';
+      });
+      expect(arr.length).toEqual(2);
+    })
+
+    it('forEach()', function () {
+      var spy = { predicate: function () {} };
+      spyOn(spy, 'predicate').and.callThrough();
+      this.delta.forEach(spy.predicate);
+      expect(spy.predicate.calls.count()).toEqual(3);
+    });
+
+    it('map()', function () {
+      var arr = this.delta.map(function (op) {
+        return typeof op.insert === 'string' ? op.insert : '';
+      });
+      expect(arr).toEqual(['Hello', '', 'World!']);
+    });
+
+    it('partition()', function () {
+      var arr = this.delta.partition(function (op) {
+        return typeof op.insert === 'string';
+      });
+      var passed = arr[0], failed = arr[1];
+      expect(passed).toEqual([this.delta.ops[0], this.delta.ops[2]]);
+      expect(failed).toEqual([this.delta.ops[1]]);
+    });
+  });
+
+  describe('length()', function () {
+    it('document', function () {
+      var delta = new Delta().insert('AB', { bold: true }).insert(1);
+      expect(delta.length()).toEqual(3);
+    });
+
+    it('mixed', function () {
+      var delta = new Delta().insert('AB', { bold: true }).insert(1).retain(2, { bold: null }).delete(1);
+      expect(delta.length()).toEqual(6);
+    });
+  });
+
+  describe('changeLength()', function () {
+    it('mixed', function () {
+      var delta = new Delta().insert('AB', { bold: true }).retain(2, { bold: null }).delete(1);
+      expect(delta.changeLength()).toEqual(1);
+    });
+  });
+
+  describe('slice()', function () {
+    it('start', function () {
+      var slice = new Delta().retain(2).insert('A').slice(2);
+      var expected = new Delta().insert('A');
+      expect(slice).toEqual(expected);
+    });
+
+    it('start and end chop', function () {
+      var slice = new Delta().insert('0123456789').slice(2, 7);
+      var expected = new Delta().insert('23456');
+      expect(slice).toEqual(expected);
+    });
+
+    it('start and end multiple chop', function () {
+      var slice = new Delta().insert('0123', { bold: true }).insert('4567').slice(3, 5);
+      var expected = new Delta().insert('3', { bold: true }).insert('4');
+      expect(slice).toEqual(expected);
+    });
+
+    it('start and end', function () {
+      var slice = new Delta().retain(2).insert('A', { bold: true }).insert('B').slice(2, 3);
+      var expected = new Delta().insert('A', { bold: true });
+      expect(slice).toEqual(expected);
+    });
+
+    it('no params', function () {
+      var delta = new Delta().retain(2).insert('A', { bold: true }).insert('B');
+      var slice = delta.slice();
+      expect(slice).toEqual(delta);
+    });
+
+    it('split ops', function () {
+      var slice = new Delta().insert('AB', { bold: true }).insert('C').slice(1, 2);
+      var expected = new Delta().insert('B', { bold: true });
+      expect(slice).toEqual(expected);
+    });
+
+    it('split ops multiple times', function () {
+      var slice = new Delta().insert('ABC', { bold: true }).insert('D').slice(1, 2);
+      var expected = new Delta().insert('B', { bold: true });
+      expect(slice).toEqual(expected);
+    });
+  });
+});

node_modules/quill-delta/test/delta/transform-position.js

@@ -0,0 +1,50 @@
+var Delta = require('../../lib/delta');
+
+
+describe('transformPosition()', function () {
+  it('insert before position', function () {
+    var delta = new Delta().insert('A');
+    expect(delta.transform(2)).toEqual(3);
+  });
+
+  it('insert after position', function () {
+    var delta = new Delta().retain(2).insert('A');
+    expect(delta.transform(1)).toEqual(1);
+  });
+
+  it('insert at position', function () {
+    var delta = new Delta().retain(2).insert('A');
+    expect(delta.transform(2, true)).toEqual(2);
+    expect(delta.transform(2, false)).toEqual(3);
+  });
+
+  it('delete before position', function () {
+    var delta = new Delta().delete(2);
+    expect(delta.transform(4)).toEqual(2);
+  });
+
+  it('delete after position', function () {
+    var delta = new Delta().retain(4).delete(2);
+    expect(delta.transform(2)).toEqual(2);
+  });
+
+  it('delete across position', function () {
+    var delta = new Delta().retain(1).delete(4);
+    expect(delta.transform(2)).toEqual(1);
+  });
+
+  it('insert and delete before position', function () {
+    var delta = new Delta().retain(2).insert('A').delete(2);
+    expect(delta.transform(4)).toEqual(3);
+  });
+
+  it('insert before and delete across position', function () {
+    var delta = new Delta().retain(2).insert('A').delete(4);
+    expect(delta.transform(4)).toEqual(3);
+  });
+
+  it('delete before and delete across position', function () {
+    var delta = new Delta().delete(1).retain(1).delete(4);
+    expect(delta.transform(4)).toEqual(1);
+  });
+});

node_modules/quill-delta/test/delta/transform.js

@@ -0,0 +1,141 @@
+var Delta = require('../../lib/delta');
+
+
+describe('transform()', function () {
+  it('insert + insert', function () {
+    var a1 = new Delta().insert('A');
+    var b1 = new Delta().insert('B');
+    var a2 = new Delta(a1);
+    var b2 = new Delta(b1);
+    var expected1 = new Delta().retain(1).insert('B');
+    var expected2 = new Delta().insert('B');
+    expect(a1.transform(b1, true)).toEqual(expected1);
+    expect(a2.transform(b2, false)).toEqual(expected2);
+  });
+
+  it('insert + retain', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().retain(1, { bold: true, color: 'red' });
+    var expected = new Delta().retain(1).retain(1, { bold: true, color: 'red' });
+    expect(a.transform(b, true)).toEqual(expected);
+  });
+
+  it('insert + delete', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().delete(1);
+    var expected = new Delta().retain(1).delete(1);
+    expect(a.transform(b, true)).toEqual(expected);
+  });
+
+  it('delete + insert', function () {
+    var a = new Delta().delete(1);
+    var b = new Delta().insert('B');
+    var expected = new Delta().insert('B');
+    expect(a.transform(b, true)).toEqual(expected);
+  });
+
+  it('delete + retain', function () {
+    var a = new Delta().delete(1);
+    var b = new Delta().retain(1, { bold: true, color: 'red' });
+    var expected = new Delta();
+    expect(a.transform(b, true)).toEqual(expected);
+  });
+
+  it('delete + delete', function () {
+    var a = new Delta().delete(1);
+    var b = new Delta().delete(1);
+    var expected = new Delta();
+    expect(a.transform(b, true)).toEqual(expected);
+  });
+
+  it('retain + insert', function () {
+    var a = new Delta().retain(1, { color: 'blue' });
+    var b = new Delta().insert('B');
+    var expected = new Delta().insert('B');
+    expect(a.transform(b, true)).toEqual(expected);
+  });
+
+  it('retain + retain', function () {
+    var a1 = new Delta().retain(1, { color: 'blue' });
+    var b1 = new Delta().retain(1, { bold: true, color: 'red' });
+    var a2 = new Delta().retain(1, { color: 'blue' });
+    var b2 = new Delta().retain(1, { bold: true, color: 'red' });
+    var expected1 = new Delta().retain(1, { bold: true });
+    var expected2 = new Delta();
+    expect(a1.transform(b1, true)).toEqual(expected1);
+    expect(b2.transform(a2, true)).toEqual(expected2);
+  });
+
+  it('retain + retain without priority', function () {
+    var a1 = new Delta().retain(1, { color: 'blue' });
+    var b1 = new Delta().retain(1, { bold: true, color: 'red' });
+    var a2 = new Delta().retain(1, { color: 'blue' });
+    var b2 = new Delta().retain(1, { bold: true, color: 'red' });
+    var expected1 = new Delta().retain(1, { bold: true, color: 'red' });
+    var expected2 = new Delta().retain(1, { color: 'blue' });
+    expect(a1.transform(b1, false)).toEqual(expected1);
+    expect(b2.transform(a2, false)).toEqual(expected2);
+  });
+
+  it('retain + delete', function () {
+    var a = new Delta().retain(1, { color: 'blue' });
+    var b = new Delta().delete(1);
+    var expected = new Delta().delete(1);
+    expect(a.transform(b, true)).toEqual(expected);
+  });
+
+  it('alternating edits', function () {
+    var a1 = new Delta().retain(2).insert('si').delete(5);
+    var b1 = new Delta().retain(1).insert('e').delete(5).retain(1).insert('ow');
+    var a2 = new Delta(a1);
+    var b2 = new Delta(b1);
+    var expected1 = new Delta().retain(1).insert('e').delete(1).retain(2).insert('ow');
+    var expected2 = new Delta().retain(2).insert('si').delete(1);
+    expect(a1.transform(b1, false)).toEqual(expected1);
+    expect(b2.transform(a2, false)).toEqual(expected2);
+  });
+
+  it('conflicting appends', function () {
+    var a1 = new Delta().retain(3).insert('aa');
+    var b1 = new Delta().retain(3).insert('bb');
+    var a2 = new Delta(a1);
+    var b2 = new Delta(b1);
+    var expected1 = new Delta().retain(5).insert('bb');
+    var expected2 = new Delta().retain(3).insert('aa');
+    expect(a1.transform(b1, true)).toEqual(expected1);
+    expect(b2.transform(a2, false)).toEqual(expected2);
+  });
+
+  it('prepend + append', function () {
+    var a1 = new Delta().insert('aa');
+    var b1 = new Delta().retain(3).insert('bb');
+    var expected1 = new Delta().retain(5).insert('bb');
+    var a2 = new Delta(a1);
+    var b2 = new Delta(b1);
+    var expected2 = new Delta().insert('aa');
+    expect(a1.transform(b1, false)).toEqual(expected1);
+    expect(b2.transform(a2, false)).toEqual(expected2);
+  });
+
+  it('trailing deletes with differing lengths', function () {
+    var a1 = new Delta().retain(2).delete(1);
+    var b1 = new Delta().delete(3);
+    var expected1 = new Delta().delete(2);
+    var a2 = new Delta(a1);
+    var b2 = new Delta(b1);
+    var expected2 = new Delta();
+    expect(a1.transform(b1, false)).toEqual(expected1);
+    expect(b2.transform(a2, false)).toEqual(expected2);
+  });
+
+  it('immutability', function () {
+    var a1 = new Delta().insert('A');
+    var a2 = new Delta().insert('A');
+    var b1 = new Delta().insert('B');
+    var b2 = new Delta().insert('B');
+    var expected = new Delta().retain(1).insert('B');
+    expect(a1.transform(b1, true)).toEqual(expected);
+    expect(a1).toEqual(a2);
+    expect(b1).toEqual(b2);
+  });
+});