monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/range.js

@@ -0,0 +1,421 @@
+import { Position } from './position.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)
+ */
+class Range {
+    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {
+        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {
+            this.startLineNumber = endLineNumber;
+            this.startColumn = endColumn;
+            this.endLineNumber = startLineNumber;
+            this.endColumn = startColumn;
+        }
+        else {
+            this.startLineNumber = startLineNumber;
+            this.startColumn = startColumn;
+            this.endLineNumber = endLineNumber;
+            this.endColumn = endColumn;
+        }
+    }
+    /**
+     * Test if this range is empty.
+     */
+    isEmpty() {
+        return Range.isEmpty(this);
+    }
+    /**
+     * Test if `range` is empty.
+     */
+    static isEmpty(range) {
+        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);
+    }
+    /**
+     * Test if position is in this range. If the position is at the edges, will return true.
+     */
+    containsPosition(position) {
+        return Range.containsPosition(this, position);
+    }
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return true.
+     */
+    static containsPosition(range, position) {
+        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {
+            return false;
+        }
+        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return false.
+     * @internal
+     */
+    static strictContainsPosition(range, position) {
+        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) {
+            return false;
+        }
+        if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Test if range is in this range. If the range is equal to this range, will return true.
+     */
+    containsRange(range) {
+        return Range.containsRange(this, range);
+    }
+    /**
+     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
+     */
+    static containsRange(range, otherRange) {
+        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {
+            return false;
+        }
+        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.
+     */
+    strictContainsRange(range) {
+        return Range.strictContainsRange(this, range);
+    }
+    /**
+     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.
+     */
+    static strictContainsRange(range, otherRange) {
+        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
+            return false;
+        }
+        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {
+            return false;
+        }
+        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    plusRange(range) {
+        return Range.plusRange(this, range);
+    }
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    static plusRange(a, b) {
+        let startLineNumber;
+        let startColumn;
+        let endLineNumber;
+        let endColumn;
+        if (b.startLineNumber < a.startLineNumber) {
+            startLineNumber = b.startLineNumber;
+            startColumn = b.startColumn;
+        }
+        else if (b.startLineNumber === a.startLineNumber) {
+            startLineNumber = b.startLineNumber;
+            startColumn = Math.min(b.startColumn, a.startColumn);
+        }
+        else {
+            startLineNumber = a.startLineNumber;
+            startColumn = a.startColumn;
+        }
+        if (b.endLineNumber > a.endLineNumber) {
+            endLineNumber = b.endLineNumber;
+            endColumn = b.endColumn;
+        }
+        else if (b.endLineNumber === a.endLineNumber) {
+            endLineNumber = b.endLineNumber;
+            endColumn = Math.max(b.endColumn, a.endColumn);
+        }
+        else {
+            endLineNumber = a.endLineNumber;
+            endColumn = a.endColumn;
+        }
+        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
+    }
+    /**
+     * A intersection of the two ranges.
+     */
+    intersectRanges(range) {
+        return Range.intersectRanges(this, range);
+    }
+    /**
+     * A intersection of the two ranges.
+     */
+    static intersectRanges(a, b) {
+        let resultStartLineNumber = a.startLineNumber;
+        let resultStartColumn = a.startColumn;
+        let resultEndLineNumber = a.endLineNumber;
+        let resultEndColumn = a.endColumn;
+        const otherStartLineNumber = b.startLineNumber;
+        const otherStartColumn = b.startColumn;
+        const otherEndLineNumber = b.endLineNumber;
+        const otherEndColumn = b.endColumn;
+        if (resultStartLineNumber < otherStartLineNumber) {
+            resultStartLineNumber = otherStartLineNumber;
+            resultStartColumn = otherStartColumn;
+        }
+        else if (resultStartLineNumber === otherStartLineNumber) {
+            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);
+        }
+        if (resultEndLineNumber > otherEndLineNumber) {
+            resultEndLineNumber = otherEndLineNumber;
+            resultEndColumn = otherEndColumn;
+        }
+        else if (resultEndLineNumber === otherEndLineNumber) {
+            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);
+        }
+        // Check if selection is now empty
+        if (resultStartLineNumber > resultEndLineNumber) {
+            return null;
+        }
+        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {
+            return null;
+        }
+        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);
+    }
+    /**
+     * Test if this range equals other.
+     */
+    equalsRange(other) {
+        return Range.equalsRange(this, other);
+    }
+    /**
+     * Test if range `a` equals `b`.
+     */
+    static equalsRange(a, b) {
+        if (!a && !b) {
+            return true;
+        }
+        return (!!a &&
+            !!b &&
+            a.startLineNumber === b.startLineNumber &&
+            a.startColumn === b.startColumn &&
+            a.endLineNumber === b.endLineNumber &&
+            a.endColumn === b.endColumn);
+    }
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    getEndPosition() {
+        return Range.getEndPosition(this);
+    }
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    static getEndPosition(range) {
+        return new Position(range.endLineNumber, range.endColumn);
+    }
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    getStartPosition() {
+        return Range.getStartPosition(this);
+    }
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    static getStartPosition(range) {
+        return new Position(range.startLineNumber, range.startColumn);
+    }
+    /**
+     * Transform to a user presentable string representation.
+     */
+    toString() {
+        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';
+    }
+    /**
+     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
+     */
+    setEndPosition(endLineNumber, endColumn) {
+        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);
+    }
+    /**
+     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
+     */
+    setStartPosition(startLineNumber, startColumn) {
+        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);
+    }
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    collapseToStart() {
+        return Range.collapseToStart(this);
+    }
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    static collapseToStart(range) {
+        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);
+    }
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    collapseToEnd() {
+        return Range.collapseToEnd(this);
+    }
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    static collapseToEnd(range) {
+        return new Range(range.endLineNumber, range.endColumn, range.endLineNumber, range.endColumn);
+    }
+    /**
+     * Moves the range by the given amount of lines.
+     */
+    delta(lineCount) {
+        return new Range(this.startLineNumber + lineCount, this.startColumn, this.endLineNumber + lineCount, this.endColumn);
+    }
+    isSingleLine() {
+        return this.startLineNumber === this.endLineNumber;
+    }
+    // ---
+    static fromPositions(start, end = start) {
+        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
+    }
+    static lift(range) {
+        if (!range) {
+            return null;
+        }
+        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);
+    }
+    /**
+     * Test if `obj` is an `IRange`.
+     */
+    static isIRange(obj) {
+        return (!!obj
+            && (typeof obj.startLineNumber === 'number')
+            && (typeof obj.startColumn === 'number')
+            && (typeof obj.endLineNumber === 'number')
+            && (typeof obj.endColumn === 'number'));
+    }
+    /**
+     * Test if the two ranges are touching in any way.
+     */
+    static areIntersectingOrTouching(a, b) {
+        // Check if `a` is before `b`
+        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {
+            return false;
+        }
+        // Check if `b` is before `a`
+        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {
+            return false;
+        }
+        // These ranges must intersect
+        return true;
+    }
+    /**
+     * Test if the two ranges are intersecting. If the ranges are touching it returns true.
+     */
+    static areIntersecting(a, b) {
+        // Check if `a` is before `b`
+        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {
+            return false;
+        }
+        // Check if `b` is before `a`
+        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {
+            return false;
+        }
+        // These ranges must intersect
+        return true;
+    }
+    /**
+     * Test if the two ranges are intersecting, but not touching at all.
+     */
+    static areOnlyIntersecting(a, b) {
+        // Check if `a` is before `b`
+        if (a.endLineNumber < (b.startLineNumber - 1) || (a.endLineNumber === b.startLineNumber && a.endColumn < (b.startColumn - 1))) {
+            return false;
+        }
+        // Check if `b` is before `a`
+        if (b.endLineNumber < (a.startLineNumber - 1) || (b.endLineNumber === a.startLineNumber && b.endColumn < (a.startColumn - 1))) {
+            return false;
+        }
+        // These ranges must intersect
+        return true;
+    }
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the startPosition and then on the endPosition
+     */
+    static compareRangesUsingStarts(a, b) {
+        if (a && b) {
+            const aStartLineNumber = a.startLineNumber | 0;
+            const bStartLineNumber = b.startLineNumber | 0;
+            if (aStartLineNumber === bStartLineNumber) {
+                const aStartColumn = a.startColumn | 0;
+                const bStartColumn = b.startColumn | 0;
+                if (aStartColumn === bStartColumn) {
+                    const aEndLineNumber = a.endLineNumber | 0;
+                    const bEndLineNumber = b.endLineNumber | 0;
+                    if (aEndLineNumber === bEndLineNumber) {
+                        const aEndColumn = a.endColumn | 0;
+                        const bEndColumn = b.endColumn | 0;
+                        return aEndColumn - bEndColumn;
+                    }
+                    return aEndLineNumber - bEndLineNumber;
+                }
+                return aStartColumn - bStartColumn;
+            }
+            return aStartLineNumber - bStartLineNumber;
+        }
+        const aExists = (a ? 1 : 0);
+        const bExists = (b ? 1 : 0);
+        return aExists - bExists;
+    }
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the endPosition and then on the startPosition
+     */
+    static compareRangesUsingEnds(a, b) {
+        if (a.endLineNumber === b.endLineNumber) {
+            if (a.endColumn === b.endColumn) {
+                if (a.startLineNumber === b.startLineNumber) {
+                    return a.startColumn - b.startColumn;
+                }
+                return a.startLineNumber - b.startLineNumber;
+            }
+            return a.endColumn - b.endColumn;
+        }
+        return a.endLineNumber - b.endLineNumber;
+    }
+    /**
+     * Test if the range spans multiple lines.
+     */
+    static spansMultipleLines(range) {
+        return range.endLineNumber > range.startLineNumber;
+    }
+    toJSON() {
+        return this;
+    }
+}
+
+export { Range };

