@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/base/common/jsonEdit.js

@@ -0,0 +1,164 @@
+import { parseTree, findNodeAtLocation } from './json.js';
+import { isEOL, format } from './jsonFormatter.js';
+function removeProperty(text, path, formattingOptions) {
+    return setProperty(text, path, undefined, formattingOptions);
+}
+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);
+}
+function applyEdits(text, edits) {
+    const 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--) {
+        const e = sortedEdits[i];
+        if (e.offset + e.length <= lastModifiedOffset) {
+            text = applyEdit(text, e);
+        }
+        else {
+            throw new Error('Overlapping edit');
+        }
+        lastModifiedOffset = e.offset;
+    }
+    return text;
+}
+export { applyEdit, applyEdits, removeProperty, setProperty, withFormatting };

package/dist/vscode/vs/base/common/jsonFormatter.js

@@ -0,0 +1,187 @@
+import { createScanner } from './json.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;
+}
+export { format, getEOL, isEOL };

package/dist/vscode/vs/base/common/keybindingParser.js

@@ -0,0 +1,87 @@
+import { ScanCodeUtils, KeyCodeUtils } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { ScanCodeChord, KeyCodeChord, Keybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
+class KeybindingParser {
+    static _readModifiers(input) {
+        input = input.toLowerCase().trim();
+        let ctrl = false;
+        let shift = false;
+        let alt = false;
+        let meta = false;
+        let matchedModifier;
+        do {
+            matchedModifier = false;
+            if (/^ctrl(\+|\-)/.test(input)) {
+                ctrl = true;
+                input = input.substr('ctrl-'.length);
+                matchedModifier = true;
+            }
+            if (/^shift(\+|\-)/.test(input)) {
+                shift = true;
+                input = input.substr('shift-'.length);
+                matchedModifier = true;
+            }
+            if (/^alt(\+|\-)/.test(input)) {
+                alt = true;
+                input = input.substr('alt-'.length);
+                matchedModifier = true;
+            }
+            if (/^meta(\+|\-)/.test(input)) {
+                meta = true;
+                input = input.substr('meta-'.length);
+                matchedModifier = true;
+            }
+            if (/^win(\+|\-)/.test(input)) {
+                meta = true;
+                input = input.substr('win-'.length);
+                matchedModifier = true;
+            }
+            if (/^cmd(\+|\-)/.test(input)) {
+                meta = true;
+                input = input.substr('cmd-'.length);
+                matchedModifier = true;
+            }
+        } while (matchedModifier);
+        let key;
+        const firstSpaceIdx = input.indexOf(' ');
+        if (firstSpaceIdx > 0) {
+            key = input.substring(0, firstSpaceIdx);
+            input = input.substring(firstSpaceIdx);
+        }
+        else {
+            key = input;
+            input = '';
+        }
+        return {
+            remains: input,
+            ctrl,
+            shift,
+            alt,
+            meta,
+            key
+        };
+    }
+    static parseChord(input) {
+        const mods = this._readModifiers(input);
+        const scanCodeMatch = mods.key.match(/^\[([^\]]+)\]$/);
+        if (scanCodeMatch) {
+            const strScanCode = scanCodeMatch[1];
+            const scanCode = ScanCodeUtils.lowerCaseToEnum(strScanCode);
+            return [( new ScanCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, scanCode)), mods.remains];
+        }
+        const keyCode = KeyCodeUtils.fromUserSettings(mods.key);
+        return [( new KeyCodeChord(mods.ctrl, mods.shift, mods.alt, mods.meta, keyCode)), mods.remains];
+    }
+    static parseKeybinding(input) {
+        if (!input) {
+            return null;
+        }
+        const chords = [];
+        let chord;
+        while (input.length > 0) {
+            [chord, input] = this.parseChord(input);
+            chords.push(chord);
+        }
+        return (chords.length > 0 ? ( new Keybinding(chords)) : null);
+    }
+}
+export { KeybindingParser };

package/dist/vscode/vs/base/common/performance.js

@@ -0,0 +1,18 @@
+const mark = (name) => {
+	performance.mark(name);
+};
+const getMarks = () => {
+	let timeOrigin = performance.timeOrigin;
+	if (typeof timeOrigin !== 'number') {
+		timeOrigin = performance.timing.navigationStart || performance.timing.redirectStart || performance.timing.fetchStart;
+	}
+	const result = [{ name: 'code/timeOrigin', startTime: Math.round(timeOrigin) }];
+	for (const entry of performance.getEntriesByType('mark')) {
+		result.push({
+			name: entry.name,
+			startTime: Math.round(timeOrigin + entry.startTime)
+		});
+	}
+	return result;
+};
+export { getMarks, mark };

package/dist/vscode/vs/base/common/skipList.js

