terminal-pilot 0.0.44 → 0.0.46

package/node_modules/jsonc-parser/lib/umd/impl/edit.js

@@ -0,0 +1,201 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./format", "./parser"], factory);
+    }
+})(function (require, exports) {
+    /*---------------------------------------------------------------------------------------------
+     *  Copyright (c) Microsoft Corporation. All rights reserved.
+     *  Licensed under the MIT License. See License.txt in the project root for license information.
+     *--------------------------------------------------------------------------------------------*/
+    'use strict';
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isWS = exports.applyEdit = exports.setProperty = exports.removeProperty = void 0;
+    const format_1 = require("./format");
+    const parser_1 = require("./parser");
+    function removeProperty(text, path, options) {
+        return setProperty(text, path, void 0, options);
+    }
+    exports.removeProperty = removeProperty;
+    function setProperty(text, originalPath, value, options) {
+        const path = originalPath.slice();
+        const errors = [];
+        const root = (0, parser_1.parseTree)(text, errors);
+        let parent = void 0;
+        let lastSegment = void 0;
+        while (path.length > 0) {
+            lastSegment = path.pop();
+            parent = (0, parser_1.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 = (0, parser_1.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}`);
+        }
+    }
+    exports.setProperty = setProperty;
+    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 && !(0, format_1.isEOL)(newText, begin - 1)) {
+                begin--;
+            }
+            while (end < newText.length && !(0, format_1.isEOL)(newText, end)) {
+                end++;
+            }
+        }
+        const edits = (0, format_1.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) }];
+    }
+    function applyEdit(text, edit) {
+        return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+    }
+    exports.applyEdit = applyEdit;
+    function isWS(text, offset) {
+        return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;
+    }
+    exports.isWS = isWS;
+});

package/node_modules/jsonc-parser/lib/umd/impl/format.js

@@ -0,0 +1,275 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./scanner", "./string-intern"], factory);
+    }
+})(function (require, exports) {
+    /*---------------------------------------------------------------------------------------------
+     *  Copyright (c) Microsoft Corporation. All rights reserved.
+     *  Licensed under the MIT License. See License.txt in the project root for license information.
+     *--------------------------------------------------------------------------------------------*/
+    'use strict';
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isEOL = exports.format = void 0;
+    const scanner_1 = require("./scanner");
+    const string_intern_1 = require("./string-intern");
+    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);
+        const eolFastPathSupported = string_intern_1.supportedEols.includes(eol);
+        let numberLineBreaks = 0;
+        let indentLevel = 0;
+        let indentValue;
+        if (options.insertSpaces) {
+            indentValue = string_intern_1.cachedSpaces[options.tabSize || 4] ?? repeat(string_intern_1.cachedSpaces[1], options.tabSize || 4);
+        }
+        else {
+            indentValue = '\t';
+        }
+        const indentType = indentValue === '\t' ? '\t' : ' ';
+        let scanner = (0, scanner_1.createScanner)(formatText, false);
+        let hasError = false;
+        function newLinesAndIndent() {
+            if (numberLineBreaks > 1) {
+                return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+            }
+            const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+            if (!eolFastPathSupported || amountOfSpaces > string_intern_1.cachedBreakLinesWithSpaces[indentType][eol].length) {
+                return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+            }
+            if (amountOfSpaces <= 0) {
+                return eol;
+            }
+            return string_intern_1.cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+        }
+        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 = (indentValue.length * initialIndentLevel < 20) && options.insertSpaces
+                ? string_intern_1.cachedSpaces[indentValue.length * initialIndentLevel]
+                : 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(string_intern_1.cachedSpaces[1], 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 = string_intern_1.cachedSpaces[1];
+                }
+            }
+            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 = string_intern_1.cachedSpaces[1];
+                }
+            }
+            else {
+                switch (firstToken) {
+                    case 3 /* SyntaxKind.OpenBracketToken */:
+                    case 1 /* SyntaxKind.OpenBraceToken */:
+                        indentLevel++;
+                        if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+                            replaceContent = newLinesAndIndent();
+                        }
+                        else {
+                            replaceContent = string_intern_1.cachedSpaces[1];
+                        }
+                        break;
+                    case 5 /* SyntaxKind.CommaToken */:
+                        if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+                            replaceContent = newLinesAndIndent();
+                        }
+                        else {
+                            replaceContent = string_intern_1.cachedSpaces[1];
+                        }
+                        break;
+                    case 12 /* SyntaxKind.LineCommentTrivia */:
+                        replaceContent = newLinesAndIndent();
+                        break;
+                    case 13 /* SyntaxKind.BlockCommentTrivia */:
+                        if (numberLineBreaks > 0) {
+                            replaceContent = newLinesAndIndent();
+                        }
+                        else if (!needsLineBreak) {
+                            replaceContent = string_intern_1.cachedSpaces[1];
+                        }
+                        break;
+                    case 6 /* SyntaxKind.ColonToken */:
+                        if (options.keepLines && numberLineBreaks > 0) {
+                            replaceContent = newLinesAndIndent();
+                        }
+                        else if (!needsLineBreak) {
+                            replaceContent = string_intern_1.cachedSpaces[1];
+                        }
+                        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 = string_intern_1.cachedSpaces[1];
+                            }
+                            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;
+    }
+    exports.format = format;
+    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 === string_intern_1.cachedSpaces[1]) {
+                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';
+    }
+    function isEOL(text, offset) {
+        return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+    }
+    exports.isEOL = isEOL;
+});