src/vs/base/common/json.ts
1326 LOC · 1090 covered · 236 uncovered · 269 ranges · 4490 concepts · 97 introducers · 2403 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
>
/*---------------------------------------------------------------------------------------------
json.ts ×14
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
>
export const enum ScanError {
7
>
None = 0,
8
>
UnexpectedEndOfComment = 1,
9
>
UnexpectedEndOfString = 2,
10
>
UnexpectedEndOfNumber = 3,
11
>
InvalidUnicode = 4,
12
>
InvalidEscapeCharacter = 5,
13
>
InvalidCharacter = 6
14
>
}
15
>
16
>
export const enum SyntaxKind {
17
>
OpenBraceToken = 1,
18
>
CloseBraceToken = 2,
19
>
OpenBracketToken = 3,
20
>
CloseBracketToken = 4,
21
>
CommaToken = 5,
22
>
ColonToken = 6,
23
>
NullKeyword = 7,
24
>
TrueKeyword = 8,
25
>
FalseKeyword = 9,
26
>
StringLiteral = 10,
27
>
NumericLiteral = 11,
28
>
LineCommentTrivia = 12,
29
>
BlockCommentTrivia = 13,
30
>
LineBreakTrivia = 14,
31
>
Trivia = 15,
32
>
Unknown = 16,
33
>
EOF = 17
34
>
}
35
>
36
>
/**
37
>
* The scanner object, representing a JSON scanner at a position in the input string.
38
>
*/
39
>
export interface JSONScanner {
40
>
/**
41
>
* Sets the scan position to a new offset. A call to 'scan' is needed to get the first token.
42
>
*/
43
>
setPosition(pos: number): void;
44
>
/**
45
>
* Read the next token. Returns the token code.
46
>
*/
47
>
scan(): SyntaxKind;
48
>
/**
49
>
* Returns the current scan position, which is after the last read token.
50
>
*/
51
>
getPosition(): number;
52
>
/**
53
>
* Returns the last read token.
54
>
*/
55
>
getToken(): SyntaxKind;
56
>
/**
57
>
* Returns the last read token value. The value for strings is the decoded string content. For numbers its of type number, for boolean it's true or false.
58
>
*/
59
>
getTokenValue(): string;
60
>
/**
61
>
* The start offset of the last read token.
62
>
*/
63
>
getTokenOffset(): number;
64
>
/**
65
>
* The length of the last read token.
66
>
*/
67
>
getTokenLength(): number;
68
>
/**
69
>
* An error code of the last scan.
70
>
*/
71
>
getTokenError(): ScanError;
72
>
}
73
>
74
>
75
>
76
>
export interface ParseError {
77
>
error: ParseErrorCode;
78
>
offset: number;
79
>
length: number;
80
>
}
81
>
82
>
export const enum ParseErrorCode {
83
>
InvalidSymbol = 1,
84
>
InvalidNumberFormat = 2,
85
>
PropertyNameExpected = 3,
86
>
ValueExpected = 4,
87
>
ColonExpected = 5,
88
>
CommaExpected = 6,
89
>
CloseBraceExpected = 7,
90
>
CloseBracketExpected = 8,
91
>
EndOfFileExpected = 9,
92
>
InvalidCommentToken = 10,
93
>
UnexpectedEndOfComment = 11,
94
>
UnexpectedEndOfString = 12,
95
>
UnexpectedEndOfNumber = 13,
96
>
InvalidUnicode = 14,
97
>
InvalidEscapeCharacter = 15,
98
>
InvalidCharacter = 16
99
>
}
100
>
101
>
export type NodeType = 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
102
>
103
>
export interface Node {
104
>
readonly type: NodeType;
105
>
readonly value?: any;
106
>
readonly offset: number;
107
>
readonly length: number;
108
>
readonly colonOffset?: number;
109
>
readonly parent?: Node;
110
>
readonly children?: Node[];
111
>
}
112
>
113
>
export type Segment = string | number;
114
>
export type JSONPath = Segment[];
115
>
116
>
export interface Location {
117
>
/**
118
>
* The previous property key or literal value (string, number, boolean or null) or undefined.
119
>
*/
120
>
previousNode?: Node;
121
>
/**
122
>
* The path describing the location in the JSON document. The path consists of a sequence strings
123
>
* representing an object property or numbers for array indices.
124
>
*/
125
>
path: JSONPath;
126
>
/**
127
>
* Matches the locations path against a pattern consisting of strings (for properties) and numbers (for array indices).
128
>
* '*' will match a single segment, of any property name or index.
129
>
* '**' will match a sequence of segments or no segment, of any property name or index.
130
>
*/
131
>
matches: (patterns: JSONPath) => boolean;
132
>
/**
133
>
* If set, the location's offset is at a property key.
134
>
*/
135
>
isAtPropertyKey: boolean;
136
>
}
137
>
138
>
export interface ParseOptions {
139
>
disallowComments?: boolean;
140
>
allowTrailingComma?: boolean;
141
>
allowEmptyContent?: boolean;
142
>
}
143
>
144
>
export namespace ParseOptions {
145
>
export const DEFAULT = {
146
>
allowTrailingComma: true
147
>
};
148
>
}
149
>
150
>
export interface JSONVisitor {
151
>
/**
152
>
* Invoked when an open brace is encountered and an object is started. The offset and length represent the location of the open brace.
153
>
*/
154
>
onObjectBegin?: (offset: number, length: number) => void;
155
>
156
>
/**
157
>
* Invoked when a property is encountered. The offset and length represent the location of the property name.
158
>
*/
159
>
onObjectProperty?: (property: string, offset: number, length: number) => void;
160
>
161
>
/**
162
>
* Invoked when a closing brace is encountered and an object is completed. The offset and length represent the location of the closing brace.
163
>
*/
164
>
onObjectEnd?: (offset: number, length: number) => void;
165
>
166
>
/**
167
>
* Invoked when an open bracket is encountered. The offset and length represent the location of the open bracket.
168
>
*/
169
>
onArrayBegin?: (offset: number, length: number) => void;
170
>
171
>
/**
172
>
* Invoked when a closing bracket is encountered. The offset and length represent the location of the closing bracket.
173
>
*/
174
>
onArrayEnd?: (offset: number, length: number) => void;
175
>
176
>
/**
177
>
* Invoked when a literal value is encountered. The offset and length represent the location of the literal value.
178
>
*/
179
>
onLiteralValue?: (value: any, offset: number, length: number) => void;
180
>
181
>
/**
182
>
* Invoked when a comma or colon separator is encountered. The offset and length represent the location of the separator.
183
>
*/
184
>
onSeparator?: (character: string, offset: number, length: number) => void;
185
>
186
>
/**
187
>
* When comments are allowed, invoked when a line or block comment is encountered. The offset and length represent the location of the comment.
188
>
*/
189
>
onComment?: (offset: number, length: number) => void;
190
>
191
>
/**
192
>
* Invoked on an error.
193
>
*/
194
>
onError?: (error: ParseErrorCode, offset: number, length: number) => void;
195
>
}
196
>
197
>
/**
198
>
* Creates a JSON scanner on the given text.
199
>
* If ignoreTrivia is set, whitespaces or comments are ignored.
200
>
*/
201
>
export function createScanner(text: string, ignoreTrivia: boolean = false): JSONScanner {
203
>
let pos = 0;
204
>
const len = text.length;
205
>
let value: string = '';
206
>
let tokenOffset = 0;
207
>
let token: SyntaxKind = SyntaxKind.Unknown;
208
>
let scanError: ScanError = ScanError.None;
209
>
210
>
function scanHexDigits(count: number): number {
212
>
let hexValue = 0;
213
>
while (digits < count) {
214
>
const ch = text.charCodeAt(pos);
215
>
if (ch >= CharacterCodes._0 && ch <= CharacterCodes._9) {
216
>
hexValue = hexValue * 16 + ch - CharacterCodes._0;
217
>
}
218
>
else if (ch >= CharacterCodes.A && ch <= CharacterCodes.F) {
219
>
hexValue = hexValue * 16 + ch - CharacterCodes.A + 10;
220
>
}
221
else if (ch >= CharacterCodes.a && ch <= CharacterCodes.f) {
222
hexValue = hexValue * 16 + ch - CharacterCodes.a + 10;
223
}
224
else {
225
break;
226
}
228
>
digits++;
229
>
}
230
>
if (digits < count) {
231
hexValue = -1;
232
}
234
>
}
236
>
function setPosition(newPosition: number) {
238
>
value = '';
239
>
tokenOffset = 0;
240
>
token = SyntaxKind.Unknown;
241
>
scanError = ScanError.None;
242
>
}
244
>
function scanNumber(): string {
246
>
if (text.charCodeAt(pos) === CharacterCodes._0) {
249
>
pos++;
250
>
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
252
>
}
254
>
if (pos < text.length && text.charCodeAt(pos) === CharacterCodes.dot) {
256
>
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
257
>
pos++;
258
>
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
260
>
}
262
scanError = ScanError.UnexpectedEndOfNumber;
263
return text.substring(start, pos);
264
}
267
>
if (pos < text.length && (text.charCodeAt(pos) === CharacterCodes.E || text.charCodeAt(pos) === CharacterCodes.e)) {
269
>
if (pos < text.length && text.charCodeAt(pos) === CharacterCodes.plus || text.charCodeAt(pos) === CharacterCodes.minus) {
270
>
pos++;
271
>
}
272
>
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
273
>
pos++;
274
>
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
276
>
}
278
>
} else {
279
scanError = ScanError.UnexpectedEndOfNumber;
280
}
283
>
}
285
>
function scanString(): string {
287
>
let result = '',
288
>
start = pos;
289
>
290
>
while (true) {
291
>
if (pos >= len) {
293
>
scanError = ScanError.UnexpectedEndOfString;
294
>
break;
295
>
}
297
>
if (ch === CharacterCodes.doubleQuote) {
298
>
result += text.substring(start, pos);
299
>
pos++;
300
>
break;
301
>
}
304
>
pos++;
305
>
if (pos >= len) {
306
scanError = ScanError.UnexpectedEndOfString;
307
break;
308
}
310
>
switch (ch2) {
311
>
case CharacterCodes.doubleQuote:
312
>
result += '\"';
313
>
break;
314
>
case CharacterCodes.backslash:
316
>
break;
319
>
break;
322
>
break;
325
>
break;
327
>
result += '\n';
328
>
break;
329
>
case CharacterCodes.r:
331
>
break;
333
>
result += '\t';
334
>
break;
335
>
case CharacterCodes.u: {
337
>
if (ch3 >= 0) {
338
>
result += String.fromCharCode(ch3);
339
>
} else {
340
scanError = ScanError.InvalidUnicode;
341
}
343
>
}
347
>
start = pos;
348
>
continue;
349
>
}
352
>
result += text.substring(start, pos);
353
>
scanError = ScanError.UnexpectedEndOfString;
354
>
break;
355
>
} else {
356
>
scanError = ScanError.InvalidCharacter;
357
>
// mark as error but continue with string
358
>
}
359
>
}
361
>
}
363
>
}
365
>
function scanNext(): SyntaxKind {
366
>
367
>
value = '';
368
>
scanError = ScanError.None;
369
>
370
>
tokenOffset = pos;
371
>
372
>
if (pos >= len) {
374
>
tokenOffset = len;
375
>
return token = SyntaxKind.EOF;
376
>
}
378
>
let code = text.charCodeAt(pos);
379
>
// trivia: whitespace
380
>
if (isWhitespace(code)) {
382
>
pos++;
383
>
value += String.fromCharCode(code);
384
>
code = text.charCodeAt(pos);
385
>
} while (isWhitespace(code));
386
>
387
>
return token = SyntaxKind.Trivia;
388
>
}
390
>
// trivia: newlines
391
>
if (isLineBreak(code)) {
393
>
value += String.fromCharCode(code);
394
>
if (code === CharacterCodes.carriageReturn && text.charCodeAt(pos) === CharacterCodes.lineFeed) {
396
>
value += '\n';
397
>
}
399
>
}
401
>
switch (code) {
402
>
// tokens: []{}:,
403
>
case CharacterCodes.openBrace:
405
>
return token = SyntaxKind.OpenBraceToken;
408
>
return token = SyntaxKind.CloseBraceToken;
411
>
return token = SyntaxKind.OpenBracketToken;
414
>
return token = SyntaxKind.CloseBracketToken;
417
>
return token = SyntaxKind.ColonToken;
420
>
return token = SyntaxKind.CommaToken;
422
>
// strings
423
>
case CharacterCodes.doubleQuote:
425
>
value = scanString();
426
>
return token = SyntaxKind.StringLiteral;
428
>
// comments
429
>
case CharacterCodes.slash: {
431
>
// Single-line comment
432
>
if (text.charCodeAt(pos + 1) === CharacterCodes.slash) {
434
>
435
>
while (pos < len) {
436
>
if (isLineBreak(text.charCodeAt(pos))) {
438
>
}
440
>
441
>
}
442
>
value = text.substring(start, pos);
443
>
return token = SyntaxKind.LineCommentTrivia;
444
>
}
446
>
// Multi-line comment
447
>
if (text.charCodeAt(pos + 1) === CharacterCodes.asterisk) {
448
>
pos += 2;
449
>
450
>
const safeLength = len - 1; // For lookahead.
451
>
let commentClosed = false;
452
>
while (pos < safeLength) {
453
>
const ch = text.charCodeAt(pos);
454
>
455
>
if (ch === CharacterCodes.asterisk && text.charCodeAt(pos + 1) === CharacterCodes.slash) {
456
>
pos += 2;
457
>
commentClosed = true;
458
>
break;
459
>
}
460
>
pos++;
461
>
}
462
>
463
>
if (!commentClosed) {
465
>
scanError = ScanError.UnexpectedEndOfComment;
466
>
}
468
>
value = text.substring(start, pos);
469
>
return token = SyntaxKind.BlockCommentTrivia;
470
>
}
472
>
value += String.fromCharCode(code);
473
>
pos++;
474
>
return token = SyntaxKind.Unknown;
475
>
}
477
>
case CharacterCodes.minus:
479
>
pos++;
480
>
if (pos === len || !isDigit(text.charCodeAt(pos))) {
482
>
}
484
>
// we fall through to proceed with scanning
485
>
// numbers
486
>
case CharacterCodes._0:
487
>
case CharacterCodes._1:
488
>
case CharacterCodes._2:
489
>
case CharacterCodes._3:
490
>
case CharacterCodes._4:
491
>
case CharacterCodes._5:
492
>
case CharacterCodes._6:
493
>
case CharacterCodes._7:
494
>
case CharacterCodes._8:
495
>
case CharacterCodes._9:
497
>
return token = SyntaxKind.NumericLiteral;
499
>
default:
501
>
while (pos < len && isUnknownContentCharacter(code)) {
502
>
pos++;
503
>
code = text.charCodeAt(pos);
504
>
}
505
>
if (tokenOffset !== pos) {
506
>
value = text.substring(tokenOffset, pos);
507
>
// keywords: true, false, null
508
>
switch (value) {
509
>
case 'true': return token = SyntaxKind.TrueKeyword;
510
>
case 'false': return token = SyntaxKind.FalseKeyword;
511
>
case 'null': return token = SyntaxKind.NullKeyword;
512
>
}
514
>
}
515
// some
516
value += String.fromCharCode(code);
517
pos++;
518
return token = SyntaxKind.Unknown;
520
>
}
521
>
522
>
function isUnknownContentCharacter(code: CharacterCodes) {
525
>
}
527
>
case CharacterCodes.closeBrace:
528
>
case CharacterCodes.closeBracket:
529
>
case CharacterCodes.openBrace:
530
>
case CharacterCodes.openBracket:
531
>
case CharacterCodes.doubleQuote:
532
>
case CharacterCodes.colon:
533
>
case CharacterCodes.comma:
534
>
case CharacterCodes.slash:
537
>
return true;
538
>
}
540
>
541
>
function scanNextNonTrivia(): SyntaxKind {
542
let result: SyntaxKind;
543
do {
544
result = scanNext();
545
} while (result >= SyntaxKind.LineCommentTrivia && result <= SyntaxKind.Trivia);
546
return result;
547
}
549
>
return {
550
>
setPosition: setPosition,
551
>
getPosition: () => pos,
552
>
scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
553
>
getToken: () => token,
554
>
getTokenValue: () => value,
555
>
getTokenOffset: () => tokenOffset,
556
>
getTokenLength: () => pos - tokenOffset,
557
>
getTokenError: () => scanError
558
>
};
559
>
}
562
>
return ch === CharacterCodes.space || ch === CharacterCodes.tab || ch === CharacterCodes.verticalTab || ch === CharacterCodes.formFeed ||
563
>
ch === CharacterCodes.nonBreakingSpace || ch === CharacterCodes.ogham || ch >= CharacterCodes.enQuad && ch <= CharacterCodes.zeroWidthSpace ||
564
>
ch === CharacterCodes.narrowNoBreakSpace || ch === CharacterCodes.mathematicalSpace || ch === CharacterCodes.ideographicSpace || ch === CharacterCodes.byteOrderMark;
565
>
}
568
>
return ch === CharacterCodes.lineFeed || ch === CharacterCodes.carriageReturn || ch === CharacterCodes.lineSeparator || ch === CharacterCodes.paragraphSeparator;
569
>
}
572
>
return ch >= CharacterCodes._0 && ch <= CharacterCodes._9;
573
>
}
575
>
const enum CharacterCodes {
576
>
nullCharacter = 0,
577
>
maxAsciiCharacter = 0x7F,
578
>
579
>
lineFeed = 0x0A, // \n
580
>
carriageReturn = 0x0D, // \r
581
>
lineSeparator = 0x2028,
582
>
paragraphSeparator = 0x2029,
583
>
584
>
// REVIEW: do we need to support this? The scanner doesn't, but our IText does. This seems
585
>
// like an odd disparity? (Or maybe it's completely fine for them to be different).
586
>
nextLine = 0x0085,
587
>
588
>
// Unicode 3.0 space characters
589
>
space = 0x0020, // " "
590
>
nonBreakingSpace = 0x00A0, //
591
>
enQuad = 0x2000,
592
>
emQuad = 0x2001,
593
>
enSpace = 0x2002,
594
>
emSpace = 0x2003,
595
>
threePerEmSpace = 0x2004,
596
>
fourPerEmSpace = 0x2005,
597
>
sixPerEmSpace = 0x2006,
598
>
figureSpace = 0x2007,
599
>
punctuationSpace = 0x2008,
600
>
thinSpace = 0x2009,
601
>
hairSpace = 0x200A,
602
>
zeroWidthSpace = 0x200B,
603
>
narrowNoBreakSpace = 0x202F,
604
>
ideographicSpace = 0x3000,
605
>
mathematicalSpace = 0x205F,
606
>
ogham = 0x1680,
607
>
608
>
_ = 0x5F,
609
>
$ = 0x24,
610
>
611
>
_0 = 0x30,
612
>
_1 = 0x31,
613
>
_2 = 0x32,
614
>
_3 = 0x33,
615
>
_4 = 0x34,
616
>
_5 = 0x35,
617
>
_6 = 0x36,
618
>
_7 = 0x37,
619
>
_8 = 0x38,
620
>
_9 = 0x39,
621
>
622
>
a = 0x61,
623
>
b = 0x62,
624
>
c = 0x63,
625
>
d = 0x64,
626
>
e = 0x65,
627
>
f = 0x66,
628
>
g = 0x67,
629
>
h = 0x68,
630
>
i = 0x69,
631
>
j = 0x6A,
632
>
k = 0x6B,
633
>
l = 0x6C,
634
>
m = 0x6D,
635
>
n = 0x6E,
636
>
o = 0x6F,
637
>
p = 0x70,
638
>
q = 0x71,
639
>
r = 0x72,
640
>
s = 0x73,
641
>
t = 0x74,
642
>
u = 0x75,
643
>
v = 0x76,
644
>
w = 0x77,
645
>
x = 0x78,
646
>
y = 0x79,
647
>
z = 0x7A,
648
>
649
>
A = 0x41,
650
>
B = 0x42,
651
>
C = 0x43,
652
>
D = 0x44,
653
>
E = 0x45,
654
>
F = 0x46,
655
>
G = 0x47,
656
>
H = 0x48,
657
>
I = 0x49,
658
>
J = 0x4A,
659
>
K = 0x4B,
660
>
L = 0x4C,
661
>
M = 0x4D,
662
>
N = 0x4E,
663
>
O = 0x4F,
664
>
P = 0x50,
665
>
Q = 0x51,
666
>
R = 0x52,
667
>
S = 0x53,
668
>
T = 0x54,
669
>
U = 0x55,
670
>
V = 0x56,
671
>
W = 0x57,
672
>
X = 0x58,
673
>
Y = 0x59,
674
>
Z = 0x5A,
675
>
676
>
ampersand = 0x26, // &
677
>
asterisk = 0x2A, // *
678
>
at = 0x40, // @
679
>
backslash = 0x5C, // \
680
>
bar = 0x7C, // |
681
>
caret = 0x5E, // ^
682
>
closeBrace = 0x7D, // }
683
>
closeBracket = 0x5D, // ]
684
>
closeParen = 0x29, // )
685
>
colon = 0x3A, // :
686
>
comma = 0x2C, // ,
687
>
dot = 0x2E, // .
688
>
doubleQuote = 0x22, // "
689
>
equals = 0x3D, // =
690
>
exclamation = 0x21, // !
691
>
greaterThan = 0x3E, // >
692
>
lessThan = 0x3C, // <
693
>
minus = 0x2D, // -
694
>
openBrace = 0x7B, // {
695
>
openBracket = 0x5B, // [
696
>
openParen = 0x28, // (
697
>
percent = 0x25, // %
698
>
plus = 0x2B, // +
699
>
question = 0x3F, // ?
700
>
semicolon = 0x3B, // ;
701
>
singleQuote = 0x27, // '
702
>
slash = 0x2F, // /
703
>
tilde = 0x7E, // ~
704
>
705
>
backspace = 0x08, // \b
706
>
formFeed = 0x0C, // \f
707
>
byteOrderMark = 0xFEFF,
708
>
tab = 0x09, // \t
709
>
verticalTab = 0x0B, // \v
710
>
}
711
>
712
>
interface NodeImpl extends Node {
713
>
type: NodeType;
714
>
value?: any;
715
>
offset: number;
716
>
length: number;
717
>
colonOffset?: number;
718
>
parent?: NodeImpl;
719
>
children?: NodeImpl[];
720
>
}
721
>
722
>
/**
723
>
* For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
724
>
*/
725
>
export function getLocation(text: string, position: number): Location {
726
const segments: Segment[] = []; // strings or numbers
727
const earlyReturnException = new Object();
728
let previousNode: NodeImpl | undefined = undefined;
729
const previousNodeInst: NodeImpl = {
730
value: {},
731
offset: 0,
732
length: 0,
733
type: 'object',
734
parent: undefined
735
};
736
let isAtPropertyKey = false;
737
function setPreviousNode(value: string, offset: number, length: number, type: NodeType) {
738
previousNodeInst.value = value;
739
previousNodeInst.offset = offset;
740
previousNodeInst.length = length;
741
previousNodeInst.type = type;
742
previousNodeInst.colonOffset = undefined;
743
previousNode = previousNodeInst;
744
}
745
try {
746
747
visit(text, {
748
onObjectBegin: (offset: number, length: number) => {
749
if (position <= offset) {
750
throw earlyReturnException;
751
}
752
previousNode = undefined;
753
isAtPropertyKey = position > offset;
754
segments.push(''); // push a placeholder (will be replaced)
755
},
756
onObjectProperty: (name: string, offset: number, length: number) => {
757
if (position < offset) {
758
throw earlyReturnException;
759
}
760
setPreviousNode(name, offset, length, 'property');
761
segments[segments.length - 1] = name;
762
if (position <= offset + length) {
763
throw earlyReturnException;
764
}
765
},
766
onObjectEnd: (offset: number, length: number) => {
767
if (position <= offset) {
768
throw earlyReturnException;
769
}
770
previousNode = undefined;
771
segments.pop();
772
},
773
onArrayBegin: (offset: number, length: number) => {
774
if (position <= offset) {
775
throw earlyReturnException;
776
}
777
previousNode = undefined;
778
segments.push(0);
779
},
780
onArrayEnd: (offset: number, length: number) => {
781
if (position <= offset) {
782
throw earlyReturnException;
783
}
784
previousNode = undefined;
785
segments.pop();
786
},
787
onLiteralValue: (value: any, offset: number, length: number) => {
788
if (position < offset) {
789
throw earlyReturnException;
790
}
791
setPreviousNode(value, offset, length, getNodeType(value));
792
793
if (position <= offset + length) {
794
throw earlyReturnException;
795
}
796
},
797
onSeparator: (sep: string, offset: number, length: number) => {
798
if (position <= offset) {
799
throw earlyReturnException;
800
}
801
if (sep === ':' && previousNode && previousNode.type === 'property') {
802
previousNode.colonOffset = offset;
803
isAtPropertyKey = false;
804
previousNode = undefined;
805
} else if (sep === ',') {
806
const last = segments[segments.length - 1];
807
if (typeof last === 'number') {
808
segments[segments.length - 1] = last + 1;
809
} else {
810
isAtPropertyKey = true;
811
segments[segments.length - 1] = '';
812
}
813
previousNode = undefined;
814
}
815
}
816
});
817
} catch (e) {
818
if (e !== earlyReturnException) {
819
throw e;
820
}
821
}
822
823
return {
824
path: segments,
825
previousNode,
826
isAtPropertyKey,
827
matches: (pattern: Segment[]) => {
828
let k = 0;
829
for (let i = 0; k < pattern.length && i < segments.length; i++) {
830
if (pattern[k] === segments[i] || pattern[k] === '*') {
831
k++;
832
} else if (pattern[k] !== '**') {
833
return false;
834
}
835
}
836
return k === pattern.length;
837
}
838
};
839
}
841
>
842
>
/**
843
>
* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
844
>
* Therefore always check the errors list to find out if the input was valid.
845
>
*/
846
>
export function parse(text: string, errors: ParseError[] = [], options: ParseOptions = ParseOptions.DEFAULT): any {
848
>
let currentParent: any = [];
849
>
const previousParents: any[] = [];
850
>
851
>
function onValue(value: unknown) {
853
>
currentParent.push(value);
854
>
} else if (currentProperty !== null) {
856
>
}
859
>
const visitor: JSONVisitor = {
860
>
onObjectBegin: () => {
862
>
onValue(object);
863
>
previousParents.push(currentParent);
864
>
currentParent = object;
865
>
currentProperty = null;
866
>
},
869
>
},
872
>
},
875
>
onValue(array);
876
>
previousParents.push(currentParent);
877
>
currentParent = array;
878
>
currentProperty = null;
879
>
},
882
>
},
884
>
onError: (error: ParseErrorCode, offset: number, length: number) => {
886
>
}
888
>
visit(text, visitor, options);
889
>
return currentParent[0];
890
>
}
892
>
893
>
/**
894
>
* Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
895
>
*/
896
>
export function parseTree(text: string, errors: ParseError[] = [], options: ParseOptions = ParseOptions.DEFAULT): Node {
897
>
let currentParent: NodeImpl = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
json.ts ×10
898
>
899
>
function ensurePropertyComplete(endOffset: number) {
900
>
if (currentParent.type === 'property') {
902
>
currentParent = currentParent.parent!;
903
>
}
905
>
906
>
function onValue(valueNode: Node): Node {
907
>
currentParent.children!.push(valueNode);
908
>
return valueNode;
909
>
}
910
>
911
>
const visitor: JSONVisitor = {
912
>
onObjectBegin: (offset: number) => {
913
>
currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
json.ts ×2
914
>
},
916
>
currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
json.ts ×4
917
>
currentParent.children!.push({ type: 'string', value: name, offset, length, parent: currentParent });
918
>
},
921
>
currentParent = currentParent.parent!;
922
>
ensurePropertyComplete(offset + length);
923
>
},
925
>
currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
json.ts ×2
926
>
},
929
>
currentParent = currentParent.parent!;
930
>
ensurePropertyComplete(offset + length);
931
>
},
933
>
onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
json.ts ×1
934
>
ensurePropertyComplete(offset + length);
935
>
},
939
>
currentParent.colonOffset = offset;
940
>
} else if (sep === ',') {
941
ensurePropertyComplete(offset);
942
}
947
>
}
949
>
visit(text, visitor, options);
950
>
951
>
const result = currentParent.children![0];
952
>
if (result) {
953
>
delete result.parent;
954
>
}
955
>
return result;
956
>
}
958
>
/**
959
>
* Finds the node at the given path in a JSON DOM.
960
>
*/
961
>
export function findNodeAtLocation(root: Node, path: JSONPath): Node | undefined {
964
>
}
966
>
for (const segment of path) {
968
>
if (node.type !== 'object' || !Array.isArray(node.children)) {
969
return undefined;
970
}
972
>
for (const propertyNode of node.children) {
973
>
if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
json.ts ×2
975
>
found = true;
976
>
break;
977
>
}
981
>
}
983
const index = segment;
984
if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
985
return undefined;
986
}
987
node = node.children[index];
988
}
991
>
}
993
>
/**
994
>
* Gets the JSON path of the given JSON DOM node
995
>
*/
996
>
export function getNodePath(node: Node): JSONPath {
997
if (!node.parent || !node.parent.children) {
998
return [];
999
}
1000
const path = getNodePath(node.parent);
1001
if (node.parent.type === 'property') {
1002
const key = node.parent.children[0].value;
1003
path.push(key);
1004
} else if (node.parent.type === 'array') {
1005
const index = node.parent.children.indexOf(node);
1006
if (index !== -1) {
1007
path.push(index);
1008
}
1009
}
1010
return path;
1011
}
1013
>
/**
1014
>
* Evaluates the JavaScript object of the given JSON DOM node
1015
>
*/
1016
>
export function getNodeValue(node: Node): any {
1017
switch (node.type) {
1018
case 'array':
1019
return node.children!.map(getNodeValue);
1020
case 'object': {
1021
const obj = Object.create(null);
1022
for (const prop of node.children!) {
1023
const valueNode = prop.children![1];
1024
if (valueNode) {
1025
obj[prop.children![0].value] = getNodeValue(valueNode);
1026
}
1027
}
1028
return obj;
1029
}
1030
case 'null':
1031
case 'string':
1032
case 'number':
1033
case 'boolean':
1034
return node.value;
1035
default:
1036
return undefined;
1037
}
1038
1039
}
1041
>
export function contains(node: Node, offset: number, includeRightBound = false): boolean {
1042
return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
1043
}
1045
>
/**
1046
>
* Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
1047
>
*/
1048
>
export function findNodeAtOffset(node: Node, offset: number, includeRightBound = false): Node | undefined {
1049
if (contains(node, offset, includeRightBound)) {
1050
const children = node.children;
1051
if (Array.isArray(children)) {
1052
for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
1053
const item = findNodeAtOffset(children[i], offset, includeRightBound);
1054
if (item) {
1055
return item;
1056
}
1057
}
1058
1059
}
1060
return node;
1061
}
1062
return undefined;
1063
}
1065
>
1066
>
/**
1067
>
* Parses the given text and invokes the visitor functions for each object, array and literal reached.
1068
>
*/
1069
>
export function visit(text: string, visitor: JSONVisitor, options: ParseOptions = ParseOptions.DEFAULT): any {
1071
>
const _scanner = createScanner(text, false);
1072
>
1073
>
function toNoArgVisit(visitFunction?: (offset: number, length: number) => void): () => void {
1074
>
return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
1075
>
}
1076
>
function toOneArgVisit<T>(visitFunction?: (arg: T, offset: number, length: number) => void): (arg: T) => void {
1077
>
return visitFunction ? (arg: T) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
1078
>
}
1079
>
1080
>
const onObjectBegin = toNoArgVisit(visitor.onObjectBegin),
1081
>
onObjectProperty = toOneArgVisit(visitor.onObjectProperty),
1082
>
onObjectEnd = toNoArgVisit(visitor.onObjectEnd),
1083
>
onArrayBegin = toNoArgVisit(visitor.onArrayBegin),
1084
>
onArrayEnd = toNoArgVisit(visitor.onArrayEnd),
1085
>
onLiteralValue = toOneArgVisit(visitor.onLiteralValue),
1086
>
onSeparator = toOneArgVisit(visitor.onSeparator),
1087
>
onComment = toNoArgVisit(visitor.onComment),
1088
>
onError = toOneArgVisit(visitor.onError);
1089
>
1090
>
const disallowComments = options && options.disallowComments;
1091
>
const allowTrailingComma = options && options.allowTrailingComma;
1092
>
function scanNext(): SyntaxKind {
1093
>
while (true) {
1094
>
const token = _scanner.scan();
1095
>
switch (_scanner.getTokenError()) {
1096
>
case ScanError.InvalidUnicode:
1097
handleError(ParseErrorCode.InvalidUnicode);
1098
break;
1100
handleError(ParseErrorCode.InvalidEscapeCharacter);
1101
break;
1103
handleError(ParseErrorCode.UnexpectedEndOfNumber);
1104
break;
1106
if (!disallowComments) {
1107
handleError(ParseErrorCode.UnexpectedEndOfComment);
1108
}
1109
break;
1111
handleError(ParseErrorCode.UnexpectedEndOfString);
1112
break;
1114
handleError(ParseErrorCode.InvalidCharacter);
1115
break;
1117
>
switch (token) {
1118
>
case SyntaxKind.LineCommentTrivia:
1119
>
case SyntaxKind.BlockCommentTrivia:
1124
>
}
1127
handleError(ParseErrorCode.InvalidSymbol);
1128
break;
1130
>
case SyntaxKind.LineBreakTrivia:
1133
>
return token;
1134
>
}
1135
>
}
1136
>
}
1137
>
1138
>
function handleError(error: ParseErrorCode, skipUntilAfter: SyntaxKind[] = [], skipUntil: SyntaxKind[] = []): void {
1140
>
if (skipUntilAfter.length + skipUntil.length > 0) {
1142
>
while (token !== SyntaxKind.EOF) {
1143
>
if (skipUntilAfter.indexOf(token) !== -1) {
1144
scanNext();
1145
break;
1147
>
break;
1148
>
}
1150
>
}
1154
>
function parseString(isValue: boolean): boolean {
1156
>
if (isValue) {
1160
>
}
1162
>
return true;
1163
>
}
1165
>
function parseLiteral(): boolean {
1167
>
case SyntaxKind.NumericLiteral: {
1169
>
try {
1170
>
value = JSON.parse(_scanner.getTokenValue());
1171
>
if (typeof value !== 'number') {
1172
handleError(ParseErrorCode.InvalidNumberFormat);
1173
value = 0;
1174
}
1176
handleError(ParseErrorCode.InvalidNumberFormat);
1177
}
1179
>
break;
1180
>
}
1183
>
break;
1186
>
break;
1189
>
break;
1194
>
return true;
1197
>
function parseProperty(): boolean {
1199
>
handleError(ParseErrorCode.PropertyNameExpected, [], [SyntaxKind.CloseBraceToken, SyntaxKind.CommaToken]);
json.ts ×2
1200
>
return false;
1201
>
}
1203
>
if (_scanner.getToken() === SyntaxKind.ColonToken) {
1204
>
onSeparator(':');
1205
>
scanNext(); // consume colon
1206
>
1207
>
if (!parseValue()) {
1208
>
handleError(ParseErrorCode.ValueExpected, [], [SyntaxKind.CloseBraceToken, SyntaxKind.CommaToken]);
json.ts ×1
1209
>
}
1211
>
handleError(ParseErrorCode.ColonExpected, [], [SyntaxKind.CloseBraceToken, SyntaxKind.CommaToken]);
json.ts ×3
1212
>
}
1214
>
}
1216
>
function parseObject(): boolean {
1218
>
scanNext(); // consume open brace
1219
>
1220
>
let needsComma = false;
1221
>
while (_scanner.getToken() !== SyntaxKind.CloseBraceToken && _scanner.getToken() !== SyntaxKind.EOF) {
1225
>
}
1227
>
scanNext(); // consume comma
1228
>
if (_scanner.getToken() === SyntaxKind.CloseBraceToken && allowTrailingComma) {
1230
>
}
1233
>
}
1235
>
handleError(ParseErrorCode.ValueExpected, [], [SyntaxKind.CloseBraceToken, SyntaxKind.CommaToken]);
json.ts ×2
1236
>
}
1238
>
}
1240
>
if (_scanner.getToken() !== SyntaxKind.CloseBraceToken) {
1241
handleError(ParseErrorCode.CloseBraceExpected, [SyntaxKind.CloseBraceToken], []);
1243
>
scanNext(); // consume close brace
1244
>
}
1245
>
return true;
1248
>
function parseArray(): boolean {
1250
>
scanNext(); // consume open bracket
1251
>
1252
>
let needsComma = false;
1253
>
while (_scanner.getToken() !== SyntaxKind.CloseBracketToken && _scanner.getToken() !== SyntaxKind.EOF) {
1257
>
}
1259
>
scanNext(); // consume comma
1260
>
if (_scanner.getToken() === SyntaxKind.CloseBracketToken && allowTrailingComma) {
1262
>
}
1265
>
}
1267
>
handleError(ParseErrorCode.ValueExpected, [], [SyntaxKind.CloseBracketToken, SyntaxKind.CommaToken]);
json.ts ×3
1268
>
}
1270
>
}
1272
>
if (_scanner.getToken() !== SyntaxKind.CloseBracketToken) {
1273
handleError(ParseErrorCode.CloseBracketExpected, [SyntaxKind.CloseBracketToken], []);
1275
>
scanNext(); // consume close bracket
1276
>
}
1277
>
return true;
1278
>
}
1280
>
function parseValue(): boolean {
1282
>
case SyntaxKind.OpenBracketToken:
1291
>
}
1293
>
scanNext();
1294
>
if (_scanner.getToken() === SyntaxKind.EOF) {
1297
>
}
1299
>
return false;
1300
>
}
1303
>
return false;
1304
>
}
1306
handleError(ParseErrorCode.EndOfFileExpected, [], []);
1307
}
1309
>
}
1311
>
export function getNodeType(value: unknown): NodeType {
1313
>
case 'boolean': return 'boolean';
1314
>
case 'number': return 'number';
1315
>
case 'string': return 'string';
1316
>
case 'object': {
1320
return 'array';
1321
}
1323
>
}
1325
>
}
1326
>
}