monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,421 +0,0 @@
-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/editor/common/rangeMapping.js

@@ -1,229 +0,0 @@
-import { groupAdjacentBy } from '../../../base/common/arrays.js';
-import { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';
-import { BugIndicatingError } from '../../../base/common/errors.js';
-import { LineRange } from '../core/ranges/lineRange.js';
-import { Position } from '../core/position.js';
-import { Range } from '../core/range.js';
-import { TextReplacement } from '../core/edits/textEdit.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Maps a line range in the original text model to a line range in the modified text model.
- */
-class LineRangeMapping {
-    static inverse(mapping, originalLineCount, modifiedLineCount) {
-        const result = [];
-        let lastOriginalEndLineNumber = 1;
-        let lastModifiedEndLineNumber = 1;
-        for (const m of mapping) {
-            const r = new LineRangeMapping(new LineRange(lastOriginalEndLineNumber, m.original.startLineNumber), new LineRange(lastModifiedEndLineNumber, m.modified.startLineNumber));
-            if (!r.modified.isEmpty) {
-                result.push(r);
-            }
-            lastOriginalEndLineNumber = m.original.endLineNumberExclusive;
-            lastModifiedEndLineNumber = m.modified.endLineNumberExclusive;
-        }
-        const r = new LineRangeMapping(new LineRange(lastOriginalEndLineNumber, originalLineCount + 1), new LineRange(lastModifiedEndLineNumber, modifiedLineCount + 1));
-        if (!r.modified.isEmpty) {
-            result.push(r);
-        }
-        return result;
-    }
-    static clip(mapping, originalRange, modifiedRange) {
-        const result = [];
-        for (const m of mapping) {
-            const original = m.original.intersect(originalRange);
-            const modified = m.modified.intersect(modifiedRange);
-            if (original && !original.isEmpty && modified && !modified.isEmpty) {
-                result.push(new LineRangeMapping(original, modified));
-            }
-        }
-        return result;
-    }
-    constructor(originalRange, modifiedRange) {
-        this.original = originalRange;
-        this.modified = modifiedRange;
-    }
-    toString() {
-        return `{${this.original.toString()}->${this.modified.toString()}}`;
-    }
-    flip() {
-        return new LineRangeMapping(this.modified, this.original);
-    }
-    join(other) {
-        return new LineRangeMapping(this.original.join(other.original), this.modified.join(other.modified));
-    }
-    /**
-     * This method assumes that the LineRangeMapping describes a valid diff!
-     * I.e. if one range is empty, the other range cannot be the entire document.
-     * It avoids various problems when the line range points to non-existing line-numbers.
-    */
-    toRangeMapping() {
-        const origInclusiveRange = this.original.toInclusiveRange();
-        const modInclusiveRange = this.modified.toInclusiveRange();
-        if (origInclusiveRange && modInclusiveRange) {
-            return new RangeMapping(origInclusiveRange, modInclusiveRange);
-        }
-        else if (this.original.startLineNumber === 1 || this.modified.startLineNumber === 1) {
-            if (!(this.modified.startLineNumber === 1 && this.original.startLineNumber === 1)) {
-                // If one line range starts at 1, the other one must start at 1 as well.
-                throw new BugIndicatingError('not a valid diff');
-            }
-            // Because one range is empty and both ranges start at line 1, none of the ranges can cover all lines.
-            // Thus, `endLineNumberExclusive` is a valid line number.
-            return new RangeMapping(new Range(this.original.startLineNumber, 1, this.original.endLineNumberExclusive, 1), new Range(this.modified.startLineNumber, 1, this.modified.endLineNumberExclusive, 1));
-        }
-        else {
-            // We can assume here that both startLineNumbers are greater than 1.
-            return new RangeMapping(new Range(this.original.startLineNumber - 1, Number.MAX_SAFE_INTEGER, this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), new Range(this.modified.startLineNumber - 1, Number.MAX_SAFE_INTEGER, this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER));
-        }
-    }
-    /**
-     * This method assumes that the LineRangeMapping describes a valid diff!
-     * I.e. if one range is empty, the other range cannot be the entire document.
-     * It avoids various problems when the line range points to non-existing line-numbers.
-    */
-    toRangeMapping2(original, modified) {
-        if (isValidLineNumber(this.original.endLineNumberExclusive, original)
-            && isValidLineNumber(this.modified.endLineNumberExclusive, modified)) {
-            return new RangeMapping(new Range(this.original.startLineNumber, 1, this.original.endLineNumberExclusive, 1), new Range(this.modified.startLineNumber, 1, this.modified.endLineNumberExclusive, 1));
-        }
-        if (!this.original.isEmpty && !this.modified.isEmpty) {
-            return new RangeMapping(Range.fromPositions(new Position(this.original.startLineNumber, 1), normalizePosition(new Position(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), original)), Range.fromPositions(new Position(this.modified.startLineNumber, 1), normalizePosition(new Position(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), modified)));
-        }
-        if (this.original.startLineNumber > 1 && this.modified.startLineNumber > 1) {
-            return new RangeMapping(Range.fromPositions(normalizePosition(new Position(this.original.startLineNumber - 1, Number.MAX_SAFE_INTEGER), original), normalizePosition(new Position(this.original.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), original)), Range.fromPositions(normalizePosition(new Position(this.modified.startLineNumber - 1, Number.MAX_SAFE_INTEGER), modified), normalizePosition(new Position(this.modified.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER), modified)));
-        }
-        // Situation now: one range is empty and one range touches the last line and one range starts at line 1.
-        // I don't think this can happen.
-        throw new BugIndicatingError();
-    }
-}
-function normalizePosition(position, content) {
-    if (position.lineNumber < 1) {
-        return new Position(1, 1);
-    }
-    if (position.lineNumber > content.length) {
-        return new Position(content.length, content[content.length - 1].length + 1);
-    }
-    const line = content[position.lineNumber - 1];
-    if (position.column > line.length + 1) {
-        return new Position(position.lineNumber, line.length + 1);
-    }
-    return position;
-}
-function isValidLineNumber(lineNumber, lines) {
-    return lineNumber >= 1 && lineNumber <= lines.length;
-}
-/**
- * Maps a line range in the original text model to a line range in the modified text model.
- * Also contains inner range mappings.
- */
-class DetailedLineRangeMapping extends LineRangeMapping {
-    static fromRangeMappings(rangeMappings) {
-        const originalRange = LineRange.join(rangeMappings.map(r => LineRange.fromRangeInclusive(r.originalRange)));
-        const modifiedRange = LineRange.join(rangeMappings.map(r => LineRange.fromRangeInclusive(r.modifiedRange)));
-        return new DetailedLineRangeMapping(originalRange, modifiedRange, rangeMappings);
-    }
-    constructor(originalRange, modifiedRange, innerChanges) {
-        super(originalRange, modifiedRange);
-        this.innerChanges = innerChanges;
-    }
-    flip() {
-        return new DetailedLineRangeMapping(this.modified, this.original, this.innerChanges?.map(c => c.flip()));
-    }
-    withInnerChangesFromLineRanges() {
-        return new DetailedLineRangeMapping(this.original, this.modified, [this.toRangeMapping()]);
-    }
-}
-/**
- * Maps a range in the original text model to a range in the modified text model.
- */
-class RangeMapping {
-    static fromEdit(edit) {
-        const newRanges = edit.getNewRanges();
-        const result = edit.replacements.map((e, idx) => new RangeMapping(e.range, newRanges[idx]));
-        return result;
-    }
-    static assertSorted(rangeMappings) {
-        for (let i = 1; i < rangeMappings.length; i++) {
-            const previous = rangeMappings[i - 1];
-            const current = rangeMappings[i];
-            if (!(previous.originalRange.getEndPosition().isBeforeOrEqual(current.originalRange.getStartPosition())
-                && previous.modifiedRange.getEndPosition().isBeforeOrEqual(current.modifiedRange.getStartPosition()))) {
-                throw new BugIndicatingError('Range mappings must be sorted');
-            }
-        }
-    }
-    constructor(originalRange, modifiedRange) {
-        this.originalRange = originalRange;
-        this.modifiedRange = modifiedRange;
-    }
-    toString() {
-        return `{${this.originalRange.toString()}->${this.modifiedRange.toString()}}`;
-    }
-    flip() {
-        return new RangeMapping(this.modifiedRange, this.originalRange);
-    }
-    /**
-     * Creates a single text edit that describes the change from the original to the modified text.
-    */
-    toTextEdit(modified) {
-        const newText = modified.getValueOfRange(this.modifiedRange);
-        return new TextReplacement(this.originalRange, newText);
-    }
-}
-function lineRangeMappingFromRangeMappings(alignments, originalLines, modifiedLines, dontAssertStartLine = false) {
-    const changes = [];
-    for (const g of groupAdjacentBy(alignments.map(a => getLineRangeMapping(a, originalLines, modifiedLines)), (a1, a2) => a1.original.intersectsOrTouches(a2.original)
-        || a1.modified.intersectsOrTouches(a2.modified))) {
-        const first = g[0];
-        const last = g[g.length - 1];
-        changes.push(new DetailedLineRangeMapping(first.original.join(last.original), first.modified.join(last.modified), g.map(a => a.innerChanges[0])));
-    }
-    assertFn(() => {
-        if (!dontAssertStartLine && changes.length > 0) {
-            if (changes[0].modified.startLineNumber !== changes[0].original.startLineNumber) {
-                return false;
-            }
-            if (modifiedLines.length.lineCount - changes[changes.length - 1].modified.endLineNumberExclusive !== originalLines.length.lineCount - changes[changes.length - 1].original.endLineNumberExclusive) {
-                return false;
-            }
-        }
-        return checkAdjacentItems(changes, (m1, m2) => m2.original.startLineNumber - m1.original.endLineNumberExclusive === m2.modified.startLineNumber - m1.modified.endLineNumberExclusive &&
-            // There has to be an unchanged line in between (otherwise both diffs should have been joined)
-            m1.original.endLineNumberExclusive < m2.original.startLineNumber &&
-            m1.modified.endLineNumberExclusive < m2.modified.startLineNumber);
-    });
-    return changes;
-}
-function getLineRangeMapping(rangeMapping, originalLines, modifiedLines) {
-    let lineStartDelta = 0;
-    let lineEndDelta = 0;
-    // rangeMapping describes the edit that replaces `rangeMapping.originalRange` with `newText := getText(modifiedLines, rangeMapping.modifiedRange)`.
-    // original: ]xxx \n <- this line is not modified
-    // modified: ]xx  \n
-    if (rangeMapping.modifiedRange.endColumn === 1 && rangeMapping.originalRange.endColumn === 1
-        && rangeMapping.originalRange.startLineNumber + lineStartDelta <= rangeMapping.originalRange.endLineNumber
-        && rangeMapping.modifiedRange.startLineNumber + lineStartDelta <= rangeMapping.modifiedRange.endLineNumber) {
-        // We can only do this if the range is not empty yet
-        lineEndDelta = -1;
-    }
-    // original: xxx[ \n <- this line is not modified
-    // modified: xxx[ \n
-    if (rangeMapping.modifiedRange.startColumn - 1 >= modifiedLines.getLineLength(rangeMapping.modifiedRange.startLineNumber)
-        && rangeMapping.originalRange.startColumn - 1 >= originalLines.getLineLength(rangeMapping.originalRange.startLineNumber)
-        && rangeMapping.originalRange.startLineNumber <= rangeMapping.originalRange.endLineNumber + lineEndDelta
-        && rangeMapping.modifiedRange.startLineNumber <= rangeMapping.modifiedRange.endLineNumber + lineEndDelta) {
-        // We can only do this if the range is not empty yet
-        lineStartDelta = 1;
-    }
-    const originalLineRange = new LineRange(rangeMapping.originalRange.startLineNumber + lineStartDelta, rangeMapping.originalRange.endLineNumber + 1 + lineEndDelta);
-    const modifiedLineRange = new LineRange(rangeMapping.modifiedRange.startLineNumber + lineStartDelta, rangeMapping.modifiedRange.endLineNumber + 1 + lineEndDelta);
-    return new DetailedLineRangeMapping(originalLineRange, modifiedLineRange, [rangeMapping]);
-}
-
-export { DetailedLineRangeMapping, LineRangeMapping, RangeMapping, getLineRangeMapping, lineRangeMappingFromRangeMappings };

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

@@ -1,17 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Represents a column range in a single line.
-*/
-class RangeSingleLine {
-    constructor(
-    /** 1-based */
-    lineNumber, columnRange) {
-        this.lineNumber = lineNumber;
-        this.columnRange = columnRange;
-    }
-}
-
-export { RangeSingleLine };