@@ -0,0 +1,160 @@
+var _a;
+class Node {
+    constructor(level, key, value) {
+        this.level = level;
+        this.key = key;
+        this.value = value;
+        this.forward = [];
+    }
+}
+const NIL = undefined;
+class SkipList {
+    constructor(comparator, capacity = 2 ** 16) {
+        this.comparator = comparator;
+        this[_a] = 'SkipList';
+        this._level = 0;
+        this._size = 0;
+        this._maxLevel = Math.max(1, Math.log2(capacity) | 0);
+        this._header = ( new Node(this._maxLevel, NIL, NIL));
+    }
+    get size() {
+        return this._size;
+    }
+    clear() {
+        this._header = ( new Node(this._maxLevel, NIL, NIL));
+    }
+    has(key) {
+        return Boolean(SkipList._search(this, key, this.comparator));
+    }
+    get(key) {
+        return SkipList._search(this, key, this.comparator)?.value;
+    }
+    set(key, value) {
+        if (SkipList._insert(this, key, value, this.comparator)) {
+            this._size += 1;
+        }
+        return this;
+    }
+    delete(key) {
+        const didDelete = SkipList._delete(this, key, this.comparator);
+        if (didDelete) {
+            this._size -= 1;
+        }
+        return didDelete;
+    }
+    forEach(callbackfn, thisArg) {
+        let node = this._header.forward[0];
+        while (node) {
+            callbackfn.call(thisArg, node.value, node.key, this);
+            node = node.forward[0];
+        }
+    }
+    [(_a = Symbol.toStringTag, Symbol.iterator)]() {
+        return this.entries();
+    }
+    *entries() {
+        let node = this._header.forward[0];
+        while (node) {
+            yield [node.key, node.value];
+            node = node.forward[0];
+        }
+    }
+    *keys() {
+        let node = this._header.forward[0];
+        while (node) {
+            yield node.key;
+            node = node.forward[0];
+        }
+    }
+    *values() {
+        let node = this._header.forward[0];
+        while (node) {
+            yield node.value;
+            node = node.forward[0];
+        }
+    }
+    toString() {
+        let result = '[SkipList]:';
+        let node = this._header.forward[0];
+        while (node) {
+            result += `node(${node.key}, ${node.value}, lvl:${node.level})`;
+            node = node.forward[0];
+        }
+        return result;
+    }
+    static _search(list, searchKey, comparator) {
+        let x = list._header;
+        for (let i = list._level - 1; i >= 0; i--) {
+            while (x.forward[i] && comparator(x.forward[i].key, searchKey) < 0) {
+                x = x.forward[i];
+            }
+        }
+        x = x.forward[0];
+        if (x && comparator(x.key, searchKey) === 0) {
+            return x;
+        }
+        return undefined;
+    }
+    static _insert(list, searchKey, value, comparator) {
+        const update = [];
+        let x = list._header;
+        for (let i = list._level - 1; i >= 0; i--) {
+            while (x.forward[i] && comparator(x.forward[i].key, searchKey) < 0) {
+                x = x.forward[i];
+            }
+            update[i] = x;
+        }
+        x = x.forward[0];
+        if (x && comparator(x.key, searchKey) === 0) {
+            x.value = value;
+            return false;
+        }
+        else {
+            const lvl = SkipList._randomLevel(list);
+            if (lvl > list._level) {
+                for (let i = list._level; i < lvl; i++) {
+                    update[i] = list._header;
+                }
+                list._level = lvl;
+            }
+            x = ( new Node(lvl, searchKey, value));
+            for (let i = 0; i < lvl; i++) {
+                x.forward[i] = update[i].forward[i];
+                update[i].forward[i] = x;
+            }
+            return true;
+        }
+    }
+    static _randomLevel(list, p = 0.5) {
+        let lvl = 1;
+        while (Math.random() < p && lvl < list._maxLevel) {
+            lvl += 1;
+        }
+        return lvl;
+    }
+    static _delete(list, searchKey, comparator) {
+        const update = [];
+        let x = list._header;
+        for (let i = list._level - 1; i >= 0; i--) {
+            while (x.forward[i] && comparator(x.forward[i].key, searchKey) < 0) {
+                x = x.forward[i];
+            }
+            update[i] = x;
+        }
+        x = x.forward[0];
+        if (!x || comparator(x.key, searchKey) !== 0) {
+            return false;
+        }
+        for (let i = 0; i < list._level; i++) {
+            if (update[i].forward[i] !== x) {
+                break;
+            }
+            update[i].forward[i] = x.forward[i];
+        }
+        while (list._level > 0 && list._header.forward[list._level - 1] === NIL) {
+            list._level -= 1;
+        }
+        return true;
+    }
+}
+export { SkipList };