monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/viewModelLines.js

@@ -0,0 +1,938 @@
+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 };