@codingame/monaco-vscode-api 1.83.8 → 1.83.9

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/lineRange.js

@@ -1,108 +0,0 @@
-import { compareBy, numberComparator } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-class LineRange {
-    static { this.compareByStart = compareBy(l => l.startLineNumber, numberComparator); }
-    static join(ranges) {
-        if (ranges.length === 0) {
-            return undefined;
-        }
-        let startLineNumber = Number.MAX_SAFE_INTEGER;
-        let endLineNumber = 0;
-        for (const range of ranges) {
-            startLineNumber = Math.min(startLineNumber, range.startLineNumber);
-            endLineNumber = Math.max(endLineNumber, range.startLineNumber + range.lineCount);
-        }
-        return ( new LineRange(startLineNumber, endLineNumber - startLineNumber));
-    }
-    static fromLineNumbers(startLineNumber, endExclusiveLineNumber) {
-        return ( new LineRange(startLineNumber, endExclusiveLineNumber - startLineNumber));
-    }
-    constructor(startLineNumber, lineCount) {
-        this.startLineNumber = startLineNumber;
-        this.lineCount = lineCount;
-        if (lineCount < 0) {
-            throw new BugIndicatingError();
-        }
-    }
-    join(other) {
-        return ( new LineRange(
-            Math.min(this.startLineNumber, other.startLineNumber),
-            Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive) - this.startLineNumber
-        ));
-    }
-    get endLineNumberExclusive() {
-        return this.startLineNumber + this.lineCount;
-    }
-    get isEmpty() {
-        return this.lineCount === 0;
-    }
-    touches(other) {
-        return (this.endLineNumberExclusive >= other.startLineNumber &&
-            other.endLineNumberExclusive >= this.startLineNumber);
-    }
-    isAfter(range) {
-        return this.startLineNumber >= range.endLineNumberExclusive;
-    }
-    isBefore(range) {
-        return range.startLineNumber >= this.endLineNumberExclusive;
-    }
-    delta(lineDelta) {
-        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount));
-    }
-    toString() {
-        return `[${this.startLineNumber},${this.endLineNumberExclusive})`;
-    }
-    equals(originalRange) {
-        return this.startLineNumber === originalRange.startLineNumber && this.lineCount === originalRange.lineCount;
-    }
-    contains(lineNumber) {
-        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;
-    }
-    deltaEnd(delta) {
-        return ( new LineRange(this.startLineNumber, this.lineCount + delta));
-    }
-    deltaStart(lineDelta) {
-        return ( new LineRange(this.startLineNumber + lineDelta, this.lineCount - lineDelta));
-    }
-    getLines(model) {
-        const result = ( new Array(this.lineCount));
-        for (let i = 0; i < this.lineCount; i++) {
-            result[i] = model.getLineContent(this.startLineNumber + i);
-        }
-        return result;
-    }
-    containsRange(range) {
-        return this.startLineNumber <= range.startLineNumber && range.endLineNumberExclusive <= this.endLineNumberExclusive;
-    }
-    toRange() {
-        return ( new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1));
-    }
-    toInclusiveRange() {
-        if (this.isEmpty) {
-            return undefined;
-        }
-        return ( new Range(
-            this.startLineNumber,
-            1,
-            this.endLineNumberExclusive - 1,
-            1073741824
-        ));
-    }
-    toInclusiveRangeOrEmpty() {
-        if (this.isEmpty) {
-            return ( new Range(this.startLineNumber, 1, this.startLineNumber, 1));
-        }
-        return ( new Range(
-            this.startLineNumber,
-            1,
-            this.endLineNumberExclusive - 1,
-            1073741824
-        ));
-    }
-    intersects(lineRange) {
-        return this.startLineNumber <= lineRange.endLineNumberExclusive
-            && lineRange.startLineNumber <= this.endLineNumberExclusive;
-    }
-}
-export { LineRange };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.js

