monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,350 +0,0 @@
-import { LineTokens } from '../tokens/lineTokens.js';
-import { Position } from '../core/position.js';
-import { LineInjectedText } from '../textModelEvents.js';
-import { ViewLineData } from '../viewModel.js';
-import { SingleLineInlineDecoration } from './inlineDecorations.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function createModelLineProjection(lineBreakData, isVisible) {
-    if (lineBreakData === null) {
-        // No mapping needed
-        if (isVisible) {
-            return IdentityModelLineProjection.INSTANCE;
-        }
-        return HiddenModelLineProjection.INSTANCE;
-    }
-    else {
-        return new ModelLineProjection(lineBreakData, isVisible);
-    }
-}
-/**
- * This projection is used to
- * * wrap model lines
- * * inject text
- */
-class ModelLineProjection {
-    constructor(lineBreakData, isVisible) {
-        this._projectionData = lineBreakData;
-        this._isVisible = isVisible;
-    }
-    isVisible() {
-        return this._isVisible;
-    }
-    setVisible(isVisible) {
-        this._isVisible = isVisible;
-        return this;
-    }
-    getProjectionData() {
-        return this._projectionData;
-    }
-    getViewLineCount() {
-        if (!this._isVisible) {
-            return 0;
-        }
-        return this._projectionData.getOutputLineCount();
-    }
-    getViewLineContent(model, modelLineNumber, outputLineIndex) {
-        this._assertVisible();
-        const startOffsetInInputWithInjections = outputLineIndex > 0 ? this._projectionData.breakOffsets[outputLineIndex - 1] : 0;
-        const endOffsetInInputWithInjections = this._projectionData.breakOffsets[outputLineIndex];
-        let r;
-        if (this._projectionData.injectionOffsets !== null) {
-            const injectedTexts = this._projectionData.injectionOffsets.map((offset, idx) => new LineInjectedText(0, 0, offset + 1, this._projectionData.injectionOptions[idx], 0));
-            const lineWithInjections = LineInjectedText.applyInjectedText(model.getLineContent(modelLineNumber), injectedTexts);
-            r = lineWithInjections.substring(startOffsetInInputWithInjections, endOffsetInInputWithInjections);
-        }
-        else {
-            r = model.getValueInRange({
-                startLineNumber: modelLineNumber,
-                startColumn: startOffsetInInputWithInjections + 1,
-                endLineNumber: modelLineNumber,
-                endColumn: endOffsetInInputWithInjections + 1
-            });
-        }
-        if (outputLineIndex > 0) {
-            r = spaces(this._projectionData.wrappedTextIndentLength) + r;
-        }
-        return r;
-    }
-    getViewLineLength(model, modelLineNumber, outputLineIndex) {
-        this._assertVisible();
-        return this._projectionData.getLineLength(outputLineIndex);
-    }
-    getViewLineMinColumn(_model, _modelLineNumber, outputLineIndex) {
-        this._assertVisible();
-        return this._projectionData.getMinOutputOffset(outputLineIndex) + 1;
-    }
-    getViewLineMaxColumn(model, modelLineNumber, outputLineIndex) {
-        this._assertVisible();
-        return this._projectionData.getMaxOutputOffset(outputLineIndex) + 1;
-    }
-    /**
-     * Try using {@link getViewLinesData} instead.
-    */
-    getViewLineData(model, modelLineNumber, outputLineIndex) {
-        const arr = new Array();
-        this.getViewLinesData(model, modelLineNumber, outputLineIndex, 1, 0, [true], arr);
-        return arr[0];
-    }
-    getViewLinesData(model, modelLineNumber, outputLineIdx, lineCount, globalStartIndex, needed, result) {
-        this._assertVisible();
-        const lineBreakData = this._projectionData;
-        const injectionOffsets = lineBreakData.injectionOffsets;
-        const injectionOptions = lineBreakData.injectionOptions;
-        let inlineDecorationsPerOutputLine = null;
-        if (injectionOffsets) {
-            inlineDecorationsPerOutputLine = [];
-            let totalInjectedTextLengthBefore = 0;
-            let currentInjectedOffset = 0;
-            for (let outputLineIndex = 0; outputLineIndex < lineBreakData.getOutputLineCount(); outputLineIndex++) {
-                const inlineDecorations = new Array();
-                inlineDecorationsPerOutputLine[outputLineIndex] = inlineDecorations;
-                const lineStartOffsetInInputWithInjections = outputLineIndex > 0 ? lineBreakData.breakOffsets[outputLineIndex - 1] : 0;
-                const lineEndOffsetInInputWithInjections = lineBreakData.breakOffsets[outputLineIndex];
-                while (currentInjectedOffset < injectionOffsets.length) {
-                    const length = injectionOptions[currentInjectedOffset].content.length;
-                    const injectedTextStartOffsetInInputWithInjections = injectionOffsets[currentInjectedOffset] + totalInjectedTextLengthBefore;
-                    const injectedTextEndOffsetInInputWithInjections = injectedTextStartOffsetInInputWithInjections + length;
-                    if (injectedTextStartOffsetInInputWithInjections > lineEndOffsetInInputWithInjections) {
-                        // Injected text only starts in later wrapped lines.
-                        break;
-                    }
-                    if (lineStartOffsetInInputWithInjections < injectedTextEndOffsetInInputWithInjections) {
-                        // Injected text ends after or in this line (but also starts in or before this line).
-                        const options = injectionOptions[currentInjectedOffset];
-                        if (options.inlineClassName) {
-                            const offset = (outputLineIndex > 0 ? lineBreakData.wrappedTextIndentLength : 0);
-                            const start = offset + Math.max(injectedTextStartOffsetInInputWithInjections - lineStartOffsetInInputWithInjections, 0);
-                            const end = offset + Math.min(injectedTextEndOffsetInInputWithInjections - lineStartOffsetInInputWithInjections, lineEndOffsetInInputWithInjections - lineStartOffsetInInputWithInjections);
-                            if (start !== end) {
-                                inlineDecorations.push(new SingleLineInlineDecoration(start, end, options.inlineClassName, options.inlineClassNameAffectsLetterSpacing));
-                            }
-                        }
-                    }
-                    if (injectedTextEndOffsetInInputWithInjections <= lineEndOffsetInInputWithInjections) {
-                        totalInjectedTextLengthBefore += length;
-                        currentInjectedOffset++;
-                    }
-                    else {
-                        // injected text breaks into next line, process it again
-                        break;
-                    }
-                }
-            }
-        }
-        let lineWithInjections;
-        if (injectionOffsets) {
-            const tokensToInsert = [];
-            for (let idx = 0; idx < injectionOffsets.length; idx++) {
-                const offset = injectionOffsets[idx];
-                const tokens = injectionOptions[idx].tokens;
-                if (tokens) {
-                    tokens.forEach((range, info) => {
-                        tokensToInsert.push({
-                            offset,
-                            text: range.substring(injectionOptions[idx].content),
-                            tokenMetadata: info.metadata,
-                        });
-                    });
-                }
-                else {
-                    tokensToInsert.push({
-                        offset,
-                        text: injectionOptions[idx].content,
-                        tokenMetadata: LineTokens.defaultTokenMetadata,
-                    });
-                }
-            }
-            lineWithInjections = model.tokenization.getLineTokens(modelLineNumber).withInserted(tokensToInsert);
-        }
-        else {
-            lineWithInjections = model.tokenization.getLineTokens(modelLineNumber);
-        }
-        for (let outputLineIndex = outputLineIdx; outputLineIndex < outputLineIdx + lineCount; outputLineIndex++) {
-            const globalIndex = globalStartIndex + outputLineIndex - outputLineIdx;
-            if (!needed[globalIndex]) {
-                result[globalIndex] = null;
-                continue;
-            }
-            result[globalIndex] = this._getViewLineData(lineWithInjections, inlineDecorationsPerOutputLine ? inlineDecorationsPerOutputLine[outputLineIndex] : null, outputLineIndex);
-        }
-    }
-    _getViewLineData(lineWithInjections, inlineDecorations, outputLineIndex) {
-        this._assertVisible();
-        const lineBreakData = this._projectionData;
-        const deltaStartIndex = (outputLineIndex > 0 ? lineBreakData.wrappedTextIndentLength : 0);
-        const lineStartOffsetInInputWithInjections = outputLineIndex > 0 ? lineBreakData.breakOffsets[outputLineIndex - 1] : 0;
-        const lineEndOffsetInInputWithInjections = lineBreakData.breakOffsets[outputLineIndex];
-        const tokens = lineWithInjections.sliceAndInflate(lineStartOffsetInInputWithInjections, lineEndOffsetInInputWithInjections, deltaStartIndex);
-        let lineContent = tokens.getLineContent();
-        if (outputLineIndex > 0) {
-            lineContent = spaces(lineBreakData.wrappedTextIndentLength) + lineContent;
-        }
-        const minColumn = this._projectionData.getMinOutputOffset(outputLineIndex) + 1;
-        const maxColumn = lineContent.length + 1;
-        const continuesWithWrappedLine = (outputLineIndex + 1 < this.getViewLineCount());
-        const startVisibleColumn = (outputLineIndex === 0 ? 0 : lineBreakData.breakOffsetsVisibleColumn[outputLineIndex - 1]);
-        return new ViewLineData(lineContent, continuesWithWrappedLine, minColumn, maxColumn, startVisibleColumn, tokens, inlineDecorations);
-    }
-    getModelColumnOfViewPosition(outputLineIndex, outputColumn) {
-        this._assertVisible();
-        return this._projectionData.translateToInputOffset(outputLineIndex, outputColumn - 1) + 1;
-    }
-    getViewPositionOfModelPosition(deltaLineNumber, inputColumn, affinity = 2 /* PositionAffinity.None */) {
-        this._assertVisible();
-        const r = this._projectionData.translateToOutputPosition(inputColumn - 1, affinity);
-        return r.toPosition(deltaLineNumber);
-    }
-    getViewLineNumberOfModelPosition(deltaLineNumber, inputColumn) {
-        this._assertVisible();
-        const r = this._projectionData.translateToOutputPosition(inputColumn - 1);
-        return deltaLineNumber + r.outputLineIndex;
-    }
-    normalizePosition(outputLineIndex, outputPosition, affinity) {
-        const baseViewLineNumber = outputPosition.lineNumber - outputLineIndex;
-        const normalizedOutputPosition = this._projectionData.normalizeOutputPosition(outputLineIndex, outputPosition.column - 1, affinity);
-        const result = normalizedOutputPosition.toPosition(baseViewLineNumber);
-        return result;
-    }
-    getInjectedTextAt(outputLineIndex, outputColumn) {
-        return this._projectionData.getInjectedText(outputLineIndex, outputColumn - 1);
-    }
-    _assertVisible() {
-        if (!this._isVisible) {
-            throw new Error('Not supported');
-        }
-    }
-}
-/**
- * This projection does not change the model line.
-*/
-class IdentityModelLineProjection {
-    static { this.INSTANCE = new IdentityModelLineProjection(); }
-    constructor() { }
-    isVisible() {
-        return true;
-    }
-    setVisible(isVisible) {
-        if (isVisible) {
-            return this;
-        }
-        return HiddenModelLineProjection.INSTANCE;
-    }
-    getProjectionData() {
-        return null;
-    }
-    getViewLineCount() {
-        return 1;
-    }
-    getViewLineContent(model, modelLineNumber, _outputLineIndex) {
-        return model.getLineContent(modelLineNumber);
-    }
-    getViewLineLength(model, modelLineNumber, _outputLineIndex) {
-        return model.getLineLength(modelLineNumber);
-    }
-    getViewLineMinColumn(model, modelLineNumber, _outputLineIndex) {
-        return model.getLineMinColumn(modelLineNumber);
-    }
-    getViewLineMaxColumn(model, modelLineNumber, _outputLineIndex) {
-        return model.getLineMaxColumn(modelLineNumber);
-    }
-    getViewLineData(model, modelLineNumber, _outputLineIndex) {
-        const lineTokens = model.tokenization.getLineTokens(modelLineNumber);
-        const lineContent = lineTokens.getLineContent();
-        return new ViewLineData(lineContent, false, 1, lineContent.length + 1, 0, lineTokens.inflate(), null);
-    }
-    getViewLinesData(model, modelLineNumber, _fromOuputLineIndex, _toOutputLineIndex, globalStartIndex, needed, result) {
-        if (!needed[globalStartIndex]) {
-            result[globalStartIndex] = null;
-            return;
-        }
-        result[globalStartIndex] = this.getViewLineData(model, modelLineNumber, 0);
-    }
-    getModelColumnOfViewPosition(_outputLineIndex, outputColumn) {
-        return outputColumn;
-    }
-    getViewPositionOfModelPosition(deltaLineNumber, inputColumn) {
-        return new Position(deltaLineNumber, inputColumn);
-    }
-    getViewLineNumberOfModelPosition(deltaLineNumber, _inputColumn) {
-        return deltaLineNumber;
-    }
-    normalizePosition(outputLineIndex, outputPosition, affinity) {
-        return outputPosition;
-    }
-    getInjectedTextAt(_outputLineIndex, _outputColumn) {
-        return null;
-    }
-}
-/**
- * This projection hides the model line.
- */
-class HiddenModelLineProjection {
-    static { this.INSTANCE = new HiddenModelLineProjection(); }
-    constructor() { }
-    isVisible() {
-        return false;
-    }
-    setVisible(isVisible) {
-        if (!isVisible) {
-            return this;
-        }
-        return IdentityModelLineProjection.INSTANCE;
-    }
-    getProjectionData() {
-        return null;
-    }
-    getViewLineCount() {
-        return 0;
-    }
-    getViewLineContent(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
-    }
-    getViewLineLength(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
-    }
-    getViewLineMinColumn(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
-    }
-    getViewLineMaxColumn(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
-    }
-    getViewLineData(_model, _modelLineNumber, _outputLineIndex) {
-        throw new Error('Not supported');
-    }
-    getViewLinesData(_model, _modelLineNumber, _fromOuputLineIndex, _toOutputLineIndex, _globalStartIndex, _needed, _result) {
-        throw new Error('Not supported');
-    }
-    getModelColumnOfViewPosition(_outputLineIndex, _outputColumn) {
-        throw new Error('Not supported');
-    }
-    getViewPositionOfModelPosition(_deltaLineNumber, _inputColumn) {
-        throw new Error('Not supported');
-    }
-    getViewLineNumberOfModelPosition(_deltaLineNumber, _inputColumn) {
-        throw new Error('Not supported');
-    }
-    normalizePosition(outputLineIndex, outputPosition, affinity) {
-        throw new Error('Not supported');
-    }
-    getInjectedTextAt(_outputLineIndex, _outputColumn) {
-        throw new Error('Not supported');
-    }
-}
-const _spaces = [''];
-function spaces(count) {
-    if (count >= _spaces.length) {
-        for (let i = 1; i <= count; i++) {
-            _spaces[i] = _makeSpaces(i);
-        }
-    }
-    return _spaces[count];
-}
-function _makeSpaces(count) {
-    return new Array(count + 1).join(' ');
-}
-
-export { createModelLineProjection };

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

