CoCalc -- linesLayout.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/editor/test/common/viewLayout/linesLayout.test.ts
³²⁹⁶ views
1
/*---------------------------------------------------------------------------------------------
2
 *  Copyright (c) Microsoft Corporation. All rights reserved.
3
 *  Licensed under the MIT License. See License.txt in the project root for license information.
4
 *--------------------------------------------------------------------------------------------*/
5
import assert from 'assert';
6
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
7
import { EditorWhitespace, LinesLayout } from '../../../common/viewLayout/linesLayout.js';
8

9
suite('Editor ViewLayout - LinesLayout', () => {
10

11
	ensureNoDisposablesAreLeakedInTestSuite();
12

13
	function insertWhitespace(linesLayout: LinesLayout, afterLineNumber: number, ordinal: number, heightInPx: number, minWidth: number): string {
14
		let id: string;
15
		linesLayout.changeWhitespace((accessor) => {
16
			id = accessor.insertWhitespace(afterLineNumber, ordinal, heightInPx, minWidth);
17
		});
18
		return id!;
19
	}
20

21
	function changeOneWhitespace(linesLayout: LinesLayout, id: string, newAfterLineNumber: number, newHeight: number): void {
22
		linesLayout.changeWhitespace((accessor) => {
23
			accessor.changeOneWhitespace(id, newAfterLineNumber, newHeight);
24
		});
25
	}
26

27
	function removeWhitespace(linesLayout: LinesLayout, id: string): void {
28
		linesLayout.changeWhitespace((accessor) => {
29
			accessor.removeWhitespace(id);
30
		});
31
	}
32

33
	test('LinesLayout 1', () => {
34

35
		// Start off with 10 lines
36
		const linesLayout = new LinesLayout(10, 10, 0, 0, []);
37

38
		// lines: [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
39
		// whitespace: -
40
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 100);
41
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
42
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 10);
43
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 20);
44
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 30);
45
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 40);
46
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 50);
47
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 60);
48
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 70);
49
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 80);
50
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 90);
51

52
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(0), 1);
53
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(1), 1);
54
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(5), 1);
55
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(9), 1);
56
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(10), 2);
57
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(11), 2);
58
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(15), 2);
59
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(19), 2);
60
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(20), 3);
61
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(21), 3);
62
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(29), 3);
63

64
		// Add whitespace of height 5px after 2nd line
65
		insertWhitespace(linesLayout, 2, 0, 5, 0);
66
		// lines: [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
67
		// whitespace: a(2,5)
68
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 105);
69
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
70
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 10);
71
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 25);
72
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 35);
73
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 45);
74

75
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(0), 1);
76
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(1), 1);
77
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(9), 1);
78
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(10), 2);
79
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(20), 3);
80
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(21), 3);
81
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(24), 3);
82
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(25), 3);
83
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(35), 4);
84
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(45), 5);
85
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(104), 10);
86
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(105), 10);
87

88
		// Add two more whitespaces of height 5px
89
		insertWhitespace(linesLayout, 3, 0, 5, 0);
90
		insertWhitespace(linesLayout, 4, 0, 5, 0);
91
		// lines: [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
92
		// whitespace: a(2,5), b(3, 5), c(4, 5)
93
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 115);
94
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
95
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 10);
96
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 25);
97
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 40);
98
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 55);
99
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 65);
100

101
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(0), 1);
102
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(1), 1);
103
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(9), 1);
104
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(10), 2);
105
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(19), 2);
106
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(20), 3);
107
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(34), 3);
108
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(35), 4);
109
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(49), 4);
110
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(50), 5);
111
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(64), 5);
112
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(65), 6);
113

114
		assert.strictEqual(linesLayout.getVerticalOffsetForWhitespaceIndex(0), 20); // 20 -> 25
115
		assert.strictEqual(linesLayout.getVerticalOffsetForWhitespaceIndex(1), 35); // 35 -> 40
116
		assert.strictEqual(linesLayout.getVerticalOffsetForWhitespaceIndex(2), 50);
117

118
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(0), 0);
119
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(19), 0);
120
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(20), 0);
121
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(21), 0);
122
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(22), 0);
123
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(23), 0);
124
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(24), 0);
125
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(25), 1);
126
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(26), 1);
127
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(34), 1);
128
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(35), 1);
129
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(36), 1);
130
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(39), 1);
131
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(40), 2);
132
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(41), 2);
133
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(49), 2);
134
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(50), 2);
135
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(51), 2);
136
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(54), 2);
137
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(55), -1);
138
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(1000), -1);
139

140
	});
141

142
	test('LinesLayout 2', () => {
143

144
		// Start off with 10 lines and one whitespace after line 2, of height 5
145
		const linesLayout = new LinesLayout(10, 1, 0, 0, []);
146
		const a = insertWhitespace(linesLayout, 2, 0, 5, 0);
147

148
		// 10 lines
149
		// whitespace: - a(2,5)
150
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 15);
151
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
152
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
153
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 7);
154
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 8);
155
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 9);
156
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 10);
157
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 11);
158
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 12);
159
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 13);
160
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 14);
161

162
		// Change whitespace height
163
		// 10 lines
164
		// whitespace: - a(2,10)
165
		changeOneWhitespace(linesLayout, a, 2, 10);
166
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 20);
167
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
168
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
169
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 12);
170
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 13);
171
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 14);
172
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 15);
173
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 16);
174
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 17);
175
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 18);
176
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 19);
177

178
		// Change whitespace position
