overleaf/services/document-updater/test/unit/js/RangesManager/RangesManagerTests.js
Eric Mc Sween 55c342134c Merge pull request #18659 from overleaf/em-crop-comments-tracked-deletes
Crop comments when processing tracked deletes

GitOrigin-RevId: 662c9ed86a8ed4959d1671ce466548487f334f45
2024-06-05 08:03:53 +00:00

1029 lines
30 KiB
JavaScript

const sinon = require('sinon')
const { expect } = require('chai')
const SandboxedModule = require('sandboxed-module')
const MODULE_PATH = '../../../../app/js/RangesManager.js'
const TEST_USER_ID = 'user-id-123'
describe('RangesManager', function () {
beforeEach(function () {
this.RangesManager = SandboxedModule.require(MODULE_PATH, {
requires: {
'@overleaf/metrics': (this.Metrics = { histogram: sinon.stub() }),
},
})
this.doc_id = 'doc-id-123'
this.project_id = 'project-id-123'
this.user_id = TEST_USER_ID
})
describe('applyUpdate', function () {
beforeEach(function () {
this.ops = [{ i: 'two ', p: 4 }]
this.historyOps = [{ i: 'two ', p: 4, hpos: 4 }]
this.meta = { user_id: this.user_id }
this.updates = [{ meta: this.meta, op: this.ops }]
this.ranges = {
comments: makeRanges([{ c: 'three ', p: 4 }]),
changes: makeRanges([{ i: 'five', p: 15 }]),
}
this.newDocLines = ['one two three four five']
// old is "one three four five"
})
describe('successfully', function () {
beforeEach(function () {
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
})
it('should return the modified the comments and changes', function () {
expect(this.result.rangesWereCollapsed).to.equal(false)
this.result.newRanges.comments[0].op.should.deep.equal({
c: 'three ',
p: 8,
})
this.result.newRanges.changes[0].op.should.deep.equal({
i: 'five',
p: 19,
})
})
it('should return unmodified updates for the history', function () {
expect(this.result.historyUpdates).to.deep.equal(this.updates)
})
})
describe('with empty comments', function () {
beforeEach(function () {
this.ranges.comments = []
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
})
it('should return an object with no comments', function () {
// Save space in redis and don't store just {}
expect(this.result.newRanges.comments).to.be.undefined
})
it('should return unmodified updates for the history', function () {
expect(this.result.historyUpdates).to.deep.equal(this.updates)
})
})
describe('with empty changes', function () {
beforeEach(function () {
this.ranges.changes = []
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
})
it('should return an object with no changes', function () {
// Save space in redis and don't store just {}
expect(this.result.newRanges.changes).to.be.undefined
})
it('should return unmodified updates for the history', function () {
expect(this.result.historyUpdates).to.deep.equal(this.updates)
})
})
describe('with too many comments', function () {
beforeEach(function () {
this.RangesManager.MAX_COMMENTS = 2
this.updates = makeUpdates([{ c: 'one', p: 0, t: 'thread-id-1' }])
this.ranges = {
comments: makeRanges([
{ c: 'three ', p: 4, t: 'thread-id-2' },
{ c: 'four ', p: 10, t: 'thread-id-3' },
]),
changes: [],
}
})
it('should throw an error', function () {
expect(() => {
this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
}).to.throw('too many comments or tracked changes')
})
})
describe('with too many changes', function () {
beforeEach(function () {
this.RangesManager.MAX_CHANGES = 2
this.updates = makeUpdates([{ i: 'one ', p: 0 }], {
tc: 'track-changes-id-yes',
})
this.ranges = {
changes: makeRanges([
{
i: 'three',
p: 4,
},
{
i: 'four',
p: 10,
},
]),
comments: [],
}
this.newDocLines = ['one two three four']
})
it('should throw an error', function () {
expect(() => {
this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
}).to.throw('too many comments or tracked changes')
})
})
describe('inconsistent changes', function () {
beforeEach(function () {
this.updates = makeUpdates([{ c: "doesn't match", p: 0 }])
})
it('should throw an error', function () {
expect(() => {
this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
}).to.throw('insertion does not match text in document')
})
})
describe('with an update that collapses a range', function () {
beforeEach(function () {
this.updates = makeUpdates([{ d: 'one', p: 0, t: 'thread-id-1' }])
this.ranges = {
comments: makeRanges([
{
c: 'n',
p: 1,
t: 'thread-id-2',
},
]),
changes: [],
}
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
})
it('should return ranges_were_collapsed == true', function () {
expect(this.result.rangesWereCollapsed).to.equal(true)
})
})
describe('with an update that deletes ranges', function () {
beforeEach(function () {
this.updates = makeUpdates([{ d: 'one two three four five', p: 0 }])
this.ranges = {
comments: makeRanges([{ c: 'n', p: 1, t: 'thread-id-2' }]),
changes: makeRanges([{ i: 'hello', p: 1, t: 'thread-id-2' }]),
}
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
})
it('should increment the range-delta histogram', function () {
this.Metrics.histogram.called.should.equal(true)
})
it('should return ranges_were_collapsed == true', function () {
expect(this.result.rangesWereCollapsed).to.equal(true)
})
})
describe('with comment updates', function () {
beforeEach(function () {
this.updates = makeUpdates([
{ i: 'two ', p: 4 },
{ c: 'one', p: 0 },
])
this.ranges = {}
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines
)
})
it('should not send comments to the history', function () {
expect(this.result.historyUpdates[0].op).to.deep.equal([
{ i: 'two ', p: 4 },
])
})
})
describe('with history ranges support', function () {
describe('inserts among tracked deletes', function () {
beforeEach(function () {
// original text is "on[1]e[22] [333](three) fo[4444]ur five"
// [] denotes tracked deletes
// () denotes tracked inserts
this.ranges = {
changes: makeRanges([
{ d: '1', p: 2 },
{ d: '22', p: 3 },
{ d: '333', p: 4 },
{ i: 'three', p: 4 },
{ d: '4444', p: 12 },
]),
}
this.updates = makeUpdates([
{ i: 'zero ', p: 0 },
{ i: 'two ', p: 9, u: true },
])
this.newDocLines = ['zero one two three four five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should offset the hpos by the length of tracked deletes before the insert', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[{ i: 'zero ', p: 0 }],
// 'two' is added just before the "333" tracked delete
[{ i: 'two ', p: 9, u: true, hpos: 12 }],
])
})
})
describe('tracked delete rejections', function () {
beforeEach(function () {
// original text is "one [two ]three four five"
// [] denotes tracked deletes
this.ranges = {
changes: makeRanges([{ d: 'two ', p: 4 }]),
}
this.updates = makeUpdates([{ i: 'tw', p: 4, u: true }])
this.newDocLines = ['one twthree four five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should mark the insert as a tracked delete rejection where appropriate', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[{ i: 'tw', p: 4, u: true, trackedDeleteRejection: true }],
])
})
})
describe('deletes over tracked changes', function () {
beforeEach(function () {
// original text is "on[1]e [22](three) f[333]ou[4444]r [55555]five"
// [] denotes tracked deletes
// () denotes tracked inserts
this.ranges = {
comments: [],
changes: makeRanges([
{ d: '1', p: 2 },
{ d: '22', p: 4 },
{ i: 'three', p: 4 },
{ d: '333', p: 11 },
{ d: '4444', p: 13 },
{ d: '55555', p: 15 },
]),
}
this.updates = makeUpdates([
{ d: 'four ', p: 10 },
{ d: 'three ', p: 4 },
])
this.newDocLines = ['one five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should split and offset deletes appropriately', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[
// the "four" delete has tracked deletes inside it, add splits
{
d: 'four ',
p: 10,
hpos: 13,
trackedChanges: [
{ type: 'delete', offset: 1, length: 3 },
{ type: 'delete', offset: 3, length: 4 },
],
},
],
// the "three" delete is offset to the right by the two first tracked
// deletes
[
{
d: 'three ',
p: 4,
hpos: 7,
trackedChanges: [{ type: 'insert', offset: 0, length: 5 }],
},
],
])
})
})
describe('deletes that overlap tracked inserts', function () {
beforeEach(function () {
// original text is "(one) (three) (four) five"
// [] denotes tracked deletes
// () denotes tracked inserts
this.ranges = {
comments: [],
changes: makeRanges([
{ i: 'one', p: 0 },
{ i: 'three', p: 4 },
{ i: 'four', p: 10 },
]),
}
this.updates = makeUpdates(
[
{ d: 'ne th', p: 1 },
{ d: 'ou', p: 6 },
],
{ tc: 'tracked-change-id' }
)
this.newDocLines = ['oree fr five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should split and offset deletes appropriately', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[
{
d: 'ne th',
p: 1,
trackedChanges: [
{ type: 'insert', offset: 0, length: 2 },
{ type: 'insert', offset: 3, length: 2 },
],
},
],
[
{
d: 'ou',
p: 6,
hpos: 7,
trackedChanges: [{ type: 'insert', offset: 0, length: 2 }],
},
],
])
})
})
describe('comments among tracked deletes', function () {
beforeEach(function () {
// original text is "on[1]e[22] [333](three) fo[4444]ur five"
// [] denotes tracked deletes
// () denotes tracked inserts
this.ranges = {
changes: makeRanges([
{ d: '1', p: 2 },
{ d: '22', p: 3 },
{ d: '333', p: 4 },
{ i: 'three', p: 4 },
{ d: '4444', p: 12 },
]),
}
this.updates = makeUpdates([
{ c: 'three ', p: 4 },
{ c: 'four ', p: 10 },
])
this.newDocLines = ['one three four five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should offset the hpos by the length of tracked deletes before the insert', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[{ c: 'three ', p: 4, hpos: 10 }],
[{ c: 'four ', p: 10, hpos: 16, hlen: 9 }],
])
})
})
describe('inserts inside comments', function () {
beforeEach(function () {
// original text is "one three four five"
this.ranges = {
comments: makeRanges([
{ c: 'three', p: 4, t: 'comment-id-1' },
{ c: 'ree four', p: 6, t: 'comment-id-2' },
]),
}
this.updates = makeUpdates([
{ i: '[before]', p: 4 },
{ i: '[inside]', p: 13 }, // 4 + 8 + 1
{ i: '[overlap]', p: 23 }, // 13 + 8 + 2
{ i: '[after]', p: 39 }, // 23 + 9 + 7
])
this.newDocLines = [
'one [before]t[inside]hr[overlap]ee four[after] five',
]
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should add the proper commentIds properties to ops', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[{ i: '[before]', p: 4 }],
[{ i: '[inside]', p: 13, commentIds: ['comment-id-1'] }],
[
{
i: '[overlap]',
p: 23,
commentIds: ['comment-id-1', 'comment-id-2'],
},
],
[{ i: '[after]', p: 39 }],
])
})
})
describe('tracked delete that overlaps the start of a comment', function () {
beforeEach(function () {
// original text is "one three four five"
this.ranges = {
comments: makeRanges([{ c: 'three', p: 4, t: 'comment-id-1' }]),
}
this.updates = makeUpdates([{ d: 'ne thr', p: 1 }], {
tc: 'tracking-id',
})
this.newDocLines = ['oee four five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should crop the beginning of the comment', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[
{ d: 'ne thr', p: 1 },
{ c: 'ee', p: 1, hpos: 7, t: 'comment-id-1' },
],
])
})
})
describe('tracked delete that overlaps a whole comment', function () {
beforeEach(function () {
// original text is "one three four five"
this.ranges = {
comments: makeRanges([{ c: 'three', p: 4, t: 'comment-id-1' }]),
}
this.updates = makeUpdates([{ d: 'ne three f', p: 1 }], {
tc: 'tracking-id',
})
this.newDocLines = ['oour five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should crop the beginning of the comment', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[
{ d: 'ne three f', p: 1 },
{ c: '', p: 1, hpos: 11, t: 'comment-id-1' },
],
])
})
})
describe('tracked delete that overlaps the end of a comment', function () {
beforeEach(function () {
// original text is "one three four five"
this.ranges = {
comments: makeRanges([{ c: 'three', p: 4, t: 'comment-id-1' }]),
}
this.updates = makeUpdates([{ d: 'ee f', p: 7 }], {
tc: 'tracking-id',
})
this.newDocLines = ['one throur five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should crop the end of the comment', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[
{ d: 'ee f', p: 7 },
{ c: 'thr', p: 4, t: 'comment-id-1' },
],
])
})
})
describe('tracked delete that overlaps the inside of a comment', function () {
beforeEach(function () {
// original text is "one three four five"
this.ranges = {
comments: makeRanges([{ c: 'three', p: 4, t: 'comment-id-1' }]),
}
this.updates = makeUpdates([{ d: 'hre', p: 5 }], {
tc: 'tracking-id',
})
this.newDocLines = ['one te four five']
this.result = this.RangesManager.applyUpdate(
this.project_id,
this.doc_id,
this.ranges,
this.updates,
this.newDocLines,
{ historyRangesSupport: true }
)
})
it('should not crop the comment', function () {
expect(this.result.historyUpdates.map(x => x.op)).to.deep.equal([
[{ d: 'hre', p: 5 }],
])
})
})
})
})
describe('acceptChanges', function () {
beforeEach(function () {
this.RangesManager = SandboxedModule.require(MODULE_PATH, {
requires: {
'@overleaf/ranges-tracker': (this.RangesTracker =
SandboxedModule.require('@overleaf/ranges-tracker')),
'@overleaf/metrics': {},
},
})
this.ranges = {
comments: [],
changes: makeRanges([
{ i: 'lorem', p: 0 },
{ i: 'ipsum', p: 10 },
{ i: 'dolor', p: 20 },
{ i: 'sit', p: 30 },
{ i: 'amet', p: 40 },
]),
}
this.removeChangeIdsSpy = sinon.spy(
this.RangesTracker.prototype,
'removeChangeIds'
)
})
describe('successfully with a single change', function () {
beforeEach(function () {
this.change_ids = [this.ranges.changes[1].id]
this.result = this.RangesManager.acceptChanges(
this.change_ids,
this.ranges
)
})
it('should log the call with the correct number of changes', function () {
this.logger.debug
.calledWith('accepting 1 changes in ranges')
.should.equal(true)
})
it('should delegate the change removal to the ranges tracker', function () {
this.removeChangeIdsSpy.calledWith(this.change_ids).should.equal(true)
})
it('should remove the change', function () {
expect(
this.result.changes.find(
change => change.id === this.ranges.changes[1].id
)
).to.be.undefined
})
it('should return the original number of changes minus 1', function () {
this.result.changes.length.should.equal(this.ranges.changes.length - 1)
})
it('should not touch other changes', function () {
for (const i of [0, 2, 3, 4]) {
expect(
this.result.changes.find(
change => change.id === this.ranges.changes[i].id
)
).to.deep.equal(this.ranges.changes[i])
}
})
})
describe('successfully with multiple changes', function () {
beforeEach(function () {
this.change_ids = [
this.ranges.changes[1].id,
this.ranges.changes[3].id,
this.ranges.changes[4].id,
]
this.result = this.RangesManager.acceptChanges(
this.change_ids,
this.ranges
)
})
it('should log the call with the correct number of changes', function () {
this.logger.debug
.calledWith(`accepting ${this.change_ids.length} changes in ranges`)
.should.equal(true)
})
it('should delegate the change removal to the ranges tracker', function () {
this.removeChangeIdsSpy.calledWith(this.change_ids).should.equal(true)
})
it('should remove the changes', function () {
for (const i of [1, 3, 4]) {
expect(
this.result.changes.find(
change => change.id === this.ranges.changes[i].id
)
).to.be.undefined
}
})
it('should return the original number of changes minus the number of accepted changes', function () {
this.result.changes.length.should.equal(this.ranges.changes.length - 3)
})
it('should not touch other changes', function () {
for (const i of [0, 2]) {
expect(
this.result.changes.find(
change => change.id === this.ranges.changes[i].id
)
).to.deep.equal(this.ranges.changes[i])
}
})
})
})
describe('getHistoryUpdatesForAcceptedChanges', function () {
beforeEach(function () {
this.RangesManager = SandboxedModule.require(MODULE_PATH, {
requires: {
'@overleaf/ranges-tracker': (this.RangesTracker =
SandboxedModule.require('@overleaf/ranges-tracker')),
'@overleaf/metrics': {},
},
})
})
it('should create history updates for accepted track inserts', function () {
// 'one two three four five' <-- text before changes
const ranges = {
comments: [],
changes: makeRanges([
{ i: 'lorem', p: 0 },
{ i: 'ipsum', p: 15 },
]),
}
const lines = ['loremone two thipsumree four five']
const result = this.RangesManager.getHistoryUpdatesForAcceptedChanges({
docId: this.doc_id,
acceptedChangeIds: ranges.changes.map(change => change.id),
changes: ranges.changes,
pathname: '',
projectHistoryId: '',
lines,
})
expect(result).to.deep.equal([
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 33,
pathname: '',
ts: ranges.changes[0].metadata.ts,
},
op: [
{
r: 'lorem',
p: 0,
tracking: { type: 'none' },
},
],
},
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 33,
pathname: '',
ts: ranges.changes[1].metadata.ts,
},
op: [
{
r: 'ipsum',
p: 15,
tracking: { type: 'none' },
},
],
},
])
})
it('should create history updates for accepted track deletes', function () {
// 'one two three four five' <-- text before changes
const ranges = {
comments: [],
changes: makeRanges([
{ d: 'two', p: 4 },
{ d: 'three', p: 5 },
]),
}
const lines = ['one four five']
const result = this.RangesManager.getHistoryUpdatesForAcceptedChanges({
docId: this.doc_id,
acceptedChangeIds: ranges.changes.map(change => change.id),
changes: ranges.changes,
pathname: '',
projectHistoryId: '',
lines,
})
expect(result).to.deep.equal([
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 15,
history_doc_length: 23,
pathname: '',
ts: ranges.changes[0].metadata.ts,
},
op: [
{
d: 'two',
p: 4,
},
],
},
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 15,
history_doc_length: 20,
pathname: '',
ts: ranges.changes[1].metadata.ts,
},
op: [
{
d: 'three',
p: 5,
},
],
},
])
})
it('should create history updates with unaccepted deletes', function () {
// 'one two three four five' <-- text before changes
const ranges = {
comments: [],
changes: makeRanges([
{ d: 'two', p: 4 },
{ d: 'three', p: 5 },
]),
}
const lines = ['one four five']
const result = this.RangesManager.getHistoryUpdatesForAcceptedChanges({
docId: this.doc_id,
acceptedChangeIds: [ranges.changes[1].id],
changes: ranges.changes,
pathname: '',
projectHistoryId: '',
lines,
})
expect(result).to.deep.equal([
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 15,
history_doc_length: 23,
pathname: '',
ts: ranges.changes[1].metadata.ts,
},
op: [
{
d: 'three',
p: 5,
hpos: 8,
},
],
},
])
})
it('should create history updates with mixed track changes', function () {
// 'one two three four five' <-- text before changes
const ranges = {
comments: [],
changes: makeRanges([
{ d: 'two', p: 4 },
{ d: 'three', p: 5 },
{ i: 'xxx ', p: 6 },
{ d: 'five', p: 15 },
]),
}
const lines = ['one xxx four ']
const result = this.RangesManager.getHistoryUpdatesForAcceptedChanges({
docId: this.doc_id,
acceptedChangeIds: [
ranges.changes[0].id,
// ranges.changes[1].id - second delete is not accepted
ranges.changes[2].id,
ranges.changes[3].id,
],
changes: ranges.changes,
pathname: '',
projectHistoryId: '',
lines,
})
expect(result).to.deep.equal([
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 15,
history_doc_length: 27,
pathname: '',
ts: ranges.changes[0].metadata.ts,
},
op: [
{
d: 'two',
p: 4,
},
],
},
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 15,
history_doc_length: 24,
pathname: '',
ts: ranges.changes[1].metadata.ts,
},
op: [
{
r: 'xxx ',
p: 6,
hpos: 11,
tracking: { type: 'none' },
},
],
},
{
doc: this.doc_id,
meta: {
user_id: TEST_USER_ID,
doc_length: 15,
history_doc_length: 24,
pathname: '',
ts: ranges.changes[2].metadata.ts,
},
op: [
{
d: 'five',
p: 15,
hpos: 20,
},
],
},
])
})
})
})
function makeRanges(ops) {
let id = 1
const changes = []
for (const op of ops) {
changes.push({
id: id.toString(),
op,
metadata: { user_id: TEST_USER_ID, ts: new Date() },
})
id += 1
}
return changes
}
function makeUpdates(ops, meta = {}) {
const updates = []
for (const op of ops) {
updates.push({
meta: { user_id: TEST_USER_ID, ...meta },
op: [op],
})
}
return updates
}