@@ -1,297 +0,0 @@
-import { assertNever } from '../../base/common/assert.js';
-import { Position } from './core/position.js';
-import { InjectedTextCursorStops } from './model.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * *input*:
- * ```
- * xxxxxxxxxxxxxxxxxxxxxxxxxxx
- * ```
- *
- * -> Applying injections `[i...i]`, *inputWithInjections*:
- * ```
- * xxxxxx[iiiiiiiiii]xxxxxxxxxxxxxxxxx[ii]xxxx
- * ```
- *
- * -> breaking at offsets `|` in `xxxxxx[iiiiiii|iii]xxxxxxxxxxx|xxxxxx[ii]xxxx|`:
- * ```
- * xxxxxx[iiiiiii
- * iii]xxxxxxxxxxx
- * xxxxxx[ii]xxxx
- * ```
- *
- * -> applying wrappedTextIndentLength, *output*:
- * ```
- * xxxxxx[iiiiiii
- *    iii]xxxxxxxxxxx
- *    xxxxxx[ii]xxxx
- * ```
- */
-class ModelLineProjectionData {
-    constructor(injectionOffsets, 
-    /**
-     * `injectionOptions.length` must equal `injectionOffsets.length`
-     */
-    injectionOptions, 
-    /**
-     * Refers to offsets after applying injections to the source.
-     * The last break offset indicates the length of the source after applying injections.
-     */
-    breakOffsets, 
-    /**
-     * Refers to offsets after applying injections
-     */
-    breakOffsetsVisibleColumn, wrappedTextIndentLength) {
-        this.injectionOffsets = injectionOffsets;
-        this.injectionOptions = injectionOptions;
-        this.breakOffsets = breakOffsets;
-        this.breakOffsetsVisibleColumn = breakOffsetsVisibleColumn;
-        this.wrappedTextIndentLength = wrappedTextIndentLength;
-    }
-    getOutputLineCount() {
-        return this.breakOffsets.length;
-    }
-    getMinOutputOffset(outputLineIndex) {
-        if (outputLineIndex > 0) {
-            return this.wrappedTextIndentLength;
-        }
-        return 0;
-    }
-    getLineLength(outputLineIndex) {
-        // These offsets refer to model text with injected text.
-        const startOffset = outputLineIndex > 0 ? this.breakOffsets[outputLineIndex - 1] : 0;
-        const endOffset = this.breakOffsets[outputLineIndex];
-        let lineLength = endOffset - startOffset;
-        if (outputLineIndex > 0) {
-            lineLength += this.wrappedTextIndentLength;
-        }
-        return lineLength;
-    }
-    getMaxOutputOffset(outputLineIndex) {
-        return this.getLineLength(outputLineIndex);
-    }
-    translateToInputOffset(outputLineIndex, outputOffset) {
-        if (outputLineIndex > 0) {
-            outputOffset = Math.max(0, outputOffset - this.wrappedTextIndentLength);
-        }
-        const offsetInInputWithInjection = outputLineIndex === 0 ? outputOffset : this.breakOffsets[outputLineIndex - 1] + outputOffset;
-        let offsetInInput = offsetInInputWithInjection;
-        if (this.injectionOffsets !== null) {
-            for (let i = 0; i < this.injectionOffsets.length; i++) {
-                if (offsetInInput > this.injectionOffsets[i]) {
-                    if (offsetInInput < this.injectionOffsets[i] + this.injectionOptions[i].content.length) {
-                        // `inputOffset` is within injected text
-                        offsetInInput = this.injectionOffsets[i];
-                    }
-                    else {
-                        offsetInInput -= this.injectionOptions[i].content.length;
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        return offsetInInput;
-    }
-    translateToOutputPosition(inputOffset, affinity = 2 /* PositionAffinity.None */) {
-        let inputOffsetInInputWithInjection = inputOffset;
-        if (this.injectionOffsets !== null) {
-            for (let i = 0; i < this.injectionOffsets.length; i++) {
-                if (inputOffset < this.injectionOffsets[i]) {
-                    break;
-                }
-                if (affinity !== 1 /* PositionAffinity.Right */ && inputOffset === this.injectionOffsets[i]) {
-                    break;
-                }
-                inputOffsetInInputWithInjection += this.injectionOptions[i].content.length;
-            }
-        }
-        return this.offsetInInputWithInjectionsToOutputPosition(inputOffsetInInputWithInjection, affinity);
-    }
-    offsetInInputWithInjectionsToOutputPosition(offsetInInputWithInjections, affinity = 2 /* PositionAffinity.None */) {
-        let low = 0;
-        let high = this.breakOffsets.length - 1;
-        let mid = 0;
-        let midStart = 0;
-        while (low <= high) {
-            mid = low + ((high - low) / 2) | 0;
-            const midStop = this.breakOffsets[mid];
-            midStart = mid > 0 ? this.breakOffsets[mid - 1] : 0;
-            if (affinity === 0 /* PositionAffinity.Left */) {
-                if (offsetInInputWithInjections <= midStart) {
-                    high = mid - 1;
-                }
-                else if (offsetInInputWithInjections > midStop) {
-                    low = mid + 1;
-                }
-                else {
-                    break;
-                }
-            }
-            else {
-                if (offsetInInputWithInjections < midStart) {
-                    high = mid - 1;
-                }
-                else if (offsetInInputWithInjections >= midStop) {
-                    low = mid + 1;
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        let outputOffset = offsetInInputWithInjections - midStart;
-        if (mid > 0) {
-            outputOffset += this.wrappedTextIndentLength;
-        }
-        return new OutputPosition(mid, outputOffset);
-    }
-    normalizeOutputPosition(outputLineIndex, outputOffset, affinity) {
-        if (this.injectionOffsets !== null) {
-            const offsetInInputWithInjections = this.outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset);
-            const normalizedOffsetInUnwrappedLine = this.normalizeOffsetInInputWithInjectionsAroundInjections(offsetInInputWithInjections, affinity);
-            if (normalizedOffsetInUnwrappedLine !== offsetInInputWithInjections) {
-                // injected text caused a change
-                return this.offsetInInputWithInjectionsToOutputPosition(normalizedOffsetInUnwrappedLine, affinity);
-            }
-        }
-        if (affinity === 0 /* PositionAffinity.Left */) {
-            if (outputLineIndex > 0 && outputOffset === this.getMinOutputOffset(outputLineIndex)) {
-                return new OutputPosition(outputLineIndex - 1, this.getMaxOutputOffset(outputLineIndex - 1));
-            }
-        }
-        else if (affinity === 1 /* PositionAffinity.Right */) {
-            const maxOutputLineIndex = this.getOutputLineCount() - 1;
-            if (outputLineIndex < maxOutputLineIndex && outputOffset === this.getMaxOutputOffset(outputLineIndex)) {
-                return new OutputPosition(outputLineIndex + 1, this.getMinOutputOffset(outputLineIndex + 1));
-            }
-        }
-        return new OutputPosition(outputLineIndex, outputOffset);
-    }
-    outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset) {
-        if (outputLineIndex > 0) {
-            outputOffset = Math.max(0, outputOffset - this.wrappedTextIndentLength);
-        }
-        const result = (outputLineIndex > 0 ? this.breakOffsets[outputLineIndex - 1] : 0) + outputOffset;
-        return result;
-    }
-    normalizeOffsetInInputWithInjectionsAroundInjections(offsetInInputWithInjections, affinity) {
-        const injectedText = this.getInjectedTextAtOffset(offsetInInputWithInjections);
-        if (!injectedText) {
-            return offsetInInputWithInjections;
-        }
-        if (affinity === 2 /* PositionAffinity.None */) {
-            if (offsetInInputWithInjections === injectedText.offsetInInputWithInjections + injectedText.length
-                && hasRightCursorStop(this.injectionOptions[injectedText.injectedTextIndex].cursorStops)) {
-                return injectedText.offsetInInputWithInjections + injectedText.length;
-            }
-            else {
-                let result = injectedText.offsetInInputWithInjections;
-                if (hasLeftCursorStop(this.injectionOptions[injectedText.injectedTextIndex].cursorStops)) {
-                    return result;
-                }
-                let index = injectedText.injectedTextIndex - 1;
-                while (index >= 0 && this.injectionOffsets[index] === this.injectionOffsets[injectedText.injectedTextIndex]) {
-                    if (hasRightCursorStop(this.injectionOptions[index].cursorStops)) {
-                        break;
-                    }
-                    result -= this.injectionOptions[index].content.length;
-                    if (hasLeftCursorStop(this.injectionOptions[index].cursorStops)) {
-                        break;
-                    }
-                    index--;
-                }
-                return result;
-            }
-        }
-        else if (affinity === 1 /* PositionAffinity.Right */ || affinity === 4 /* PositionAffinity.RightOfInjectedText */) {
-            let result = injectedText.offsetInInputWithInjections + injectedText.length;
-            let index = injectedText.injectedTextIndex;
-            // traverse all injected text that touch each other
-            while (index + 1 < this.injectionOffsets.length && this.injectionOffsets[index + 1] === this.injectionOffsets[index]) {
-                result += this.injectionOptions[index + 1].content.length;
-                index++;
-            }
-            return result;
-        }
-        else if (affinity === 0 /* PositionAffinity.Left */ || affinity === 3 /* PositionAffinity.LeftOfInjectedText */) {
-            // affinity is left
-            let result = injectedText.offsetInInputWithInjections;
-            let index = injectedText.injectedTextIndex;
-            // traverse all injected text that touch each other
-            while (index - 1 >= 0 && this.injectionOffsets[index - 1] === this.injectionOffsets[index]) {
-                result -= this.injectionOptions[index - 1].content.length;
-                index--;
-            }
-            return result;
-        }
-        assertNever();
-    }
-    getInjectedText(outputLineIndex, outputOffset) {
-        const offset = this.outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset);
-        const injectedText = this.getInjectedTextAtOffset(offset);
-        if (!injectedText) {
-            return null;
-        }
-        return {
-            options: this.injectionOptions[injectedText.injectedTextIndex]
-        };
-    }
-    getInjectedTextAtOffset(offsetInInputWithInjections) {
-        const injectionOffsets = this.injectionOffsets;
-        const injectionOptions = this.injectionOptions;
-        if (injectionOffsets !== null) {
-            let totalInjectedTextLengthBefore = 0;
-            for (let i = 0; i < injectionOffsets.length; i++) {
-                const length = injectionOptions[i].content.length;
-                const injectedTextStartOffsetInInputWithInjections = injectionOffsets[i] + totalInjectedTextLengthBefore;
-                const injectedTextEndOffsetInInputWithInjections = injectionOffsets[i] + totalInjectedTextLengthBefore + length;
-                if (injectedTextStartOffsetInInputWithInjections > offsetInInputWithInjections) {
-                    // Injected text starts later.
-                    break; // All later injected texts have an even larger offset.
-                }
-                if (offsetInInputWithInjections <= injectedTextEndOffsetInInputWithInjections) {
-                    // Injected text ends after or with the given position (but also starts with or before it).
-                    return {
-                        injectedTextIndex: i,
-                        offsetInInputWithInjections: injectedTextStartOffsetInInputWithInjections,
-                        length
-                    };
-                }
-                totalInjectedTextLengthBefore += length;
-            }
-        }
-        return undefined;
-    }
-}
-function hasRightCursorStop(cursorStop) {
-    if (cursorStop === null || cursorStop === undefined) {
-        return true;
-    }
-    return cursorStop === InjectedTextCursorStops.Right || cursorStop === InjectedTextCursorStops.Both;
-}
-function hasLeftCursorStop(cursorStop) {
-    if (cursorStop === null || cursorStop === undefined) {
-        return true;
-    }
-    return cursorStop === InjectedTextCursorStops.Left || cursorStop === InjectedTextCursorStops.Both;
-}
-class OutputPosition {
-    constructor(outputLineIndex, outputOffset) {
-        this.outputLineIndex = outputLineIndex;
-        this.outputOffset = outputOffset;
-    }
-    toString() {
-        return `${this.outputLineIndex}:${this.outputOffset}`;
-    }
-    toPosition(baseLineNumber) {
-        return new Position(baseLineNumber + this.outputLineIndex, this.outputOffset + 1);
-    }
-}
-
-export { ModelLineProjectionData, OutputPosition };