@specship/specship-win32-arm64 0.13.0 → 0.14.0

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

@@ -1,201 +0,0 @@
-(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/lib/node_modules/jsonc-parser/lib/umd/impl/format.js

@@ -1,275 +0,0 @@
-(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;
-});