179
		// 10 lines
180
		// whitespace: - a(5,10)
181
		changeOneWhitespace(linesLayout, a, 5, 10);
182
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 20);
183
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
184
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
185
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 2);
186
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 3);
187
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 4);
188
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 15);
189
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 16);
190
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 17);
191
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 18);
192
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 19);
193

194
		// Pretend that lines 5 and 6 were deleted
195
		// 8 lines
196
		// whitespace: - a(4,10)
197
		linesLayout.onLinesDeleted(5, 6);
198
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 18);
199
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
200
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
201
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 2);
202
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 3);
203
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 14);
204
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 15);
205
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 16);
206
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 17);
207

208
		// Insert two lines at the beginning
209
		// 10 lines
210
		// whitespace: - a(6,10)
211
		linesLayout.onLinesInserted(1, 2);
212
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 20);
213
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
214
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
215
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 2);
216
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 3);
217
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 4);
218
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 5);
219
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 16);
220
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 17);
221
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 18);
222
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 19);
223

224
		// Remove whitespace
225
		// 10 lines
226
		removeWhitespace(linesLayout, a);
227
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 10);
228
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
229
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
230
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 2);
231
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 3);
232
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 4);
233
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 5);
234
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 6);
235
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 7);
236
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 8);
237
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 9);
238
	});
239

240
	test('LinesLayout Padding', () => {
241
		// Start off with 10 lines
242
		const linesLayout = new LinesLayout(10, 10, 15, 20, []);
243

244
		// lines: [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
245
		// whitespace: -
246
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 135);
247
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 15);
248
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 25);
249
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 35);
250
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 45);
251
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 55);
252
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 65);
253
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 75);
254
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 85);
255
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 95);
256
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 105);
257

258
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(0), 1);
259
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(10), 1);
260
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(15), 1);
261
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(24), 1);
262
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(25), 2);
263
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(34), 2);
264
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(35), 3);
265

266
		// Add whitespace of height 5px after 2nd line
267
		insertWhitespace(linesLayout, 2, 0, 5, 0);
268
		// lines: [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
269
		// whitespace: a(2,5)
270
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 140);
271
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 15);
272
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 25);
273
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 40);
274
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 50);
275

276
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(0), 1);
277
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(10), 1);
278
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(25), 2);
279
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(34), 2);
280
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(35), 3);
281
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(39), 3);
282
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(40), 3);
283
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(41), 3);
284
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(49), 3);
285
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(50), 4);
286

287
		// Add two more whitespaces of height 5px
288
		insertWhitespace(linesLayout, 3, 0, 5, 0);
289
		insertWhitespace(linesLayout, 4, 0, 5, 0);
290
		// lines: [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
291
		// whitespace: a(2,5), b(3, 5), c(4, 5)
292
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 150);
293
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 15);
294
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 25);
295
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 40);
296
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 55);
297
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 70);
298
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 80);
299

300
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(0), 1);
301
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(15), 1);
302
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(24), 1);
303
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(30), 2);
304
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(35), 3);
305
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(39), 3);
306
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(40), 3);
307
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(49), 3);
308
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(50), 4);
309
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(54), 4);
310
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(55), 4);
311
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(64), 4);
312
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(65), 5);
313
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(69), 5);
314
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(70), 5);
315
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(80), 6);
316

317
		assert.strictEqual(linesLayout.getVerticalOffsetForWhitespaceIndex(0), 35); // 35 -> 40
318
		assert.strictEqual(linesLayout.getVerticalOffsetForWhitespaceIndex(1), 50); // 50 -> 55
319
		assert.strictEqual(linesLayout.getVerticalOffsetForWhitespaceIndex(2), 65);
320

321
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(0), 0);
322
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(34), 0);
323
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(35), 0);
324
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(39), 0);
325
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(40), 1);
326
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(49), 1);
327
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(50), 1);
328
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(54), 1);
329
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(55), 2);
330
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(64), 2);
331
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(65), 2);
332
		assert.strictEqual(linesLayout.getWhitespaceIndexAtOrAfterVerticallOffset(70), -1);
333
	});
334

335
	test('LinesLayout getLineNumberAtOrAfterVerticalOffset', () => {
336
		const linesLayout = new LinesLayout(10, 1, 0, 0, []);
337
		insertWhitespace(linesLayout, 6, 0, 10, 0);
338

339
		// 10 lines
340
		// whitespace: - a(6,10)
341
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 20);
342
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
343
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
344
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 2);
345
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 3);
346
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 4);
347
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 5);
348
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 16);
349
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 17);
350
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 18);
351
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 19);
352

353
		// Do some hit testing
354
		// line      [1, 2, 3, 4, 5, 6,  7,  8,  9, 10]
355
		// vertical: [0, 1, 2, 3, 4, 5, 16, 17, 18, 19]
356
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(-100), 1);
357
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(-1), 1);
358
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(0), 1);
359
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(1), 2);
360
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(2), 3);
361
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(3), 4);
362
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(4), 5);
363
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(5), 6);
364
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(6), 7);
365
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(7), 7);
366
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(8), 7);
367
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(9), 7);
368
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(10), 7);
369
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(11), 7);
370
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(12), 7);
371
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(13), 7);
372
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(14), 7);
373
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(15), 7);
374
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(16), 7);
375
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(17), 8);
376
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(18), 9);
377
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(19), 10);
378
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(20), 10);
379
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(21), 10);
380
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(22), 10);
381
		assert.strictEqual(linesLayout.getLineNumberAtOrAfterVerticalOffset(23), 10);