@@ -1,258 +0,0 @@
-import { lastOrDefault, compareBy, numberComparator } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { findLast } from 'monaco-editor/esm/vs/base/common/arraysFind.js';
-import { assertFn, checkAdjacentItems } from 'monaco-editor/esm/vs/base/common/assert.js';
-import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { concatArrays } from '../utils.js';
-import { LineRangeEdit } from './editing.js';
-import { LineRange } from './lineRange.js';
-import { rangeIsBeforeOrTouching, rangeContainsPosition, lengthBetweenPositions, addLength } from './rangeUtils.js';
-class LineRangeMapping {
-    static join(mappings) {
-        return mappings.reduce((acc, cur) => acc ? acc.join(cur) : cur, undefined);
-    }
-    constructor(inputRange, outputRange) {
-        this.inputRange = inputRange;
-        this.outputRange = outputRange;
-    }
-    extendInputRange(extendedInputRange) {
-        if (!extendedInputRange.containsRange(this.inputRange)) {
-            throw new BugIndicatingError();
-        }
-        const startDelta = extendedInputRange.startLineNumber - this.inputRange.startLineNumber;
-        const endDelta = extendedInputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
-        return ( new LineRangeMapping(extendedInputRange, ( new LineRange(
-            this.outputRange.startLineNumber + startDelta,
-            this.outputRange.lineCount - startDelta + endDelta
-        ))));
-    }
-    join(other) {
-        return ( new LineRangeMapping(
-            this.inputRange.join(other.inputRange),
-            this.outputRange.join(other.outputRange)
-        ));
-    }
-    get resultingDeltaFromOriginalToModified() {
-        return this.outputRange.endLineNumberExclusive - this.inputRange.endLineNumberExclusive;
-    }
-    toString() {
-        return `${( this.inputRange.toString())} -> ${( this.outputRange.toString())}`;
-    }
-    addOutputLineDelta(delta) {
-        return ( new LineRangeMapping(this.inputRange, this.outputRange.delta(delta)));
-    }
-    addInputLineDelta(delta) {
-        return ( new LineRangeMapping(this.inputRange.delta(delta), this.outputRange));
-    }
-    reverse() {
-        return ( new LineRangeMapping(this.outputRange, this.inputRange));
-    }
-}
-class DocumentLineRangeMap {
-    static betweenOutputs(inputToOutput1, inputToOutput2, inputLineCount) {
-        const alignments = MappingAlignment.compute(inputToOutput1, inputToOutput2);
-        const mappings = ( alignments.map((m) => ( new LineRangeMapping(m.output1Range, m.output2Range))));
-        return ( new DocumentLineRangeMap(mappings, inputLineCount));
-    }
-    constructor(
-    lineRangeMappings, inputLineCount) {
-        this.lineRangeMappings = lineRangeMappings;
-        this.inputLineCount = inputLineCount;
-        assertFn(() => {
-            return checkAdjacentItems(lineRangeMappings, (m1, m2) => m1.inputRange.isBefore(m2.inputRange) && m1.outputRange.isBefore(m2.outputRange) &&
-                m2.inputRange.startLineNumber - m1.inputRange.endLineNumberExclusive === m2.outputRange.startLineNumber - m1.outputRange.endLineNumberExclusive);
-        });
-    }
-    project(lineNumber) {
-        const lastBefore = findLast(this.lineRangeMappings, r => r.inputRange.startLineNumber <= lineNumber);
-        if (!lastBefore) {
-            return ( new LineRangeMapping(( new LineRange(lineNumber, 1)), ( new LineRange(lineNumber, 1))));
-        }
-        if (lastBefore.inputRange.contains(lineNumber)) {
-            return lastBefore;
-        }
-        const containingRange = ( new LineRange(lineNumber, 1));
-        const mappedRange = ( new LineRange(lineNumber +
-            lastBefore.outputRange.endLineNumberExclusive -
-            lastBefore.inputRange.endLineNumberExclusive, 1));
-        return ( new LineRangeMapping(containingRange, mappedRange));
-    }
-    get outputLineCount() {
-        const last = lastOrDefault(this.lineRangeMappings);
-        const diff = last ? last.outputRange.endLineNumberExclusive - last.inputRange.endLineNumberExclusive : 0;
-        return this.inputLineCount + diff;
-    }
-    reverse() {
-        return ( new DocumentLineRangeMap(( this.lineRangeMappings.map(r => r.reverse())), this.outputLineCount));
-    }
-}
-class MappingAlignment {
-    static compute(fromInputToOutput1, fromInputToOutput2) {
-        const compareByStartLineNumber = compareBy((d) => d.inputRange.startLineNumber, numberComparator);
-        const combinedDiffs = concatArrays(( fromInputToOutput1.map((diff) => ({ source: 0, diff }))), ( fromInputToOutput2.map((diff) => ({ source: 1, diff })))).sort(compareBy((d) => d.diff, compareByStartLineNumber));
-        const currentDiffs = [( new Array()), ( new Array())];
-        const deltaFromBaseToInput = [0, 0];
-        const alignments = ( new Array());
-        function pushAndReset(inputRange) {
-            const mapping1 = LineRangeMapping.join(currentDiffs[0]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[0])));
-            const mapping2 = LineRangeMapping.join(currentDiffs[1]) || ( new LineRangeMapping(inputRange, inputRange.delta(deltaFromBaseToInput[1])));
-            alignments.push(( new MappingAlignment(
-                currentInputRange,
-                mapping1.extendInputRange(currentInputRange).outputRange,
-                currentDiffs[0],
-                mapping2.extendInputRange(currentInputRange).outputRange,
-                currentDiffs[1]
-            )));
-            currentDiffs[0] = [];
-            currentDiffs[1] = [];
-        }
-        let currentInputRange;
-        for (const diff of combinedDiffs) {
-            const range = diff.diff.inputRange;
-            if (currentInputRange && !currentInputRange.touches(range)) {
-                pushAndReset(currentInputRange);
-                currentInputRange = undefined;
-            }
-            deltaFromBaseToInput[diff.source] =
-                diff.diff.resultingDeltaFromOriginalToModified;
-            currentInputRange = currentInputRange ? currentInputRange.join(range) : range;
-            currentDiffs[diff.source].push(diff.diff);
-        }
-        if (currentInputRange) {
-            pushAndReset(currentInputRange);
-        }
-        return alignments;
-    }
-    constructor(inputRange, output1Range, output1LineMappings, output2Range, output2LineMappings) {
-        this.inputRange = inputRange;
-        this.output1Range = output1Range;
-        this.output1LineMappings = output1LineMappings;
-        this.output2Range = output2Range;
-        this.output2LineMappings = output2LineMappings;
-    }
-    toString() {
-        return `${this.output1Range} <- ${this.inputRange} -> ${this.output2Range}`;
-    }
-}
-class DetailedLineRangeMapping extends LineRangeMapping {
-    static join(mappings) {
-        return mappings.reduce((acc, cur) => acc ? acc.join(cur) : cur, undefined);
-    }
-    constructor(inputRange, inputTextModel, outputRange, outputTextModel, rangeMappings) {
-        super(inputRange, outputRange);
-        this.inputTextModel = inputTextModel;
-        this.outputTextModel = outputTextModel;
-        this.rangeMappings = rangeMappings || [( new RangeMapping(this.inputRange.toRange(), this.outputRange.toRange()))];
-    }
-    addOutputLineDelta(delta) {
-        return ( new DetailedLineRangeMapping(
-            this.inputRange,
-            this.inputTextModel,
-            this.outputRange.delta(delta),
-            this.outputTextModel,
-            ( this.rangeMappings.map(d => d.addOutputLineDelta(delta)))
-        ));
-    }
-    addInputLineDelta(delta) {
-        return ( new DetailedLineRangeMapping(
-            this.inputRange.delta(delta),
-            this.inputTextModel,
-            this.outputRange,
-            this.outputTextModel,
-            ( this.rangeMappings.map(d => d.addInputLineDelta(delta)))
-        ));
-    }
-    join(other) {
-        return ( new DetailedLineRangeMapping(
-            this.inputRange.join(other.inputRange),
-            this.inputTextModel,
-            this.outputRange.join(other.outputRange),
-            this.outputTextModel
-        ));
-    }
-    getLineEdit() {
-        return ( new LineRangeEdit(this.inputRange, this.getOutputLines()));
-    }
-    getReverseLineEdit() {
-        return ( new LineRangeEdit(this.outputRange, this.getInputLines()));
-    }
-    getOutputLines() {
-        return this.outputRange.getLines(this.outputTextModel);
-    }
-    getInputLines() {
-        return this.inputRange.getLines(this.inputTextModel);
-    }
-}
-class RangeMapping {
-    constructor(inputRange, outputRange) {
-        this.inputRange = inputRange;
-        this.outputRange = outputRange;
-    }
-    toString() {
-        function rangeToString(range) {
-            return `[${range.startLineNumber}:${range.startColumn}, ${range.endLineNumber}:${range.endColumn})`;
-        }
-        return `${rangeToString(this.inputRange)} -> ${rangeToString(this.outputRange)}`;
-    }
-    addOutputLineDelta(deltaLines) {
-        return ( new RangeMapping(this.inputRange, ( new Range(
-            this.outputRange.startLineNumber + deltaLines,
-            this.outputRange.startColumn,
-            this.outputRange.endLineNumber + deltaLines,
-            this.outputRange.endColumn
-        ))));
-    }
-    addInputLineDelta(deltaLines) {
-        return ( new RangeMapping(( new Range(
-            this.inputRange.startLineNumber + deltaLines,
-            this.inputRange.startColumn,
-            this.inputRange.endLineNumber + deltaLines,
-            this.inputRange.endColumn
-        )), this.outputRange));
-    }
-    reverse() {
-        return ( new RangeMapping(this.outputRange, this.inputRange));
-    }
-}
-class DocumentRangeMap {
-    constructor(
-    rangeMappings, inputLineCount) {
-        this.rangeMappings = rangeMappings;
-        this.inputLineCount = inputLineCount;
-        assertFn(() => checkAdjacentItems(rangeMappings, (m1, m2) => rangeIsBeforeOrTouching(m1.inputRange, m2.inputRange) &&
-            rangeIsBeforeOrTouching(m1.outputRange, m2.outputRange)
-));
-    }
-    project(position) {
-        const lastBefore = findLast(this.rangeMappings, r => r.inputRange.getStartPosition().isBeforeOrEqual(position));
-        if (!lastBefore) {
-            return ( new RangeMapping(
-                Range.fromPositions(position, position),
-                Range.fromPositions(position, position)
-            ));
-        }
-        if (rangeContainsPosition(lastBefore.inputRange, position)) {
-            return lastBefore;
-        }
-        const dist = lengthBetweenPositions(lastBefore.inputRange.getEndPosition(), position);
-        const outputPos = addLength(lastBefore.outputRange.getEndPosition(), dist);
-        return ( new RangeMapping(Range.fromPositions(position), Range.fromPositions(outputPos)));
-    }
-    projectRange(range) {
-        const start = this.project(range.getStartPosition());
-        const end = this.project(range.getEndPosition());
-        return ( new RangeMapping(
-            start.inputRange.plusRange(end.inputRange),
-            start.outputRange.plusRange(end.outputRange)
-        ));
-    }
-    get outputLineCount() {
-        const last = lastOrDefault(this.rangeMappings);
-        const diff = last ? last.outputRange.endLineNumber - last.inputRange.endLineNumber : 0;
-        return this.inputLineCount + diff;
-    }
-    reverse() {
-        return ( new DocumentRangeMap(( this.rangeMappings.map(m => m.reverse())), this.outputLineCount));
-    }
-}
-export { DetailedLineRangeMapping, DocumentLineRangeMap, DocumentRangeMap, LineRangeMapping, MappingAlignment, RangeMapping };