first commit

node_modules/rich-text/test/delta/builder.js

@@ -0,0 +1,187 @@
+var Delta = require('../../lib/delta');
+var expect = require('chai').expect;
+
+
+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).to.exist;
+    expect(delta.ops).to.exist;
+    expect(delta.ops.length).to.equal(0);
+  });
+
+  it('empty ops', function () {
+    var delta = new Delta().insert('').delete(0).retain(0);
+    expect(delta).to.exist;
+    expect(delta.ops).to.exist;
+    expect(delta.ops.length).to.equal(0);
+  });
+
+  it('array of ops', function () {
+    var delta = new Delta(ops);
+    expect(delta.ops).to.deep.equal(ops);
+  });
+
+  it('delta in object form', function () {
+    var delta = new Delta({ ops: ops });
+    expect(delta.ops).to.deep.equal(ops);
+  });
+
+  it('delta', function () {
+    var original = new Delta(ops);
+    var delta = new Delta(original);
+    expect(delta.ops).to.deep.equal(original.ops);
+    expect(delta.ops).to.deep.equal(ops);
+  });
+});
+
+describe('insert()', function () {
+  it('insert(text)', function () {
+    var delta = new Delta().insert('test');
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ insert: 'test' });
+  });
+
+  it('insert(embed)', function () {
+    var delta = new Delta().insert(1);
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ 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).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ insert: 1, attributes: obj });
+  });
+
+  it('insert(text, attributes)', function () {
+    var delta = new Delta().insert('test', { bold: true });
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ 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).to.deep.equal(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).to.deep.equal(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).to.deep.equal(expected);
+  });
+
+  it('insert(text, {})', function () {
+    var delta = new Delta().insert('a', {});
+    var expected = new Delta().insert('a');
+    expect(delta).to.deep.equal(expected);
+  });
+});
+
+describe('delete()', function () {
+  it('delete(0)', function () {
+    var delta = new Delta().delete(0);
+    expect(delta.ops.length).to.equal(0);
+  });
+
+  it('delete(positive)', function () {
+    var delta = new Delta().delete(1);
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ delete: 1 });
+  });
+});
+
+describe('retain()', function () {
+  it('retain(0)', function () {
+    var delta = new Delta().retain(0);
+    expect(delta.ops.length).to.equal(0);
+  });
+
+  it('retain(length)', function () {
+    var delta = new Delta().retain(2);
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ retain: 2 });
+  });
+
+  it('retain(length, attributes)', function () {
+    var delta = new Delta().retain(1, { bold: true });
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ 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).to.deep.equal(expected);
+  });
+});
+
+describe('push()', function () {
+  it('push(op) into empty', function () {
+    var delta = new Delta();
+    delta.push({ insert: 'test' });
+    expect(delta.ops.length).to.equal(1);
+  });
+
+  it('push(op) consecutive delete', function () {
+    var delta = new Delta().delete(2);
+    delta.push({ delete: 3 });
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ delete: 5 });
+  });
+
+  it('push(op) consecutive text', function () {
+    var delta = new Delta().insert('a');
+    delta.push({ insert: 'b' });
+    expect(delta.ops.length).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ 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).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ 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).to.equal(1);
+    expect(delta.ops[0]).to.deep.equal({ 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).to.equal(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).to.equal(2);
+  });
+
+  it('push(op) consecutive embeds with matching attributes', function () {
+    var delta = new Delta().insert({ url: 'http://quilljs.com' });
+    delta.push({ attributes: { url: 'http://quilljs.com' } });
+    expect(delta.ops.length).to.equal(2);
+  });
+});

node_modules/rich-text/test/delta/compose.js

@@ -0,0 +1,127 @@
+var Delta = require('../../lib/delta');
+var expect = require('chai').expect;
+
+
+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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(expected);
+    expect(b.compose(deleteFirst)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(expected);
+  });
+});

node_modules/rich-text/test/delta/diff.js

@@ -0,0 +1,72 @@
+var Delta = require('../../lib/delta');
+var expect = require('chai').expect;
+
+
+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)).to.deep.equal(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)).to.deep.equal(expected);
+  });
+
+  it('retain', function () {
+    var a = new Delta().insert('A');
+    var b = new Delta().insert('A');
+    var expected = new Delta();
+    expect(a.diff(b)).to.deep.equal(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)).to.deep.equal(expected);
+  });
+
+  it('embed match', function () {
+    var a = new Delta().insert(1);
+    var b = new Delta().insert(1);
+    var expected = new Delta();
+    expect(a.diff(b)).to.deep.equal(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)).to.deep.equal(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);
+    }).to.throw(Error);
+    expect(function () {
+      b.diff(a);
+    }).to.throw(Error);
+  });
+
+  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)).to.deep.equal(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)).to.deep.equal(expected);
+  });
+});

node_modules/rich-text/test/delta/helpers.js

@@ -0,0 +1,81 @@
+var Delta = require('../../lib/delta');
+var expect = require('chai').expect;
+
+
+describe('helpers', function () {
+  describe('chop()', function () {
+    it('retain', function () {
+      var delta = new Delta().insert('Test').retain(4);
+      var expected = new Delta().insert('Test');
+      expect(delta.chop()).to.deep.equal(expected);
+    });
+
+    it('insert', function () {
+      var delta = new Delta().insert('Test');
+      var expected = new Delta().insert('Test');
+      expect(delta.chop()).to.deep.equal(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()).to.deep.equal(expected);
+    })
+  });
+
+  describe('length()', function () {
+    it('document', function () {
+      var delta = new Delta().insert('AB', { bold: true }).insert(1);
+      expect(delta.length()).to.equal(3);
+    });
+
+    it('mixed', function () {
+      var delta = new Delta().insert('AB', { bold: true }).insert(1).retain(2, { bold: null }).delete(1);
+      expect(delta.length()).to.equal(6);
+    });
+  });
+
+  describe('slice()', function () {
+    it('start', function () {
+      var slice = new Delta().retain(2).insert('A').slice(2);
+      var expected = new Delta().insert('A');
+      expect(slice).to.deep.equal(expected);
+    });
+
+    it('start and end chop', function () {
+      var slice = new Delta().insert('0123456789').slice(2, 7);
+      var expected = new Delta().insert('23456');
+      expect(slice).to.deep.equal(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).to.deep.equal(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).to.deep.equal(expected);
+    });
+
+    it('no params', function () {
+      var delta = new Delta().retain(2).insert('A', { bold: true }).insert('B');
+      var slice = delta.slice();
+      expect(slice).to.deep.equal(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).to.deep.equal(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).to.deep.equal(expected);
+    });
+  });
+});

node_modules/rich-text/test/delta/transform-position.js

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

node_modules/rich-text/test/delta/transform.js

@@ -0,0 +1,131 @@
+var Delta = require('../../lib/delta');
+var expect = require('chai').expect;
+
+
+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)).to.deep.equal(expected1);
+    expect(a2.transform(b2, false)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(expected1);
+    expect(b2.transform(a2, true)).to.deep.equal(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)).to.deep.equal(expected1);
+    expect(b2.transform(a2, false)).to.deep.equal(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)).to.deep.equal(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)).to.deep.equal(expected1);
+    expect(b2.transform(a2, false)).to.deep.equal(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)).to.deep.equal(expected1);
+    expect(b2.transform(a2, false)).to.deep.equal(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)).to.deep.equal(expected1);
+    expect(b2.transform(a2, false)).to.deep.equal(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)).to.deep.equal(expected1);
+    expect(b2.transform(a2, false)).to.deep.equal(expected2);
+  });
+});