382
	});
383

384
	test('LinesLayout getCenteredLineInViewport', () => {
385
		const linesLayout = new LinesLayout(10, 1, 0, 0, []);
386
		insertWhitespace(linesLayout, 6, 0, 10, 0);
387

388
		// 10 lines
389
		// whitespace: - a(6,10)
390
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 20);
391
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
392
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 1);
393
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 2);
394
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 3);
395
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 4);
396
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 5);
397
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 16);
398
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 17);
399
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 18);
400
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 19);
401

402
		// Find centered line in viewport 1
403
		// line      [1, 2, 3, 4, 5, 6,  7,  8,  9, 10]
404
		// vertical: [0, 1, 2, 3, 4, 5, 16, 17, 18, 19]
405
		assert.strictEqual(linesLayout.getLinesViewportData(0, 1).centeredLineNumber, 1);
406
		assert.strictEqual(linesLayout.getLinesViewportData(0, 2).centeredLineNumber, 2);
407
		assert.strictEqual(linesLayout.getLinesViewportData(0, 3).centeredLineNumber, 2);
408
		assert.strictEqual(linesLayout.getLinesViewportData(0, 4).centeredLineNumber, 3);
409
		assert.strictEqual(linesLayout.getLinesViewportData(0, 5).centeredLineNumber, 3);
410
		assert.strictEqual(linesLayout.getLinesViewportData(0, 6).centeredLineNumber, 4);
411
		assert.strictEqual(linesLayout.getLinesViewportData(0, 7).centeredLineNumber, 4);
412
		assert.strictEqual(linesLayout.getLinesViewportData(0, 8).centeredLineNumber, 5);
413
		assert.strictEqual(linesLayout.getLinesViewportData(0, 9).centeredLineNumber, 5);
414
		assert.strictEqual(linesLayout.getLinesViewportData(0, 10).centeredLineNumber, 6);
415
		assert.strictEqual(linesLayout.getLinesViewportData(0, 11).centeredLineNumber, 6);
416
		assert.strictEqual(linesLayout.getLinesViewportData(0, 12).centeredLineNumber, 6);
417
		assert.strictEqual(linesLayout.getLinesViewportData(0, 13).centeredLineNumber, 6);
418
		assert.strictEqual(linesLayout.getLinesViewportData(0, 14).centeredLineNumber, 6);
419
		assert.strictEqual(linesLayout.getLinesViewportData(0, 15).centeredLineNumber, 6);
420
		assert.strictEqual(linesLayout.getLinesViewportData(0, 16).centeredLineNumber, 6);
421
		assert.strictEqual(linesLayout.getLinesViewportData(0, 17).centeredLineNumber, 7);
422
		assert.strictEqual(linesLayout.getLinesViewportData(0, 18).centeredLineNumber, 7);
423
		assert.strictEqual(linesLayout.getLinesViewportData(0, 19).centeredLineNumber, 7);
424
		assert.strictEqual(linesLayout.getLinesViewportData(0, 20).centeredLineNumber, 7);
425
		assert.strictEqual(linesLayout.getLinesViewportData(0, 21).centeredLineNumber, 7);
426
		assert.strictEqual(linesLayout.getLinesViewportData(0, 22).centeredLineNumber, 7);
427
		assert.strictEqual(linesLayout.getLinesViewportData(0, 23).centeredLineNumber, 7);
428
		assert.strictEqual(linesLayout.getLinesViewportData(0, 24).centeredLineNumber, 7);
429
		assert.strictEqual(linesLayout.getLinesViewportData(0, 25).centeredLineNumber, 7);
430
		assert.strictEqual(linesLayout.getLinesViewportData(0, 26).centeredLineNumber, 7);
431
		assert.strictEqual(linesLayout.getLinesViewportData(0, 27).centeredLineNumber, 7);
432
		assert.strictEqual(linesLayout.getLinesViewportData(0, 28).centeredLineNumber, 7);
433
		assert.strictEqual(linesLayout.getLinesViewportData(0, 29).centeredLineNumber, 7);
434
		assert.strictEqual(linesLayout.getLinesViewportData(0, 30).centeredLineNumber, 7);
435
		assert.strictEqual(linesLayout.getLinesViewportData(0, 31).centeredLineNumber, 7);
436
		assert.strictEqual(linesLayout.getLinesViewportData(0, 32).centeredLineNumber, 7);
437
		assert.strictEqual(linesLayout.getLinesViewportData(0, 33).centeredLineNumber, 7);
438

439
		// Find centered line in viewport 2
440
		// line      [1, 2, 3, 4, 5, 6,  7,  8,  9, 10]
441
		// vertical: [0, 1, 2, 3, 4, 5, 16, 17, 18, 19]
442
		assert.strictEqual(linesLayout.getLinesViewportData(0, 20).centeredLineNumber, 7);
443
		assert.strictEqual(linesLayout.getLinesViewportData(1, 20).centeredLineNumber, 7);
444
		assert.strictEqual(linesLayout.getLinesViewportData(2, 20).centeredLineNumber, 7);
445
		assert.strictEqual(linesLayout.getLinesViewportData(3, 20).centeredLineNumber, 7);
446
		assert.strictEqual(linesLayout.getLinesViewportData(4, 20).centeredLineNumber, 7);
447
		assert.strictEqual(linesLayout.getLinesViewportData(5, 20).centeredLineNumber, 7);
