Updated the files.
This commit is contained in:
parent
1553e6b971
commit
753967d4f5
23418 changed files with 3784666 additions and 0 deletions
185
my-app/node_modules/jsonc-parser/lib/esm/impl/edit.js
generated
vendored
Executable file
185
my-app/node_modules/jsonc-parser/lib/esm/impl/edit.js
generated
vendored
Executable file
|
|
@ -0,0 +1,185 @@
|
|||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
import { format, isEOL } from './format';
|
||||
import { parseTree, findNodeAtLocation } from './parser';
|
||||
export function removeProperty(text, path, options) {
|
||||
return setProperty(text, path, void 0, options);
|
||||
}
|
||||
export function setProperty(text, originalPath, value, options) {
|
||||
const path = originalPath.slice();
|
||||
const errors = [];
|
||||
const root = parseTree(text, errors);
|
||||
let parent = void 0;
|
||||
let lastSegment = void 0;
|
||||
while (path.length > 0) {
|
||||
lastSegment = path.pop();
|
||||
parent = findNodeAtLocation(root, path);
|
||||
if (parent === void 0 && value !== void 0) {
|
||||
if (typeof lastSegment === 'string') {
|
||||
value = { [lastSegment]: value };
|
||||
}
|
||||
else {
|
||||
value = [value];
|
||||
}
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!parent) {
|
||||
// empty document
|
||||
if (value === void 0) { // delete
|
||||
throw new Error('Can not delete in empty document');
|
||||
}
|
||||
return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
|
||||
}
|
||||
else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
|
||||
const existing = findNodeAtLocation(parent, [lastSegment]);
|
||||
if (existing !== void 0) {
|
||||
if (value === void 0) { // delete
|
||||
if (!existing.parent) {
|
||||
throw new Error('Malformed AST');
|
||||
}
|
||||
const propertyIndex = parent.children.indexOf(existing.parent);
|
||||
let removeBegin;
|
||||
let removeEnd = existing.parent.offset + existing.parent.length;
|
||||
if (propertyIndex > 0) {
|
||||
// remove the comma of the previous node
|
||||
let previous = parent.children[propertyIndex - 1];
|
||||
removeBegin = previous.offset + previous.length;
|
||||
}
|
||||
else {
|
||||
removeBegin = parent.offset + 1;
|
||||
if (parent.children.length > 1) {
|
||||
// remove the comma of the next node
|
||||
let next = parent.children[1];
|
||||
removeEnd = next.offset;
|
||||
}
|
||||
}
|
||||
return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, options);
|
||||
}
|
||||
else {
|
||||
// set value of existing property
|
||||
return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (value === void 0) { // delete
|
||||
return []; // property does not exist, nothing to do
|
||||
}
|
||||
const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
|
||||
const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
|
||||
let edit;
|
||||
if (index > 0) {
|
||||
let previous = parent.children[index - 1];
|
||||
edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
|
||||
}
|
||||
else if (parent.children.length === 0) {
|
||||
edit = { offset: parent.offset + 1, length: 0, content: newProperty };
|
||||
}
|
||||
else {
|
||||
edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
|
||||
}
|
||||
return withFormatting(text, edit, options);
|
||||
}
|
||||
}
|
||||
else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
|
||||
const insertIndex = lastSegment;
|
||||
if (insertIndex === -1) {
|
||||
// Insert
|
||||
const newProperty = `${JSON.stringify(value)}`;
|
||||
let edit;
|
||||
if (parent.children.length === 0) {
|
||||
edit = { offset: parent.offset + 1, length: 0, content: newProperty };
|
||||
}
|
||||
else {
|
||||
const previous = parent.children[parent.children.length - 1];
|
||||
edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
|
||||
}
|
||||
return withFormatting(text, edit, options);
|
||||
}
|
||||
else if (value === void 0 && parent.children.length >= 0) {
|
||||
// Removal
|
||||
const removalIndex = lastSegment;
|
||||
const toRemove = parent.children[removalIndex];
|
||||
let edit;
|
||||
if (parent.children.length === 1) {
|
||||
// only item
|
||||
edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
|
||||
}
|
||||
else if (parent.children.length - 1 === removalIndex) {
|
||||
// last item
|
||||
let previous = parent.children[removalIndex - 1];
|
||||
let offset = previous.offset + previous.length;
|
||||
let parentEndOffset = parent.offset + parent.length;
|
||||
edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
|
||||
}
|
||||
else {
|
||||
edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
|
||||
}
|
||||
return withFormatting(text, edit, options);
|
||||
}
|
||||
else if (value !== void 0) {
|
||||
let edit;
|
||||
const newProperty = `${JSON.stringify(value)}`;
|
||||
if (!options.isArrayInsertion && parent.children.length > lastSegment) {
|
||||
const toModify = parent.children[lastSegment];
|
||||
edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
|
||||
}
|
||||
else if (parent.children.length === 0 || lastSegment === 0) {
|
||||
edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + ',' };
|
||||
}
|
||||
else {
|
||||
const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
|
||||
const previous = parent.children[index - 1];
|
||||
edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
|
||||
}
|
||||
return withFormatting(text, edit, options);
|
||||
}
|
||||
else {
|
||||
throw new Error(`Can not ${value === void 0 ? 'remove' : (options.isArrayInsertion ? 'insert' : 'modify')} Array index ${insertIndex} as length is not sufficient`);
|
||||
}
|
||||
}
|
||||
else {
|
||||
throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
|
||||
}
|
||||
}
|
||||
function withFormatting(text, edit, options) {
|
||||
if (!options.formattingOptions) {
|
||||
return [edit];
|
||||
}
|
||||
// apply the edit
|
||||
let newText = applyEdit(text, edit);
|
||||
// format the new text
|
||||
let begin = edit.offset;
|
||||
let end = edit.offset + edit.content.length;
|
||||
if (edit.length === 0 || edit.content.length === 0) { // insert or remove
|
||||
while (begin > 0 && !isEOL(newText, begin - 1)) {
|
||||
begin--;
|
||||
}
|
||||
while (end < newText.length && !isEOL(newText, end)) {
|
||||
end++;
|
||||
}
|
||||
}
|
||||
const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
|
||||
// apply the formatting edits and track the begin and end offsets of the changes
|
||||
for (let i = edits.length - 1; i >= 0; i--) {
|
||||
const edit = edits[i];
|
||||
newText = applyEdit(newText, edit);
|
||||
begin = Math.min(begin, edit.offset);
|
||||
end = Math.max(end, edit.offset + edit.length);
|
||||
end += edit.content.length - edit.length;
|
||||
}
|
||||
// create a single edit with all changes
|
||||
const editLength = text.length - (newText.length - end) - begin;
|
||||
return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
|
||||
}
|
||||
export function applyEdit(text, edit) {
|
||||
return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
|
||||
}
|
||||
export function isWS(text, offset) {
|
||||
return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;
|
||||
}
|
||||
251
my-app/node_modules/jsonc-parser/lib/esm/impl/format.js
generated
vendored
Executable file
251
my-app/node_modules/jsonc-parser/lib/esm/impl/format.js
generated
vendored
Executable file
|
|
@ -0,0 +1,251 @@
|
|||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
import { createScanner } from './scanner';
|
||||
export function format(documentText, range, options) {
|
||||
let initialIndentLevel;
|
||||
let formatText;
|
||||
let formatTextStart;
|
||||
let rangeStart;
|
||||
let rangeEnd;
|
||||
if (range) {
|
||||
rangeStart = range.offset;
|
||||
rangeEnd = rangeStart + range.length;
|
||||
formatTextStart = rangeStart;
|
||||
while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
|
||||
formatTextStart--;
|
||||
}
|
||||
let endOffset = rangeEnd;
|
||||
while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
|
||||
endOffset++;
|
||||
}
|
||||
formatText = documentText.substring(formatTextStart, endOffset);
|
||||
initialIndentLevel = computeIndentLevel(formatText, options);
|
||||
}
|
||||
else {
|
||||
formatText = documentText;
|
||||
initialIndentLevel = 0;
|
||||
formatTextStart = 0;
|
||||
rangeStart = 0;
|
||||
rangeEnd = documentText.length;
|
||||
}
|
||||
const eol = getEOL(options, documentText);
|
||||
let numberLineBreaks = 0;
|
||||
let indentLevel = 0;
|
||||
let indentValue;
|
||||
if (options.insertSpaces) {
|
||||
indentValue = repeat(' ', options.tabSize || 4);
|
||||
}
|
||||
else {
|
||||
indentValue = '\t';
|
||||
}
|
||||
let scanner = createScanner(formatText, false);
|
||||
let hasError = false;
|
||||
function newLinesAndIndent() {
|
||||
if (numberLineBreaks > 1) {
|
||||
return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
|
||||
}
|
||||
else {
|
||||
return eol + repeat(indentValue, initialIndentLevel + indentLevel);
|
||||
}
|
||||
}
|
||||
function scanNext() {
|
||||
let token = scanner.scan();
|
||||
numberLineBreaks = 0;
|
||||
while (token === 15 /* SyntaxKind.Trivia */ || token === 14 /* SyntaxKind.LineBreakTrivia */) {
|
||||
if (token === 14 /* SyntaxKind.LineBreakTrivia */ && options.keepLines) {
|
||||
numberLineBreaks += 1;
|
||||
}
|
||||
else if (token === 14 /* SyntaxKind.LineBreakTrivia */) {
|
||||
numberLineBreaks = 1;
|
||||
}
|
||||
token = scanner.scan();
|
||||
}
|
||||
hasError = token === 16 /* SyntaxKind.Unknown */ || scanner.getTokenError() !== 0 /* ScanError.None */;
|
||||
return token;
|
||||
}
|
||||
const editOperations = [];
|
||||
function addEdit(text, startOffset, endOffset) {
|
||||
if (!hasError && (!range || (startOffset < rangeEnd && endOffset > rangeStart)) && documentText.substring(startOffset, endOffset) !== text) {
|
||||
editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
|
||||
}
|
||||
}
|
||||
let firstToken = scanNext();
|
||||
if (options.keepLines && numberLineBreaks > 0) {
|
||||
addEdit(repeat(eol, numberLineBreaks), 0, 0);
|
||||
}
|
||||
if (firstToken !== 17 /* SyntaxKind.EOF */) {
|
||||
let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
|
||||
let initialIndent = repeat(indentValue, initialIndentLevel);
|
||||
addEdit(initialIndent, formatTextStart, firstTokenStart);
|
||||
}
|
||||
while (firstToken !== 17 /* SyntaxKind.EOF */) {
|
||||
let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
|
||||
let secondToken = scanNext();
|
||||
let replaceContent = '';
|
||||
let needsLineBreak = false;
|
||||
while (numberLineBreaks === 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
|
||||
let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
|
||||
addEdit(' ', firstTokenEnd, commentTokenStart);
|
||||
firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
|
||||
needsLineBreak = secondToken === 12 /* SyntaxKind.LineCommentTrivia */;
|
||||
replaceContent = needsLineBreak ? newLinesAndIndent() : '';
|
||||
secondToken = scanNext();
|
||||
}
|
||||
if (secondToken === 2 /* SyntaxKind.CloseBraceToken */) {
|
||||
if (firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
|
||||
indentLevel--;
|
||||
}
|
||||
;
|
||||
if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else if (options.keepLines) {
|
||||
replaceContent = ' ';
|
||||
}
|
||||
}
|
||||
else if (secondToken === 4 /* SyntaxKind.CloseBracketToken */) {
|
||||
if (firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
|
||||
indentLevel--;
|
||||
}
|
||||
;
|
||||
if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else if (options.keepLines) {
|
||||
replaceContent = ' ';
|
||||
}
|
||||
}
|
||||
else {
|
||||
switch (firstToken) {
|
||||
case 3 /* SyntaxKind.OpenBracketToken */:
|
||||
case 1 /* SyntaxKind.OpenBraceToken */:
|
||||
indentLevel++;
|
||||
if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else {
|
||||
replaceContent = ' ';
|
||||
}
|
||||
break;
|
||||
case 5 /* SyntaxKind.CommaToken */:
|
||||
if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else {
|
||||
replaceContent = ' ';
|
||||
}
|
||||
break;
|
||||
case 12 /* SyntaxKind.LineCommentTrivia */:
|
||||
replaceContent = newLinesAndIndent();
|
||||
break;
|
||||
case 13 /* SyntaxKind.BlockCommentTrivia */:
|
||||
if (numberLineBreaks > 0) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else if (!needsLineBreak) {
|
||||
replaceContent = ' ';
|
||||
}
|
||||
break;
|
||||
case 6 /* SyntaxKind.ColonToken */:
|
||||
if (options.keepLines && numberLineBreaks > 0) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else if (!needsLineBreak) {
|
||||
replaceContent = ' ';
|
||||
}
|
||||
break;
|
||||
case 10 /* SyntaxKind.StringLiteral */:
|
||||
if (options.keepLines && numberLineBreaks > 0) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else if (secondToken === 6 /* SyntaxKind.ColonToken */ && !needsLineBreak) {
|
||||
replaceContent = '';
|
||||
}
|
||||
break;
|
||||
case 7 /* SyntaxKind.NullKeyword */:
|
||||
case 8 /* SyntaxKind.TrueKeyword */:
|
||||
case 9 /* SyntaxKind.FalseKeyword */:
|
||||
case 11 /* SyntaxKind.NumericLiteral */:
|
||||
case 2 /* SyntaxKind.CloseBraceToken */:
|
||||
case 4 /* SyntaxKind.CloseBracketToken */:
|
||||
if (options.keepLines && numberLineBreaks > 0) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else {
|
||||
if ((secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */) && !needsLineBreak) {
|
||||
replaceContent = ' ';
|
||||
}
|
||||
else if (secondToken !== 5 /* SyntaxKind.CommaToken */ && secondToken !== 17 /* SyntaxKind.EOF */) {
|
||||
hasError = true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 16 /* SyntaxKind.Unknown */:
|
||||
hasError = true;
|
||||
break;
|
||||
}
|
||||
if (numberLineBreaks > 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
}
|
||||
if (secondToken === 17 /* SyntaxKind.EOF */) {
|
||||
if (options.keepLines && numberLineBreaks > 0) {
|
||||
replaceContent = newLinesAndIndent();
|
||||
}
|
||||
else {
|
||||
replaceContent = options.insertFinalNewline ? eol : '';
|
||||
}
|
||||
}
|
||||
const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
|
||||
addEdit(replaceContent, firstTokenEnd, secondTokenStart);
|
||||
firstToken = secondToken;
|
||||
}
|
||||
return editOperations;
|
||||
}
|
||||
function repeat(s, count) {
|
||||
let result = '';
|
||||
for (let i = 0; i < count; i++) {
|
||||
result += s;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function computeIndentLevel(content, options) {
|
||||
let i = 0;
|
||||
let nChars = 0;
|
||||
const tabSize = options.tabSize || 4;
|
||||
while (i < content.length) {
|
||||
let ch = content.charAt(i);
|
||||
if (ch === ' ') {
|
||||
nChars++;
|
||||
}
|
||||
else if (ch === '\t') {
|
||||
nChars += tabSize;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return Math.floor(nChars / tabSize);
|
||||
}
|
||||
function getEOL(options, text) {
|
||||
for (let i = 0; i < text.length; i++) {
|
||||
const ch = text.charAt(i);
|
||||
if (ch === '\r') {
|
||||
if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
|
||||
return '\r\n';
|
||||
}
|
||||
return '\r';
|
||||
}
|
||||
else if (ch === '\n') {
|
||||
return '\n';
|
||||
}
|
||||
}
|
||||
return (options && options.eol) || '\n';
|
||||
}
|
||||
export function isEOL(text, offset) {
|
||||
return '\r\n'.indexOf(text.charAt(offset)) !== -1;
|
||||
}
|
||||
632
my-app/node_modules/jsonc-parser/lib/esm/impl/parser.js
generated
vendored
Executable file
632
my-app/node_modules/jsonc-parser/lib/esm/impl/parser.js
generated
vendored
Executable file
|
|
@ -0,0 +1,632 @@
|
|||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
import { createScanner } from './scanner';
|
||||
var ParseOptions;
|
||||
(function (ParseOptions) {
|
||||
ParseOptions.DEFAULT = {
|
||||
allowTrailingComma: false
|
||||
};
|
||||
})(ParseOptions || (ParseOptions = {}));
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
export function getLocation(text, position) {
|
||||
const segments = []; // strings or numbers
|
||||
const earlyReturnException = new Object();
|
||||
let previousNode = undefined;
|
||||
const previousNodeInst = {
|
||||
value: {},
|
||||
offset: 0,
|
||||
length: 0,
|
||||
type: 'object',
|
||||
parent: undefined
|
||||
};
|
||||
let isAtPropertyKey = false;
|
||||
function setPreviousNode(value, offset, length, type) {
|
||||
previousNodeInst.value = value;
|
||||
previousNodeInst.offset = offset;
|
||||
previousNodeInst.length = length;
|
||||
previousNodeInst.type = type;
|
||||
previousNodeInst.colonOffset = undefined;
|
||||
previousNode = previousNodeInst;
|
||||
}
|
||||
try {
|
||||
visit(text, {
|
||||
onObjectBegin: (offset, length) => {
|
||||
if (position <= offset) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
previousNode = undefined;
|
||||
isAtPropertyKey = position > offset;
|
||||
segments.push(''); // push a placeholder (will be replaced)
|
||||
},
|
||||
onObjectProperty: (name, offset, length) => {
|
||||
if (position < offset) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
setPreviousNode(name, offset, length, 'property');
|
||||
segments[segments.length - 1] = name;
|
||||
if (position <= offset + length) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
},
|
||||
onObjectEnd: (offset, length) => {
|
||||
if (position <= offset) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
previousNode = undefined;
|
||||
segments.pop();
|
||||
},
|
||||
onArrayBegin: (offset, length) => {
|
||||
if (position <= offset) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
previousNode = undefined;
|
||||
segments.push(0);
|
||||
},
|
||||
onArrayEnd: (offset, length) => {
|
||||
if (position <= offset) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
previousNode = undefined;
|
||||
segments.pop();
|
||||
},
|
||||
onLiteralValue: (value, offset, length) => {
|
||||
if (position < offset) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
setPreviousNode(value, offset, length, getNodeType(value));
|
||||
if (position <= offset + length) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
},
|
||||
onSeparator: (sep, offset, length) => {
|
||||
if (position <= offset) {
|
||||
throw earlyReturnException;
|
||||
}
|
||||
if (sep === ':' && previousNode && previousNode.type === 'property') {
|
||||
previousNode.colonOffset = offset;
|
||||
isAtPropertyKey = false;
|
||||
previousNode = undefined;
|
||||
}
|
||||
else if (sep === ',') {
|
||||
const last = segments[segments.length - 1];
|
||||
if (typeof last === 'number') {
|
||||
segments[segments.length - 1] = last + 1;
|
||||
}
|
||||
else {
|
||||
isAtPropertyKey = true;
|
||||
segments[segments.length - 1] = '';
|
||||
}
|
||||
previousNode = undefined;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
catch (e) {
|
||||
if (e !== earlyReturnException) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
return {
|
||||
path: segments,
|
||||
previousNode,
|
||||
isAtPropertyKey,
|
||||
matches: (pattern) => {
|
||||
let k = 0;
|
||||
for (let i = 0; k < pattern.length && i < segments.length; i++) {
|
||||
if (pattern[k] === segments[i] || pattern[k] === '*') {
|
||||
k++;
|
||||
}
|
||||
else if (pattern[k] !== '**') {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return k === pattern.length;
|
||||
}
|
||||
};
|
||||
}
|
||||
/**
|
||||
* 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.
|
||||
* Therefore always check the errors list to find out if the input was valid.
|
||||
*/
|
||||
export function parse(text, errors = [], options = ParseOptions.DEFAULT) {
|
||||
let currentProperty = null;
|
||||
let currentParent = [];
|
||||
const previousParents = [];
|
||||
function onValue(value) {
|
||||
if (Array.isArray(currentParent)) {
|
||||
currentParent.push(value);
|
||||
}
|
||||
else if (currentProperty !== null) {
|
||||
currentParent[currentProperty] = value;
|
||||
}
|
||||
}
|
||||
const visitor = {
|
||||
onObjectBegin: () => {
|
||||
const object = {};
|
||||
onValue(object);
|
||||
previousParents.push(currentParent);
|
||||
currentParent = object;
|
||||
currentProperty = null;
|
||||
},
|
||||
onObjectProperty: (name) => {
|
||||
currentProperty = name;
|
||||
},
|
||||
onObjectEnd: () => {
|
||||
currentParent = previousParents.pop();
|
||||
},
|
||||
onArrayBegin: () => {
|
||||
const array = [];
|
||||
onValue(array);
|
||||
previousParents.push(currentParent);
|
||||
currentParent = array;
|
||||
currentProperty = null;
|
||||
},
|
||||
onArrayEnd: () => {
|
||||
currentParent = previousParents.pop();
|
||||
},
|
||||
onLiteralValue: onValue,
|
||||
onError: (error, offset, length) => {
|
||||
errors.push({ error, offset, length });
|
||||
}
|
||||
};
|
||||
visit(text, visitor, options);
|
||||
return currentParent[0];
|
||||
}
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
export function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
|
||||
let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
|
||||
function ensurePropertyComplete(endOffset) {
|
||||
if (currentParent.type === 'property') {
|
||||
currentParent.length = endOffset - currentParent.offset;
|
||||
currentParent = currentParent.parent;
|
||||
}
|
||||
}
|
||||
function onValue(valueNode) {
|
||||
currentParent.children.push(valueNode);
|
||||
return valueNode;
|
||||
}
|
||||
const visitor = {
|
||||
onObjectBegin: (offset) => {
|
||||
currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
|
||||
},
|
||||
onObjectProperty: (name, offset, length) => {
|
||||
currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
|
||||
currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });
|
||||
},
|
||||
onObjectEnd: (offset, length) => {
|
||||
ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
|
||||
currentParent.length = offset + length - currentParent.offset;
|
||||
currentParent = currentParent.parent;
|
||||
ensurePropertyComplete(offset + length);
|
||||
},
|
||||
onArrayBegin: (offset, length) => {
|
||||
currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
|
||||
},
|
||||
onArrayEnd: (offset, length) => {
|
||||
currentParent.length = offset + length - currentParent.offset;
|
||||
currentParent = currentParent.parent;
|
||||
ensurePropertyComplete(offset + length);
|
||||
},
|
||||
onLiteralValue: (value, offset, length) => {
|
||||
onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
|
||||
ensurePropertyComplete(offset + length);
|
||||
},
|
||||
onSeparator: (sep, offset, length) => {
|
||||
if (currentParent.type === 'property') {
|
||||
if (sep === ':') {
|
||||
currentParent.colonOffset = offset;
|
||||
}
|
||||
else if (sep === ',') {
|
||||
ensurePropertyComplete(offset);
|
||||
}
|
||||
}
|
||||
},
|
||||
onError: (error, offset, length) => {
|
||||
errors.push({ error, offset, length });
|
||||
}
|
||||
};
|
||||
visit(text, visitor, options);
|
||||
const result = currentParent.children[0];
|
||||
if (result) {
|
||||
delete result.parent;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
/**
|
||||
* Finds the node at the given path in a JSON DOM.
|
||||
*/
|
||||
export function findNodeAtLocation(root, path) {
|
||||
if (!root) {
|
||||
return undefined;
|
||||
}
|
||||
let node = root;
|
||||
for (let segment of path) {
|
||||
if (typeof segment === 'string') {
|
||||
if (node.type !== 'object' || !Array.isArray(node.children)) {
|
||||
return undefined;
|
||||
}
|
||||
let found = false;
|
||||
for (const propertyNode of node.children) {
|
||||
if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
|
||||
node = propertyNode.children[1];
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
else {
|
||||
const index = segment;
|
||||
if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
|
||||
return undefined;
|
||||
}
|
||||
node = node.children[index];
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
/**
|
||||
* Gets the JSON path of the given JSON DOM node
|
||||
*/
|
||||
export function getNodePath(node) {
|
||||
if (!node.parent || !node.parent.children) {
|
||||
return [];
|
||||
}
|
||||
const path = getNodePath(node.parent);
|
||||
if (node.parent.type === 'property') {
|
||||
const key = node.parent.children[0].value;
|
||||
path.push(key);
|
||||
}
|
||||
else if (node.parent.type === 'array') {
|
||||
const index = node.parent.children.indexOf(node);
|
||||
if (index !== -1) {
|
||||
path.push(index);
|
||||
}
|
||||
}
|
||||
return path;
|
||||
}
|
||||
/**
|
||||
* Evaluates the JavaScript object of the given JSON DOM node
|
||||
*/
|
||||
export function getNodeValue(node) {
|
||||
switch (node.type) {
|
||||
case 'array':
|
||||
return node.children.map(getNodeValue);
|
||||
case 'object':
|
||||
const obj = Object.create(null);
|
||||
for (let prop of node.children) {
|
||||
const valueNode = prop.children[1];
|
||||
if (valueNode) {
|
||||
obj[prop.children[0].value] = getNodeValue(valueNode);
|
||||
}
|
||||
}
|
||||
return obj;
|
||||
case 'null':
|
||||
case 'string':
|
||||
case 'number':
|
||||
case 'boolean':
|
||||
return node.value;
|
||||
default:
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
export function contains(node, offset, includeRightBound = false) {
|
||||
return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
|
||||
}
|
||||
/**
|
||||
* Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
|
||||
*/
|
||||
export function findNodeAtOffset(node, offset, includeRightBound = false) {
|
||||
if (contains(node, offset, includeRightBound)) {
|
||||
const children = node.children;
|
||||
if (Array.isArray(children)) {
|
||||
for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
|
||||
const item = findNodeAtOffset(children[i], offset, includeRightBound);
|
||||
if (item) {
|
||||
return item;
|
||||
}
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
/**
|
||||
* Parses the given text and invokes the visitor functions for each object, array and literal reached.
|
||||
*/
|
||||
export function visit(text, visitor, options = ParseOptions.DEFAULT) {
|
||||
const _scanner = createScanner(text, false);
|
||||
// Important: Only pass copies of this to visitor functions to prevent accidental modification, and
|
||||
// to not affect visitor functions which stored a reference to a previous JSONPath
|
||||
const _jsonPath = [];
|
||||
function toNoArgVisit(visitFunction) {
|
||||
return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
|
||||
}
|
||||
function toNoArgVisitWithPath(visitFunction) {
|
||||
return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
|
||||
}
|
||||
function toOneArgVisit(visitFunction) {
|
||||
return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
|
||||
}
|
||||
function toOneArgVisitWithPath(visitFunction) {
|
||||
return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
|
||||
}
|
||||
const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
|
||||
const disallowComments = options && options.disallowComments;
|
||||
const allowTrailingComma = options && options.allowTrailingComma;
|
||||
function scanNext() {
|
||||
while (true) {
|
||||
const token = _scanner.scan();
|
||||
switch (_scanner.getTokenError()) {
|
||||
case 4 /* ScanError.InvalidUnicode */:
|
||||
handleError(14 /* ParseErrorCode.InvalidUnicode */);
|
||||
break;
|
||||
case 5 /* ScanError.InvalidEscapeCharacter */:
|
||||
handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
|
||||
break;
|
||||
case 3 /* ScanError.UnexpectedEndOfNumber */:
|
||||
handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
|
||||
break;
|
||||
case 1 /* ScanError.UnexpectedEndOfComment */:
|
||||
if (!disallowComments) {
|
||||
handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
|
||||
}
|
||||
break;
|
||||
case 2 /* ScanError.UnexpectedEndOfString */:
|
||||
handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
|
||||
break;
|
||||
case 6 /* ScanError.InvalidCharacter */:
|
||||
handleError(16 /* ParseErrorCode.InvalidCharacter */);
|
||||
break;
|
||||
}
|
||||
switch (token) {
|
||||
case 12 /* SyntaxKind.LineCommentTrivia */:
|
||||
case 13 /* SyntaxKind.BlockCommentTrivia */:
|
||||
if (disallowComments) {
|
||||
handleError(10 /* ParseErrorCode.InvalidCommentToken */);
|
||||
}
|
||||
else {
|
||||
onComment();
|
||||
}
|
||||
break;
|
||||
case 16 /* SyntaxKind.Unknown */:
|
||||
handleError(1 /* ParseErrorCode.InvalidSymbol */);
|
||||
break;
|
||||
case 15 /* SyntaxKind.Trivia */:
|
||||
case 14 /* SyntaxKind.LineBreakTrivia */:
|
||||
break;
|
||||
default:
|
||||
return token;
|
||||
}
|
||||
}
|
||||
}
|
||||
function handleError(error, skipUntilAfter = [], skipUntil = []) {
|
||||
onError(error);
|
||||
if (skipUntilAfter.length + skipUntil.length > 0) {
|
||||
let token = _scanner.getToken();
|
||||
while (token !== 17 /* SyntaxKind.EOF */) {
|
||||
if (skipUntilAfter.indexOf(token) !== -1) {
|
||||
scanNext();
|
||||
break;
|
||||
}
|
||||
else if (skipUntil.indexOf(token) !== -1) {
|
||||
break;
|
||||
}
|
||||
token = scanNext();
|
||||
}
|
||||
}
|
||||
}
|
||||
function parseString(isValue) {
|
||||
const value = _scanner.getTokenValue();
|
||||
if (isValue) {
|
||||
onLiteralValue(value);
|
||||
}
|
||||
else {
|
||||
onObjectProperty(value);
|
||||
// add property name afterwards
|
||||
_jsonPath.push(value);
|
||||
}
|
||||
scanNext();
|
||||
return true;
|
||||
}
|
||||
function parseLiteral() {
|
||||
switch (_scanner.getToken()) {
|
||||
case 11 /* SyntaxKind.NumericLiteral */:
|
||||
const tokenValue = _scanner.getTokenValue();
|
||||
let value = Number(tokenValue);
|
||||
if (isNaN(value)) {
|
||||
handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
|
||||
value = 0;
|
||||
}
|
||||
onLiteralValue(value);
|
||||
break;
|
||||
case 7 /* SyntaxKind.NullKeyword */:
|
||||
onLiteralValue(null);
|
||||
break;
|
||||
case 8 /* SyntaxKind.TrueKeyword */:
|
||||
onLiteralValue(true);
|
||||
break;
|
||||
case 9 /* SyntaxKind.FalseKeyword */:
|
||||
onLiteralValue(false);
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
scanNext();
|
||||
return true;
|
||||
}
|
||||
function parseProperty() {
|
||||
if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
|
||||
handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
|
||||
return false;
|
||||
}
|
||||
parseString(false);
|
||||
if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
|
||||
onSeparator(':');
|
||||
scanNext(); // consume colon
|
||||
if (!parseValue()) {
|
||||
handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
|
||||
}
|
||||
}
|
||||
else {
|
||||
handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
|
||||
}
|
||||
_jsonPath.pop(); // remove processed property name
|
||||
return true;
|
||||
}
|
||||
function parseObject() {
|
||||
onObjectBegin();
|
||||
scanNext(); // consume open brace
|
||||
let needsComma = false;
|
||||
while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
|
||||
if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
|
||||
if (!needsComma) {
|
||||
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
|
||||
}
|
||||
onSeparator(',');
|
||||
scanNext(); // consume comma
|
||||
if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (needsComma) {
|
||||
handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
|
||||
}
|
||||
if (!parseProperty()) {
|
||||
handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
|
||||
}
|
||||
needsComma = true;
|
||||
}
|
||||
onObjectEnd();
|
||||
if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
|
||||
handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
|
||||
}
|
||||
else {
|
||||
scanNext(); // consume close brace
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function parseArray() {
|
||||
onArrayBegin();
|
||||
scanNext(); // consume open bracket
|
||||
let isFirstElement = true;
|
||||
let needsComma = false;
|
||||
while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
|
||||
if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
|
||||
if (!needsComma) {
|
||||
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
|
||||
}
|
||||
onSeparator(',');
|
||||
scanNext(); // consume comma
|
||||
if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (needsComma) {
|
||||
handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
|
||||
}
|
||||
if (isFirstElement) {
|
||||
_jsonPath.push(0);
|
||||
isFirstElement = false;
|
||||
}
|
||||
else {
|
||||
_jsonPath[_jsonPath.length - 1]++;
|
||||
}
|
||||
if (!parseValue()) {
|
||||
handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
|
||||
}
|
||||
needsComma = true;
|
||||
}
|
||||
onArrayEnd();
|
||||
if (!isFirstElement) {
|
||||
_jsonPath.pop(); // remove array index
|
||||
}
|
||||
if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
|
||||
handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
|
||||
}
|
||||
else {
|
||||
scanNext(); // consume close bracket
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function parseValue() {
|
||||
switch (_scanner.getToken()) {
|
||||
case 3 /* SyntaxKind.OpenBracketToken */:
|
||||
return parseArray();
|
||||
case 1 /* SyntaxKind.OpenBraceToken */:
|
||||
return parseObject();
|
||||
case 10 /* SyntaxKind.StringLiteral */:
|
||||
return parseString(true);
|
||||
default:
|
||||
return parseLiteral();
|
||||
}
|
||||
}
|
||||
scanNext();
|
||||
if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
|
||||
if (options.allowEmptyContent) {
|
||||
return true;
|
||||
}
|
||||
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
|
||||
return false;
|
||||
}
|
||||
if (!parseValue()) {
|
||||
handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
|
||||
return false;
|
||||
}
|
||||
if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
|
||||
handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
/**
|
||||
* Takes JSON with JavaScript-style comments and remove
|
||||
* them. Optionally replaces every none-newline character
|
||||
* of comments with a replaceCharacter
|
||||
*/
|
||||
export function stripComments(text, replaceCh) {
|
||||
let _scanner = createScanner(text), parts = [], kind, offset = 0, pos;
|
||||
do {
|
||||
pos = _scanner.getPosition();
|
||||
kind = _scanner.scan();
|
||||
switch (kind) {
|
||||
case 12 /* SyntaxKind.LineCommentTrivia */:
|
||||
case 13 /* SyntaxKind.BlockCommentTrivia */:
|
||||
case 17 /* SyntaxKind.EOF */:
|
||||
if (offset !== pos) {
|
||||
parts.push(text.substring(offset, pos));
|
||||
}
|
||||
if (replaceCh !== undefined) {
|
||||
parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
|
||||
}
|
||||
offset = _scanner.getPosition();
|
||||
break;
|
||||
}
|
||||
} while (kind !== 17 /* SyntaxKind.EOF */);
|
||||
return parts.join('');
|
||||
}
|
||||
export function getNodeType(value) {
|
||||
switch (typeof value) {
|
||||
case 'boolean': return 'boolean';
|
||||
case 'number': return 'number';
|
||||
case 'string': return 'string';
|
||||
case 'object': {
|
||||
if (!value) {
|
||||
return 'null';
|
||||
}
|
||||
else if (Array.isArray(value)) {
|
||||
return 'array';
|
||||
}
|
||||
return 'object';
|
||||
}
|
||||
default: return 'null';
|
||||
}
|
||||
}
|
||||
443
my-app/node_modules/jsonc-parser/lib/esm/impl/scanner.js
generated
vendored
Executable file
443
my-app/node_modules/jsonc-parser/lib/esm/impl/scanner.js
generated
vendored
Executable file
|
|
@ -0,0 +1,443 @@
|
|||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
/**
|
||||
* Creates a JSON scanner on the given text.
|
||||
* If ignoreTrivia is set, whitespaces or comments are ignored.
|
||||
*/
|
||||
export function createScanner(text, ignoreTrivia = false) {
|
||||
const len = text.length;
|
||||
let pos = 0, value = '', tokenOffset = 0, token = 16 /* SyntaxKind.Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* ScanError.None */;
|
||||
function scanHexDigits(count, exact) {
|
||||
let digits = 0;
|
||||
let value = 0;
|
||||
while (digits < count || !exact) {
|
||||
let ch = text.charCodeAt(pos);
|
||||
if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {
|
||||
value = value * 16 + ch - 48 /* CharacterCodes._0 */;
|
||||
}
|
||||
else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {
|
||||
value = value * 16 + ch - 65 /* CharacterCodes.A */ + 10;
|
||||
}
|
||||
else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {
|
||||
value = value * 16 + ch - 97 /* CharacterCodes.a */ + 10;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
digits++;
|
||||
}
|
||||
if (digits < count) {
|
||||
value = -1;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
function setPosition(newPosition) {
|
||||
pos = newPosition;
|
||||
value = '';
|
||||
tokenOffset = 0;
|
||||
token = 16 /* SyntaxKind.Unknown */;
|
||||
scanError = 0 /* ScanError.None */;
|
||||
}
|
||||
function scanNumber() {
|
||||
let start = pos;
|
||||
if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {
|
||||
pos++;
|
||||
}
|
||||
else {
|
||||
pos++;
|
||||
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {
|
||||
pos++;
|
||||
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
||||
pos++;
|
||||
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
|
||||
return text.substring(start, pos);
|
||||
}
|
||||
}
|
||||
let end = pos;
|
||||
if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {
|
||||
pos++;
|
||||
if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {
|
||||
pos++;
|
||||
}
|
||||
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
||||
pos++;
|
||||
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
||||
pos++;
|
||||
}
|
||||
end = pos;
|
||||
}
|
||||
else {
|
||||
scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
|
||||
}
|
||||
}
|
||||
return text.substring(start, end);
|
||||
}
|
||||
function scanString() {
|
||||
let result = '', start = pos;
|
||||
while (true) {
|
||||
if (pos >= len) {
|
||||
result += text.substring(start, pos);
|
||||
scanError = 2 /* ScanError.UnexpectedEndOfString */;
|
||||
break;
|
||||
}
|
||||
const ch = text.charCodeAt(pos);
|
||||
if (ch === 34 /* CharacterCodes.doubleQuote */) {
|
||||
result += text.substring(start, pos);
|
||||
pos++;
|
||||
break;
|
||||
}
|
||||
if (ch === 92 /* CharacterCodes.backslash */) {
|
||||
result += text.substring(start, pos);
|
||||
pos++;
|
||||
if (pos >= len) {
|
||||
scanError = 2 /* ScanError.UnexpectedEndOfString */;
|
||||
break;
|
||||
}
|
||||
const ch2 = text.charCodeAt(pos++);
|
||||
switch (ch2) {
|
||||
case 34 /* CharacterCodes.doubleQuote */:
|
||||
result += '\"';
|
||||
break;
|
||||
case 92 /* CharacterCodes.backslash */:
|
||||
result += '\\';
|
||||
break;
|
||||
case 47 /* CharacterCodes.slash */:
|
||||
result += '/';
|
||||
break;
|
||||
case 98 /* CharacterCodes.b */:
|
||||
result += '\b';
|
||||
break;
|
||||
case 102 /* CharacterCodes.f */:
|
||||
result += '\f';
|
||||
break;
|
||||
case 110 /* CharacterCodes.n */:
|
||||
result += '\n';
|
||||
break;
|
||||
case 114 /* CharacterCodes.r */:
|
||||
result += '\r';
|
||||
break;
|
||||
case 116 /* CharacterCodes.t */:
|
||||
result += '\t';
|
||||
break;
|
||||
case 117 /* CharacterCodes.u */:
|
||||
const ch3 = scanHexDigits(4, true);
|
||||
if (ch3 >= 0) {
|
||||
result += String.fromCharCode(ch3);
|
||||
}
|
||||
else {
|
||||
scanError = 4 /* ScanError.InvalidUnicode */;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
scanError = 5 /* ScanError.InvalidEscapeCharacter */;
|
||||
}
|
||||
start = pos;
|
||||
continue;
|
||||
}
|
||||
if (ch >= 0 && ch <= 0x1f) {
|
||||
if (isLineBreak(ch)) {
|
||||
result += text.substring(start, pos);
|
||||
scanError = 2 /* ScanError.UnexpectedEndOfString */;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
scanError = 6 /* ScanError.InvalidCharacter */;
|
||||
// mark as error but continue with string
|
||||
}
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function scanNext() {
|
||||
value = '';
|
||||
scanError = 0 /* ScanError.None */;
|
||||
tokenOffset = pos;
|
||||
lineStartOffset = lineNumber;
|
||||
prevTokenLineStartOffset = tokenLineStartOffset;
|
||||
if (pos >= len) {
|
||||
// at the end
|
||||
tokenOffset = len;
|
||||
return token = 17 /* SyntaxKind.EOF */;
|
||||
}
|
||||
let code = text.charCodeAt(pos);
|
||||
// trivia: whitespace
|
||||
if (isWhiteSpace(code)) {
|
||||
do {
|
||||
pos++;
|
||||
value += String.fromCharCode(code);
|
||||
code = text.charCodeAt(pos);
|
||||
} while (isWhiteSpace(code));
|
||||
return token = 15 /* SyntaxKind.Trivia */;
|
||||
}
|
||||
// trivia: newlines
|
||||
if (isLineBreak(code)) {
|
||||
pos++;
|
||||
value += String.fromCharCode(code);
|
||||
if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
|
||||
pos++;
|
||||
value += '\n';
|
||||
}
|
||||
lineNumber++;
|
||||
tokenLineStartOffset = pos;
|
||||
return token = 14 /* SyntaxKind.LineBreakTrivia */;
|
||||
}
|
||||
switch (code) {
|
||||
// tokens: []{}:,
|
||||
case 123 /* CharacterCodes.openBrace */:
|
||||
pos++;
|
||||
return token = 1 /* SyntaxKind.OpenBraceToken */;
|
||||
case 125 /* CharacterCodes.closeBrace */:
|
||||
pos++;
|
||||
return token = 2 /* SyntaxKind.CloseBraceToken */;
|
||||
case 91 /* CharacterCodes.openBracket */:
|
||||
pos++;
|
||||
return token = 3 /* SyntaxKind.OpenBracketToken */;
|
||||
case 93 /* CharacterCodes.closeBracket */:
|
||||
pos++;
|
||||
return token = 4 /* SyntaxKind.CloseBracketToken */;
|
||||
case 58 /* CharacterCodes.colon */:
|
||||
pos++;
|
||||
return token = 6 /* SyntaxKind.ColonToken */;
|
||||
case 44 /* CharacterCodes.comma */:
|
||||
pos++;
|
||||
return token = 5 /* SyntaxKind.CommaToken */;
|
||||
// strings
|
||||
case 34 /* CharacterCodes.doubleQuote */:
|
||||
pos++;
|
||||
value = scanString();
|
||||
return token = 10 /* SyntaxKind.StringLiteral */;
|
||||
// comments
|
||||
case 47 /* CharacterCodes.slash */:
|
||||
const start = pos - 1;
|
||||
// Single-line comment
|
||||
if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
|
||||
pos += 2;
|
||||
while (pos < len) {
|
||||
if (isLineBreak(text.charCodeAt(pos))) {
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
value = text.substring(start, pos);
|
||||
return token = 12 /* SyntaxKind.LineCommentTrivia */;
|
||||
}
|
||||
// Multi-line comment
|
||||
if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
|
||||
pos += 2;
|
||||
const safeLength = len - 1; // For lookahead.
|
||||
let commentClosed = false;
|
||||
while (pos < safeLength) {
|
||||
const ch = text.charCodeAt(pos);
|
||||
if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
|
||||
pos += 2;
|
||||
commentClosed = true;
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
if (isLineBreak(ch)) {
|
||||
if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
|
||||
pos++;
|
||||
}
|
||||
lineNumber++;
|
||||
tokenLineStartOffset = pos;
|
||||
}
|
||||
}
|
||||
if (!commentClosed) {
|
||||
pos++;
|
||||
scanError = 1 /* ScanError.UnexpectedEndOfComment */;
|
||||
}
|
||||
value = text.substring(start, pos);
|
||||
return token = 13 /* SyntaxKind.BlockCommentTrivia */;
|
||||
}
|
||||
// just a single slash
|
||||
value += String.fromCharCode(code);
|
||||
pos++;
|
||||
return token = 16 /* SyntaxKind.Unknown */;
|
||||
// numbers
|
||||
case 45 /* CharacterCodes.minus */:
|
||||
value += String.fromCharCode(code);
|
||||
pos++;
|
||||
if (pos === len || !isDigit(text.charCodeAt(pos))) {
|
||||
return token = 16 /* SyntaxKind.Unknown */;
|
||||
}
|
||||
// found a minus, followed by a number so
|
||||
// we fall through to proceed with scanning
|
||||
// numbers
|
||||
case 48 /* CharacterCodes._0 */:
|
||||
case 49 /* CharacterCodes._1 */:
|
||||
case 50 /* CharacterCodes._2 */:
|
||||
case 51 /* CharacterCodes._3 */:
|
||||
case 52 /* CharacterCodes._4 */:
|
||||
case 53 /* CharacterCodes._5 */:
|
||||
case 54 /* CharacterCodes._6 */:
|
||||
case 55 /* CharacterCodes._7 */:
|
||||
case 56 /* CharacterCodes._8 */:
|
||||
case 57 /* CharacterCodes._9 */:
|
||||
value += scanNumber();
|
||||
return token = 11 /* SyntaxKind.NumericLiteral */;
|
||||
// literals and unknown symbols
|
||||
default:
|
||||
// is a literal? Read the full word.
|
||||
while (pos < len && isUnknownContentCharacter(code)) {
|
||||
pos++;
|
||||
code = text.charCodeAt(pos);
|
||||
}
|
||||
if (tokenOffset !== pos) {
|
||||
value = text.substring(tokenOffset, pos);
|
||||
// keywords: true, false, null
|
||||
switch (value) {
|
||||
case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;
|
||||
case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;
|
||||
case 'null': return token = 7 /* SyntaxKind.NullKeyword */;
|
||||
}
|
||||
return token = 16 /* SyntaxKind.Unknown */;
|
||||
}
|
||||
// some
|
||||
value += String.fromCharCode(code);
|
||||
pos++;
|
||||
return token = 16 /* SyntaxKind.Unknown */;
|
||||
}
|
||||
}
|
||||
function isUnknownContentCharacter(code) {
|
||||
if (isWhiteSpace(code) || isLineBreak(code)) {
|
||||
return false;
|
||||
}
|
||||
switch (code) {
|
||||
case 125 /* CharacterCodes.closeBrace */:
|
||||
case 93 /* CharacterCodes.closeBracket */:
|
||||
case 123 /* CharacterCodes.openBrace */:
|
||||
case 91 /* CharacterCodes.openBracket */:
|
||||
case 34 /* CharacterCodes.doubleQuote */:
|
||||
case 58 /* CharacterCodes.colon */:
|
||||
case 44 /* CharacterCodes.comma */:
|
||||
case 47 /* CharacterCodes.slash */:
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
function scanNextNonTrivia() {
|
||||
let result;
|
||||
do {
|
||||
result = scanNext();
|
||||
} while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);
|
||||
return result;
|
||||
}
|
||||
return {
|
||||
setPosition: setPosition,
|
||||
getPosition: () => pos,
|
||||
scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
|
||||
getToken: () => token,
|
||||
getTokenValue: () => value,
|
||||
getTokenOffset: () => tokenOffset,
|
||||
getTokenLength: () => pos - tokenOffset,
|
||||
getTokenStartLine: () => lineStartOffset,
|
||||
getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
|
||||
getTokenError: () => scanError,
|
||||
};
|
||||
}
|
||||
function isWhiteSpace(ch) {
|
||||
return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */;
|
||||
}
|
||||
function isLineBreak(ch) {
|
||||
return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */;
|
||||
}
|
||||
function isDigit(ch) {
|
||||
return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
|
||||
}
|
||||
var CharacterCodes;
|
||||
(function (CharacterCodes) {
|
||||
CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
|
||||
CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
|
||||
CharacterCodes[CharacterCodes["space"] = 32] = "space";
|
||||
CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
|
||||
CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
|
||||
CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
|
||||
CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
|
||||
CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
|
||||
CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
|
||||
CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
|
||||
CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
|
||||
CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
|
||||
CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
|
||||
CharacterCodes[CharacterCodes["a"] = 97] = "a";
|
||||
CharacterCodes[CharacterCodes["b"] = 98] = "b";
|
||||
CharacterCodes[CharacterCodes["c"] = 99] = "c";
|
||||
CharacterCodes[CharacterCodes["d"] = 100] = "d";
|
||||
CharacterCodes[CharacterCodes["e"] = 101] = "e";
|
||||
CharacterCodes[CharacterCodes["f"] = 102] = "f";
|
||||
CharacterCodes[CharacterCodes["g"] = 103] = "g";
|
||||
CharacterCodes[CharacterCodes["h"] = 104] = "h";
|
||||
CharacterCodes[CharacterCodes["i"] = 105] = "i";
|
||||
CharacterCodes[CharacterCodes["j"] = 106] = "j";
|
||||
CharacterCodes[CharacterCodes["k"] = 107] = "k";
|
||||
CharacterCodes[CharacterCodes["l"] = 108] = "l";
|
||||
CharacterCodes[CharacterCodes["m"] = 109] = "m";
|
||||
CharacterCodes[CharacterCodes["n"] = 110] = "n";
|
||||
CharacterCodes[CharacterCodes["o"] = 111] = "o";
|
||||
CharacterCodes[CharacterCodes["p"] = 112] = "p";
|
||||
CharacterCodes[CharacterCodes["q"] = 113] = "q";
|
||||
CharacterCodes[CharacterCodes["r"] = 114] = "r";
|
||||
CharacterCodes[CharacterCodes["s"] = 115] = "s";
|
||||
CharacterCodes[CharacterCodes["t"] = 116] = "t";
|
||||
CharacterCodes[CharacterCodes["u"] = 117] = "u";
|
||||
CharacterCodes[CharacterCodes["v"] = 118] = "v";
|
||||
CharacterCodes[CharacterCodes["w"] = 119] = "w";
|
||||
CharacterCodes[CharacterCodes["x"] = 120] = "x";
|
||||
CharacterCodes[CharacterCodes["y"] = 121] = "y";
|
||||
CharacterCodes[CharacterCodes["z"] = 122] = "z";
|
||||
CharacterCodes[CharacterCodes["A"] = 65] = "A";
|
||||
CharacterCodes[CharacterCodes["B"] = 66] = "B";
|
||||
CharacterCodes[CharacterCodes["C"] = 67] = "C";
|
||||
CharacterCodes[CharacterCodes["D"] = 68] = "D";
|
||||
CharacterCodes[CharacterCodes["E"] = 69] = "E";
|
||||
CharacterCodes[CharacterCodes["F"] = 70] = "F";
|
||||
CharacterCodes[CharacterCodes["G"] = 71] = "G";
|
||||
CharacterCodes[CharacterCodes["H"] = 72] = "H";
|
||||
CharacterCodes[CharacterCodes["I"] = 73] = "I";
|
||||
CharacterCodes[CharacterCodes["J"] = 74] = "J";
|
||||
CharacterCodes[CharacterCodes["K"] = 75] = "K";
|
||||
CharacterCodes[CharacterCodes["L"] = 76] = "L";
|
||||
CharacterCodes[CharacterCodes["M"] = 77] = "M";
|
||||
CharacterCodes[CharacterCodes["N"] = 78] = "N";
|
||||
CharacterCodes[CharacterCodes["O"] = 79] = "O";
|
||||
CharacterCodes[CharacterCodes["P"] = 80] = "P";
|
||||
CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
|
||||
CharacterCodes[CharacterCodes["R"] = 82] = "R";
|
||||
CharacterCodes[CharacterCodes["S"] = 83] = "S";
|
||||
CharacterCodes[CharacterCodes["T"] = 84] = "T";
|
||||
CharacterCodes[CharacterCodes["U"] = 85] = "U";
|
||||
CharacterCodes[CharacterCodes["V"] = 86] = "V";
|
||||
CharacterCodes[CharacterCodes["W"] = 87] = "W";
|
||||
CharacterCodes[CharacterCodes["X"] = 88] = "X";
|
||||
CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
|
||||
CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
|
||||
CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
|
||||
CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
|
||||
CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
|
||||
CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
|
||||
CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
|
||||
CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
|
||||
CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
|
||||
CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
|
||||
CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
|
||||
CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
|
||||
CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
|
||||
CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
|
||||
CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
|
||||
CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
|
||||
CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
|
||||
})(CharacterCodes || (CharacterCodes = {}));
|
||||
349
my-app/node_modules/jsonc-parser/lib/esm/main.d.ts
generated
vendored
Executable file
349
my-app/node_modules/jsonc-parser/lib/esm/main.d.ts
generated
vendored
Executable file
|
|
@ -0,0 +1,349 @@
|
|||
/**
|
||||
* Creates a JSON scanner on the given text.
|
||||
* If ignoreTrivia is set, whitespaces or comments are ignored.
|
||||
*/
|
||||
export declare const createScanner: (text: string, ignoreTrivia?: boolean) => JSONScanner;
|
||||
export declare const enum ScanError {
|
||||
None = 0,
|
||||
UnexpectedEndOfComment = 1,
|
||||
UnexpectedEndOfString = 2,
|
||||
UnexpectedEndOfNumber = 3,
|
||||
InvalidUnicode = 4,
|
||||
InvalidEscapeCharacter = 5,
|
||||
InvalidCharacter = 6
|
||||
}
|
||||
export declare const enum SyntaxKind {
|
||||
OpenBraceToken = 1,
|
||||
CloseBraceToken = 2,
|
||||
OpenBracketToken = 3,
|
||||
CloseBracketToken = 4,
|
||||
CommaToken = 5,
|
||||
ColonToken = 6,
|
||||
NullKeyword = 7,
|
||||
TrueKeyword = 8,
|
||||
FalseKeyword = 9,
|
||||
StringLiteral = 10,
|
||||
NumericLiteral = 11,
|
||||
LineCommentTrivia = 12,
|
||||
BlockCommentTrivia = 13,
|
||||
LineBreakTrivia = 14,
|
||||
Trivia = 15,
|
||||
Unknown = 16,
|
||||
EOF = 17
|
||||
}
|
||||
/**
|
||||
* The scanner object, representing a JSON scanner at a position in the input string.
|
||||
*/
|
||||
export interface JSONScanner {
|
||||
/**
|
||||
* Sets the scan position to a new offset. A call to 'scan' is needed to get the first token.
|
||||
*/
|
||||
setPosition(pos: number): void;
|
||||
/**
|
||||
* Read the next token. Returns the token code.
|
||||
*/
|
||||
scan(): SyntaxKind;
|
||||
/**
|
||||
* Returns the zero-based current scan position, which is after the last read token.
|
||||
*/
|
||||
getPosition(): number;
|
||||
/**
|
||||
* Returns the last read token.
|
||||
*/
|
||||
getToken(): SyntaxKind;
|
||||
/**
|
||||
* Returns the last read token value. The value for strings is the decoded string content. For numbers it's of type number, for boolean it's true or false.
|
||||
*/
|
||||
getTokenValue(): string;
|
||||
/**
|
||||
* The zero-based start offset of the last read token.
|
||||
*/
|
||||
getTokenOffset(): number;
|
||||
/**
|
||||
* The length of the last read token.
|
||||
*/
|
||||
getTokenLength(): number;
|
||||
/**
|
||||
* The zero-based start line number of the last read token.
|
||||
*/
|
||||
getTokenStartLine(): number;
|
||||
/**
|
||||
* The zero-based start character (column) of the last read token.
|
||||
*/
|
||||
getTokenStartCharacter(): number;
|
||||
/**
|
||||
* An error code of the last scan.
|
||||
*/
|
||||
getTokenError(): ScanError;
|
||||
}
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
export declare const getLocation: (text: string, position: number) => Location;
|
||||
/**
|
||||
* 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.
|
||||
* Therefore, always check the errors list to find out if the input was valid.
|
||||
*/
|
||||
export declare const parse: (text: string, errors?: ParseError[], options?: ParseOptions) => any;
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
export declare const parseTree: (text: string, errors?: ParseError[], options?: ParseOptions) => Node | undefined;
|
||||
/**
|
||||
* Finds the node at the given path in a JSON DOM.
|
||||
*/
|
||||
export declare const findNodeAtLocation: (root: Node, path: JSONPath) => Node | undefined;
|
||||
/**
|
||||
* Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
|
||||
*/
|
||||
export declare const findNodeAtOffset: (root: Node, offset: number, includeRightBound?: boolean) => Node | undefined;
|
||||
/**
|
||||
* Gets the JSON path of the given JSON DOM node
|
||||
*/
|
||||
export declare const getNodePath: (node: Node) => JSONPath;
|
||||
/**
|
||||
* Evaluates the JavaScript object of the given JSON DOM node
|
||||
*/
|
||||
export declare const getNodeValue: (node: Node) => any;
|
||||
/**
|
||||
* Parses the given text and invokes the visitor functions for each object, array and literal reached.
|
||||
*/
|
||||
export declare const visit: (text: string, visitor: JSONVisitor, options?: ParseOptions) => any;
|
||||
/**
|
||||
* Takes JSON with JavaScript-style comments and remove
|
||||
* them. Optionally replaces every none-newline character
|
||||
* of comments with a replaceCharacter
|
||||
*/
|
||||
export declare const stripComments: (text: string, replaceCh?: string) => string;
|
||||
export interface ParseError {
|
||||
error: ParseErrorCode;
|
||||
offset: number;
|
||||
length: number;
|
||||
}
|
||||
export declare const enum ParseErrorCode {
|
||||
InvalidSymbol = 1,
|
||||
InvalidNumberFormat = 2,
|
||||
PropertyNameExpected = 3,
|
||||
ValueExpected = 4,
|
||||
ColonExpected = 5,
|
||||
CommaExpected = 6,
|
||||
CloseBraceExpected = 7,
|
||||
CloseBracketExpected = 8,
|
||||
EndOfFileExpected = 9,
|
||||
InvalidCommentToken = 10,
|
||||
UnexpectedEndOfComment = 11,
|
||||
UnexpectedEndOfString = 12,
|
||||
UnexpectedEndOfNumber = 13,
|
||||
InvalidUnicode = 14,
|
||||
InvalidEscapeCharacter = 15,
|
||||
InvalidCharacter = 16
|
||||
}
|
||||
export declare function printParseErrorCode(code: ParseErrorCode): "InvalidSymbol" | "InvalidNumberFormat" | "PropertyNameExpected" | "ValueExpected" | "ColonExpected" | "CommaExpected" | "CloseBraceExpected" | "CloseBracketExpected" | "EndOfFileExpected" | "InvalidCommentToken" | "UnexpectedEndOfComment" | "UnexpectedEndOfString" | "UnexpectedEndOfNumber" | "InvalidUnicode" | "InvalidEscapeCharacter" | "InvalidCharacter" | "<unknown ParseErrorCode>";
|
||||
export declare type NodeType = 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
|
||||
export interface Node {
|
||||
readonly type: NodeType;
|
||||
readonly value?: any;
|
||||
readonly offset: number;
|
||||
readonly length: number;
|
||||
readonly colonOffset?: number;
|
||||
readonly parent?: Node;
|
||||
readonly children?: Node[];
|
||||
}
|
||||
/**
|
||||
* A {@linkcode JSONPath} segment. Either a string representing an object property name
|
||||
* or a number (starting at 0) for array indices.
|
||||
*/
|
||||
export declare type Segment = string | number;
|
||||
export declare type JSONPath = Segment[];
|
||||
export interface Location {
|
||||
/**
|
||||
* The previous property key or literal value (string, number, boolean or null) or undefined.
|
||||
*/
|
||||
previousNode?: Node;
|
||||
/**
|
||||
* The path describing the location in the JSON document. The path consists of a sequence of strings
|
||||
* representing an object property or numbers for array indices.
|
||||
*/
|
||||
path: JSONPath;
|
||||
/**
|
||||
* Matches the locations path against a pattern consisting of strings (for properties) and numbers (for array indices).
|
||||
* '*' will match a single segment of any property name or index.
|
||||
* '**' will match a sequence of segments of any property name or index, or no segment.
|
||||
*/
|
||||
matches: (patterns: JSONPath) => boolean;
|
||||
/**
|
||||
* If set, the location's offset is at a property key.
|
||||
*/
|
||||
isAtPropertyKey: boolean;
|
||||
}
|
||||
export interface ParseOptions {
|
||||
disallowComments?: boolean;
|
||||
allowTrailingComma?: boolean;
|
||||
allowEmptyContent?: boolean;
|
||||
}
|
||||
/**
|
||||
* Visitor called by {@linkcode visit} when parsing JSON.
|
||||
*
|
||||
* The visitor functions have the following common parameters:
|
||||
* - `offset`: Global offset within the JSON document, starting at 0
|
||||
* - `startLine`: Line number, starting at 0
|
||||
* - `startCharacter`: Start character (column) within the current line, starting at 0
|
||||
*
|
||||
* Additionally some functions have a `pathSupplier` parameter which can be used to obtain the
|
||||
* current `JSONPath` within the document.
|
||||
*/
|
||||
export interface JSONVisitor {
|
||||
/**
|
||||
* Invoked when an open brace is encountered and an object is started. The offset and length represent the location of the open brace.
|
||||
*/
|
||||
onObjectBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
|
||||
/**
|
||||
* Invoked when a property is encountered. The offset and length represent the location of the property name.
|
||||
* The `JSONPath` created by the `pathSupplier` refers to the enclosing JSON object, it does not include the
|
||||
* property name yet.
|
||||
*/
|
||||
onObjectProperty?: (property: string, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
|
||||
/**
|
||||
* Invoked when a closing brace is encountered and an object is completed. The offset and length represent the location of the closing brace.
|
||||
*/
|
||||
onObjectEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
|
||||
/**
|
||||
* Invoked when an open bracket is encountered. The offset and length represent the location of the open bracket.
|
||||
*/
|
||||
onArrayBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
|
||||
/**
|
||||
* Invoked when a closing bracket is encountered. The offset and length represent the location of the closing bracket.
|
||||
*/
|
||||
onArrayEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
|
||||
/**
|
||||
* Invoked when a literal value is encountered. The offset and length represent the location of the literal value.
|
||||
*/
|
||||
onLiteralValue?: (value: any, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
|
||||
/**
|
||||
* Invoked when a comma or colon separator is encountered. The offset and length represent the location of the separator.
|
||||
*/
|
||||
onSeparator?: (character: string, offset: number, length: number, startLine: number, startCharacter: number) => void;
|
||||
/**
|
||||
* When comments are allowed, invoked when a line or block comment is encountered. The offset and length represent the location of the comment.
|
||||
*/
|
||||
onComment?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
|
||||
/**
|
||||
* Invoked on an error.
|
||||
*/
|
||||
onError?: (error: ParseErrorCode, offset: number, length: number, startLine: number, startCharacter: number) => void;
|
||||
}
|
||||
/**
|
||||
* An edit result describes a textual edit operation. It is the result of a {@linkcode format} and {@linkcode modify} operation.
|
||||
* It consist of one or more edits describing insertions, replacements or removals of text segments.
|
||||
* * The offsets of the edits refer to the original state of the document.
|
||||
* * No two edits change or remove the same range of text in the original document.
|
||||
* * Multiple edits can have the same offset if they are multiple inserts, or an insert followed by a remove or replace.
|
||||
* * The order in the array defines which edit is applied first.
|
||||
* To apply an edit result use {@linkcode applyEdits}.
|
||||
* In general multiple EditResults must not be concatenated because they might impact each other, producing incorrect or malformed JSON data.
|
||||
*/
|
||||
export declare type EditResult = Edit[];
|
||||
/**
|
||||
* Represents a text modification
|
||||
*/
|
||||
export interface Edit {
|
||||
/**
|
||||
* The start offset of the modification.
|
||||
*/
|
||||
offset: number;
|
||||
/**
|
||||
* The length of the modification. Must not be negative. Empty length represents an *insert*.
|
||||
*/
|
||||
length: number;
|
||||
/**
|
||||
* The new content. Empty content represents a *remove*.
|
||||
*/
|
||||
content: string;
|
||||
}
|
||||
/**
|
||||
* A text range in the document
|
||||
*/
|
||||
export interface Range {
|
||||
/**
|
||||
* The start offset of the range.
|
||||
*/
|
||||
offset: number;
|
||||
/**
|
||||
* The length of the range. Must not be negative.
|
||||
*/
|
||||
length: number;
|
||||
}
|
||||
/**
|
||||
* Options used by {@linkcode format} when computing the formatting edit operations
|
||||
*/
|
||||
export interface FormattingOptions {
|
||||
/**
|
||||
* If indentation is based on spaces (`insertSpaces` = true), the number of spaces that make an indent.
|
||||
*/
|
||||
tabSize?: number;
|
||||
/**
|
||||
* Is indentation based on spaces?
|
||||
*/
|
||||
insertSpaces?: boolean;
|
||||
/**
|
||||
* The default 'end of line' character. If not set, '\n' is used as default.
|
||||
*/
|
||||
eol?: string;
|
||||
/**
|
||||
* If set, will add a new line at the end of the document.
|
||||
*/
|
||||
insertFinalNewline?: boolean;
|
||||
/**
|
||||
* If true, will keep line positions as is in the formatting
|
||||
*/
|
||||
keepLines?: boolean;
|
||||
}
|
||||
/**
|
||||
* Computes the edit operations needed to format a JSON document.
|
||||
*
|
||||
* @param documentText The input text
|
||||
* @param range The range to format or `undefined` to format the full content
|
||||
* @param options The formatting options
|
||||
* @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
|
||||
* To apply the edit operations to the input, use {@linkcode applyEdits}.
|
||||
*/
|
||||
export declare function format(documentText: string, range: Range | undefined, options: FormattingOptions): EditResult;
|
||||
/**
|
||||
* Options used by {@linkcode modify} when computing the modification edit operations
|
||||
*/
|
||||
export interface ModificationOptions {
|
||||
/**
|
||||
* Formatting options. If undefined, the newly inserted code will be inserted unformatted.
|
||||
*/
|
||||
formattingOptions?: FormattingOptions;
|
||||
/**
|
||||
* Default false. If `JSONPath` refers to an index of an array and `isArrayInsertion` is `true`, then
|
||||
* {@linkcode modify} will insert a new item at that location instead of overwriting its contents.
|
||||
*/
|
||||
isArrayInsertion?: boolean;
|
||||
/**
|
||||
* Optional function to define the insertion index given an existing list of properties.
|
||||
*/
|
||||
getInsertionIndex?: (properties: string[]) => number;
|
||||
}
|
||||
/**
|
||||
* Computes the edit operations needed to modify a value in the JSON document.
|
||||
*
|
||||
* @param documentText The input text
|
||||
* @param path The path of the value to change. The path represents either to the document root, a property or an array item.
|
||||
* If the path points to an non-existing property or item, it will be created.
|
||||
* @param value The new value for the specified property or item. If the value is undefined,
|
||||
* the property or item will be removed.
|
||||
* @param options Options
|
||||
* @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
|
||||
* To apply the edit operations to the input, use {@linkcode applyEdits}.
|
||||
*/
|
||||
export declare function modify(text: string, path: JSONPath, value: any, options: ModificationOptions): EditResult;
|
||||
/**
|
||||
* Applies edits to an input string.
|
||||
* @param text The input text
|
||||
* @param edits Edit operations following the format described in {@linkcode EditResult}.
|
||||
* @returns The text with the applied edits.
|
||||
* @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
|
||||
*/
|
||||
export declare function applyEdits(text: string, edits: EditResult): string;
|
||||
178
my-app/node_modules/jsonc-parser/lib/esm/main.js
generated
vendored
Executable file
178
my-app/node_modules/jsonc-parser/lib/esm/main.js
generated
vendored
Executable file
|
|
@ -0,0 +1,178 @@
|
|||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
'use strict';
|
||||
import * as formatter from './impl/format';
|
||||
import * as edit from './impl/edit';
|
||||
import * as scanner from './impl/scanner';
|
||||
import * as parser from './impl/parser';
|
||||
/**
|
||||
* Creates a JSON scanner on the given text.
|
||||
* If ignoreTrivia is set, whitespaces or comments are ignored.
|
||||
*/
|
||||
export const createScanner = scanner.createScanner;
|
||||
export var ScanError;
|
||||
(function (ScanError) {
|
||||
ScanError[ScanError["None"] = 0] = "None";
|
||||
ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
|
||||
ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
|
||||
ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
|
||||
ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
|
||||
ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
|
||||
ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
|
||||
})(ScanError || (ScanError = {}));
|
||||
export var SyntaxKind;
|
||||
(function (SyntaxKind) {
|
||||
SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
|
||||
SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
|
||||
SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
|
||||
SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
|
||||
SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
|
||||
SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
|
||||
SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
|
||||
SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
|
||||
SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
|
||||
SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
|
||||
SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
|
||||
SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
|
||||
SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
|
||||
SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
|
||||
SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
|
||||
SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
|
||||
SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
|
||||
})(SyntaxKind || (SyntaxKind = {}));
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
export const getLocation = parser.getLocation;
|
||||
/**
|
||||
* 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.
|
||||
* Therefore, always check the errors list to find out if the input was valid.
|
||||
*/
|
||||
export const parse = parser.parse;
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
export const parseTree = parser.parseTree;
|
||||
/**
|
||||
* Finds the node at the given path in a JSON DOM.
|
||||
*/
|
||||
export const findNodeAtLocation = parser.findNodeAtLocation;
|
||||
/**
|
||||
* Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
|
||||
*/
|
||||
export const findNodeAtOffset = parser.findNodeAtOffset;
|
||||
/**
|
||||
* Gets the JSON path of the given JSON DOM node
|
||||
*/
|
||||
export const getNodePath = parser.getNodePath;
|
||||
/**
|
||||
* Evaluates the JavaScript object of the given JSON DOM node
|
||||
*/
|
||||
export const getNodeValue = parser.getNodeValue;
|
||||
/**
|
||||
* Parses the given text and invokes the visitor functions for each object, array and literal reached.
|
||||
*/
|
||||
export const visit = parser.visit;
|
||||
/**
|
||||
* Takes JSON with JavaScript-style comments and remove
|
||||
* them. Optionally replaces every none-newline character
|
||||
* of comments with a replaceCharacter
|
||||
*/
|
||||
export const stripComments = parser.stripComments;
|
||||
export var ParseErrorCode;
|
||||
(function (ParseErrorCode) {
|
||||
ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
|
||||
ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
|
||||
ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
|
||||
ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
|
||||
ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
|
||||
ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
|
||||
ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
|
||||
ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
|
||||
ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
|
||||
ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
|
||||
ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
|
||||
ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
|
||||
ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
|
||||
ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
|
||||
ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
|
||||
ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
|
||||
})(ParseErrorCode || (ParseErrorCode = {}));
|
||||
export function printParseErrorCode(code) {
|
||||
switch (code) {
|
||||
case 1 /* ParseErrorCode.InvalidSymbol */: return 'InvalidSymbol';
|
||||
case 2 /* ParseErrorCode.InvalidNumberFormat */: return 'InvalidNumberFormat';
|
||||
case 3 /* ParseErrorCode.PropertyNameExpected */: return 'PropertyNameExpected';
|
||||
case 4 /* ParseErrorCode.ValueExpected */: return 'ValueExpected';
|
||||
case 5 /* ParseErrorCode.ColonExpected */: return 'ColonExpected';
|
||||
case 6 /* ParseErrorCode.CommaExpected */: return 'CommaExpected';
|
||||
case 7 /* ParseErrorCode.CloseBraceExpected */: return 'CloseBraceExpected';
|
||||
case 8 /* ParseErrorCode.CloseBracketExpected */: return 'CloseBracketExpected';
|
||||
case 9 /* ParseErrorCode.EndOfFileExpected */: return 'EndOfFileExpected';
|
||||
case 10 /* ParseErrorCode.InvalidCommentToken */: return 'InvalidCommentToken';
|
||||
case 11 /* ParseErrorCode.UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';
|
||||
case 12 /* ParseErrorCode.UnexpectedEndOfString */: return 'UnexpectedEndOfString';
|
||||
case 13 /* ParseErrorCode.UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';
|
||||
case 14 /* ParseErrorCode.InvalidUnicode */: return 'InvalidUnicode';
|
||||
case 15 /* ParseErrorCode.InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';
|
||||
case 16 /* ParseErrorCode.InvalidCharacter */: return 'InvalidCharacter';
|
||||
}
|
||||
return '<unknown ParseErrorCode>';
|
||||
}
|
||||
/**
|
||||
* Computes the edit operations needed to format a JSON document.
|
||||
*
|
||||
* @param documentText The input text
|
||||
* @param range The range to format or `undefined` to format the full content
|
||||
* @param options The formatting options
|
||||
* @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
|
||||
* To apply the edit operations to the input, use {@linkcode applyEdits}.
|
||||
*/
|
||||
export function format(documentText, range, options) {
|
||||
return formatter.format(documentText, range, options);
|
||||
}
|
||||
/**
|
||||
* Computes the edit operations needed to modify a value in the JSON document.
|
||||
*
|
||||
* @param documentText The input text
|
||||
* @param path The path of the value to change. The path represents either to the document root, a property or an array item.
|
||||
* If the path points to an non-existing property or item, it will be created.
|
||||
* @param value The new value for the specified property or item. If the value is undefined,
|
||||
* the property or item will be removed.
|
||||
* @param options Options
|
||||
* @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
|
||||
* To apply the edit operations to the input, use {@linkcode applyEdits}.
|
||||
*/
|
||||
export function modify(text, path, value, options) {
|
||||
return edit.setProperty(text, path, value, options);
|
||||
}
|
||||
/**
|
||||
* Applies edits to an input string.
|
||||
* @param text The input text
|
||||
* @param edits Edit operations following the format described in {@linkcode EditResult}.
|
||||
* @returns The text with the applied edits.
|
||||
* @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
|
||||
*/
|
||||
export function applyEdits(text, edits) {
|
||||
let sortedEdits = edits.slice(0).sort((a, b) => {
|
||||
const diff = a.offset - b.offset;
|
||||
if (diff === 0) {
|
||||
return a.length - b.length;
|
||||
}
|
||||
return diff;
|
||||
});
|
||||
let lastModifiedOffset = text.length;
|
||||
for (let i = sortedEdits.length - 1; i >= 0; i--) {
|
||||
let e = sortedEdits[i];
|
||||
if (e.offset + e.length <= lastModifiedOffset) {
|
||||
text = edit.applyEdit(text, e);
|
||||
}
|
||||
else {
|
||||
throw new Error('Overlapping edit');
|
||||
}
|
||||
lastModifiedOffset = e.offset;
|
||||
}
|
||||
return text;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue