monaco-editor11 1.0.9 → 1.1.1

package/dist/workers/editor/common/treeSitterTree.js

@@ -1,395 +0,0 @@
-import { TaskQueue } from '../../../../../base/common/async.js';
-import { Disposable, toDisposable } from '../../../../../base/common/lifecycle.js';
-import '../../../../../base/common/observableInternal/index.js';
-import { setTimeout0 } from '../../../../../base/common/platform.js';
-import { ILogService } from '../../../../../platform/log/common/log.js';
-import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';
-import { TextLength } from '../../../core/text/textLength.js';
-import { gotoParent, getClosestPreviousNodes, nextSiblingOrParentSibling, gotoNthChild } from './cursorUtils.js';
-import { Range } from '../../../core/range.js';
-import { transaction } from '../../../../../base/common/observableInternal/transaction.js';
-import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
-
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-let TreeSitterTree = class TreeSitterTree extends Disposable {
-    constructor(languageId, _ranges, 
-    // readonly treeSitterLanguage: Language,
-    /** Must have the language set! */
-    _parser, _parserClass, 
-    // private readonly _injectionQuery: TreeSitter.Query,
-    textModel, _logService, _telemetryService) {
-        super();
-        this.languageId = languageId;
-        this._ranges = _ranges;
-        this._parser = _parser;
-        this._parserClass = _parserClass;
-        this.textModel = textModel;
-        this._logService = _logService;
-        this._telemetryService = _telemetryService;
-        this._tree = observableValue(this, undefined);
-        this.tree = this._tree;
-        this._treeLastParsedVersion = observableValue(this, -1);
-        this.treeLastParsedVersion = this._treeLastParsedVersion;
-        this._onDidChangeContentQueue = new TaskQueue();
-        this._tree = observableValue(this, undefined);
-        this.tree = this._tree;
-        this._register(toDisposable(() => {
-            this._tree.get()?.delete();
-            this._lastFullyParsed?.delete();
-            this._lastFullyParsedWithEdits?.delete();
-            this._parser.delete();
-        }));
-        this.handleContentChange(undefined, this._ranges);
-    }
-    handleContentChange(e, ranges) {
-        const version = this.textModel.getVersionId();
-        let newRanges = [];
-        if (ranges) {
-            newRanges = this._setRanges(ranges);
-        }
-        if (e) {
-            this._applyEdits(e.changes);
-        }
-        this._onDidChangeContentQueue.clearPending();
-        this._onDidChangeContentQueue.schedule(async () => {
-            if (this._store.isDisposed) {
-                // No need to continue the queue if we are disposed
-                return;
-            }
-            const oldTree = this._lastFullyParsed;
-            let changedNodes;
-            if (this._lastFullyParsedWithEdits && this._lastFullyParsed) {
-                changedNodes = this._findChangedNodes(this._lastFullyParsedWithEdits, this._lastFullyParsed);
-            }
-            const completed = await this._parseAndUpdateTree(version);
-            if (completed) {
-                let ranges;
-                if (!changedNodes) {
-                    if (this._ranges) {
-                        ranges = this._ranges.map(r => ({ newRange: new Range(r.startPosition.row + 1, r.startPosition.column + 1, r.endPosition.row + 1, r.endPosition.column + 1), oldRangeLength: r.endIndex - r.startIndex, newRangeStartOffset: r.startIndex, newRangeEndOffset: r.endIndex }));
-                    }
-                }
-                else if (oldTree && changedNodes) {
-                    ranges = this._findTreeChanges(completed, changedNodes, newRanges);
-                }
-                if (!ranges) {
-                    ranges = [{ newRange: this.textModel.getFullModelRange(), newRangeStartOffset: 0, newRangeEndOffset: this.textModel.getValueLength() }];
-                }
-                const previousTree = this._tree.get();
-                transaction(tx => {
-                    this._tree.set(completed, tx, { ranges, versionId: version });
-                    this._treeLastParsedVersion.set(version, tx);
-                });
-                previousTree?.delete();
-            }
-        });
-    }
-    _applyEdits(changes) {
-        for (const change of changes) {
-            const originalTextLength = TextLength.ofRange(Range.lift(change.range));
-            const newTextLength = TextLength.ofText(change.text);
-            const summedTextLengths = change.text.length === 0 ? newTextLength : originalTextLength.add(newTextLength);
-            const edit = {
-                startIndex: change.rangeOffset,
-                oldEndIndex: change.rangeOffset + change.rangeLength,
-                newEndIndex: change.rangeOffset + change.text.length,
-                startPosition: { row: change.range.startLineNumber - 1, column: change.range.startColumn - 1 },
-                oldEndPosition: { row: change.range.endLineNumber - 1, column: change.range.endColumn - 1 },
-                newEndPosition: { row: change.range.startLineNumber + summedTextLengths.lineCount - 1, column: summedTextLengths.lineCount ? summedTextLengths.columnCount : (change.range.endColumn + summedTextLengths.columnCount) }
-            };
-            this._tree.get()?.edit(edit);
-            this._lastFullyParsedWithEdits?.edit(edit);
-        }
-    }
-    _findChangedNodes(newTree, oldTree) {
-        if ((this._ranges && this._ranges.every(range => range.startPosition.row !== newTree.rootNode.startPosition.row)) || newTree.rootNode.startPosition.row !== 0) {
-            return [];
-        }
-        const newCursor = newTree.walk();
-        const oldCursor = oldTree.walk();
-        const nodes = [];
-        let next = true;
-        do {
-            if (newCursor.currentNode.hasChanges) {
-                // Check if only one of the children has changes.
-                // If it's only one, then we go to that child.
-                // If it's more then, we need to go to each child
-                // If it's none, then we've found one of our ranges
-                const newChildren = newCursor.currentNode.children;
-                const indexChangedChildren = [];
-                const changedChildren = newChildren.filter((c, index) => {
-                    if (c?.hasChanges || (oldCursor.currentNode.children.length <= index)) {
-                        indexChangedChildren.push(index);
-                        return true;
-                    }
-                    return false;
-                });
-                // If we have changes and we *had* an error, the whole node should be refreshed.
-                if ((changedChildren.length === 0) || (newCursor.currentNode.hasError !== oldCursor.currentNode.hasError)) {
-                    // walk up again until we get to the first one that's named as unnamed nodes can be too granular
-                    while (newCursor.currentNode.parent && next && !newCursor.currentNode.isNamed) {
-                        next = gotoParent(newCursor, oldCursor);
-                    }
-                    // Use the end position of the previous node and the start position of the current node
-                    const newNode = newCursor.currentNode;
-                    const closestPreviousNode = getClosestPreviousNodes(newCursor, newTree) ?? newNode;
-                    nodes.push({
-                        startIndex: closestPreviousNode.startIndex,
-                        endIndex: newNode.endIndex,
-                        startPosition: closestPreviousNode.startPosition,
-                        endPosition: newNode.endPosition
-                    });
-                    next = nextSiblingOrParentSibling(newCursor, oldCursor);
-                }
-                else if (changedChildren.length >= 1) {
-                    next = gotoNthChild(newCursor, oldCursor, indexChangedChildren[0]);
-                }
-            }
-            else {
-                next = nextSiblingOrParentSibling(newCursor, oldCursor);
-            }
-        } while (next);
-        newCursor.delete();
-        oldCursor.delete();
-        return nodes;
-    }
-    _findTreeChanges(newTree, changedNodes, newRanges) {
-        let newRangeIndex = 0;
-        const mergedChanges = [];
-        // Find the parent in the new tree of the changed node
-        for (let nodeIndex = 0; nodeIndex < changedNodes.length; nodeIndex++) {
-            const node = changedNodes[nodeIndex];
-            if (mergedChanges.length > 0) {
-                if ((node.startIndex >= mergedChanges[mergedChanges.length - 1].newRangeStartOffset) && (node.endIndex <= mergedChanges[mergedChanges.length - 1].newRangeEndOffset)) {
-                    // This node is within the previous range, skip it
-                    continue;
-                }
-            }
-            const cursor = newTree.walk();
-            const cursorContainersNode = () => cursor.startIndex < node.startIndex && cursor.endIndex > node.endIndex;
-            while (cursorContainersNode()) {
-                // See if we can go to a child
-                let child = cursor.gotoFirstChild();
-                let foundChild = false;
-                while (child) {
-                    if (cursorContainersNode() && cursor.currentNode.isNamed) {
-                        foundChild = true;
-                        break;
-                    }
-                    else {
-                        child = cursor.gotoNextSibling();
-                    }
-                }
-                if (!foundChild) {
-                    cursor.gotoParent();
-                    break;
-                }
-                if (cursor.currentNode.childCount === 0) {
-                    break;
-                }
-            }
-            const startPosition = cursor.currentNode.startPosition;
-            const endPosition = cursor.currentNode.endPosition;
-            const startIndex = cursor.currentNode.startIndex;
-            const endIndex = cursor.currentNode.endIndex;
-            const newChange = { newRange: new Range(startPosition.row + 1, startPosition.column + 1, endPosition.row + 1, endPosition.column + 1), newRangeStartOffset: startIndex, newRangeEndOffset: endIndex };
-            if ((newRangeIndex < newRanges.length) && rangesIntersect(newRanges[newRangeIndex], { startIndex, endIndex})) {
-                // combine the new change with the range
-                if (newRanges[newRangeIndex].startIndex < newChange.newRangeStartOffset) {
-                    newChange.newRange = newChange.newRange.setStartPosition(newRanges[newRangeIndex].startPosition.row + 1, newRanges[newRangeIndex].startPosition.column + 1);
-                    newChange.newRangeStartOffset = newRanges[newRangeIndex].startIndex;
-                }
-                if (newRanges[newRangeIndex].endIndex > newChange.newRangeEndOffset) {
-                    newChange.newRange = newChange.newRange.setEndPosition(newRanges[newRangeIndex].endPosition.row + 1, newRanges[newRangeIndex].endPosition.column + 1);
-                    newChange.newRangeEndOffset = newRanges[newRangeIndex].endIndex;
-                }
-                newRangeIndex++;
-            }
-            else if (newRangeIndex < newRanges.length && newRanges[newRangeIndex].endIndex < newChange.newRangeStartOffset) {
-                // add the full range to the merged changes
-                mergedChanges.push({
-                    newRange: new Range(newRanges[newRangeIndex].startPosition.row + 1, newRanges[newRangeIndex].startPosition.column + 1, newRanges[newRangeIndex].endPosition.row + 1, newRanges[newRangeIndex].endPosition.column + 1),
-                    newRangeStartOffset: newRanges[newRangeIndex].startIndex,
-                    newRangeEndOffset: newRanges[newRangeIndex].endIndex
-                });
-            }
-            if ((mergedChanges.length > 0) && (mergedChanges[mergedChanges.length - 1].newRangeEndOffset >= newChange.newRangeStartOffset)) {
-                // Merge the changes
-                mergedChanges[mergedChanges.length - 1].newRange = Range.fromPositions(mergedChanges[mergedChanges.length - 1].newRange.getStartPosition(), newChange.newRange.getEndPosition());
-                mergedChanges[mergedChanges.length - 1].newRangeEndOffset = newChange.newRangeEndOffset;
-            }
-            else {
-                mergedChanges.push(newChange);
-            }
-        }
-        return this._constrainRanges(mergedChanges);
-    }
-    _constrainRanges(changes) {
-        if (!this._ranges) {
-            return changes;
-        }
-        const constrainedChanges = [];
-        let changesIndex = 0;
-        let rangesIndex = 0;
-        while (changesIndex < changes.length && rangesIndex < this._ranges.length) {
-            const change = changes[changesIndex];
-            const range = this._ranges[rangesIndex];
-            if (change.newRangeEndOffset < range.startIndex) {
-                // Change is before the range, move to the next change
-                changesIndex++;
-            }
-            else if (change.newRangeStartOffset > range.endIndex) {
-                // Change is after the range, move to the next range
-                rangesIndex++;
-            }
-            else {
-                // Change is within the range, constrain it
-                const newRangeStartOffset = Math.max(change.newRangeStartOffset, range.startIndex);
-                const newRangeEndOffset = Math.min(change.newRangeEndOffset, range.endIndex);
-                const newRange = change.newRange.intersectRanges(new Range(range.startPosition.row + 1, range.startPosition.column + 1, range.endPosition.row + 1, range.endPosition.column + 1));
-                constrainedChanges.push({
-                    newRange,
-                    newRangeEndOffset,
-                    newRangeStartOffset
-                });
-                // Remove the intersected range from the current change
-                if (newRangeEndOffset < change.newRangeEndOffset) {
-                    change.newRange = Range.fromPositions(newRange.getEndPosition(), change.newRange.getEndPosition());
-                    change.newRangeStartOffset = newRangeEndOffset + 1;
-                }
-                else {
-                    // Move to the next change
-                    changesIndex++;
-                }
-            }
-        }
-        return constrainedChanges;
-    }
-    async _parseAndUpdateTree(version) {
-        const tree = await this._parse();
-        if (tree) {
-            this._lastFullyParsed?.delete();
-            this._lastFullyParsed = tree.copy();
-            this._lastFullyParsedWithEdits?.delete();
-            this._lastFullyParsedWithEdits = tree.copy();
-            return tree;
-        }
-        else if (!this._tree.get()) {
-            // No tree means this is the initial parse and there were edits
-            // parse function doesn't handle this well and we can end up with an incorrect tree, so we reset
-            this._parser.reset();
-        }
-        return undefined;
-    }
-    _parse() {
-        let parseType = "fullParse" /* TelemetryParseType.Full */;
-        if (this._tree.get()) {
-            parseType = "incrementalParse" /* TelemetryParseType.Incremental */;
-        }
-        return this._parseAndYield(parseType);
-    }
-    async _parseAndYield(parseType) {
-        let time = 0;
-        let passes = 0;
-        const inProgressVersion = this.textModel.getVersionId();
-        let newTree;
-        const progressCallback = newTimeOutProgressCallback();
-        do {
-            const timer = performance.now();
-            newTree = this._parser.parse((index, position) => this._parseCallback(index), this._tree.get(), { progressCallback, includedRanges: this._ranges });
-            time += performance.now() - timer;
-            passes++;
-            // So long as this isn't the initial parse, even if the model changes and edits are applied, the tree parsing will continue correctly after the await.
-            await new Promise(resolve => setTimeout0(resolve));
-        } while (!this._store.isDisposed && !newTree && inProgressVersion === this.textModel.getVersionId());
-        this._sendParseTimeTelemetry(parseType, time, passes);
-        return (newTree && (inProgressVersion === this.textModel.getVersionId())) ? newTree : undefined;
-    }
-    _parseCallback(index) {
-        try {
-            return this.textModel.getTextBuffer().getNearestChunk(index);
-        }
-        catch (e) {
-            this._logService.debug('Error getting chunk for tree-sitter parsing', e);
-        }
-        return undefined;
-    }
-    _setRanges(newRanges) {
-        const unKnownRanges = [];
-        // If we have existing ranges, find the parts of the new ranges that are not included in the existing ones
-        if (this._ranges) {
-            for (const newRange of newRanges) {
-                let isFullyIncluded = false;
-                for (let i = 0; i < this._ranges.length; i++) {
-                    const existingRange = this._ranges[i];
-                    if (rangesEqual(existingRange, newRange) || rangesIntersect(existingRange, newRange)) {
-                        isFullyIncluded = true;
-                        break;
-                    }
-                }
-                if (!isFullyIncluded) {
-                    unKnownRanges.push(newRange);
-                }
-            }
-        }
-        else {
-            // No existing ranges, all new ranges are unknown
-            unKnownRanges.push(...newRanges);
-        }
-        this._ranges = newRanges;
-        return unKnownRanges;
-    }
-    _sendParseTimeTelemetry(parseType, time, passes) {
-        this._logService.debug(`Tree parsing (${parseType}) took ${time} ms and ${passes} passes.`);
-        if (parseType === "fullParse" /* TelemetryParseType.Full */) {
-            this._telemetryService.publicLog2(`treeSitter.fullParse`, { languageId: this.languageId, time, passes });
-        }
-        else {
-            this._telemetryService.publicLog2(`treeSitter.incrementalParse`, { languageId: this.languageId, time, passes });
-        }
-    }
-    createParsedTreeSync(src) {
-        const parser = new this._parserClass();
-        parser.setLanguage(this._parser.language);
-        const tree = parser.parse(src);
-        parser.delete();
-        return tree ?? undefined;
-    }
-};
-TreeSitterTree = __decorate([
-    __param(5, ILogService),
-    __param(6, ITelemetryService)
-], TreeSitterTree);
-function newTimeOutProgressCallback() {
-    let lastYieldTime = performance.now();
-    return function parseProgressCallback(_state) {
-        const now = performance.now();
-        if (now - lastYieldTime > 50) {
-            lastYieldTime = now;
-            return true;
-        }
-        return false;
-    };
-}
-function rangesEqual(a, b) {
-    return (a.startPosition.row === b.startPosition.row)
-        && (a.startPosition.column === b.startPosition.column)
-        && (a.endPosition.row === b.endPosition.row)
-        && (a.endPosition.column === b.endPosition.column)
-        && (a.startIndex === b.startIndex)
-        && (a.endIndex === b.endIndex);
-}
-function rangesIntersect(a, b) {
-    return (a.startIndex <= b.startIndex && a.endIndex >= b.startIndex) ||
-        (b.startIndex <= a.startIndex && b.endIndex >= a.startIndex);
-}
-
-export { TreeSitterTree, rangesEqual, rangesIntersect };