448
		assert.strictEqual(linesLayout.getLinesViewportData(6, 20).centeredLineNumber, 7);
449
		assert.strictEqual(linesLayout.getLinesViewportData(7, 20).centeredLineNumber, 7);
450
		assert.strictEqual(linesLayout.getLinesViewportData(8, 20).centeredLineNumber, 7);
451
		assert.strictEqual(linesLayout.getLinesViewportData(9, 20).centeredLineNumber, 7);
452
		assert.strictEqual(linesLayout.getLinesViewportData(10, 20).centeredLineNumber, 7);
453
		assert.strictEqual(linesLayout.getLinesViewportData(11, 20).centeredLineNumber, 7);
454
		assert.strictEqual(linesLayout.getLinesViewportData(12, 20).centeredLineNumber, 7);
455
		assert.strictEqual(linesLayout.getLinesViewportData(13, 20).centeredLineNumber, 7);
456
		assert.strictEqual(linesLayout.getLinesViewportData(14, 20).centeredLineNumber, 8);
457
		assert.strictEqual(linesLayout.getLinesViewportData(15, 20).centeredLineNumber, 8);
458
		assert.strictEqual(linesLayout.getLinesViewportData(16, 20).centeredLineNumber, 9);
459
		assert.strictEqual(linesLayout.getLinesViewportData(17, 20).centeredLineNumber, 9);
460
		assert.strictEqual(linesLayout.getLinesViewportData(18, 20).centeredLineNumber, 10);
461
		assert.strictEqual(linesLayout.getLinesViewportData(19, 20).centeredLineNumber, 10);
462
		assert.strictEqual(linesLayout.getLinesViewportData(20, 23).centeredLineNumber, 10);
463
		assert.strictEqual(linesLayout.getLinesViewportData(21, 23).centeredLineNumber, 10);
464
		assert.strictEqual(linesLayout.getLinesViewportData(22, 23).centeredLineNumber, 10);
465
	});
466

467
	test('LinesLayout getLinesViewportData 1', () => {
468
		const linesLayout = new LinesLayout(10, 10, 0, 0, []);
469
		insertWhitespace(linesLayout, 6, 0, 100, 0);
470

471
		// 10 lines
472
		// whitespace: - a(6,100)
473
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 200);
474
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
475
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 10);
476
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 20);
477
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 30);
478
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 40);
479
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 50);
480
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 160);
481
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 170);
482
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 180);
483
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 190);
484

485
		// viewport 0->50
486
		let viewportData = linesLayout.getLinesViewportData(0, 50);
487
		assert.strictEqual(viewportData.startLineNumber, 1);
488
		assert.strictEqual(viewportData.endLineNumber, 5);
489
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 1);
490
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 5);
491
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [0, 10, 20, 30, 40]);
492

493
		// viewport 1->51
494
		viewportData = linesLayout.getLinesViewportData(1, 51);
495
		assert.strictEqual(viewportData.startLineNumber, 1);
496
		assert.strictEqual(viewportData.endLineNumber, 6);
497
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 2);
498
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 5);
499
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [0, 10, 20, 30, 40, 50]);
500

501
		// viewport 5->55
502
		viewportData = linesLayout.getLinesViewportData(5, 55);
503
		assert.strictEqual(viewportData.startLineNumber, 1);
504
		assert.strictEqual(viewportData.endLineNumber, 6);
505
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 2);
506
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 5);
507
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [0, 10, 20, 30, 40, 50]);
508

509
		// viewport 10->60
510
		viewportData = linesLayout.getLinesViewportData(10, 60);
511
		assert.strictEqual(viewportData.startLineNumber, 2);
512
		assert.strictEqual(viewportData.endLineNumber, 6);
513
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 2);
514
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 6);
515
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [10, 20, 30, 40, 50]);
516

517
		// viewport 50->100
518
		viewportData = linesLayout.getLinesViewportData(50, 100);
519
		assert.strictEqual(viewportData.startLineNumber, 6);
520
		assert.strictEqual(viewportData.endLineNumber, 6);
521
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 6);
522
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 6);
523
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50]);
524

525
		// viewport 60->110
526
		viewportData = linesLayout.getLinesViewportData(60, 110);
527
		assert.strictEqual(viewportData.startLineNumber, 7);
528
		assert.strictEqual(viewportData.endLineNumber, 7);
529
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 7);
530
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
531
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [160]);
532

533
		// viewport 65->115
534
		viewportData = linesLayout.getLinesViewportData(65, 115);
535
		assert.strictEqual(viewportData.startLineNumber, 7);
536
		assert.strictEqual(viewportData.endLineNumber, 7);
537
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 7);
538
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
539
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [160]);
540

541
		// viewport 50->159
542
		viewportData = linesLayout.getLinesViewportData(50, 159);
543
		assert.strictEqual(viewportData.startLineNumber, 6);
544
		assert.strictEqual(viewportData.endLineNumber, 6);
545
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 6);
546
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 6);
547
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50]);
548

549
		// viewport 50->160
550
		viewportData = linesLayout.getLinesViewportData(50, 160);
551
		assert.strictEqual(viewportData.startLineNumber, 6);
552
		assert.strictEqual(viewportData.endLineNumber, 6);
553
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 6);
554
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 6);
555
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50]);
556

557
		// viewport 51->161
558
		viewportData = linesLayout.getLinesViewportData(51, 161);
559
		assert.strictEqual(viewportData.startLineNumber, 6);
