.config/coc/extensions/node_modules/coc-json/node_modules/jsonc-parser/lib/esm/impl/parser.js

   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 'use strict';
   6 import { createScanner } from './scanner';
   7 var ParseOptions;
   8 (function (ParseOptions) {
   9     ParseOptions.DEFAULT = {
  10         allowTrailingComma: false
  11     };
  12 })(ParseOptions || (ParseOptions = {}));
  13 /**
  14  * 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.
  15  */
  16 export function getLocation(text, position) {
  17     var segments = []; // strings or numbers
  18     var earlyReturnException = new Object();
  19     var previousNode = undefined;
  20     var previousNodeInst = {
  21         value: {},
  22         offset: 0,
  23         length: 0,
  24         type: 'object',
  25         parent: undefined
  26     };
  27     var isAtPropertyKey = false;
  28     function setPreviousNode(value, offset, length, type) {
  29         previousNodeInst.value = value;
  30         previousNodeInst.offset = offset;
  31         previousNodeInst.length = length;
  32         previousNodeInst.type = type;
  33         previousNodeInst.colonOffset = undefined;
  34         previousNode = previousNodeInst;
  35     }
  36     try {
  37         visit(text, {
  38             onObjectBegin: function (offset, length) {
  39                 if (position <= offset) {
  40                     throw earlyReturnException;
  41                 }
  42                 previousNode = undefined;
  43                 isAtPropertyKey = position > offset;
  44                 segments.push(''); // push a placeholder (will be replaced)
  45             },
  46             onObjectProperty: function (name, offset, length) {
  47                 if (position < offset) {
  48                     throw earlyReturnException;
  49                 }
  50                 setPreviousNode(name, offset, length, 'property');
  51                 segments[segments.length - 1] = name;
  52                 if (position <= offset + length) {
  53                     throw earlyReturnException;
  54                 }
  55             },
  56             onObjectEnd: function (offset, length) {
  57                 if (position <= offset) {
  58                     throw earlyReturnException;
  59                 }
  60                 previousNode = undefined;
  61                 segments.pop();
  62             },
  63             onArrayBegin: function (offset, length) {
  64                 if (position <= offset) {
  65                     throw earlyReturnException;
  66                 }
  67                 previousNode = undefined;
  68                 segments.push(0);
  69             },
  70             onArrayEnd: function (offset, length) {
  71                 if (position <= offset) {
  72                     throw earlyReturnException;
  73                 }
  74                 previousNode = undefined;
  75                 segments.pop();
  76             },
  77             onLiteralValue: function (value, offset, length) {
  78                 if (position < offset) {
  79                     throw earlyReturnException;
  80                 }
  81                 setPreviousNode(value, offset, length, getNodeType(value));
  82                 if (position <= offset + length) {
  83                     throw earlyReturnException;
  84                 }
  85             },
  86             onSeparator: function (sep, offset, length) {
  87                 if (position <= offset) {
  88                     throw earlyReturnException;
  89                 }
  90                 if (sep === ':' && previousNode && previousNode.type === 'property') {
  91                     previousNode.colonOffset = offset;
  92                     isAtPropertyKey = false;
  93                     previousNode = undefined;
  94                 }
  95                 else if (sep === ',') {
  96                     var last = segments[segments.length - 1];
  97                     if (typeof last === 'number') {
  98                         segments[segments.length - 1] = last + 1;
  99                     }
 100                     else {
 101                         isAtPropertyKey = true;
 102                         segments[segments.length - 1] = '';
 103                     }
 104                     previousNode = undefined;
 105                 }
 106             }
 107         });
 108     }
 109     catch (e) {
 110         if (e !== earlyReturnException) {
 111             throw e;
 112         }
 113     }
 114     return {
 115         path: segments,
 116         previousNode: previousNode,
 117         isAtPropertyKey: isAtPropertyKey,
 118         matches: function (pattern) {
 119             var k = 0;
 120             for (var i = 0; k < pattern.length && i < segments.length; i++) {
 121                 if (pattern[k] === segments[i] || pattern[k] === '*') {
 122                     k++;
 123                 }
 124                 else if (pattern[k] !== '**') {
 125                     return false;
 126                 }
 127             }
 128             return k === pattern.length;
 129         }
 130     };
 131 }
 132 /**
 133  * 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.
 134  * Therefore always check the errors list to find out if the input was valid.
 135  */
 136 export function parse(text, errors, options) {
 137     if (errors === void 0) { errors = []; }
 138     if (options === void 0) { options = ParseOptions.DEFAULT; }
 139     var currentProperty = null;
 140     var currentParent = [];
 141     var previousParents = [];
 142     function onValue(value) {
 143         if (Array.isArray(currentParent)) {
 144             currentParent.push(value);
 145         }
 146         else if (currentProperty !== null) {
 147             currentParent[currentProperty] = value;
 148         }
 149     }
 150     var visitor = {
 151         onObjectBegin: function () {
 152             var object = {};
 153             onValue(object);
 154             previousParents.push(currentParent);
 155             currentParent = object;
 156             currentProperty = null;
 157         },
 158         onObjectProperty: function (name) {
 159             currentProperty = name;
 160         },
 161         onObjectEnd: function () {
 162             currentParent = previousParents.pop();
 163         },
 164         onArrayBegin: function () {
 165             var array = [];
 166             onValue(array);
 167             previousParents.push(currentParent);
 168             currentParent = array;
 169             currentProperty = null;
 170         },
 171         onArrayEnd: function () {
 172             currentParent = previousParents.pop();
 173         },
 174         onLiteralValue: onValue,
 175         onError: function (error, offset, length) {
 176             errors.push({ error: error, offset: offset, length: length });
 177         }
 178     };
 179     visit(text, visitor, options);
 180     return currentParent[0];
 181 }
 182 /**
 183  * 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.
 184  */
 185 export function parseTree(text, errors, options) {
 186     if (errors === void 0) { errors = []; }
 187     if (options === void 0) { options = ParseOptions.DEFAULT; }
 188     var currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
 189     function ensurePropertyComplete(endOffset) {
 190         if (currentParent.type === 'property') {
 191             currentParent.length = endOffset - currentParent.offset;
 192             currentParent = currentParent.parent;
 193         }
 194     }
 195     function onValue(valueNode) {
 196         currentParent.children.push(valueNode);
 197         return valueNode;
 198     }
 199     var visitor = {
 200         onObjectBegin: function (offset) {
 201             currentParent = onValue({ type: 'object', offset: offset, length: -1, parent: currentParent, children: [] });
 202         },
 203         onObjectProperty: function (name, offset, length) {
 204             currentParent = onValue({ type: 'property', offset: offset, length: -1, parent: currentParent, children: [] });
 205             currentParent.children.push({ type: 'string', value: name, offset: offset, length: length, parent: currentParent });
 206         },
 207         onObjectEnd: function (offset, length) {
 208             ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
 209             currentParent.length = offset + length - currentParent.offset;
 210             currentParent = currentParent.parent;
 211             ensurePropertyComplete(offset + length);
 212         },
 213         onArrayBegin: function (offset, length) {
 214             currentParent = onValue({ type: 'array', offset: offset, length: -1, parent: currentParent, children: [] });
 215         },
 216         onArrayEnd: function (offset, length) {
 217             currentParent.length = offset + length - currentParent.offset;
 218             currentParent = currentParent.parent;
 219             ensurePropertyComplete(offset + length);
 220         },
 221         onLiteralValue: function (value, offset, length) {
 222             onValue({ type: getNodeType(value), offset: offset, length: length, parent: currentParent, value: value });
 223             ensurePropertyComplete(offset + length);
 224         },
 225         onSeparator: function (sep, offset, length) {
 226             if (currentParent.type === 'property') {
 227                 if (sep === ':') {
 228                     currentParent.colonOffset = offset;
 229                 }
 230                 else if (sep === ',') {
 231                     ensurePropertyComplete(offset);
 232                 }
 233             }
 234         },
 235         onError: function (error, offset, length) {
 236             errors.push({ error: error, offset: offset, length: length });
 237         }
 238     };
 239     visit(text, visitor, options);
 240     var result = currentParent.children[0];
 241     if (result) {
 242         delete result.parent;
 243     }
 244     return result;
 245 }
 246 /**
 247  * Finds the node at the given path in a JSON DOM.
 248  */
 249 export function findNodeAtLocation(root, path) {
 250     if (!root) {
 251         return undefined;
 252     }
 253     var node = root;
 254     for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
 255         var segment = path_1[_i];
 256         if (typeof segment === 'string') {
 257             if (node.type !== 'object' || !Array.isArray(node.children)) {
 258                 return undefined;
 259             }
 260             var found = false;
 261             for (var _a = 0, _b = node.children; _a < _b.length; _a++) {
 262                 var propertyNode = _b[_a];
 263                 if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
 264                     node = propertyNode.children[1];
 265                     found = true;
 266                     break;
 267                 }
 268             }
 269             if (!found) {
 270                 return undefined;
 271             }
 272         }
 273         else {
 274             var index = segment;
 275             if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
 276                 return undefined;
 277             }
 278             node = node.children[index];
 279         }
 280     }
 281     return node;
 282 }
 283 /**
 284  * Gets the JSON path of the given JSON DOM node
 285  */
 286 export function getNodePath(node) {
 287     if (!node.parent || !node.parent.children) {
 288         return [];
 289     }
 290     var path = getNodePath(node.parent);
 291     if (node.parent.type === 'property') {
 292         var key = node.parent.children[0].value;
 293         path.push(key);
 294     }
 295     else if (node.parent.type === 'array') {
 296         var index = node.parent.children.indexOf(node);
 297         if (index !== -1) {
 298             path.push(index);
 299         }
 300     }
 301     return path;
 302 }
 303 /**
 304  * Evaluates the JavaScript object of the given JSON DOM node
 305  */
 306 export function getNodeValue(node) {
 307     switch (node.type) {
 308         case 'array':
 309             return node.children.map(getNodeValue);
 310         case 'object':
 311             var obj = Object.create(null);
 312             for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
 313                 var prop = _a[_i];
 314                 var valueNode = prop.children[1];
 315                 if (valueNode) {
 316                     obj[prop.children[0].value] = getNodeValue(valueNode);
 317                 }
 318             }
 319             return obj;
 320         case 'null':
 321         case 'string':
 322         case 'number':
 323         case 'boolean':
 324             return node.value;
 325         default:
 326             return undefined;
 327     }
 328 }
 329 export function contains(node, offset, includeRightBound) {
 330     if (includeRightBound === void 0) { includeRightBound = false; }
 331     return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
 332 }
 333 /**
 334  * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
 335  */
 336 export function findNodeAtOffset(node, offset, includeRightBound) {
 337     if (includeRightBound === void 0) { includeRightBound = false; }
 338     if (contains(node, offset, includeRightBound)) {
 339         var children = node.children;
 340         if (Array.isArray(children)) {
 341             for (var i = 0; i < children.length && children[i].offset <= offset; i++) {
 342                 var item = findNodeAtOffset(children[i], offset, includeRightBound);
 343                 if (item) {
 344                     return item;
 345                 }
 346             }
 347         }
 348         return node;
 349     }
 350     return undefined;
 351 }
 352 /**
 353  * Parses the given text and invokes the visitor functions for each object, array and literal reached.
 354  */
 355 export function visit(text, visitor, options) {
 356     if (options === void 0) { options = ParseOptions.DEFAULT; }
 357     var _scanner = createScanner(text, false);
 358     function toNoArgVisit(visitFunction) {
 359         return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
 360     }
 361     function toOneArgVisit(visitFunction) {
 362         return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
 363     }
 364     var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
 365     var disallowComments = options && options.disallowComments;
 366     var allowTrailingComma = options && options.allowTrailingComma;
 367     function scanNext() {
 368         while (true) {
 369             var token = _scanner.scan();
 370             switch (_scanner.getTokenError()) {
 371                 case 4 /* InvalidUnicode */:
 372                     handleError(14 /* InvalidUnicode */);
 373                     break;
 374                 case 5 /* InvalidEscapeCharacter */:
 375                     handleError(15 /* InvalidEscapeCharacter */);
 376                     break;
 377                 case 3 /* UnexpectedEndOfNumber */:
 378                     handleError(13 /* UnexpectedEndOfNumber */);
 379                     break;
 380                 case 1 /* UnexpectedEndOfComment */:
 381                     if (!disallowComments) {
 382                         handleError(11 /* UnexpectedEndOfComment */);
 383                     }
 384                     break;
 385                 case 2 /* UnexpectedEndOfString */:
 386                     handleError(12 /* UnexpectedEndOfString */);
 387                     break;
 388                 case 6 /* InvalidCharacter */:
 389                     handleError(16 /* InvalidCharacter */);
 390                     break;
 391             }
 392             switch (token) {
 393                 case 12 /* LineCommentTrivia */:
 394                 case 13 /* BlockCommentTrivia */:
 395                     if (disallowComments) {
 396                         handleError(10 /* InvalidCommentToken */);
 397                     }
 398                     else {
 399                         onComment();
 400                     }
 401                     break;
 402                 case 16 /* Unknown */:
 403                     handleError(1 /* InvalidSymbol */);
 404                     break;
 405                 case 15 /* Trivia */:
 406                 case 14 /* LineBreakTrivia */:
 407                     break;
 408                 default:
 409                     return token;
 410             }
 411         }
 412     }
 413     function handleError(error, skipUntilAfter, skipUntil) {
 414         if (skipUntilAfter === void 0) { skipUntilAfter = []; }
 415         if (skipUntil === void 0) { skipUntil = []; }
 416         onError(error);
 417         if (skipUntilAfter.length + skipUntil.length > 0) {
 418             var token = _scanner.getToken();
 419             while (token !== 17 /* EOF */) {
 420                 if (skipUntilAfter.indexOf(token) !== -1) {
 421                     scanNext();
 422                     break;
 423                 }
 424                 else if (skipUntil.indexOf(token) !== -1) {
 425                     break;
 426                 }
 427                 token = scanNext();
 428             }
 429         }
 430     }
 431     function parseString(isValue) {
 432         var value = _scanner.getTokenValue();
 433         if (isValue) {
 434             onLiteralValue(value);
 435         }
 436         else {
 437             onObjectProperty(value);
 438         }
 439         scanNext();
 440         return true;
 441     }
 442     function parseLiteral() {
 443         switch (_scanner.getToken()) {
 444             case 11 /* NumericLiteral */:
 445                 var tokenValue = _scanner.getTokenValue();
 446                 var value = Number(tokenValue);
 447                 if (isNaN(value)) {
 448                     handleError(2 /* InvalidNumberFormat */);
 449                     value = 0;
 450                 }
 451                 onLiteralValue(value);
 452                 break;
 453             case 7 /* NullKeyword */:
 454                 onLiteralValue(null);
 455                 break;
 456             case 8 /* TrueKeyword */:
 457                 onLiteralValue(true);
 458                 break;
 459             case 9 /* FalseKeyword */:
 460                 onLiteralValue(false);
 461                 break;
 462             default:
 463                 return false;
 464         }
 465         scanNext();
 466         return true;
 467     }
 468     function parseProperty() {
 469         if (_scanner.getToken() !== 10 /* StringLiteral */) {
 470             handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
 471             return false;
 472         }
 473         parseString(false);
 474         if (_scanner.getToken() === 6 /* ColonToken */) {
 475             onSeparator(':');
 476             scanNext(); // consume colon
 477             if (!parseValue()) {
 478                 handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
 479             }
 480         }
 481         else {
 482             handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
 483         }
 484         return true;
 485     }
 486     function parseObject() {
 487         onObjectBegin();
 488         scanNext(); // consume open brace
 489         var needsComma = false;
 490         while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {
 491             if (_scanner.getToken() === 5 /* CommaToken */) {
 492                 if (!needsComma) {
 493                     handleError(4 /* ValueExpected */, [], []);
 494                 }
 495                 onSeparator(',');
 496                 scanNext(); // consume comma
 497                 if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {
 498                     break;
 499                 }
 500             }
 501             else if (needsComma) {
 502                 handleError(6 /* CommaExpected */, [], []);
 503             }
 504             if (!parseProperty()) {
 505                 handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
 506             }
 507             needsComma = true;
 508         }
 509         onObjectEnd();
 510         if (_scanner.getToken() !== 2 /* CloseBraceToken */) {
 511             handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);
 512         }
 513         else {
 514             scanNext(); // consume close brace
 515         }
 516         return true;
 517     }
 518     function parseArray() {
 519         onArrayBegin();
 520         scanNext(); // consume open bracket
 521         var needsComma = false;
 522         while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {
 523             if (_scanner.getToken() === 5 /* CommaToken */) {
 524                 if (!needsComma) {
 525                     handleError(4 /* ValueExpected */, [], []);
 526                 }
 527                 onSeparator(',');
 528                 scanNext(); // consume comma
 529                 if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {
 530                     break;
 531                 }
 532             }
 533             else if (needsComma) {
 534                 handleError(6 /* CommaExpected */, [], []);
 535             }
 536             if (!parseValue()) {
 537                 handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
 538             }
 539             needsComma = true;
 540         }
 541         onArrayEnd();
 542         if (_scanner.getToken() !== 4 /* CloseBracketToken */) {
 543             handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);
 544         }
 545         else {
 546             scanNext(); // consume close bracket
 547         }
 548         return true;
 549     }
 550     function parseValue() {
 551         switch (_scanner.getToken()) {
 552             case 3 /* OpenBracketToken */:
 553                 return parseArray();
 554             case 1 /* OpenBraceToken */:
 555                 return parseObject();
 556             case 10 /* StringLiteral */:
 557                 return parseString(true);
 558             default:
 559                 return parseLiteral();
 560         }
 561     }
 562     scanNext();
 563     if (_scanner.getToken() === 17 /* EOF */) {
 564         if (options.allowEmptyContent) {
 565             return true;
 566         }
 567         handleError(4 /* ValueExpected */, [], []);
 568         return false;
 569     }
 570     if (!parseValue()) {
 571         handleError(4 /* ValueExpected */, [], []);
 572         return false;
 573     }
 574     if (_scanner.getToken() !== 17 /* EOF */) {
 575         handleError(9 /* EndOfFileExpected */, [], []);
 576     }
 577     return true;
 578 }
 579 /**
 580  * Takes JSON with JavaScript-style comments and remove
 581  * them. Optionally replaces every none-newline character
 582  * of comments with a replaceCharacter
 583  */
 584 export function stripComments(text, replaceCh) {
 585     var _scanner = createScanner(text), parts = [], kind, offset = 0, pos;
 586     do {
 587         pos = _scanner.getPosition();
 588         kind = _scanner.scan();
 589         switch (kind) {
 590             case 12 /* LineCommentTrivia */:
 591             case 13 /* BlockCommentTrivia */:
 592             case 17 /* EOF */:
 593                 if (offset !== pos) {
 594                     parts.push(text.substring(offset, pos));
 595                 }
 596                 if (replaceCh !== undefined) {
 597                     parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
 598                 }
 599                 offset = _scanner.getPosition();
 600                 break;
 601         }
 602     } while (kind !== 17 /* EOF */);
 603     return parts.join('');
 604 }
 605 export function getNodeType(value) {
 606     switch (typeof value) {
 607         case 'boolean': return 'boolean';
 608         case 'number': return 'number';
 609         case 'string': return 'string';
 610         case 'object': {
 611             if (!value) {
 612                 return 'null';
 613             }
 614             else if (Array.isArray(value)) {
 615                 return 'array';
 616             }
 617             return 'object';
 618         }
 619         default: return 'null';
 620     }
 621 }