@codingame/monaco-vscode-api 1.76.2 → 1.76.3-next.0

package/dist/configuration2.js

@@ -0,0 +1,339 @@
+import { X as parseTree, Y as findNodeAtLocation, Z as createScanner } from './polyfill.js';
+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 lineBreak = false;
+    let indentLevel = 0;
+    let indentValue;
+    if (options.insertSpaces) {
+        indentValue = repeat(' ', options.tabSize || 4);
+    }
+    else {
+        indentValue = '\t';
+    }
+    const scanner = createScanner(formatText, false);
+    let hasError = false;
+    function newLineAndIndent() {
+        return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    function scanNext() {
+        let token = scanner.scan();
+        lineBreak = false;
+        while (token === 15  || token === 14 ) {
+            lineBreak = lineBreak || (token === 14 );
+            token = scanner.scan();
+        }
+        hasError = token === 16  || scanner.getTokenError() !== 0 ;
+        return token;
+    }
+    const editOperations = [];
+    function addEdit(text, startOffset, endOffset) {
+        if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
+            editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+        }
+    }
+    let firstToken = scanNext();
+    if (firstToken !== 17 ) {
+        const firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+        const initialIndent = repeat(indentValue, initialIndentLevel);
+        addEdit(initialIndent, formatTextStart, firstTokenStart);
+    }
+    while (firstToken !== 17 ) {
+        let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+        let secondToken = scanNext();
+        let replaceContent = '';
+        while (!lineBreak && (secondToken === 12  || secondToken === 13 )) {
+            const commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+            addEdit(' ', firstTokenEnd, commentTokenStart);
+            firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+            replaceContent = secondToken === 12  ? newLineAndIndent() : '';
+            secondToken = scanNext();
+        }
+        if (secondToken === 2 ) {
+            if (firstToken !== 1 ) {
+                indentLevel--;
+                replaceContent = newLineAndIndent();
+            }
+        }
+        else if (secondToken === 4 ) {
+            if (firstToken !== 3 ) {
+                indentLevel--;
+                replaceContent = newLineAndIndent();
+            }
+        }
+        else {
+            switch (firstToken) {
+                case 3 :
+                case 1 :
+                    indentLevel++;
+                    replaceContent = newLineAndIndent();
+                    break;
+                case 5 :
+                case 12 :
+                    replaceContent = newLineAndIndent();
+                    break;
+                case 13 :
+                    if (lineBreak) {
+                        replaceContent = newLineAndIndent();
+                    }
+                    else {
+                        replaceContent = ' ';
+                    }
+                    break;
+                case 6 :
+                    replaceContent = ' ';
+                    break;
+                case 10 :
+                    if (secondToken === 6 ) {
+                        replaceContent = '';
+                        break;
+                    }
+                case 7 :
+                case 8 :
+                case 9 :
+                case 11 :
+                case 2 :
+                case 4 :
+                    if (secondToken === 12  || secondToken === 13 ) {
+                        replaceContent = ' ';
+                    }
+                    else if (secondToken !== 5  && secondToken !== 17 ) {
+                        hasError = true;
+                    }
+                    break;
+                case 16 :
+                    hasError = true;
+                    break;
+            }
+            if (lineBreak && (secondToken === 12  || secondToken === 13 )) {
+                replaceContent = newLineAndIndent();
+            }
+        }
+        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) {
+        const 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';
+}
+function isEOL(text, offset) {
+    return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+}
+function setProperty(text, originalPath, value, formattingOptions, getInsertionIndex) {
+    const path = originalPath.slice();
+    const errors = [];
+    const root = parseTree(text, errors);
+    let parent = undefined;
+    let lastSegment = undefined;
+    while (path.length > 0) {
+        lastSegment = path.pop();
+        parent = findNodeAtLocation(root, path);
+        if (parent === undefined && value !== undefined) {
+            if (typeof lastSegment === 'string') {
+                value = { [lastSegment]: value };
+            }
+            else {
+                value = [value];
+            }
+        }
+        else {
+            break;
+        }
+    }
+    if (!parent) {
+        if (value === undefined) {
+            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) }, formattingOptions);
+    }
+    else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
+        const existing = findNodeAtLocation(parent, [lastSegment]);
+        if (existing !== undefined) {
+            if (value === undefined) {
+                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) {
+                    const previous = parent.children[propertyIndex - 1];
+                    removeBegin = previous.offset + previous.length;
+                }
+                else {
+                    removeBegin = parent.offset + 1;
+                    if (parent.children.length > 1) {
+                        const next = parent.children[1];
+                        removeEnd = next.offset;
+                    }
+                }
+                return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, formattingOptions);
+            }
+            else {
+                return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, formattingOptions);
+            }
+        }
+        else {
+            if (value === undefined) {
+                return [];
+            }
+            const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+            const index = getInsertionIndex ? getInsertionIndex(( parent.children.map(p => p.children[0].value))) : parent.children.length;
+            let edit;
+            if (index > 0) {
+                const 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, formattingOptions);
+        }
+    }
+    else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
+        if (value !== undefined) {
+            const newProperty = `${JSON.stringify(value)}`;
+            let edit;
+            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 === -1 || 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, formattingOptions);
+        }
+        else {
+            const removalIndex = lastSegment;
+            const toRemove = parent.children[removalIndex];
+            let edit;
+            if (parent.children.length === 1) {
+                edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
+            }
+            else if (parent.children.length - 1 === removalIndex) {
+                const previous = parent.children[removalIndex - 1];
+                const offset = previous.offset + previous.length;
+                const 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, formattingOptions);
+        }
+    }
+    else {
+        throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
+    }
+}
+function withFormatting(text, edit, formattingOptions) {
+    let newText = applyEdit(text, edit);
+    let begin = edit.offset;
+    let end = edit.offset + edit.content.length;
+    if (edit.length === 0 || edit.content.length === 0) {
+        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 }, formattingOptions);
+    for (let i = edits.length - 1; i >= 0; i--) {
+        const curr = edits[i];
+        newText = applyEdit(newText, curr);
+        begin = Math.min(begin, curr.offset);
+        end = Math.max(end, curr.offset + curr.length);
+        end += curr.content.length - curr.length;
+    }
+    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);
+}
+const FOLDER_CONFIG_FOLDER_NAME = '.vscode';
+const defaultSettingsSchemaId = 'vscode://schemas/settings/default';
+const userSettingsSchemaId = 'vscode://schemas/settings/user';
+const profileSettingsSchemaId = 'vscode://schemas/settings/profile';
+const machineSettingsSchemaId = 'vscode://schemas/settings/machine';
+const workspaceSettingsSchemaId = 'vscode://schemas/settings/workspace';
+const folderSettingsSchemaId = 'vscode://schemas/settings/folder';
+const launchSchemaId = 'vscode://schemas/launch';
+const TASKS_CONFIGURATION_KEY = 'tasks';
+const LAUNCH_CONFIGURATION_KEY = 'launch';
+const WORKSPACE_STANDALONE_CONFIGURATIONS = Object.create(null);
+WORKSPACE_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${FOLDER_CONFIG_FOLDER_NAME}/${TASKS_CONFIGURATION_KEY}.json`;
+WORKSPACE_STANDALONE_CONFIGURATIONS[LAUNCH_CONFIGURATION_KEY] = `${FOLDER_CONFIG_FOLDER_NAME}/${LAUNCH_CONFIGURATION_KEY}.json`;
+const USER_STANDALONE_CONFIGURATIONS = Object.create(null);
+USER_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY] = `${TASKS_CONFIGURATION_KEY}.json`;
+export { defaultSettingsSchemaId as d, folderSettingsSchemaId as f, launchSchemaId as l, machineSettingsSchemaId as m, profileSettingsSchemaId as p, setProperty as s, userSettingsSchemaId as u, workspaceSettingsSchemaId as w };