560
		assert.strictEqual(viewportData.endLineNumber, 7);
561
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 7);
562
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
563
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50, 160]);
564

565

566
		// viewport 150->169
567
		viewportData = linesLayout.getLinesViewportData(150, 169);
568
		assert.strictEqual(viewportData.startLineNumber, 7);
569
		assert.strictEqual(viewportData.endLineNumber, 7);
570
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 7);
571
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
572
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [160]);
573

574
		// viewport 159->169
575
		viewportData = linesLayout.getLinesViewportData(159, 169);
576
		assert.strictEqual(viewportData.startLineNumber, 7);
577
		assert.strictEqual(viewportData.endLineNumber, 7);
578
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 7);
579
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
580
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [160]);
581

582
		// viewport 160->169
583
		viewportData = linesLayout.getLinesViewportData(160, 169);
584
		assert.strictEqual(viewportData.startLineNumber, 7);
585
		assert.strictEqual(viewportData.endLineNumber, 7);
586
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 7);
587
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
588
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [160]);
589

590

591
		// viewport 160->1000
592
		viewportData = linesLayout.getLinesViewportData(160, 1000);
593
		assert.strictEqual(viewportData.startLineNumber, 7);
594
		assert.strictEqual(viewportData.endLineNumber, 10);
595
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 7);
596
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 10);
597
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [160, 170, 180, 190]);
598
	});
599

600
	test('LinesLayout getLinesViewportData 2 & getWhitespaceViewportData', () => {
601
		const linesLayout = new LinesLayout(10, 10, 0, 0, []);
602
		const a = insertWhitespace(linesLayout, 6, 0, 100, 0);
603
		const b = insertWhitespace(linesLayout, 7, 0, 50, 0);
604

605
		// 10 lines
606
		// whitespace: - a(6,100), b(7, 50)
607
		assert.strictEqual(linesLayout.getLinesTotalHeight(), 250);
608
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(1), 0);
609
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(2), 10);
610
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(3), 20);
611
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(4), 30);
612
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(5), 40);
613
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(6), 50);
614
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(7), 160);
615
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(8), 220);
616
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(9), 230);
617
		assert.strictEqual(linesLayout.getVerticalOffsetForLineNumber(10), 240);
618

619
		// viewport 50->160
620
		let viewportData = linesLayout.getLinesViewportData(50, 160);
621
		assert.strictEqual(viewportData.startLineNumber, 6);
622
		assert.strictEqual(viewportData.endLineNumber, 6);
623
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 6);
624
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 6);
625
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50]);
626
		let whitespaceData = linesLayout.getWhitespaceViewportData(50, 160);
627
		assert.deepStrictEqual(whitespaceData, [{
628
			id: a,
629
			afterLineNumber: 6,
630
			verticalOffset: 60,
631
			height: 100
632
		}]);
633

634
		// viewport 50->219
635
		viewportData = linesLayout.getLinesViewportData(50, 219);
636
		assert.strictEqual(viewportData.startLineNumber, 6);
637
		assert.strictEqual(viewportData.endLineNumber, 7);
638
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 6);
639
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
640
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50, 160]);
641
		whitespaceData = linesLayout.getWhitespaceViewportData(50, 219);
642
		assert.deepStrictEqual(whitespaceData, [{
643
			id: a,
644
			afterLineNumber: 6,
645
			verticalOffset: 60,
646
			height: 100
647
		}, {
648
			id: b,
649
			afterLineNumber: 7,
650
			verticalOffset: 170,
651
			height: 50
652
		}]);
653

654
		// viewport 50->220
655
		viewportData = linesLayout.getLinesViewportData(50, 220);
656
		assert.strictEqual(viewportData.startLineNumber, 6);
657
		assert.strictEqual(viewportData.endLineNumber, 7);
658
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 6);
659
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 7);
660
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50, 160]);
661

662
		// viewport 50->250
663
		viewportData = linesLayout.getLinesViewportData(50, 250);
664
		assert.strictEqual(viewportData.startLineNumber, 6);
665
		assert.strictEqual(viewportData.endLineNumber, 10);
666
		assert.strictEqual(viewportData.completelyVisibleStartLineNumber, 6);
667
		assert.strictEqual(viewportData.completelyVisibleEndLineNumber, 10);
668
		assert.deepStrictEqual(viewportData.relativeVerticalOffset, [50, 160, 220, 230, 240]);
669
	});
670

671
	test('LinesLayout getWhitespaceAtVerticalOffset', () => {
672
		const linesLayout = new LinesLayout(10, 10, 0, 0, []);
673
		const a = insertWhitespace(linesLayout, 6, 0, 100, 0);
674
		const b = insertWhitespace(linesLayout, 7, 0, 50, 0);
675

676
		let whitespace = linesLayout.getWhitespaceAtVerticalOffset(0);
677
		assert.strictEqual(whitespace, null);
678

679
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(59);
680
		assert.strictEqual(whitespace, null);
681

682
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(60);
683
		assert.strictEqual(whitespace!.id, a);
684

685
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(61);
686
		assert.strictEqual(whitespace!.id, a);
687

688
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(159);
689
		assert.strictEqual(whitespace!.id, a);
690

691
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(160);
692
		assert.strictEqual(whitespace, null);
693

694
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(161);
695
		assert.strictEqual(whitespace, null);
696

697
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(169);
698
		assert.strictEqual(whitespace, null);
699

700
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(170);
701
		assert.strictEqual(whitespace!.id, b);
702

703
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(171);
704
		assert.strictEqual(whitespace!.id, b);
705

706
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(219);
707
		assert.strictEqual(whitespace!.id, b);
708

709
		whitespace = linesLayout.getWhitespaceAtVerticalOffset(220);
710
		assert.strictEqual(whitespace, null);
711
	});
