monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,938 +0,0 @@
-import { ArrayQueue } from '../../../base/common/arrays.js';
-import { Position } from '../core/position.js';
-import { Range } from '../core/range.js';
-import { IndentGuide, IndentGuideHorizontalLine } from '../textModelGuides.js';
-import { ModelDecorationOptions } from '../model/textModel.js';
-import { LineInjectedText } from '../textModelEvents.js';
-import { ViewLinesDeletedEvent, ViewLinesInsertedEvent, ViewLinesChangedEvent } from '../viewEvents.js';
-import { createModelLineProjection } from './modelLineProjection.js';
-import { ConstantTimePrefixSumComputer } from '../model/prefixSumComputer.js';
-import { ViewLineData } from '../viewModel.js';
-import { IdentityCoordinatesConverter } from '../coordinatesConverter.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class ViewModelLinesFromProjectedModel {
-    constructor(editorId, model, domLineBreaksComputerFactory, monospaceLineBreaksComputerFactory, fontInfo, tabSize, wrappingStrategy, wrappingColumn, wrappingIndent, wordBreak, wrapOnEscapedLineFeeds) {
-        this._editorId = editorId;
-        this.model = model;
-        this._validModelVersionId = -1;
-        this._domLineBreaksComputerFactory = domLineBreaksComputerFactory;
-        this._monospaceLineBreaksComputerFactory = monospaceLineBreaksComputerFactory;
-        this.fontInfo = fontInfo;
-        this.tabSize = tabSize;
-        this.wrappingStrategy = wrappingStrategy;
-        this.wrappingColumn = wrappingColumn;
-        this.wrappingIndent = wrappingIndent;
-        this.wordBreak = wordBreak;
-        this.wrapOnEscapedLineFeeds = wrapOnEscapedLineFeeds;
-        this._constructLines(/*resetHiddenAreas*/ true, null);
-    }
-    dispose() {
-        this.hiddenAreasDecorationIds = this.model.deltaDecorations(this.hiddenAreasDecorationIds, []);
-    }
-    createCoordinatesConverter() {
-        return new CoordinatesConverter(this);
-    }
-    _constructLines(resetHiddenAreas, previousLineBreaks) {
-        this.modelLineProjections = [];
-        if (resetHiddenAreas) {
-            this.hiddenAreasDecorationIds = this.model.deltaDecorations(this.hiddenAreasDecorationIds, []);
-        }
-        const linesContent = this.model.getLinesContent();
-        const injectedTextDecorations = this.model.getInjectedTextDecorations(this._editorId);
-        const lineCount = linesContent.length;
-        const lineBreaksComputer = this.createLineBreaksComputer();
-        const injectedTextQueue = new ArrayQueue(LineInjectedText.fromDecorations(injectedTextDecorations));
-        for (let i = 0; i < lineCount; i++) {
-            const lineInjectedText = injectedTextQueue.takeWhile(t => t.lineNumber === i + 1);
-            lineBreaksComputer.addRequest(linesContent[i], lineInjectedText, previousLineBreaks ? previousLineBreaks[i] : null);
-        }
-        const linesBreaks = lineBreaksComputer.finalize();
-        const values = [];
-        const hiddenAreas = this.hiddenAreasDecorationIds.map((areaId) => this.model.getDecorationRange(areaId)).sort(Range.compareRangesUsingStarts);
-        let hiddenAreaStart = 1, hiddenAreaEnd = 0;
-        let hiddenAreaIdx = -1;
-        let nextLineNumberToUpdateHiddenArea = (hiddenAreaIdx + 1 < hiddenAreas.length) ? hiddenAreaEnd + 1 : lineCount + 2;
-        for (let i = 0; i < lineCount; i++) {
-            const lineNumber = i + 1;
-            if (lineNumber === nextLineNumberToUpdateHiddenArea) {
-                hiddenAreaIdx++;
-                hiddenAreaStart = hiddenAreas[hiddenAreaIdx].startLineNumber;
-                hiddenAreaEnd = hiddenAreas[hiddenAreaIdx].endLineNumber;
-                nextLineNumberToUpdateHiddenArea = (hiddenAreaIdx + 1 < hiddenAreas.length) ? hiddenAreaEnd + 1 : lineCount + 2;
-            }
-            const isInHiddenArea = (lineNumber >= hiddenAreaStart && lineNumber <= hiddenAreaEnd);
-            const line = createModelLineProjection(linesBreaks[i], !isInHiddenArea);
-            values[i] = line.getViewLineCount();
-            this.modelLineProjections[i] = line;
-        }
-        this._validModelVersionId = this.model.getVersionId();
-        this.projectedModelLineLineCounts = new ConstantTimePrefixSumComputer(values);
-    }
-    getHiddenAreas() {
-        return this.hiddenAreasDecorationIds.map((decId) => this.model.getDecorationRange(decId));
-    }
-    setHiddenAreas(_ranges) {
-        const validatedRanges = _ranges.map(r => this.model.validateRange(r));
-        const newRanges = normalizeLineRanges(validatedRanges);
-        // TODO@Martin: Please stop calling this method on each model change!
-        // This checks if there really was a change
-        const oldRanges = this.hiddenAreasDecorationIds.map((areaId) => this.model.getDecorationRange(areaId)).sort(Range.compareRangesUsingStarts);
-        if (newRanges.length === oldRanges.length) {
-            let hasDifference = false;
-            for (let i = 0; i < newRanges.length; i++) {
-                if (!newRanges[i].equalsRange(oldRanges[i])) {
-                    hasDifference = true;
-                    break;
-                }
-            }
-            if (!hasDifference) {
-                return false;
-            }
-        }
-        const newDecorations = newRanges.map((r) => ({
-            range: r,
-            options: ModelDecorationOptions.EMPTY,
-        }));
-        this.hiddenAreasDecorationIds = this.model.deltaDecorations(this.hiddenAreasDecorationIds, newDecorations);
-        const hiddenAreas = newRanges;
-        let hiddenAreaStart = 1, hiddenAreaEnd = 0;
-        let hiddenAreaIdx = -1;
-        let nextLineNumberToUpdateHiddenArea = (hiddenAreaIdx + 1 < hiddenAreas.length) ? hiddenAreaEnd + 1 : this.modelLineProjections.length + 2;
-        let hasVisibleLine = false;
-        for (let i = 0; i < this.modelLineProjections.length; i++) {
-            const lineNumber = i + 1;
-            if (lineNumber === nextLineNumberToUpdateHiddenArea) {
-                hiddenAreaIdx++;
-                hiddenAreaStart = hiddenAreas[hiddenAreaIdx].startLineNumber;
-                hiddenAreaEnd = hiddenAreas[hiddenAreaIdx].endLineNumber;
-                nextLineNumberToUpdateHiddenArea = (hiddenAreaIdx + 1 < hiddenAreas.length) ? hiddenAreaEnd + 1 : this.modelLineProjections.length + 2;
-            }
-            let lineChanged = false;
-            if (lineNumber >= hiddenAreaStart && lineNumber <= hiddenAreaEnd) {
-                // Line should be hidden
-                if (this.modelLineProjections[i].isVisible()) {
-                    this.modelLineProjections[i] = this.modelLineProjections[i].setVisible(false);
-                    lineChanged = true;
-                }
-            }
-            else {
-                hasVisibleLine = true;
-                // Line should be visible
-                if (!this.modelLineProjections[i].isVisible()) {
-                    this.modelLineProjections[i] = this.modelLineProjections[i].setVisible(true);
-                    lineChanged = true;
-                }
-            }
-            if (lineChanged) {
-                const newOutputLineCount = this.modelLineProjections[i].getViewLineCount();
-                this.projectedModelLineLineCounts.setValue(i, newOutputLineCount);
-            }
-        }
-        if (!hasVisibleLine) {
-            // Cannot have everything be hidden => reveal everything!
-            this.setHiddenAreas([]);
-        }
-        return true;
-    }
-    modelPositionIsVisible(modelLineNumber, _modelColumn) {
-        if (modelLineNumber < 1 || modelLineNumber > this.modelLineProjections.length) {
-            // invalid arguments
-            return false;
-        }
-        return this.modelLineProjections[modelLineNumber - 1].isVisible();
-    }
-    getModelLineViewLineCount(modelLineNumber) {
-        if (modelLineNumber < 1 || modelLineNumber > this.modelLineProjections.length) {
-            // invalid arguments
-            return 1;
-        }
-        return this.modelLineProjections[modelLineNumber - 1].getViewLineCount();
-    }
-    setTabSize(newTabSize) {
-        if (this.tabSize === newTabSize) {
-            return false;
-        }
-        this.tabSize = newTabSize;
-        this._constructLines(/*resetHiddenAreas*/ false, null);
-        return true;
-    }
-    setWrappingSettings(fontInfo, wrappingStrategy, wrappingColumn, wrappingIndent, wordBreak) {
-        const equalFontInfo = this.fontInfo.equals(fontInfo);
-        const equalWrappingStrategy = (this.wrappingStrategy === wrappingStrategy);
-        const equalWrappingColumn = (this.wrappingColumn === wrappingColumn);
-        const equalWrappingIndent = (this.wrappingIndent === wrappingIndent);
-        const equalWordBreak = (this.wordBreak === wordBreak);
-        if (equalFontInfo && equalWrappingStrategy && equalWrappingColumn && equalWrappingIndent && equalWordBreak) {
-            return false;
-        }
-        const onlyWrappingColumnChanged = (equalFontInfo && equalWrappingStrategy && !equalWrappingColumn && equalWrappingIndent && equalWordBreak);
-        this.fontInfo = fontInfo;
-        this.wrappingStrategy = wrappingStrategy;
-        this.wrappingColumn = wrappingColumn;
-        this.wrappingIndent = wrappingIndent;
-        this.wordBreak = wordBreak;
-        let previousLineBreaks = null;
-        if (onlyWrappingColumnChanged) {
-            previousLineBreaks = [];
-            for (let i = 0, len = this.modelLineProjections.length; i < len; i++) {
-                previousLineBreaks[i] = this.modelLineProjections[i].getProjectionData();
-            }
-        }
-        this._constructLines(/*resetHiddenAreas*/ false, previousLineBreaks);
-        return true;
-    }
-    createLineBreaksComputer() {
-        const lineBreaksComputerFactory = (this.wrappingStrategy === 'advanced'
-            ? this._domLineBreaksComputerFactory
-            : this._monospaceLineBreaksComputerFactory);
-        return lineBreaksComputerFactory.createLineBreaksComputer(this.fontInfo, this.tabSize, this.wrappingColumn, this.wrappingIndent, this.wordBreak, this.wrapOnEscapedLineFeeds);
-    }
-    onModelFlushed() {
-        this._constructLines(/*resetHiddenAreas*/ true, null);
-    }
-    onModelLinesDeleted(versionId, fromLineNumber, toLineNumber) {
-        if (!versionId || versionId <= this._validModelVersionId) {
-            // Here we check for versionId in case the lines were reconstructed in the meantime.
-            // We don't want to apply stale change events on top of a newer read model state.
-            return null;
-        }
-        const outputFromLineNumber = (fromLineNumber === 1 ? 1 : this.projectedModelLineLineCounts.getPrefixSum(fromLineNumber - 1) + 1);
-        const outputToLineNumber = this.projectedModelLineLineCounts.getPrefixSum(toLineNumber);
-        this.modelLineProjections.splice(fromLineNumber - 1, toLineNumber - fromLineNumber + 1);
-        this.projectedModelLineLineCounts.removeValues(fromLineNumber - 1, toLineNumber - fromLineNumber + 1);
-        return new ViewLinesDeletedEvent(outputFromLineNumber, outputToLineNumber);
-    }
-    onModelLinesInserted(versionId, fromLineNumber, _toLineNumber, lineBreaks) {
-        if (!versionId || versionId <= this._validModelVersionId) {
-            // Here we check for versionId in case the lines were reconstructed in the meantime.
-            // We don't want to apply stale change events on top of a newer read model state.
-            return null;
-        }
-        // cannot use this.getHiddenAreas() because those decorations have already seen the effect of this model change
-        const isInHiddenArea = (fromLineNumber > 2 && !this.modelLineProjections[fromLineNumber - 2].isVisible());
-        const outputFromLineNumber = (fromLineNumber === 1 ? 1 : this.projectedModelLineLineCounts.getPrefixSum(fromLineNumber - 1) + 1);
-        let totalOutputLineCount = 0;
-        const insertLines = [];
-        const insertPrefixSumValues = [];
-        for (let i = 0, len = lineBreaks.length; i < len; i++) {
-            const line = createModelLineProjection(lineBreaks[i], !isInHiddenArea);
-            insertLines.push(line);
-            const outputLineCount = line.getViewLineCount();
-            totalOutputLineCount += outputLineCount;
-            insertPrefixSumValues[i] = outputLineCount;
-        }
-        // TODO@Alex: use arrays.arrayInsert
-        this.modelLineProjections =
-            this.modelLineProjections.slice(0, fromLineNumber - 1)
-                .concat(insertLines)
-                .concat(this.modelLineProjections.slice(fromLineNumber - 1));
-        this.projectedModelLineLineCounts.insertValues(fromLineNumber - 1, insertPrefixSumValues);
-        return new ViewLinesInsertedEvent(outputFromLineNumber, outputFromLineNumber + totalOutputLineCount - 1);
-    }
-    onModelLineChanged(versionId, lineNumber, lineBreakData) {
-        if (versionId !== null && versionId <= this._validModelVersionId) {
-            // Here we check for versionId in case the lines were reconstructed in the meantime.
-            // We don't want to apply stale change events on top of a newer read model state.
-            return [false, null, null, null];
-        }
-        const lineIndex = lineNumber - 1;
-        const oldOutputLineCount = this.modelLineProjections[lineIndex].getViewLineCount();
-        const isVisible = this.modelLineProjections[lineIndex].isVisible();
-        const line = createModelLineProjection(lineBreakData, isVisible);
-        this.modelLineProjections[lineIndex] = line;
-        const newOutputLineCount = this.modelLineProjections[lineIndex].getViewLineCount();
-        let lineMappingChanged = false;
-        let changeFrom = 0;
-        let changeTo = -1;
-        let insertFrom = 0;
-        let insertTo = -1;
-        let deleteFrom = 0;
-        let deleteTo = -1;
-        if (oldOutputLineCount > newOutputLineCount) {
-            changeFrom = this.projectedModelLineLineCounts.getPrefixSum(lineNumber - 1) + 1;
-            changeTo = changeFrom + newOutputLineCount - 1;
-            deleteFrom = changeTo + 1;
-            deleteTo = deleteFrom + (oldOutputLineCount - newOutputLineCount) - 1;
-            lineMappingChanged = true;
-        }
-        else if (oldOutputLineCount < newOutputLineCount) {
-            changeFrom = this.projectedModelLineLineCounts.getPrefixSum(lineNumber - 1) + 1;
-            changeTo = changeFrom + oldOutputLineCount - 1;
-            insertFrom = changeTo + 1;
-            insertTo = insertFrom + (newOutputLineCount - oldOutputLineCount) - 1;
-            lineMappingChanged = true;
-        }
-        else {
-            changeFrom = this.projectedModelLineLineCounts.getPrefixSum(lineNumber - 1) + 1;
-            changeTo = changeFrom + newOutputLineCount - 1;
-        }
-        this.projectedModelLineLineCounts.setValue(lineIndex, newOutputLineCount);
-        const viewLinesChangedEvent = (changeFrom <= changeTo ? new ViewLinesChangedEvent(changeFrom, changeTo - changeFrom + 1) : null);
-        const viewLinesInsertedEvent = (insertFrom <= insertTo ? new ViewLinesInsertedEvent(insertFrom, insertTo) : null);
-        const viewLinesDeletedEvent = (deleteFrom <= deleteTo ? new ViewLinesDeletedEvent(deleteFrom, deleteTo) : null);
-        return [lineMappingChanged, viewLinesChangedEvent, viewLinesInsertedEvent, viewLinesDeletedEvent];
-    }
-    acceptVersionId(versionId) {
-        this._validModelVersionId = versionId;
-        if (this.modelLineProjections.length === 1 && !this.modelLineProjections[0].isVisible()) {
-            // At least one line must be visible => reset hidden areas
-            this.setHiddenAreas([]);
-        }
-    }
-    getViewLineCount() {
-        return this.projectedModelLineLineCounts.getTotalSum();
-    }
-    _toValidViewLineNumber(viewLineNumber) {
-        if (viewLineNumber < 1) {
-            return 1;
-        }
-        const viewLineCount = this.getViewLineCount();
-        if (viewLineNumber > viewLineCount) {
-            return viewLineCount;
-        }
-        return viewLineNumber | 0;
-    }
-    getActiveIndentGuide(viewLineNumber, minLineNumber, maxLineNumber) {
-        viewLineNumber = this._toValidViewLineNumber(viewLineNumber);
-        minLineNumber = this._toValidViewLineNumber(minLineNumber);
-        maxLineNumber = this._toValidViewLineNumber(maxLineNumber);
-        const modelPosition = this.convertViewPositionToModelPosition(viewLineNumber, this.getViewLineMinColumn(viewLineNumber));
-        const modelMinPosition = this.convertViewPositionToModelPosition(minLineNumber, this.getViewLineMinColumn(minLineNumber));
-        const modelMaxPosition = this.convertViewPositionToModelPosition(maxLineNumber, this.getViewLineMinColumn(maxLineNumber));
-        const result = this.model.guides.getActiveIndentGuide(modelPosition.lineNumber, modelMinPosition.lineNumber, modelMaxPosition.lineNumber);
-        const viewStartPosition = this.convertModelPositionToViewPosition(result.startLineNumber, 1);
-        const viewEndPosition = this.convertModelPositionToViewPosition(result.endLineNumber, this.model.getLineMaxColumn(result.endLineNumber));
-        return {
-            startLineNumber: viewStartPosition.lineNumber,
-            endLineNumber: viewEndPosition.lineNumber,
-            indent: result.indent
-        };
-    }
-    // #region ViewLineInfo
-    getViewLineInfo(viewLineNumber) {
-        viewLineNumber = this._toValidViewLineNumber(viewLineNumber);
-        const r = this.projectedModelLineLineCounts.getIndexOf(viewLineNumber - 1);
-        const lineIndex = r.index;
-        const remainder = r.remainder;
-        return new ViewLineInfo(lineIndex + 1, remainder);
-    }
-    getMinColumnOfViewLine(viewLineInfo) {
-        return this.modelLineProjections[viewLineInfo.modelLineNumber - 1].getViewLineMinColumn(this.model, viewLineInfo.modelLineNumber, viewLineInfo.modelLineWrappedLineIdx);
-    }
-    getMaxColumnOfViewLine(viewLineInfo) {
-        return this.modelLineProjections[viewLineInfo.modelLineNumber - 1].getViewLineMaxColumn(this.model, viewLineInfo.modelLineNumber, viewLineInfo.modelLineWrappedLineIdx);
-    }
-    getModelStartPositionOfViewLine(viewLineInfo) {
-        const line = this.modelLineProjections[viewLineInfo.modelLineNumber - 1];
-        const minViewColumn = line.getViewLineMinColumn(this.model, viewLineInfo.modelLineNumber, viewLineInfo.modelLineWrappedLineIdx);
-        const column = line.getModelColumnOfViewPosition(viewLineInfo.modelLineWrappedLineIdx, minViewColumn);
-        return new Position(viewLineInfo.modelLineNumber, column);
-    }
-    getModelEndPositionOfViewLine(viewLineInfo) {
-        const line = this.modelLineProjections[viewLineInfo.modelLineNumber - 1];
-        const maxViewColumn = line.getViewLineMaxColumn(this.model, viewLineInfo.modelLineNumber, viewLineInfo.modelLineWrappedLineIdx);
-        const column = line.getModelColumnOfViewPosition(viewLineInfo.modelLineWrappedLineIdx, maxViewColumn);
-        return new Position(viewLineInfo.modelLineNumber, column);
-    }
-    getViewLineInfosGroupedByModelRanges(viewStartLineNumber, viewEndLineNumber) {
-        const startViewLine = this.getViewLineInfo(viewStartLineNumber);
-        const endViewLine = this.getViewLineInfo(viewEndLineNumber);
-        const result = new Array();
-        let lastVisibleModelPos = this.getModelStartPositionOfViewLine(startViewLine);
-        let viewLines = new Array();
-        for (let curModelLine = startViewLine.modelLineNumber; curModelLine <= endViewLine.modelLineNumber; curModelLine++) {
-            const line = this.modelLineProjections[curModelLine - 1];
-            if (line.isVisible()) {
-                const startOffset = curModelLine === startViewLine.modelLineNumber
-                    ? startViewLine.modelLineWrappedLineIdx
-                    : 0;
-                const endOffset = curModelLine === endViewLine.modelLineNumber
-                    ? endViewLine.modelLineWrappedLineIdx + 1
-                    : line.getViewLineCount();
-                for (let i = startOffset; i < endOffset; i++) {
-                    viewLines.push(new ViewLineInfo(curModelLine, i));
-                }
-            }
-            if (!line.isVisible() && lastVisibleModelPos) {
-                const lastVisibleModelPos2 = new Position(curModelLine - 1, this.model.getLineMaxColumn(curModelLine - 1) + 1);
-                const modelRange = Range.fromPositions(lastVisibleModelPos, lastVisibleModelPos2);
-                result.push(new ViewLineInfoGroupedByModelRange(modelRange, viewLines));
-                viewLines = [];
-                lastVisibleModelPos = null;
-            }
-            else if (line.isVisible() && !lastVisibleModelPos) {
-                lastVisibleModelPos = new Position(curModelLine, 1);
-            }
-        }
-        if (lastVisibleModelPos) {
-            const modelRange = Range.fromPositions(lastVisibleModelPos, this.getModelEndPositionOfViewLine(endViewLine));
-            result.push(new ViewLineInfoGroupedByModelRange(modelRange, viewLines));
-        }
-        return result;
-    }
-    // #endregion
-    getViewLinesBracketGuides(viewStartLineNumber, viewEndLineNumber, activeViewPosition, options) {
-        const modelActivePosition = activeViewPosition ? this.convertViewPositionToModelPosition(activeViewPosition.lineNumber, activeViewPosition.column) : null;
-        const resultPerViewLine = [];
-        for (const group of this.getViewLineInfosGroupedByModelRanges(viewStartLineNumber, viewEndLineNumber)) {
-            const modelRangeStartLineNumber = group.modelRange.startLineNumber;
-            const bracketGuidesPerModelLine = this.model.guides.getLinesBracketGuides(modelRangeStartLineNumber, group.modelRange.endLineNumber, modelActivePosition, options);
-            for (const viewLineInfo of group.viewLines) {
-                const bracketGuides = bracketGuidesPerModelLine[viewLineInfo.modelLineNumber - modelRangeStartLineNumber];
-                // visibleColumns stay as they are (this is a bug and needs to be fixed, but it is not a regression)
-                // model-columns must be converted to view-model columns.
-                const result = bracketGuides.map(g => {
-                    if (g.forWrappedLinesAfterColumn !== -1) {
-                        const p = this.modelLineProjections[viewLineInfo.modelLineNumber - 1].getViewPositionOfModelPosition(0, g.forWrappedLinesAfterColumn);
-                        if (p.lineNumber >= viewLineInfo.modelLineWrappedLineIdx) {
-                            return undefined;
-                        }
-                    }
-                    if (g.forWrappedLinesBeforeOrAtColumn !== -1) {
-                        const p = this.modelLineProjections[viewLineInfo.modelLineNumber - 1].getViewPositionOfModelPosition(0, g.forWrappedLinesBeforeOrAtColumn);
-                        if (p.lineNumber < viewLineInfo.modelLineWrappedLineIdx) {
-                            return undefined;
-                        }
-                    }
-                    if (!g.horizontalLine) {
-                        return g;
-                    }
-                    let column = -1;
-                    if (g.column !== -1) {
-                        const p = this.modelLineProjections[viewLineInfo.modelLineNumber - 1].getViewPositionOfModelPosition(0, g.column);
-                        if (p.lineNumber === viewLineInfo.modelLineWrappedLineIdx) {
-                            column = p.column;
-                        }
-                        else if (p.lineNumber < viewLineInfo.modelLineWrappedLineIdx) {
-                            column = this.getMinColumnOfViewLine(viewLineInfo);
-                        }
-                        else if (p.lineNumber > viewLineInfo.modelLineWrappedLineIdx) {
-                            return undefined;
-                        }
-                    }
-                    const viewPosition = this.convertModelPositionToViewPosition(viewLineInfo.modelLineNumber, g.horizontalLine.endColumn);
-                    const p = this.modelLineProjections[viewLineInfo.modelLineNumber - 1].getViewPositionOfModelPosition(0, g.horizontalLine.endColumn);
-                    if (p.lineNumber === viewLineInfo.modelLineWrappedLineIdx) {
-                        return new IndentGuide(g.visibleColumn, column, g.className, new IndentGuideHorizontalLine(g.horizontalLine.top, viewPosition.column), -1, -1);
-                    }
-                    else if (p.lineNumber < viewLineInfo.modelLineWrappedLineIdx) {
-                        return undefined;
-                    }
-                    else {
-                        if (g.visibleColumn !== -1) {
-                            // Don't repeat horizontal lines that use visibleColumn for unrelated lines.
-                            return undefined;
-                        }
-                        return new IndentGuide(g.visibleColumn, column, g.className, new IndentGuideHorizontalLine(g.horizontalLine.top, this.getMaxColumnOfViewLine(viewLineInfo)), -1, -1);
-                    }
-                });
-                resultPerViewLine.push(result.filter((r) => !!r));
-            }
-        }
-        return resultPerViewLine;
-    }
-    getViewLinesIndentGuides(viewStartLineNumber, viewEndLineNumber) {
-        // TODO: Use the same code as in `getViewLinesBracketGuides`.
-        // Future TODO: Merge with `getViewLinesBracketGuides`.
-        // However, this requires more refactoring of indent guides.
-        viewStartLineNumber = this._toValidViewLineNumber(viewStartLineNumber);
-        viewEndLineNumber = this._toValidViewLineNumber(viewEndLineNumber);
-        const modelStart = this.convertViewPositionToModelPosition(viewStartLineNumber, this.getViewLineMinColumn(viewStartLineNumber));
-        const modelEnd = this.convertViewPositionToModelPosition(viewEndLineNumber, this.getViewLineMaxColumn(viewEndLineNumber));
-        let result = [];
-        const resultRepeatCount = [];
-        const resultRepeatOption = [];
-        const modelStartLineIndex = modelStart.lineNumber - 1;
-        const modelEndLineIndex = modelEnd.lineNumber - 1;
-        let reqStart = null;
-        for (let modelLineIndex = modelStartLineIndex; modelLineIndex <= modelEndLineIndex; modelLineIndex++) {
-            const line = this.modelLineProjections[modelLineIndex];
-            if (line.isVisible()) {
-                const viewLineStartIndex = line.getViewLineNumberOfModelPosition(0, modelLineIndex === modelStartLineIndex ? modelStart.column : 1);
-                const viewLineEndIndex = line.getViewLineNumberOfModelPosition(0, this.model.getLineMaxColumn(modelLineIndex + 1));
-                const count = viewLineEndIndex - viewLineStartIndex + 1;
-                let option = 0 /* IndentGuideRepeatOption.BlockNone */;
-                if (count > 1 && line.getViewLineMinColumn(this.model, modelLineIndex + 1, viewLineEndIndex) === 1) {
-                    // wrapped lines should block indent guides
-                    option = (viewLineStartIndex === 0 ? 1 /* IndentGuideRepeatOption.BlockSubsequent */ : 2 /* IndentGuideRepeatOption.BlockAll */);
-                }
-                resultRepeatCount.push(count);
-                resultRepeatOption.push(option);
-                // merge into previous request
-                if (reqStart === null) {
-                    reqStart = new Position(modelLineIndex + 1, 0);
-                }
-            }
-            else {
-                // hit invisible line => flush request
-                if (reqStart !== null) {
-                    result = result.concat(this.model.guides.getLinesIndentGuides(reqStart.lineNumber, modelLineIndex));
-                    reqStart = null;
-                }
-            }
-        }
-        if (reqStart !== null) {
-            result = result.concat(this.model.guides.getLinesIndentGuides(reqStart.lineNumber, modelEnd.lineNumber));
-            reqStart = null;
-        }
-        const viewLineCount = viewEndLineNumber - viewStartLineNumber + 1;
-        const viewIndents = new Array(viewLineCount);
-        let currIndex = 0;
-        for (let i = 0, len = result.length; i < len; i++) {
-            let value = result[i];
-            const count = Math.min(viewLineCount - currIndex, resultRepeatCount[i]);
-            const option = resultRepeatOption[i];
-            let blockAtIndex;
-            if (option === 2 /* IndentGuideRepeatOption.BlockAll */) {
-                blockAtIndex = 0;
-            }
-            else if (option === 1 /* IndentGuideRepeatOption.BlockSubsequent */) {
-                blockAtIndex = 1;
-            }
-            else {
-                blockAtIndex = count;
-            }
-            for (let j = 0; j < count; j++) {
-                if (j === blockAtIndex) {
-                    value = 0;
-                }
-                viewIndents[currIndex++] = value;
-            }
-        }
-        return viewIndents;
-    }
-    getViewLineContent(viewLineNumber) {
-        const info = this.getViewLineInfo(viewLineNumber);
-        return this.modelLineProjections[info.modelLineNumber - 1].getViewLineContent(this.model, info.modelLineNumber, info.modelLineWrappedLineIdx);
-    }
-    getViewLineLength(viewLineNumber) {
-        const info = this.getViewLineInfo(viewLineNumber);
-        return this.modelLineProjections[info.modelLineNumber - 1].getViewLineLength(this.model, info.modelLineNumber, info.modelLineWrappedLineIdx);
-    }
-    getViewLineMinColumn(viewLineNumber) {
-        const info = this.getViewLineInfo(viewLineNumber);
-        return this.modelLineProjections[info.modelLineNumber - 1].getViewLineMinColumn(this.model, info.modelLineNumber, info.modelLineWrappedLineIdx);
-    }
-    getViewLineMaxColumn(viewLineNumber) {
-        const info = this.getViewLineInfo(viewLineNumber);
-        return this.modelLineProjections[info.modelLineNumber - 1].getViewLineMaxColumn(this.model, info.modelLineNumber, info.modelLineWrappedLineIdx);
-    }
-    getViewLineData(viewLineNumber) {
-        const info = this.getViewLineInfo(viewLineNumber);
-        return this.modelLineProjections[info.modelLineNumber - 1].getViewLineData(this.model, info.modelLineNumber, info.modelLineWrappedLineIdx);
-    }
-    getViewLinesData(viewStartLineNumber, viewEndLineNumber, needed) {
-        viewStartLineNumber = this._toValidViewLineNumber(viewStartLineNumber);
-        viewEndLineNumber = this._toValidViewLineNumber(viewEndLineNumber);
-        const start = this.projectedModelLineLineCounts.getIndexOf(viewStartLineNumber - 1);
-        let viewLineNumber = viewStartLineNumber;
-        const startModelLineIndex = start.index;
-        const startRemainder = start.remainder;
-        const result = [];
-        for (let modelLineIndex = startModelLineIndex, len = this.model.getLineCount(); modelLineIndex < len; modelLineIndex++) {
-            const line = this.modelLineProjections[modelLineIndex];
-            if (!line.isVisible()) {
-                continue;
-            }
-            const fromViewLineIndex = (modelLineIndex === startModelLineIndex ? startRemainder : 0);
-            let remainingViewLineCount = line.getViewLineCount() - fromViewLineIndex;
-            let lastLine = false;
-            if (viewLineNumber + remainingViewLineCount > viewEndLineNumber) {
-                lastLine = true;
-                remainingViewLineCount = viewEndLineNumber - viewLineNumber + 1;
-            }
-            line.getViewLinesData(this.model, modelLineIndex + 1, fromViewLineIndex, remainingViewLineCount, viewLineNumber - viewStartLineNumber, needed, result);
-            viewLineNumber += remainingViewLineCount;
-            if (lastLine) {
-                break;
-            }
-        }
-        return result;
-    }
-    validateViewPosition(viewLineNumber, viewColumn, expectedModelPosition) {
-        viewLineNumber = this._toValidViewLineNumber(viewLineNumber);
-        const r = this.projectedModelLineLineCounts.getIndexOf(viewLineNumber - 1);
-        const lineIndex = r.index;
-        const remainder = r.remainder;
-        const line = this.modelLineProjections[lineIndex];
-        const minColumn = line.getViewLineMinColumn(this.model, lineIndex + 1, remainder);
-        const maxColumn = line.getViewLineMaxColumn(this.model, lineIndex + 1, remainder);
-        if (viewColumn < minColumn) {
-            viewColumn = minColumn;
-        }
-        if (viewColumn > maxColumn) {
-            viewColumn = maxColumn;
-        }
-        const computedModelColumn = line.getModelColumnOfViewPosition(remainder, viewColumn);
-        const computedModelPosition = this.model.validatePosition(new Position(lineIndex + 1, computedModelColumn));
-        if (computedModelPosition.equals(expectedModelPosition)) {
-            return new Position(viewLineNumber, viewColumn);
-        }
-        return this.convertModelPositionToViewPosition(expectedModelPosition.lineNumber, expectedModelPosition.column);
-    }
-    validateViewRange(viewRange, expectedModelRange) {
-        const validViewStart = this.validateViewPosition(viewRange.startLineNumber, viewRange.startColumn, expectedModelRange.getStartPosition());
-        const validViewEnd = this.validateViewPosition(viewRange.endLineNumber, viewRange.endColumn, expectedModelRange.getEndPosition());
-        return new Range(validViewStart.lineNumber, validViewStart.column, validViewEnd.lineNumber, validViewEnd.column);
-    }
-    convertViewPositionToModelPosition(viewLineNumber, viewColumn) {
-        const info = this.getViewLineInfo(viewLineNumber);
-        const inputColumn = this.modelLineProjections[info.modelLineNumber - 1].getModelColumnOfViewPosition(info.modelLineWrappedLineIdx, viewColumn);
-        // console.log('out -> in ' + viewLineNumber + ',' + viewColumn + ' ===> ' + (lineIndex+1) + ',' + inputColumn);
-        return this.model.validatePosition(new Position(info.modelLineNumber, inputColumn));
-    }
-    convertViewRangeToModelRange(viewRange) {
-        const start = this.convertViewPositionToModelPosition(viewRange.startLineNumber, viewRange.startColumn);
-        const end = this.convertViewPositionToModelPosition(viewRange.endLineNumber, viewRange.endColumn);
-        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
-    }
-    convertModelPositionToViewPosition(_modelLineNumber, _modelColumn, affinity = 2 /* PositionAffinity.None */, allowZeroLineNumber = false, belowHiddenRanges = false) {
-        const validPosition = this.model.validatePosition(new Position(_modelLineNumber, _modelColumn));
-        const inputLineNumber = validPosition.lineNumber;
-        const inputColumn = validPosition.column;
-        let lineIndex = inputLineNumber - 1, lineIndexChanged = false;
-        if (belowHiddenRanges) {
-            while (lineIndex < this.modelLineProjections.length && !this.modelLineProjections[lineIndex].isVisible()) {
-                lineIndex++;
-                lineIndexChanged = true;
-            }
-        }
-        else {
-            while (lineIndex > 0 && !this.modelLineProjections[lineIndex].isVisible()) {
-                lineIndex--;
-                lineIndexChanged = true;
-            }
-        }
-        if (lineIndex === 0 && !this.modelLineProjections[lineIndex].isVisible()) {
-            // Could not reach a real line
-            // console.log('in -> out ' + inputLineNumber + ',' + inputColumn + ' ===> ' + 1 + ',' + 1);
-            // TODO@alexdima@hediet this isn't soo pretty
-            return new Position(allowZeroLineNumber ? 0 : 1, 1);
-        }
-        const deltaLineNumber = 1 + this.projectedModelLineLineCounts.getPrefixSum(lineIndex);
-        let r;
-        if (lineIndexChanged) {
-            if (belowHiddenRanges) {
-                r = this.modelLineProjections[lineIndex].getViewPositionOfModelPosition(deltaLineNumber, 1, affinity);
-            }
-            else {
-                r = this.modelLineProjections[lineIndex].getViewPositionOfModelPosition(deltaLineNumber, this.model.getLineMaxColumn(lineIndex + 1), affinity);
-            }
-        }
-        else {
-            r = this.modelLineProjections[inputLineNumber - 1].getViewPositionOfModelPosition(deltaLineNumber, inputColumn, affinity);
-        }
-        // console.log('in -> out ' + inputLineNumber + ',' + inputColumn + ' ===> ' + r.lineNumber + ',' + r);
-        return r;
-    }
-    /**
-     * @param affinity The affinity in case of an empty range. Has no effect for non-empty ranges.
-    */
-    convertModelRangeToViewRange(modelRange, affinity = 0 /* PositionAffinity.Left */) {
-        if (modelRange.isEmpty()) {
-            const start = this.convertModelPositionToViewPosition(modelRange.startLineNumber, modelRange.startColumn, affinity);
-            return Range.fromPositions(start);
-        }
-        else {
-            const start = this.convertModelPositionToViewPosition(modelRange.startLineNumber, modelRange.startColumn, 1 /* PositionAffinity.Right */);
-            const end = this.convertModelPositionToViewPosition(modelRange.endLineNumber, modelRange.endColumn, 0 /* PositionAffinity.Left */);
-            return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
-        }
-    }
-    getViewLineNumberOfModelPosition(modelLineNumber, modelColumn) {
-        let lineIndex = modelLineNumber - 1;
-        if (this.modelLineProjections[lineIndex].isVisible()) {
-            // this model line is visible
-            const deltaLineNumber = 1 + this.projectedModelLineLineCounts.getPrefixSum(lineIndex);
-            return this.modelLineProjections[lineIndex].getViewLineNumberOfModelPosition(deltaLineNumber, modelColumn);
-        }
-        // this model line is not visible
-        while (lineIndex > 0 && !this.modelLineProjections[lineIndex].isVisible()) {
-            lineIndex--;
-        }
-        if (lineIndex === 0 && !this.modelLineProjections[lineIndex].isVisible()) {
-            // Could not reach a real line
-            return 1;
-        }
-        const deltaLineNumber = 1 + this.projectedModelLineLineCounts.getPrefixSum(lineIndex);
-        return this.modelLineProjections[lineIndex].getViewLineNumberOfModelPosition(deltaLineNumber, this.model.getLineMaxColumn(lineIndex + 1));
-    }
-    getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations) {
-        const modelStart = this.convertViewPositionToModelPosition(range.startLineNumber, range.startColumn);
-        const modelEnd = this.convertViewPositionToModelPosition(range.endLineNumber, range.endColumn);
-        if (modelEnd.lineNumber - modelStart.lineNumber <= range.endLineNumber - range.startLineNumber) {
-            // most likely there are no hidden lines => fast path
-            // fetch decorations from column 1 to cover the case of wrapped lines that have whole line decorations at column 1
-            return this.model.getDecorationsInRange(new Range(modelStart.lineNumber, 1, modelEnd.lineNumber, modelEnd.column), ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations);
-        }
-        let result = [];
-        const modelStartLineIndex = modelStart.lineNumber - 1;
-        const modelEndLineIndex = modelEnd.lineNumber - 1;
-        let reqStart = null;
-        for (let modelLineIndex = modelStartLineIndex; modelLineIndex <= modelEndLineIndex; modelLineIndex++) {
-            const line = this.modelLineProjections[modelLineIndex];
-            if (line.isVisible()) {
-                // merge into previous request
-                if (reqStart === null) {
-                    reqStart = new Position(modelLineIndex + 1, modelLineIndex === modelStartLineIndex ? modelStart.column : 1);
-                }
-            }
-            else {
-                // hit invisible line => flush request
-                if (reqStart !== null) {
-                    const maxLineColumn = this.model.getLineMaxColumn(modelLineIndex);
-                    result = result.concat(this.model.getDecorationsInRange(new Range(reqStart.lineNumber, reqStart.column, modelLineIndex, maxLineColumn), ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
-                    reqStart = null;
-                }
-            }
-        }
-        if (reqStart !== null) {
-            result = result.concat(this.model.getDecorationsInRange(new Range(reqStart.lineNumber, reqStart.column, modelEnd.lineNumber, modelEnd.column), ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
-            reqStart = null;
-        }
-        result.sort((a, b) => {
-            const res = Range.compareRangesUsingStarts(a.range, b.range);
-            if (res === 0) {
-                if (a.id < b.id) {
-                    return -1;
-                }
-                if (a.id > b.id) {
-                    return 1;
-                }
-                return 0;
-            }
-            return res;
-        });
-        // Eliminate duplicate decorations that might have intersected our visible ranges multiple times
-        const finalResult = [];
-        let finalResultLen = 0;
-        let prevDecId = null;
-        for (const dec of result) {
-            const decId = dec.id;
-            if (prevDecId === decId) {
-                // skip
-                continue;
-            }
-            prevDecId = decId;
-            finalResult[finalResultLen++] = dec;
-        }
-        return finalResult;
-    }
-    getInjectedTextAt(position) {
-        const info = this.getViewLineInfo(position.lineNumber);
-        return this.modelLineProjections[info.modelLineNumber - 1].getInjectedTextAt(info.modelLineWrappedLineIdx, position.column);
-    }
-    normalizePosition(position, affinity) {
-        const info = this.getViewLineInfo(position.lineNumber);
-        return this.modelLineProjections[info.modelLineNumber - 1].normalizePosition(info.modelLineWrappedLineIdx, position, affinity);
-    }
-    getLineIndentColumn(lineNumber) {
-        const info = this.getViewLineInfo(lineNumber);
-        if (info.modelLineWrappedLineIdx === 0) {
-            return this.model.getLineIndentColumn(info.modelLineNumber);
-        }
-        // wrapped lines have no indentation.
-        // We deliberately don't handle the case that indentation is wrapped
-        // to avoid two view lines reporting indentation for the very same model line.
-        return 0;
-    }
-}
-/**
- * Overlapping unsorted ranges:
- * [   )      [ )       [  )
- *    [    )      [       )
- * ->
- * Non overlapping sorted ranges:
- * [       )  [ ) [        )
- *
- * Note: This function only considers line information! Columns are ignored.
-*/
-function normalizeLineRanges(ranges) {
-    if (ranges.length === 0) {
-        return [];
-    }
-    const sortedRanges = ranges.slice();
-    sortedRanges.sort(Range.compareRangesUsingStarts);
-    const result = [];
-    let currentRangeStart = sortedRanges[0].startLineNumber;
-    let currentRangeEnd = sortedRanges[0].endLineNumber;
-    for (let i = 1, len = sortedRanges.length; i < len; i++) {
-        const range = sortedRanges[i];
-        if (range.startLineNumber > currentRangeEnd + 1) {
-            result.push(new Range(currentRangeStart, 1, currentRangeEnd, 1));
-            currentRangeStart = range.startLineNumber;
-            currentRangeEnd = range.endLineNumber;
-        }
-        else if (range.endLineNumber > currentRangeEnd) {
-            currentRangeEnd = range.endLineNumber;
-        }
-    }
-    result.push(new Range(currentRangeStart, 1, currentRangeEnd, 1));
-    return result;
-}
-/**
- * Represents a view line. Can be used to efficiently query more information about it.
- */
-class ViewLineInfo {
-    constructor(modelLineNumber, modelLineWrappedLineIdx) {
-        this.modelLineNumber = modelLineNumber;
-        this.modelLineWrappedLineIdx = modelLineWrappedLineIdx;
-    }
-}
-/**
- * A list of view lines that have a contiguous span in the model.
-*/
-class ViewLineInfoGroupedByModelRange {
-    constructor(modelRange, viewLines) {
-        this.modelRange = modelRange;
-        this.viewLines = viewLines;
-    }
-}
-class CoordinatesConverter {
-    constructor(lines) {
-        this._lines = lines;
-    }
-    // View -> Model conversion and related methods
-    convertViewPositionToModelPosition(viewPosition) {
-        return this._lines.convertViewPositionToModelPosition(viewPosition.lineNumber, viewPosition.column);
-    }
-    convertViewRangeToModelRange(viewRange) {
-        return this._lines.convertViewRangeToModelRange(viewRange);
-    }
-    validateViewPosition(viewPosition, expectedModelPosition) {
-        return this._lines.validateViewPosition(viewPosition.lineNumber, viewPosition.column, expectedModelPosition);
-    }
-    validateViewRange(viewRange, expectedModelRange) {
-        return this._lines.validateViewRange(viewRange, expectedModelRange);
-    }
-    // Model -> View conversion and related methods
-    convertModelPositionToViewPosition(modelPosition, affinity, allowZero, belowHiddenRanges) {
-        return this._lines.convertModelPositionToViewPosition(modelPosition.lineNumber, modelPosition.column, affinity, allowZero, belowHiddenRanges);
-    }
-    convertModelRangeToViewRange(modelRange, affinity) {
-        return this._lines.convertModelRangeToViewRange(modelRange, affinity);
-    }
-    modelPositionIsVisible(modelPosition) {
-        return this._lines.modelPositionIsVisible(modelPosition.lineNumber, modelPosition.column);
-    }
-    getModelLineViewLineCount(modelLineNumber) {
-        return this._lines.getModelLineViewLineCount(modelLineNumber);
-    }
-    getViewLineNumberOfModelPosition(modelLineNumber, modelColumn) {
-        return this._lines.getViewLineNumberOfModelPosition(modelLineNumber, modelColumn);
-    }
-}
-class ViewModelLinesFromModelAsIs {
-    constructor(model) {
-        this.model = model;
-    }
-    dispose() {
-    }
-    createCoordinatesConverter() {
-        return new IdentityCoordinatesConverter(this.model);
-    }
-    getHiddenAreas() {
-        return [];
-    }
-    setHiddenAreas(_ranges) {
-        return false;
-    }
-    setTabSize(_newTabSize) {
-        return false;
-    }
-    setWrappingSettings(_fontInfo, _wrappingStrategy, _wrappingColumn, _wrappingIndent) {
-        return false;
-    }
-    createLineBreaksComputer() {
-        const result = [];
-        return {
-            addRequest: (lineText, injectedText, previousLineBreakData) => {
-                result.push(null);
-            },
-            finalize: () => {
-                return result;
-            }
-        };
-    }
-    onModelFlushed() {
-    }
-    onModelLinesDeleted(_versionId, fromLineNumber, toLineNumber) {
-        return new ViewLinesDeletedEvent(fromLineNumber, toLineNumber);
-    }
-    onModelLinesInserted(_versionId, fromLineNumber, toLineNumber, lineBreaks) {
-        return new ViewLinesInsertedEvent(fromLineNumber, toLineNumber);
-    }
-    onModelLineChanged(_versionId, lineNumber, lineBreakData) {
-        return [false, new ViewLinesChangedEvent(lineNumber, 1), null, null];
-    }
-    acceptVersionId(_versionId) {
-    }
-    getViewLineCount() {
-        return this.model.getLineCount();
-    }
-    getActiveIndentGuide(viewLineNumber, _minLineNumber, _maxLineNumber) {
-        return {
-            startLineNumber: viewLineNumber,
-            endLineNumber: viewLineNumber,
-            indent: 0
-        };
-    }
-    getViewLinesBracketGuides(startLineNumber, endLineNumber, activePosition) {
-        return new Array(endLineNumber - startLineNumber + 1).fill([]);
-    }
-    getViewLinesIndentGuides(viewStartLineNumber, viewEndLineNumber) {
-        const viewLineCount = viewEndLineNumber - viewStartLineNumber + 1;
-        const result = new Array(viewLineCount);
-        for (let i = 0; i < viewLineCount; i++) {
-            result[i] = 0;
-        }
-        return result;
-    }
-    getViewLineContent(viewLineNumber) {
-        return this.model.getLineContent(viewLineNumber);
-    }
-    getViewLineLength(viewLineNumber) {
-        return this.model.getLineLength(viewLineNumber);
-    }
-    getViewLineMinColumn(viewLineNumber) {
-        return this.model.getLineMinColumn(viewLineNumber);
-    }
-    getViewLineMaxColumn(viewLineNumber) {
-        return this.model.getLineMaxColumn(viewLineNumber);
-    }
-    getViewLineData(viewLineNumber) {
-        const lineTokens = this.model.tokenization.getLineTokens(viewLineNumber);
-        const lineContent = lineTokens.getLineContent();
-        return new ViewLineData(lineContent, false, 1, lineContent.length + 1, 0, lineTokens.inflate(), null);
-    }
-    getViewLinesData(viewStartLineNumber, viewEndLineNumber, needed) {
-        const lineCount = this.model.getLineCount();
-        viewStartLineNumber = Math.min(Math.max(1, viewStartLineNumber), lineCount);
-        viewEndLineNumber = Math.min(Math.max(1, viewEndLineNumber), lineCount);
-        const result = [];
-        for (let lineNumber = viewStartLineNumber; lineNumber <= viewEndLineNumber; lineNumber++) {
-            const idx = lineNumber - viewStartLineNumber;
-            result[idx] = needed[idx] ? this.getViewLineData(lineNumber) : null;
-        }
-        return result;
-    }
-    getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations) {
-        return this.model.getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations, onlyMarginDecorations);
-    }
-    normalizePosition(position, affinity) {
-        return this.model.normalizePosition(position, affinity);
-    }
-    getLineIndentColumn(lineNumber) {
-        return this.model.getLineIndentColumn(lineNumber);
-    }
-    getInjectedTextAt(position) {
-        // Identity lines collection does not support injected text.
-        return null;
-    }
-}
-
-export { ViewModelLinesFromModelAsIs, ViewModelLinesFromProjectedModel };