package/dist/workers/rangeMap.js

@@ -0,0 +1,161 @@
+import { Range } from '../../../common/range.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Returns the intersection between a ranged group and a range.
+ * Returns `[]` if the intersection is empty.
+ */
+function groupIntersect(range, groups) {
+    const result = [];
+    for (const r of groups) {
+        if (range.start >= r.range.end) {
+            continue;
+        }
+        if (range.end < r.range.start) {
+            break;
+        }
+        const intersection = Range.intersect(range, r.range);
+        if (Range.isEmpty(intersection)) {
+            continue;
+        }
+        result.push({
+            range: intersection,
+            size: r.size
+        });
+    }
+    return result;
+}
+/**
+ * Shifts a range by that `much`.
+ */
+function shift({ start, end }, much) {
+    return { start: start + much, end: end + much };
+}
+/**
+ * Consolidates a collection of ranged groups.
+ *
+ * Consolidation is the process of merging consecutive ranged groups
+ * that share the same `size`.
+ */
+function consolidate(groups) {
+    const result = [];
+    let previousGroup = null;
+    for (const group of groups) {
+        const start = group.range.start;
+        const end = group.range.end;
+        const size = group.size;
+        if (previousGroup && size === previousGroup.size) {
+            previousGroup.range.end = end;
+            continue;
+        }
+        previousGroup = { range: { start, end }, size };
+        result.push(previousGroup);
+    }
+    return result;
+}
+/**
+ * Concatenates several collections of ranged groups into a single
+ * collection.
+ */
+function concat(...groups) {
+    return consolidate(groups.reduce((r, g) => r.concat(g), []));
+}
+class RangeMap {
+    get paddingTop() {
+        return this._paddingTop;
+    }
+    set paddingTop(paddingTop) {
+        this._size = this._size + paddingTop - this._paddingTop;
+        this._paddingTop = paddingTop;
+    }
+    constructor(topPadding) {
+        this.groups = [];
+        this._size = 0;
+        this._paddingTop = 0;
+        this._paddingTop = topPadding ?? 0;
+        this._size = this._paddingTop;
+    }
+    splice(index, deleteCount, items = []) {
+        const diff = items.length - deleteCount;
+        const before = groupIntersect({ start: 0, end: index }, this.groups);
+        const after = groupIntersect({ start: index + deleteCount, end: Number.POSITIVE_INFINITY }, this.groups)
+            .map(g => ({ range: shift(g.range, diff), size: g.size }));
+        const middle = items.map((item, i) => ({
+            range: { start: index + i, end: index + i + 1 },
+            size: item.size
+        }));
+        this.groups = concat(before, middle, after);
+        this._size = this._paddingTop + this.groups.reduce((t, g) => t + (g.size * (g.range.end - g.range.start)), 0);
+    }
+    /**
+     * Returns the number of items in the range map.
+     */
+    get count() {
+        const len = this.groups.length;
+        if (!len) {
+            return 0;
+        }
+        return this.groups[len - 1].range.end;
+    }
+    /**
+     * Returns the sum of the sizes of all items in the range map.
+     */
+    get size() {
+        return this._size;
+    }
+    /**
+     * Returns the index of the item at the given position.
+     */
+    indexAt(position) {
+        if (position < 0) {
+            return -1;
+        }
+        if (position < this._paddingTop) {
+            return 0;
+        }
+        let index = 0;
+        let size = this._paddingTop;
+        for (const group of this.groups) {
+            const count = group.range.end - group.range.start;
+            const newSize = size + (count * group.size);
+            if (position < newSize) {
+                return index + Math.floor((position - size) / group.size);
+            }
+            index += count;
+            size = newSize;
+        }
+        return index;
+    }
+    /**
+     * Returns the index of the item right after the item at the
+     * index of the given position.
+     */
+    indexAfter(position) {
+        return Math.min(this.indexAt(position) + 1, this.count);
+    }
+    /**
+     * Returns the start position of the item at the given index.
+     */
+    positionAt(index) {
+        if (index < 0) {
+            return -1;
+        }
+        let position = 0;
+        let count = 0;
+        for (const group of this.groups) {
+            const groupCount = group.range.end - group.range.start;
+            const newCount = count + groupCount;
+            if (index < newCount) {
+                return this._paddingTop + position + ((index - count) * group.size);
+            }
+            position += groupCount * group.size;
+            count = newCount;
+        }
+        return -1;
+    }
+}
+
+export { RangeMap, consolidate, groupIntersect, shift };