package/dist/workers/editor/common/treeViewsDnd.js

@@ -1,24 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class TreeViewsDnDService {
-    constructor() {
-        this._dragOperations = new Map();
-    }
-    removeDragOperationTransfer(uuid) {
-        if ((uuid && this._dragOperations.has(uuid))) {
-            const operation = this._dragOperations.get(uuid);
-            this._dragOperations.delete(uuid);
-            return operation;
-        }
-        return undefined;
-    }
-}
-class DraggedTreeItemsIdentifier {
-    constructor(identifier) {
-        this.identifier = identifier;
-    }
-}
-
-export { DraggedTreeItemsIdentifier, TreeViewsDnDService };

package/dist/workers/editor/common/treeViewsDndService.js

@@ -1,12 +0,0 @@
-import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
-import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
-import { TreeViewsDnDService } from './treeViewsDnd.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const ITreeViewsDnDService = createDecorator('treeViewsDndService');
-registerSingleton(ITreeViewsDnDService, TreeViewsDnDService, 1 /* InstantiationType.Delayed */);
-
-export { ITreeViewsDnDService };

package/dist/workers/editor/common/trimTrailingWhitespaceCommand.js

@@ -1,98 +0,0 @@
-import { lastNonWhitespaceIndex } from '../../../base/common/strings.js';
-import { EditOperation } from '../core/editOperation.js';
-import { Range } from '../core/range.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class TrimTrailingWhitespaceCommand {
-    constructor(selection, cursors, trimInRegexesAndStrings) {
-        this._selection = selection;
-        this._cursors = cursors;
-        this._selectionId = null;
-        this._trimInRegexesAndStrings = trimInRegexesAndStrings;
-    }
-    getEditOperations(model, builder) {
-        const ops = trimTrailingWhitespace(model, this._cursors, this._trimInRegexesAndStrings);
-        for (let i = 0, len = ops.length; i < len; i++) {
-            const op = ops[i];
-            builder.addEditOperation(op.range, op.text);
-        }
-        this._selectionId = builder.trackSelection(this._selection);
-    }
-    computeCursorState(model, helper) {
-        return helper.getTrackedSelection(this._selectionId);
-    }
-}
-/**
- * Generate commands for trimming trailing whitespace on a model and ignore lines on which cursors are sitting.
- */
-function trimTrailingWhitespace(model, cursors, trimInRegexesAndStrings) {
-    // Sort cursors ascending
-    cursors.sort((a, b) => {
-        if (a.lineNumber === b.lineNumber) {
-            return a.column - b.column;
-        }
-        return a.lineNumber - b.lineNumber;
-    });
-    // Reduce multiple cursors on the same line and only keep the last one on the line
-    for (let i = cursors.length - 2; i >= 0; i--) {
-        if (cursors[i].lineNumber === cursors[i + 1].lineNumber) {
-            // Remove cursor at `i`
-            cursors.splice(i, 1);
-        }
-    }
-    const r = [];
-    let rLen = 0;
-    let cursorIndex = 0;
-    const cursorLen = cursors.length;
-    for (let lineNumber = 1, lineCount = model.getLineCount(); lineNumber <= lineCount; lineNumber++) {
-        const lineContent = model.getLineContent(lineNumber);
-        const maxLineColumn = lineContent.length + 1;
-        let minEditColumn = 0;
-        if (cursorIndex < cursorLen && cursors[cursorIndex].lineNumber === lineNumber) {
-            minEditColumn = cursors[cursorIndex].column;
-            cursorIndex++;
-            if (minEditColumn === maxLineColumn) {
-                // The cursor is at the end of the line => no edits for sure on this line
-                continue;
-            }
-        }
-        if (lineContent.length === 0) {
-            continue;
-        }
-        const lastNonWhitespaceIndex$1 = lastNonWhitespaceIndex(lineContent);
-        let fromColumn = 0;
-        if (lastNonWhitespaceIndex$1 === -1) {
-            // Entire line is whitespace
-            fromColumn = 1;
-        }
-        else if (lastNonWhitespaceIndex$1 !== lineContent.length - 1) {
-            // There is trailing whitespace
-            fromColumn = lastNonWhitespaceIndex$1 + 2;
-        }
-        else {
-            // There is no trailing whitespace
-            continue;
-        }
-        if (!trimInRegexesAndStrings) {
-            if (!model.tokenization.hasAccurateTokensForLine(lineNumber)) {
-                // We don't want to force line tokenization, as that can be expensive, but we also don't want to trim
-                // trailing whitespace in lines that are not tokenized yet, as that can be wrong and trim whitespace from
-                // lines that the user requested we don't. So we bail out if the tokens are not accurate for this line.
-                continue;
-            }
-            const lineTokens = model.tokenization.getLineTokens(lineNumber);
-            const fromColumnType = lineTokens.getStandardTokenType(lineTokens.findTokenIndexAtOffset(fromColumn));
-            if (fromColumnType === 2 /* StandardTokenType.String */ || fromColumnType === 3 /* StandardTokenType.RegEx */) {
-                continue;
-            }
-        }
-        fromColumn = Math.max(minEditColumn, fromColumn);
-        r[rLen++] = EditOperation.delete(new Range(lineNumber, fromColumn, lineNumber, maxLineColumn));
-    }
-    return r;
-}
-
-export { TrimTrailingWhitespaceCommand, trimTrailingWhitespace };