712

713
	test('LinesLayout', () => {
714

715
		const linesLayout = new LinesLayout(100, 20, 0, 0, []);
716

717
		// Insert a whitespace after line number 2, of height 10
718
		const a = insertWhitespace(linesLayout, 2, 0, 10, 0);
719
		// whitespaces: a(2, 10)
720
		assert.strictEqual(linesLayout.getWhitespacesCount(), 1);
721
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 2);
722
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 10);
723
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 10);
724
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 10);
725
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
726
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
727
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 10);
728
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 10);
729

730
		// Insert a whitespace again after line number 2, of height 20
731
		let b = insertWhitespace(linesLayout, 2, 0, 20, 0);
732
		// whitespaces: a(2, 10), b(2, 20)
733
		assert.strictEqual(linesLayout.getWhitespacesCount(), 2);
734
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 2);
735
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 10);
736
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 2);
737
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 20);
738
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 10);
739
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 30);
740
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 30);
741
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
742
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
743
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 30);
744
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 30);
745

746
		// Change last inserted whitespace height to 30
747
		changeOneWhitespace(linesLayout, b, 2, 30);
748
		// whitespaces: a(2, 10), b(2, 30)
749
		assert.strictEqual(linesLayout.getWhitespacesCount(), 2);
750
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 2);
751
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 10);
752
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 2);
753
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 30);
754
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 10);
755
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 40);
756
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 40);
757
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
758
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
759
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 40);
760
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 40);
761

762
		// Remove last inserted whitespace
763
		removeWhitespace(linesLayout, b);
764
		// whitespaces: a(2, 10)
765
		assert.strictEqual(linesLayout.getWhitespacesCount(), 1);
766
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 2);
767
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 10);
768
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 10);
769
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 10);
770
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
771
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
772
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 10);
773
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 10);
774

775
		// Add a whitespace before the first line of height 50
776
		b = insertWhitespace(linesLayout, 0, 0, 50, 0);
777
		// whitespaces: b(0, 50), a(2, 10)
778
		assert.strictEqual(linesLayout.getWhitespacesCount(), 2);
779
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 0);
780
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 50);
781
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 2);
782
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 10);
783
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 50);
784
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 60);
785
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 60);
786
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 50);
787
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 50);
788
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 60);
789
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 60);
790

791
		// Add a whitespace after line 4 of height 20
792
		insertWhitespace(linesLayout, 4, 0, 20, 0);
793
		// whitespaces: b(0, 50), a(2, 10), c(4, 20)
794
		assert.strictEqual(linesLayout.getWhitespacesCount(), 3);
795
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 0);
796
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 50);
797
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 2);
798
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 10);
799
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 4);
800
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(2), 20);
801
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 50);
802
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 60);
803
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(2), 80);
804
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 80);
805
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 50);
806
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 50);
807
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 60);
808
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 60);
809
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 80);
810

811
		// Add a whitespace after line 3 of height 30
812
		insertWhitespace(linesLayout, 3, 0, 30, 0);
813
		// whitespaces: b(0, 50), a(2, 10), d(3, 30), c(4, 20)
814
		assert.strictEqual(linesLayout.getWhitespacesCount(), 4);
815
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 0);
816
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 50);
817
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 2);
818
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 10);
819
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 3);
820
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(2), 30);
821
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(3), 4);
822
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(3), 20);
823
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 50);
824
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 60);
825
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(2), 90);
826
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(3), 110);
827
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 110);
828
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 50);
829
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 50);
830
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 60);
831
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 90);
832
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 110);
833

834
		// Change whitespace after line 2 to height of 100
835
		changeOneWhitespace(linesLayout, a, 2, 100);
836
		// whitespaces: b(0, 50), a(2, 100), d(3, 30), c(4, 20)
837
		assert.strictEqual(linesLayout.getWhitespacesCount(), 4);
838
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 0);
839
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 50);
840
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 2);
841
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 100);
842
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 3);
843
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(2), 30);
844
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(3), 4);
845
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(3), 20);
846
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 50);
847
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 150);
848
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(2), 180);
849
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(3), 200);
850
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 200);
851
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 50);
852
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 50);
853
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 150);
854
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 180);
855
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 200);
856

857
		// Remove whitespace after line 2
858
		removeWhitespace(linesLayout, a);
859
		// whitespaces: b(0, 50), d(3, 30), c(4, 20)
860
		assert.strictEqual(linesLayout.getWhitespacesCount(), 3);
861
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 0);
862
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 50);
863
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
864
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 30);
865
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 4);
866
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(2), 20);
867
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 50);
868
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 80);
869
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(2), 100);
870
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 100);
871
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 50);
872
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 50);
873
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 50);
874
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 80);
875
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 100);
876

877
		// Remove whitespace before line 1
878
		removeWhitespace(linesLayout, b);
879
		// whitespaces: d(3, 30), c(4, 20)
880
		assert.strictEqual(linesLayout.getWhitespacesCount(), 2);
881
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 3);
882
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 30);
883
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 4);
884
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 20);
885
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 30);
886
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 50);
887
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 50);
888
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
889
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
890
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 0);
891
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 30);
892
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 50);
893

