monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,350 @@
+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

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