src/vs/platform/userDataSync/common/settingsMerge.ts
656 LOC · 631 covered · 25 uncovered · 221 ranges · 735 concepts · 118 introducers · 419 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
settingsMerge.ts ×19
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
>
6
>
import { distinct } from '../../../base/common/arrays.js';
7
>
import { IStringDictionary } from '../../../base/common/collections.js';
8
>
import { JSONVisitor, parse, visit } from '../../../base/common/json.js';
9
>
import { applyEdits, setProperty, withFormatting } from '../../../base/common/jsonEdit.js';
10
>
import { Edit, FormattingOptions, getEOL } from '../../../base/common/jsonFormatter.js';
11
>
import * as objects from '../../../base/common/objects.js';
12
>
import { IConfigurationService } from '../../configuration/common/configuration.js';
13
>
import * as contentUtil from './content.js';
14
>
import { getDisallowedIgnoredSettings, IConflictSetting } from './userDataSync.js';
15
>
16
>
export interface IMergeResult {
17
>
localContent: string | null;
18
>
remoteContent: string | null;
19
>
hasConflicts: boolean;
20
>
conflictsSettings: IConflictSetting[];
21
>
}
22
>
23
>
export function getIgnoredSettings(defaultIgnoredSettings: string[], configurationService: IConfigurationService, settingsContent?: string): string[] {
25
>
if (settingsContent) {
28
>
value = getIgnoredSettingsFromConfig(configurationService);
29
>
}
30
>
const added: string[] = [], removed: string[] = [...getDisallowedIgnoredSettings()];
31
>
if (Array.isArray(value)) {
32
>
for (const key of value) {
34
removed.push(key.substring(1));
36
>
added.push(key);
37
>
}
38
>
}
40
>
return distinct([...defaultIgnoredSettings, ...added,].filter(setting => !removed.includes(setting)));
41
>
}
43
>
function getIgnoredSettingsFromConfig(configurationService: IConfigurationService): ReadonlyArray<string> {
settingsSync.ts ×10
44
>
let userValue = configurationService.inspect<string[]>('settingsSync.ignoredSettings').userValue;
45
>
if (userValue !== undefined) {
47
>
}
48
>
userValue = configurationService.inspect<string[]>('sync.ignoredSettings').userValue;
settingsMerge.ts ×2
49
>
if (userValue !== undefined) {
50
return userValue;
51
}
52
>
return configurationService.getValue<string[]>('settingsSync.ignoredSettings') || [];
settingsMerge.ts ×2
56
>
const parsed = parse(settingsContent);
57
>
return parsed ? parsed['settingsSync.ignoredSettings'] || parsed['sync.ignoredSettings'] || [] : [];
58
>
}
60
>
export function removeComments(content: string, formattingOptions: FormattingOptions): string {
61
const source = parse(content) || {};
62
let result = '{}';
63
for (const key of Object.keys(source)) {
64
const edits = setProperty(result, [key], source[key], formattingOptions);
65
result = applyEdits(result, edits);
66
}
67
return result;
68
}
70
>
export function updateIgnoredSettings(targetContent: string, sourceContent: string, ignoredSettings: string[], formattingOptions: FormattingOptions): string {
73
>
const source = parse(sourceContent) || {};
74
>
const target = parse(targetContent);
75
>
if (!target) {
77
>
}
79
>
for (const key of ignoredSettings) {
80
>
const sourceValue = source[key];
81
>
const targetValue = target[key];
82
>
83
>
// Remove in target
84
>
if (sourceValue === undefined) {
85
>
targetContent = contentUtil.edit(targetContent, [key], undefined, formattingOptions);
settingsMerge.ts ×1
86
>
}
88
>
// Update in target
89
>
else if (targetValue !== undefined) {
90
>
targetContent = contentUtil.edit(targetContent, [key], sourceValue, formattingOptions);
settingsMerge.ts ×1
91
>
}
93
>
else {
94
>
settingsToAdd.push(findSettingNode(key, sourceTree)!);
95
>
}
97
>
98
>
settingsToAdd.sort((a, b) => a.startOffset - b.startOffset);
99
>
settingsToAdd.forEach(s => targetContent = addSetting(s.setting!.key, sourceContent, targetContent, formattingOptions));
100
>
}
102
>
}
104
>
export function merge(originalLocalContent: string, originalRemoteContent: string, baseContent: string | null, ignoredSettings: string[], resolvedConflicts: { key: string; value: any | undefined }[], formattingOptions: FormattingOptions): IMergeResult {
106
>
const localContentWithoutIgnoredSettings = updateIgnoredSettings(originalLocalContent, originalRemoteContent, ignoredSettings, formattingOptions);
107
>
const localForwarded = baseContent !== localContentWithoutIgnoredSettings;
108
>
const remoteForwarded = baseContent !== originalRemoteContent;
109
>
110
>
/* no changes */
111
>
if (!localForwarded && !remoteForwarded) {
112
>
return { conflictsSettings: [], localContent: null, remoteContent: null, hasConflicts: false };
settingsMerge.ts ×1
113
>
}
115
>
/* local has changed and remote has not */
117
>
return { conflictsSettings: [], localContent: null, remoteContent: localContentWithoutIgnoredSettings, hasConflicts: false };
settingsMerge.ts ×1
118
>
}
120
>
/* remote has changed and local has not */
122
>
return { conflictsSettings: [], localContent: updateIgnoredSettings(originalRemoteContent, originalLocalContent, ignoredSettings, formattingOptions), remoteContent: null, hasConflicts: false };
settingsMerge.ts ×1
123
>
}
125
>
/* local is empty and not synced before */
127
>
const localContent = areSame(originalLocalContent, originalRemoteContent, ignoredSettings) ? null : updateIgnoredSettings(originalRemoteContent, originalLocalContent, ignoredSettings, formattingOptions);
settingsMerge.ts ×1
128
>
return { conflictsSettings: [], localContent, remoteContent: null, hasConflicts: false };
129
>
}
131
>
/* remote and local has changed */
132
>
let localContent = originalLocalContent;
133
>
let remoteContent = originalRemoteContent;
134
>
const local = parse(originalLocalContent);
135
>
const remote = parse(originalRemoteContent);
137
>
138
>
const ignored = ignoredSettings.reduce((set, key) => { set.add(key); return set; }, new Set<string>());
139
>
const localToRemote = compare(local, remote, ignored);
140
>
const baseToLocal = compare(base, local, ignored);
141
>
const baseToRemote = compare(base, remote, ignored);
142
>
143
>
const conflicts: Map<string, IConflictSetting> = new Map<string, IConflictSetting>();
144
>
const handledConflicts: Set<string> = new Set<string>();
145
>
const handleConflict = (conflictKey: string): void => {
147
>
const resolvedConflict = resolvedConflicts.filter(({ key }) => key === conflictKey)[0];
148
>
if (resolvedConflict) {
149
>
localContent = contentUtil.edit(localContent, [conflictKey], resolvedConflict.value, formattingOptions);
settingsMerge.ts ×1
150
>
remoteContent = contentUtil.edit(remoteContent, [conflictKey], resolvedConflict.value, formattingOptions);
152
>
conflicts.set(conflictKey, { key: conflictKey, localValue: local[conflictKey], remoteValue: remote[conflictKey] });
153
>
}
154
>
};
156
>
// Removed settings in Local
157
>
for (const key of baseToLocal.removed.values()) {
159
>
if (baseToRemote.updated.has(key)) {
161
>
}
163
>
else {
164
>
remoteContent = contentUtil.edit(remoteContent, [key], undefined, formattingOptions);
165
>
}
168
>
// Removed settings in Remote
169
>
for (const key of baseToRemote.removed.values()) {
171
continue;
172
}
174
>
if (baseToLocal.updated.has(key)) {
176
>
}
178
>
else {
179
>
localContent = contentUtil.edit(localContent, [key], undefined, formattingOptions);
180
>
}
183
>
// Updated settings in Local
184
>
for (const key of baseToLocal.updated.values()) {
187
>
}
189
>
if (baseToRemote.updated.has(key)) {
191
>
if (localToRemote.updated.has(key)) {
193
>
}
195
>
remoteContent = contentUtil.edit(remoteContent, [key], local[key], formattingOptions);
settingsMerge.ts ×1
196
>
}
199
>
// Updated settings in Remote
200
>
for (const key of baseToRemote.updated.values()) {
203
>
}
205
>
if (baseToLocal.updated.has(key)) {
207
>
if (localToRemote.updated.has(key)) {
208
handleConflict(key);
209
}
211
>
localContent = contentUtil.edit(localContent, [key], remote[key], formattingOptions);
settingsMerge.ts ×1
212
>
}
215
>
// Added settings in Local
216
>
for (const key of baseToLocal.added.values()) {
218
continue;
219
}
221
>
if (baseToRemote.added.has(key)) {
223
>
if (localToRemote.updated.has(key)) {
225
>
}
227
>
remoteContent = addSetting(key, localContent, remoteContent, formattingOptions);
settingsMerge.ts ×1
228
>
}
231
>
// Added settings in remote
232
>
for (const key of baseToRemote.added.values()) {
235
>
}
237
>
if (baseToLocal.added.has(key)) {
239
>
if (localToRemote.updated.has(key)) {
240
handleConflict(key);
241
}
243
>
localContent = addSetting(key, remoteContent, localContent, formattingOptions);
settingsMerge.ts ×1
244
>
}
247
>
const hasConflicts = conflicts.size > 0 || !areSame(localContent, remoteContent, ignoredSettings);
248
>
const hasLocalChanged = hasConflicts || !areSame(localContent, originalLocalContent, []);
settingsMerge.ts ×7
249
>
const hasRemoteChanged = hasConflicts || !areSame(remoteContent, originalRemoteContent, []);
250
>
return { localContent: hasLocalChanged ? localContent : null, remoteContent: hasRemoteChanged ? remoteContent : null, conflictsSettings: [...conflicts.values()], hasConflicts };
251
>
}
253
>
function areSame(localContent: string, remoteContent: string, ignoredSettings: string[]): boolean {
settingsMerge.ts ×1
254
>
if (localContent === remoteContent) {
256
>
}
258
>
const local = parse(localContent);
259
>
const remote = parse(remoteContent);
260
>
const ignored = ignoredSettings.reduce((set, key) => { set.add(key); return set; }, new Set<string>());
261
>
const localTree = parseSettings(localContent).filter(node => !(node.setting && ignored.has(node.setting.key)));
262
>
const remoteTree = parseSettings(remoteContent).filter(node => !(node.setting && ignored.has(node.setting.key)));
263
>
264
>
if (localTree.length !== remoteTree.length) {
266
>
}
268
>
for (let index = 0; index < localTree.length; index++) {
270
>
const remoteNode = remoteTree[index];
271
>
if (localNode.setting && remoteNode.setting) {
274
>
}
275
>
if (!objects.equals(local[localNode.setting.key], remote[localNode.setting.key])) {
settingsMerge.ts ×1
276
return false;
277
}
280
>
return false;
281
>
}
282
>
} else {
283
return false;
284
}
287
>
return true;
288
>
}
290
>
export function isEmpty(content: string): boolean {
292
>
const nodes = parseSettings(content);
293
>
return nodes.length === 0;
294
>
}
295
return true;
296
}
298
>
function compare(from: IStringDictionary<any> | null, to: IStringDictionary<any>, ignored: Set<string>): { added: Set<string>; removed: Set<string>; updated: Set<string> } {
settingsMerge.ts ×9
299
>
const fromKeys = from ? Object.keys(from).filter(key => !ignored.has(key)) : [];
300
>
const toKeys = Object.keys(to).filter(key => !ignored.has(key));
301
>
const added = toKeys.filter(key => !fromKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, new Set<string>());
302
>
const removed = fromKeys.filter(key => !toKeys.includes(key)).reduce((r, key) => { r.add(key); return r; }, new Set<string>());
303
>
const updated: Set<string> = new Set<string>();
304
>
305
>
if (from) {
306
>
for (const key of fromKeys) {
309
>
}
311
>
const value2 = to[key];
312
>
if (!objects.equals(value1, value2)) {
314
>
}
317
>
318
>
return { added, removed, updated };
319
>
}
321
>
export function addSetting(key: string, sourceContent: string, targetContent: string, formattingOptions: FormattingOptions): string {
323
>
const sourceTree = parseSettings(sourceContent);
324
>
const targetTree = parseSettings(targetContent);
325
>
const insertLocation = getInsertLocation(key, sourceTree, targetTree);
326
>
return insertAtLocation(targetContent, key, source[key], insertLocation, targetTree, formattingOptions);
327
>
}
329
>
interface InsertLocation {
330
>
index: number;
331
>
insertAfter: boolean;
332
>
}
333
>
334
>
function getInsertLocation(key: string, sourceTree: INode[], targetTree: INode[]): InsertLocation {
settingsMerge.ts ×5
335
>
336
>
const sourceNodeIndex = sourceTree.findIndex(node => node.setting?.key === key);
337
>
338
>
const sourcePreviousNode: INode = sourceTree[sourceNodeIndex - 1];
339
>
if (sourcePreviousNode) {
341
>
Previous node in source is a setting.
342
>
Find the same setting in the target.
343
>
Insert it after that setting
344
>
*/
345
>
if (sourcePreviousNode.setting) {
346
>
const targetPreviousSetting = findSettingNode(sourcePreviousNode.setting.key, targetTree);
settingsMerge.ts ×2
347
>
if (targetPreviousSetting) {
349
>
return { index: targetTree.indexOf(targetPreviousSetting), insertAfter: true };
350
>
}
353
>
else {
354
>
const sourcePreviousSettingNode = findPreviousSettingNode(sourceNodeIndex, sourceTree);
355
>
/*
356
>
Source has a setting defined before the setting to be added.
357
>
Find the same previous setting in the target.
358
>
If found, insert before its next setting so that comments are retrieved.
359
>
Otherwise, insert at the end.
360
>
*/
361
>
if (sourcePreviousSettingNode) {
362
>
const targetPreviousSetting = findSettingNode(sourcePreviousSettingNode.setting!.key, targetTree);
settingsMerge.ts ×3
363
>
if (targetPreviousSetting) {
364
>
const targetNextSetting = findNextSettingNode(targetTree.indexOf(targetPreviousSetting), targetTree);
settingsMerge.ts ×3
365
>
const sourceCommentNodes = findNodesBetween(sourceTree, sourcePreviousSettingNode, sourceTree[sourceNodeIndex]);
366
>
if (targetNextSetting) {
367
>
const targetCommentNodes = findNodesBetween(targetTree, targetPreviousSetting, targetNextSetting);
settingsMerge.ts ×2
368
>
const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes, targetCommentNodes);
369
>
if (targetCommentNode) {
370
>
return { index: targetTree.indexOf(targetCommentNode), insertAfter: true }; /* Insert after comment */
settingsMerge.ts ×1
372
>
return { index: targetTree.indexOf(targetNextSetting), insertAfter: false }; /* Insert before target next setting */
settingsMerge.ts ×1
373
>
}
375
>
const targetCommentNodes = findNodesBetween(targetTree, targetPreviousSetting, targetTree[targetTree.length - 1]);
settingsMerge.ts ×3
376
>
const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes, targetCommentNodes);
377
>
if (targetCommentNode) {
378
>
return { index: targetTree.indexOf(targetCommentNode), insertAfter: true }; /* Insert after comment */
settingsMerge.ts ×1
380
>
return { index: targetTree.length - 1, insertAfter: true }; /* Insert at the end */
settingsMerge.ts ×1
381
>
}
387
>
const sourceNextNode = sourceTree[sourceNodeIndex + 1];
388
>
if (sourceNextNode) {
390
>
Next node in source is a setting.
391
>
Find the same setting in the target.
392
>
Insert it before that setting
393
>
*/
394
>
if (sourceNextNode.setting) {
395
>
const targetNextSetting = findSettingNode(sourceNextNode.setting.key, targetTree);
settingsMerge.ts ×1
396
>
if (targetNextSetting) {
397
>
/* Insert before target's next setting */
398
>
return { index: targetTree.indexOf(targetNextSetting), insertAfter: false };
399
>
}
400
>
}
402
>
else {
403
>
const sourceNextSettingNode = findNextSettingNode(sourceNodeIndex, sourceTree);
404
>
/*
405
>
Source has a setting defined after the setting to be added.
406
>
Find the same next setting in the target.
407
>
If found, insert after its previous setting so that comments are retrieved.
408
>
Otherwise, insert at the beginning.
409
>
*/
410
>
if (sourceNextSettingNode) {
411
>
const targetNextSetting = findSettingNode(sourceNextSettingNode.setting!.key, targetTree);
412
>
if (targetNextSetting) {
413
>
const targetPreviousSetting = findPreviousSettingNode(targetTree.indexOf(targetNextSetting), targetTree);
414
>
const sourceCommentNodes = findNodesBetween(sourceTree, sourceTree[sourceNodeIndex], sourceNextSettingNode);
415
>
if (targetPreviousSetting) {
416
>
const targetCommentNodes = findNodesBetween(targetTree, targetPreviousSetting, targetNextSetting);
settingsMerge.ts ×2
417
>
const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes.reverse(), targetCommentNodes.reverse());
418
>
if (targetCommentNode) {
419
>
return { index: targetTree.indexOf(targetCommentNode), insertAfter: false }; /* Insert before comment */
settingsMerge.ts ×1
421
>
return { index: targetTree.indexOf(targetPreviousSetting), insertAfter: true }; /* Insert after target previous setting */
settingsMerge.ts ×1
422
>
}
424
>
const targetCommentNodes = findNodesBetween(targetTree, targetTree[0], targetNextSetting);
settingsMerge.ts ×3
425
>
const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes.reverse(), targetCommentNodes.reverse());
426
>
if (targetCommentNode) {
427
>
return { index: targetTree.indexOf(targetCommentNode), insertAfter: false }; /* Insert before comment */
settingsMerge.ts ×1
430
>
}
433
>
}
434
>
}
438
>
return { index: targetTree.length - 1, insertAfter: true };
439
>
}
441
>
function insertAtLocation(content: string, key: string, value: any, location: InsertLocation, tree: INode[], formattingOptions: FormattingOptions): string {
settingsMerge.ts ×5
442
>
let edits: Edit[];
443
>
/* Insert at the end */
444
>
if (location.index === -1) {
447
>
edits = getEditToInsertAtLocation(content, key, value, location, tree, formattingOptions).map(edit => withFormatting(content, edit, formattingOptions)[0]);
settingsMerge.ts ×3
448
>
}
450
>
}
452
>
function getEditToInsertAtLocation(content: string, key: string, value: any, location: InsertLocation, tree: INode[], formattingOptions: FormattingOptions): Edit[] {
settingsMerge.ts ×3
453
>
const newProperty = `${JSON.stringify(key)}: ${JSON.stringify(value)}`;
454
>
const eol = getEOL(formattingOptions, content);
455
>
const node = tree[location.index];
456
>
457
>
if (location.insertAfter) {
459
>
const edits: Edit[] = [];
460
>
461
>
/* Insert after a setting */
462
>
if (node.setting) {
463
>
edits.push({ offset: node.endOffset, length: 0, content: ',' + newProperty });
settingsMerge.ts ×1
464
>
}
466
>
/* Insert after a comment */
467
>
else {
468
>
469
>
const nextSettingNode = findNextSettingNode(location.index, tree);
470
>
const previousSettingNode = findPreviousSettingNode(location.index, tree);
471
>
const previousSettingCommaOffset = previousSettingNode?.setting?.commaOffset;
472
>
473
>
/* If there is a previous setting and it does not has comma then add it */
474
>
if (previousSettingNode && previousSettingCommaOffset === undefined) {
475
>
edits.push({ offset: previousSettingNode.endOffset, length: 0, content: ',' });
jsonEdit.ts ×2
476
>
}
478
>
const isPreviouisSettingIncludesComment = previousSettingCommaOffset !== undefined && previousSettingCommaOffset > node.endOffset;
479
>
edits.push({
480
>
offset: isPreviouisSettingIncludesComment ? previousSettingCommaOffset + 1 : node.endOffset,
481
>
length: 0,
482
>
content: nextSettingNode ? eol + newProperty + ',' : eol + newProperty
483
>
});
484
>
}
486
>
487
>
return edits;
488
>
}
490
>
else {
491
>
492
>
/* Insert before a setting */
493
>
if (node.setting) {
494
>
return [{ offset: node.startOffset, length: 0, content: newProperty + ',' }];
settingsMerge.ts ×1
495
>
}
497
>
/* Insert before a comment */
498
>
const content = (tree[location.index - 1] && !tree[location.index - 1].setting /* previous node is comment */ ? eol : '')
settingsMerge.ts ×2
499
>
+ newProperty
500
>
+ (findNextSettingNode(location.index, tree) ? ',' : '')
501
>
+ eol;
502
>
return [{ offset: node.startOffset, length: 0, content }];
503
>
}
505
>
}
508
>
return tree.filter(node => node.setting?.key === key)[0];
509
>
}
511
>
function findPreviousSettingNode(index: number, tree: INode[]): INode | undefined {
settingsMerge.ts ×2
512
>
for (let i = index - 1; i >= 0; i--) {
513
>
if (tree[i].setting) {
515
>
}
518
>
}
520
>
function findNextSettingNode(index: number, tree: INode[]): INode | undefined {
settingsMerge.ts ×1
521
>
for (let i = index + 1; i < tree.length; i++) {
524
>
}
527
>
}
529
>
function findNodesBetween(nodes: INode[], from: INode, till: INode): INode[] {
settingsMerge.ts ×4
530
>
const fromIndex = nodes.indexOf(from);
531
>
const tillIndex = nodes.indexOf(till);
532
>
return nodes.filter((node, index) => fromIndex < index && index < tillIndex);
533
>
}
535
>
function findLastMatchingTargetCommentNode(sourceComments: INode[], targetComments: INode[]): INode | undefined {
settingsMerge.ts ×4
536
>
if (sourceComments.length && targetComments.length) {
538
>
for (; index < targetComments.length && index < sourceComments.length; index++) {
539
>
if (sourceComments[index].value !== targetComments[index].value) {
541
>
}
544
>
}
546
>
}
548
>
interface INode {
549
>
readonly startOffset: number;
550
>
readonly endOffset: number;
551
>
readonly value: string;
552
>
readonly setting?: {
553
>
readonly key: string;
554
>
readonly commaOffset: number | undefined;
555
>
};
556
>
readonly comment?: string;
557
>
}
558
>
560
>
const nodes: INode[] = [];
561
>
let hierarchyLevel = -1;
562
>
let startOffset: number;
563
>
let key: string;
564
>
565
>
const visitor: JSONVisitor = {
566
>
onObjectBegin: (offset: number) => {
568
>
},
571
>
// this is setting key
572
>
startOffset = offset;
573
>
key = name;
574
>
}
575
>
},
578
>
if (hierarchyLevel === 0) {
580
>
startOffset,
581
>
endOffset: offset + length,
582
>
value: content.substring(startOffset, offset + length),
583
>
setting: {
584
>
key,
585
>
commaOffset: undefined
586
>
}
587
>
});
588
>
}
592
>
},
595
>
if (hierarchyLevel === 0) {
597
>
startOffset,
598
>
endOffset: offset + length,
599
>
value: content.substring(startOffset, offset + length),
600
>
setting: {
601
>
key,
602
>
commaOffset: undefined
603
>
}
604
>
});
605
>
}
609
>
nodes.push({
610
>
startOffset,
611
>
endOffset: offset + length,
612
>
value: content.substring(startOffset, offset + length),
613
>
setting: {
614
>
key,
615
>
commaOffset: undefined
616
>
}
617
>
});
618
>
}
619
>
},
622
>
if (sep === ',') {
624
>
for (; index >= 0; index--) {
625
>
if (nodes[index].setting) {
626
>
break;
627
>
}
628
>
}
629
>
const node = nodes[index];
630
>
if (node) {
631
>
nodes.splice(index, 1, {
632
>
startOffset: node.startOffset,
633
>
endOffset: node.endOffset,
634
>
value: node.value,
635
>
setting: {
636
>
key: node.setting!.key,
637
>
commaOffset: offset
638
>
}
639
>
});
640
>
}
641
>
}
643
>
},
646
>
nodes.push({
647
>
startOffset: offset,
648
>
endOffset: offset + length,
649
>
value: content.substring(offset, offset + length),
650
>
});
651
>
}
652
>
}
654
>
visit(content, visitor);
655
>
return nodes;
656
>
}