894
		// Delete line 1
895
		linesLayout.onLinesDeleted(1, 1);
896
		// whitespaces: d(2, 30), c(3, 20)
897
		assert.strictEqual(linesLayout.getWhitespacesCount(), 2);
898
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 2);
899
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 30);
900
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
901
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 20);
902
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 30);
903
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 50);
904
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 50);
905
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
906
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
907
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 30);
908
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 50);
909
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 50);
910

911
		// Insert a line before line 1
912
		linesLayout.onLinesInserted(1, 1);
913
		// whitespaces: d(3, 30), c(4, 20)
914
		assert.strictEqual(linesLayout.getWhitespacesCount(), 2);
915
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 3);
916
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 30);
917
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 4);
918
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 20);
919
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 30);
920
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 50);
921
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 50);
922
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
923
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
924
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 0);
925
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 30);
926
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 50);
927

928
		// Delete line 4
929
		linesLayout.onLinesDeleted(4, 4);
930
		// whitespaces: d(3, 30), c(3, 20)
931
		assert.strictEqual(linesLayout.getWhitespacesCount(), 2);
932
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 3);
933
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(0), 30);
934
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
935
		assert.strictEqual(linesLayout.getHeightForWhitespaceIndex(1), 20);
936
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(0), 30);
937
		assert.strictEqual(linesLayout.getWhitespacesAccumulatedHeight(1), 50);
938
		assert.strictEqual(linesLayout.getWhitespacesTotalHeight(), 50);
939
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(1), 0);
940
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(2), 0);
941
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(3), 0);
942
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(4), 50);
943
		assert.strictEqual(linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(5), 50);
944
	});
945

946
	test('LinesLayout findInsertionIndex', () => {
947

948
		const makeInternalWhitespace = (afterLineNumbers: number[], ordinal: number = 0) => {
949
			return afterLineNumbers.map((afterLineNumber) => new EditorWhitespace('', afterLineNumber, ordinal, 0, 0));
950
		};
951

952
		let arr: EditorWhitespace[];
953

954
		arr = makeInternalWhitespace([]);
955
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
956
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 0);
957
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 0);
958

959
		arr = makeInternalWhitespace([1]);
960
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
961
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
962
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
963

964
		arr = makeInternalWhitespace([1, 3]);
965
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
966
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
967
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
968
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 2);
969
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
970

971
		arr = makeInternalWhitespace([1, 3, 5]);
972
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
973
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
974
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
975
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 2);
976
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
977
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 5, 0), 3);
978
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 6, 0), 3);
979

980
		arr = makeInternalWhitespace([1, 3, 5], 3);
981
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
982
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 0);
983
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
984
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 1);
985
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
986
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 5, 0), 2);
987
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 6, 0), 3);
988

989
		arr = makeInternalWhitespace([1, 3, 5, 7]);
990
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
991
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
992
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
993
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 2);
994
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
995
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 5, 0), 3);
996
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 6, 0), 3);
997
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 7, 0), 4);
998
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 8, 0), 4);
999

1000
		arr = makeInternalWhitespace([1, 3, 5, 7, 9]);
1001
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
1002
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
1003
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
1004
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 2);
1005
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
1006
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 5, 0), 3);
1007
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 6, 0), 3);
1008
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 7, 0), 4);
1009
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 8, 0), 4);
1010
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 9, 0), 5);
1011
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 10, 0), 5);
1012

1013
		arr = makeInternalWhitespace([1, 3, 5, 7, 9, 11]);
1014
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
1015
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
1016
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
1017
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 2);
1018
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
1019
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 5, 0), 3);
1020
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 6, 0), 3);
1021
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 7, 0), 4);
1022
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 8, 0), 4);
1023
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 9, 0), 5);
1024
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 10, 0), 5);
1025
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 11, 0), 6);
1026
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 12, 0), 6);
1027

1028
		arr = makeInternalWhitespace([1, 3, 5, 7, 9, 11, 13]);
1029
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
1030
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
1031
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
1032
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 2);
1033
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
1034
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 5, 0), 3);
1035
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 6, 0), 3);
1036
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 7, 0), 4);
1037
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 8, 0), 4);
1038
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 9, 0), 5);
1039
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 10, 0), 5);
1040
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 11, 0), 6);
1041
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 12, 0), 6);
1042
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 13, 0), 7);
1043
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 14, 0), 7);
1044

1045
		arr = makeInternalWhitespace([1, 3, 5, 7, 9, 11, 13, 15]);
1046
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 0, 0), 0);
1047
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 1, 0), 1);
1048
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 2, 0), 1);
1049
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 3, 0), 2);
1050
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 4, 0), 2);
1051
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 5, 0), 3);
1052
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 6, 0), 3);
1053
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 7, 0), 4);
1054
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 8, 0), 4);
1055
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 9, 0), 5);
1056
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 10, 0), 5);
1057
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 11, 0), 6);
1058
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 12, 0), 6);
1059
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 13, 0), 7);
1060
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 14, 0), 7);
1061
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 15, 0), 8);
1062
		assert.strictEqual(LinesLayout.findInsertionIndex(arr, 16, 0), 8);
1063
	});
1064

1065
	test('LinesLayout changeWhitespaceAfterLineNumber & getFirstWhitespaceIndexAfterLineNumber', () => {
1066
		const linesLayout = new LinesLayout(100, 20, 0, 0, []);
1067

1068
		const a = insertWhitespace(linesLayout, 0, 0, 1, 0);
1069
		const b = insertWhitespace(linesLayout, 7, 0, 1, 0);
1070
		const c = insertWhitespace(linesLayout, 3, 0, 1, 0);
1071

1072
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1073
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 0);
1074
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), c); // 3
1075
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
1076
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), b); // 7
1077
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 7);
1078

1079
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(1), 1); // c
1080
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(2), 1); // c
1081
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(3), 1); // c
1082
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(4), 2); // b
1083
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(5), 2); // b
1084
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(6), 2); // b
1085
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(7), 2); // b
1086
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(8), -1); // --
1087

1088
		// Do not really move a
1089
		changeOneWhitespace(linesLayout, a, 1, 1);
1090

1091
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 1
1092
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 1);
1093
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), c); // 3
1094
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
1095
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), b); // 7
1096
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 7);
1097

1098
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(1), 0); // a
1099
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(2), 1); // c
1100
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(3), 1); // c
1101
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(4), 2); // b
1102
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(5), 2); // b
1103
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(6), 2); // b
1104
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(7), 2); // b
1105
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(8), -1); // --
1106

1107

1108
		// Do not really move a
1109
		changeOneWhitespace(linesLayout, a, 2, 1);
1110

1111
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 2
1112
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 2);
1113
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), c); // 3
1114
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
1115
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), b); // 7
1116
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 7);
1117

1118
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(1), 0); // a
1119
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(2), 0); // a
1120
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(3), 1); // c
1121
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(4), 2); // b
1122
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(5), 2); // b
1123
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(6), 2); // b
1124
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(7), 2); // b
1125
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(8), -1); // --
1126

1127

1128
		// Change a to conflict with c => a gets placed after c
1129
		changeOneWhitespace(linesLayout, a, 3, 1);
1130

1131
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), c); // 3
1132
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 3);
1133
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), a); // 3
1134
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
1135
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), b); // 7
1136
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 7);
1137

1138
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(1), 0); // c
1139
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(2), 0); // c
1140
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(3), 0); // c
1141
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(4), 2); // b
1142
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(5), 2); // b
1143
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(6), 2); // b
1144
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(7), 2); // b
1145
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(8), -1); // --
1146

1147

1148
		// Make a no-op
1149
		changeOneWhitespace(linesLayout, c, 3, 1);
1150

1151
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), c); // 3
1152
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 3);
1153
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), a); // 3
1154
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 3);
1155
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), b); // 7
1156
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 7);
1157

1158
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(1), 0); // c
1159
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(2), 0); // c
1160
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(3), 0); // c
1161
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(4), 2); // b
1162
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(5), 2); // b
1163
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(6), 2); // b
1164
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(7), 2); // b
1165
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(8), -1); // --
1166

1167

1168

1169
		// Conflict c with b => c gets placed after b
1170
		changeOneWhitespace(linesLayout, c, 7, 1);
1171

1172
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 3
1173
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(0), 3);
1174
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), b); // 7
1175
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(1), 7);
1176
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), c); // 7
1177
		assert.strictEqual(linesLayout.getAfterLineNumberForWhitespaceIndex(2), 7);
1178

1179
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(1), 0); // a
1180
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(2), 0); // a
1181
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(3), 0); // a
1182
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(4), 1); // b
1183
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(5), 1); // b
1184
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(6), 1); // b
1185
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(7), 1); // b
1186
		assert.strictEqual(linesLayout.getFirstWhitespaceIndexAfterLineNumber(8), -1); // --
1187
	});
1188

1189
	test('LinesLayout Bug', () => {
1190
		const linesLayout = new LinesLayout(100, 20, 0, 0, []);
1191

1192
		const a = insertWhitespace(linesLayout, 0, 0, 1, 0);
1193
		const b = insertWhitespace(linesLayout, 7, 0, 1, 0);
1194

1195
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1196
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), b); // 7
1197

1198
		const c = insertWhitespace(linesLayout, 3, 0, 1, 0);
1199

1200
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1201
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), c); // 3
1202
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), b); // 7
1203

1204
		const d = insertWhitespace(linesLayout, 2, 0, 1, 0);
1205
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1206
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), d); // 2
1207
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), c); // 3
1208
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(3), b); // 7
1209

1210
		const e = insertWhitespace(linesLayout, 8, 0, 1, 0);
1211
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1212
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), d); // 2
1213
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), c); // 3
1214
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(3), b); // 7
1215
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(4), e); // 8
1216

1217
		const f = insertWhitespace(linesLayout, 11, 0, 1, 0);
1218
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1219
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), d); // 2
1220
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), c); // 3
1221
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(3), b); // 7
1222
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(4), e); // 8
1223
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(5), f); // 11
1224

1225
		const g = insertWhitespace(linesLayout, 10, 0, 1, 0);
1226
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1227
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), d); // 2
1228
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), c); // 3
1229
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(3), b); // 7
1230
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(4), e); // 8
1231
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(5), g); // 10
1232
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(6), f); // 11
1233

1234
		const h = insertWhitespace(linesLayout, 0, 0, 1, 0);
1235
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(0), a); // 0
1236
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(1), h); // 0
1237
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(2), d); // 2
1238
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(3), c); // 3
1239
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(4), b); // 7
1240
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(5), e); // 8
1241
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(6), g); // 10
1242
		assert.strictEqual(linesLayout.getIdForWhitespaceIndex(7), f); // 11
1243
	});
1244
});
1245

1246
Product

Resources

Company
