@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode/src/vs/editor/common/config/editorOptions.js

@@ -1,5 +1,5 @@
-import { equals as equals$1 } from '../../../base/common/arrays.js';
-import { equals } from '../../../base/common/objects.js';
+import { equals } from '../../../base/common/arrays.js';
+import { equals as equals$1 } from '../../../base/common/objects.js';
 import { isMacintosh, isLinux } from '../../../base/common/platform.js';
 import { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';
 import { USUAL_WORD_SEPARATORS } from '../core/wordHelper.js';
@@ -45,7 +45,7 @@ function applyUpdate(value, update) {
         return ( new ApplyUpdateResult(update, value !== update));
     }
     if (Array.isArray(value) || Array.isArray(update)) {
-        const arrayEquals = Array.isArray(value) && Array.isArray(update) && equals$1(value, update);
+        const arrayEquals = Array.isArray(value) && Array.isArray(update) && equals(value, update);
         return ( new ApplyUpdateResult(update, !arrayEquals));
     }
     let didChange = false;
@@ -383,7 +383,7 @@ function _cursorStyleFromString(cursorStyle) {
 }
 class EditorClassName extends ComputedEditorOption {
     constructor() {
-        super(141 );
+        super(142 );
     }
     compute(env, options, _) {
         const classNames = ['monaco-editor'];
@@ -402,7 +402,7 @@ class EditorClassName extends ComputedEditorOption {
         if (options.get(111 )) {
             classNames.push('showUnused');
         }
-        if (options.get(139 )) {
+        if (options.get(140 )) {
             classNames.push('showDeprecated');
         }
         return classNames.join(' ');
@@ -953,7 +953,7 @@ class EditorHover extends BaseEditorOption {
 }
 class EditorLayoutInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(144 );
+        super(145 );
     }
     compute(env, options, _) {
         return EditorLayoutInfoComputer.computeLayout(options, {
@@ -1124,10 +1124,10 @@ class EditorLayoutInfoComputer extends ComputedEditorOption {
         const maxDigitWidth = env.maxDigitWidth;
         const pixelRatio = env.pixelRatio;
         const viewLineCount = env.viewLineCount;
-        const wordWrapOverride2 = options.get(136 );
-        const wordWrapOverride1 = (wordWrapOverride2 === 'inherit' ? options.get(135 ) : wordWrapOverride2);
-        const wordWrap = (wordWrapOverride1 === 'inherit' ? options.get(131 ) : wordWrapOverride1);
-        const wordWrapColumn = options.get(134 );
+        const wordWrapOverride2 = options.get(137 );
+        const wordWrapOverride1 = (wordWrapOverride2 === 'inherit' ? options.get(136 ) : wordWrapOverride2);
+        const wordWrap = (wordWrapOverride1 === 'inherit' ? options.get(132 ) : wordWrapOverride1);
+        const wordWrapColumn = options.get(135 );
         const isDominatedByLongLines = env.isDominatedByLongLines;
         const showGlyphMargin = options.get(57 );
         const showLineNumbers = ((options.get(68 ).renderType !== 0) );
@@ -1233,7 +1233,7 @@ class EditorLayoutInfoComputer extends ComputedEditorOption {
 }
 class WrappingStrategy extends BaseEditorOption {
     constructor() {
-        super(138 , 'wrappingStrategy', 'simple', {
+        super(139 , 'wrappingStrategy', 'simple', {
             'editor.wrappingStrategy': {
                 enumDescriptions: [
                     ( localizeWithPath(
@@ -1277,7 +1277,7 @@ var ShowLightbulbIconMode;
 })(ShowLightbulbIconMode || (ShowLightbulbIconMode = {})));
 class EditorLightbulb extends BaseEditorOption {
     constructor() {
-        const defaults = { enabled: ShowLightbulbIconMode.OnCode };
+        const defaults = { enabled: ShowLightbulbIconMode.On };
         super(65 , 'lightbulb', defaults, {
             'editor.lightbulb.enabled': {
                 type: 'string',
@@ -1381,7 +1381,7 @@ class EditorStickyScroll extends BaseEditorOption {
 class EditorInlayHints extends BaseEditorOption {
     constructor() {
         const defaults = { enabled: 'on', fontSize: 0, fontFamily: '', padding: false };
-        super(140 , 'inlayHints', defaults, {
+        super(141 , 'inlayHints', defaults, {
             'editor.inlayHints.enabled': {
                 type: 'string',
                 default: defaults.enabled,
@@ -1509,6 +1509,9 @@ class EditorMinimap extends BaseEditorOption {
             renderCharacters: true,
             maxColumn: 120,
             scale: 1,
+            showRegionSectionHeaders: true,
+            showMarkSectionHeaders: true,
+            sectionHeaderFontSize: 9,
         };
         super(73 , 'minimap', defaults, {
             'editor.minimap.enabled': {
@@ -1605,6 +1608,33 @@ class EditorMinimap extends BaseEditorOption {
                     'minimap.maxColumn',
                     "Limit the width of the minimap to render at most a certain number of columns."
                 ))
+            },
+            'editor.minimap.showRegionSectionHeaders': {
+                type: 'boolean',
+                default: defaults.showRegionSectionHeaders,
+                description: ( localizeWithPath(
+                    'vs/editor/common/config/editorOptions',
+                    'minimap.showRegionSectionHeaders',
+                    "Controls whether named regions are shown as section headers in the minimap."
+                ))
+            },
+            'editor.minimap.showMarkSectionHeaders': {
+                type: 'boolean',
+                default: defaults.showMarkSectionHeaders,
+                description: ( localizeWithPath(
+                    'vs/editor/common/config/editorOptions',
+                    'minimap.showMarkSectionHeaders',
+                    "Controls whether MARK: comments are shown as section headers in the minimap."
+                ))
+            },
+            'editor.minimap.sectionHeaderFontSize': {
+                type: 'number',
+                default: defaults.sectionHeaderFontSize,
+                description: ( localizeWithPath(
+                    'vs/editor/common/config/editorOptions',
+                    'minimap.sectionHeaderFontSize',
+                    "Controls the font size of section headers in the minimap."
+                ))
             }
         });
     }
@@ -1622,6 +1652,9 @@ class EditorMinimap extends BaseEditorOption {
             renderCharacters: boolean(input.renderCharacters, this.defaultValue.renderCharacters),
             scale: EditorIntOption.clampedInt(input.scale, 1, 1, 3),
             maxColumn: EditorIntOption.clampedInt(input.maxColumn, this.defaultValue.maxColumn, 1, 10000),
+            showRegionSectionHeaders: boolean(input.showRegionSectionHeaders, this.defaultValue.showRegionSectionHeaders),
+            showMarkSectionHeaders: boolean(input.showMarkSectionHeaders, this.defaultValue.showMarkSectionHeaders),
+            sectionHeaderFontSize: EditorFloatOption.clamp(input.sectionHeaderFontSize ?? this.defaultValue.sectionHeaderFontSize, 4, 32),
         };
     }
 }
@@ -1709,7 +1742,7 @@ class EditorParameterHints extends BaseEditorOption {
 }
 class EditorPixelRatio extends ComputedEditorOption {
     constructor() {
-        super(142 );
+        super(143 );
     }
     compute(env, options, _) {
         return env.pixelRatio;
@@ -2219,13 +2252,13 @@ class UnicodeHighlight extends BaseEditorOption {
     applyUpdate(value, update) {
         let didChange = false;
         if (update.allowedCharacters && value) {
-            if (!equals(value.allowedCharacters, update.allowedCharacters)) {
+            if (!equals$1(value.allowedCharacters, update.allowedCharacters)) {
                 value = { ...value, allowedCharacters: update.allowedCharacters };
                 didChange = true;
             }
         }
         if (update.allowedLocales && value) {
-            if (!equals(value.allowedLocales, update.allowedLocales)) {
+            if (!equals$1(value.allowedLocales, update.allowedLocales)) {
                 value = { ...value, allowedLocales: update.allowedLocales };
                 didChange = true;
             }
@@ -3141,9 +3174,57 @@ class SmartSelect extends BaseEditorOption {
         };
     }
 }
+class WordSegmenterLocales extends BaseEditorOption {
+    constructor() {
+        const defaults = [];
+        super(130 , 'wordSegmenterLocales', defaults, {
+            anyOf: [
+                {
+                    description: ( localizeWithPath(
+                        'vs/editor/common/config/editorOptions',
+                        'wordSegmenterLocales',
+                        "Locales to be used for word segmentation when doing word related navigations or operations. Specify the BCP 47 language tag of the word you wish to recognize (e.g., ja, zh-CN, zh-Hant-TW, etc.)."
+                    )),
+                    type: 'string',
+                }, {
+                    description: ( localizeWithPath(
+                        'vs/editor/common/config/editorOptions',
+                        'wordSegmenterLocales',
+                        "Locales to be used for word segmentation when doing word related navigations or operations. Specify the BCP 47 language tag of the word you wish to recognize (e.g., ja, zh-CN, zh-Hant-TW, etc.)."
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                }
+            ]
+        });
+    }
+    validate(input) {
+        if (typeof input === 'string') {
+            input = [input];
+        }
+        if (Array.isArray(input)) {
+            const validLocales = [];
+            for (const locale of input) {
+                if (typeof locale === 'string') {
+                    try {
+                        if (Intl.Segmenter.supportedLocalesOf(locale).length > 0) {
+                            validLocales.push(locale);
+                        }
+                    }
+                    catch {
+                    }
+                }
+            }
+            return validLocales;
+        }
+        return this.defaultValue;
+    }
+}
 class WrappingIndentOption extends BaseEditorOption {
     constructor() {
-        super(137 , 'wrappingIndent', 1 , {
+        super(138 , 'wrappingIndent', 1 , {
             'editor.wrappingIndent': {
                 type: 'string',
                 enum: ['none', 'same', 'indent', 'deepIndent'],
@@ -3197,10 +3278,10 @@ class WrappingIndentOption extends BaseEditorOption {
 }
 class EditorWrappingInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(145 );
+        super(146 );
     }
     compute(env, options, _) {
-        const layoutInfo = options.get(144 );
+        const layoutInfo = options.get(145 );
         return {
             isDominatedByLongLines: env.isDominatedByLongLines,
             isWordWrapMinified: layoutInfo.isWordWrapMinified,
@@ -3647,7 +3728,7 @@ const EditorOptions = {
         )) }
     ))),
     colorDecoratorActivatedOn: register(( new EditorStringEnumOption(
-        147 ,
+        148 ,
         'colorDecoratorsActivatedOn',
         'clickAndHover',
         ['clickAndHover', 'hover', 'click'],
@@ -3801,7 +3882,7 @@ const EditorOptions = {
             markdownDescription: ( localizeWithPath(
                 'vs/editor/common/config/editorOptions',
                 'cursorSurroundingLinesStyle',
-                "Controls when `#cursorSurroundingLines#` should be enforced."
+                "Controls when `#editor.cursorSurroundingLines#` should be enforced."
             ))
         }
     ))),
@@ -4484,7 +4565,7 @@ const EditorOptions = {
         )) }
     ))),
     showDeprecated: register(( new EditorBooleanOption(
-        139 ,
+        140 ,
         'showDeprecated',
         true,
         { description: ( localizeWithPath(
@@ -4551,7 +4632,7 @@ const EditorOptions = {
     inlineSuggest: register(( new InlineEditorSuggest())),
     inlineEdit: register(( new InlineEditorEdit())),
     inlineCompletionsAccessibilityVerbose: register(( new EditorBooleanOption(
-        148 ,
+        149 ,
         'inlineCompletionsAccessibilityVerbose',
         false,
         { description: ( localizeWithPath(
@@ -4704,7 +4785,7 @@ const EditorOptions = {
         { description: ( localizeWithPath(
             'vs/editor/common/config/editorOptions',
             'useTabStops',
-            "Inserting and deleting whitespace follows tab stops."
+            "Spaces and tabs are inserted and deleted in alignment with tab stops."
         )) }
     ))),
     wordBreak: register(( new EditorStringEnumOption(
@@ -4732,8 +4813,9 @@ const EditorOptions = {
             ))
         }
     ))),
+    wordSegmenterLocales: register(( new WordSegmenterLocales())),
     wordSeparators: register(( new EditorStringOption(
-        130 ,
+        131 ,
         'wordSeparators',
         USUAL_WORD_SEPARATORS,
         { description: ( localizeWithPath(
@@ -4743,7 +4825,7 @@ const EditorOptions = {
         )) }
     ))),
     wordWrap: register(( new EditorStringEnumOption(
-        131 ,
+        132 ,
         'wordWrap',
         'off',
         ['off', 'on', 'wordWrapColumn', 'bounded'],
@@ -4783,17 +4865,17 @@ const EditorOptions = {
         }
     ))),
     wordWrapBreakAfterCharacters: register(( new EditorStringOption(
-        132 ,
+        133 ,
         'wordWrapBreakAfterCharacters',
         ' \t})]?|/&.,;¢°′″‰℃、。｡､￠，．：；？！％・･ゝゞヽヾーァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ々〻ｧｨｩｪｫｬｭｮｯｰ”〉》」』】〕）］｝｣'
     ))),
     wordWrapBreakBeforeCharacters: register(( new EditorStringOption(
-        133 ,
+        134 ,
         'wordWrapBreakBeforeCharacters',
         '([{‘“〈《「『【〔（［｛｢£¥＄￡￥+＋'
     ))),
     wordWrapColumn: register(( new EditorIntOption(
-        134 ,
+        135 ,
         'wordWrapColumn',
         80,
         1,
@@ -4809,20 +4891,20 @@ const EditorOptions = {
         }
     ))),
     wordWrapOverride1: register(( new EditorStringEnumOption(
-        135 ,
+        136 ,
         'wordWrapOverride1',
         'inherit',
         ['off', 'on', 'inherit']
     ))),
     wordWrapOverride2: register(( new EditorStringEnumOption(
-        136 ,
+        137 ,
         'wordWrapOverride2',
         'inherit',
         ['off', 'on', 'inherit']
     ))),
     editorClassName: register(( new EditorClassName())),
     defaultColorDecorators: register(( new EditorBooleanOption(
-        146 ,
+        147 ,
         'defaultColorDecorators',
         false,
         { markdownDescription: ( localizeWithPath(
@@ -4833,7 +4915,7 @@ const EditorOptions = {
     ))),
     pixelRatio: register(( new EditorPixelRatio())),
     tabFocusMode: register(( new EditorBooleanOption(
-        143 ,
+        144 ,
         'tabFocusMode',
         false,
         { markdownDescription: ( localizeWithPath(

package/vscode/src/vs/editor/common/core/editorColorRegistry.js

@@ -1,6 +1,16 @@
 import { localizeWithPath } from '../../../nls.js';
 import { Color, RGBA } from '../../../base/common/color.js';
-import { registerColor, contrastBorder, activeContrastBorder, editorFindMatchHighlight, editorBackground, editorWarningForeground, editorWarningBorder, editorInfoForeground, editorInfoBorder, editorWarningBackground } from '../../../platform/theme/common/colorRegistry.js';
+import { registerColor } from '../../../platform/theme/common/colorUtils.js';
+import { contrastBorder, activeContrastBorder } from '../../../platform/theme/common/colors/baseColors.js';
+import '../../../platform/theme/common/colors/chartsColors.js';
+import { editorFindMatchHighlight, editorBackground, editorWarningForeground, editorWarningBorder, editorInfoForeground, editorInfoBorder, editorWarningBackground } from '../../../platform/theme/common/colors/editorColors.js';
+import '../../../platform/theme/common/colors/inputColors.js';
+import '../../../platform/theme/common/colors/listColors.js';
+import '../../../platform/theme/common/colors/menuColors.js';
+import '../../../platform/theme/common/colors/minimapColors.js';
+import '../../../platform/theme/common/colors/miscColors.js';
+import '../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../platform/theme/common/colors/searchColors.js';
 import { registerThemingParticipant } from '../../../platform/theme/common/themeService.js';
 const editorLineHighlight = registerColor('editor.lineHighlightBackground', { dark: null, light: null, hcDark: null, hcLight: null }, ( localizeWithPath(
  'vs/editor/common/core/editorColorRegistry',
@@ -42,6 +52,26 @@ const editorCursorBackground = registerColor('editorCursor.background', null, (
  'editorCursorBackground',
  'The background color of the editor cursor. Allows customizing the color of a character overlapped by a block cursor.'
 )));
+const editorMultiCursorPrimaryForeground = registerColor('editorMultiCursor.primary.foreground', { dark: editorCursorForeground, light: editorCursorForeground, hcDark: editorCursorForeground, hcLight: editorCursorForeground }, ( localizeWithPath(
+ 'vs/editor/common/core/editorColorRegistry',
+ 'editorMultiCursorPrimaryForeground',
+ 'Color of the primary editor cursor when multiple cursors are present.'
+)));
+const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', { dark: editorCursorBackground, light: editorCursorBackground, hcDark: editorCursorBackground, hcLight: editorCursorBackground }, ( localizeWithPath(
+ 'vs/editor/common/core/editorColorRegistry',
+ 'editorMultiCursorPrimaryBackground',
+ 'The background color of the primary editor cursor when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'
+)));
+const editorMultiCursorSecondaryForeground = registerColor('editorMultiCursor.secondary.foreground', { dark: editorCursorForeground, light: editorCursorForeground, hcDark: editorCursorForeground, hcLight: editorCursorForeground }, ( localizeWithPath(
+ 'vs/editor/common/core/editorColorRegistry',
+ 'editorMultiCursorSecondaryForeground',
+ 'Color of secondary editor cursors when multiple cursors are present.'
+)));
+const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', { dark: editorCursorBackground, light: editorCursorBackground, hcDark: editorCursorBackground, hcLight: editorCursorBackground }, ( localizeWithPath(
+ 'vs/editor/common/core/editorColorRegistry',
+ 'editorMultiCursorSecondaryBackground',
+ 'The background color of secondary editor cursors when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'
+)));
 const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, ( localizeWithPath(
  'vs/editor/common/core/editorColorRegistry',
  'editorWhitespaces',
@@ -343,4 +373,4 @@ registerThemingParticipant((theme, collector) => {
         collector.addRule(`.monaco-editor .inputarea.ime-input { background-color: ${imeBackground}; }`);
     }
 });
-export { deprecatedEditorActiveIndentGuides, deprecatedEditorIndentGuides, editorActiveIndentGuide1, editorActiveIndentGuide2, editorActiveIndentGuide3, editorActiveIndentGuide4, editorActiveIndentGuide5, editorActiveIndentGuide6, editorBracketHighlightingForeground1, editorBracketHighlightingForeground2, editorBracketHighlightingForeground3, editorBracketHighlightingForeground4, editorBracketHighlightingForeground5, editorBracketHighlightingForeground6, editorBracketHighlightingUnexpectedBracketForeground, editorBracketPairGuideActiveBackground1, editorBracketPairGuideActiveBackground2, editorBracketPairGuideActiveBackground3, editorBracketPairGuideActiveBackground4, editorBracketPairGuideActiveBackground5, editorBracketPairGuideActiveBackground6, editorBracketPairGuideBackground1, editorBracketPairGuideBackground2, editorBracketPairGuideBackground3, editorBracketPairGuideBackground4, editorBracketPairGuideBackground5, editorBracketPairGuideBackground6, editorCursorBackground, editorCursorForeground, editorDimmedLineNumber, editorGutter, editorIndentGuide1, editorIndentGuide2, editorIndentGuide3, editorIndentGuide4, editorIndentGuide5, editorIndentGuide6, editorLineHighlight, editorLineHighlightBorder, editorLineNumbers, editorOverviewRulerBackground, editorOverviewRulerBorder, editorRangeHighlight, editorUnnecessaryCodeOpacity, editorWhitespaces, overviewRulerError, overviewRulerInfo, overviewRulerRangeHighlight, overviewRulerWarning };
+export { deprecatedEditorActiveIndentGuides, deprecatedEditorIndentGuides, editorActiveIndentGuide1, editorActiveIndentGuide2, editorActiveIndentGuide3, editorActiveIndentGuide4, editorActiveIndentGuide5, editorActiveIndentGuide6, editorBracketHighlightingForeground1, editorBracketHighlightingForeground2, editorBracketHighlightingForeground3, editorBracketHighlightingForeground4, editorBracketHighlightingForeground5, editorBracketHighlightingForeground6, editorBracketHighlightingUnexpectedBracketForeground, editorBracketPairGuideActiveBackground1, editorBracketPairGuideActiveBackground2, editorBracketPairGuideActiveBackground3, editorBracketPairGuideActiveBackground4, editorBracketPairGuideActiveBackground5, editorBracketPairGuideActiveBackground6, editorBracketPairGuideBackground1, editorBracketPairGuideBackground2, editorBracketPairGuideBackground3, editorBracketPairGuideBackground4, editorBracketPairGuideBackground5, editorBracketPairGuideBackground6, editorCursorBackground, editorCursorForeground, editorDimmedLineNumber, editorGutter, editorIndentGuide1, editorIndentGuide2, editorIndentGuide3, editorIndentGuide4, editorIndentGuide5, editorIndentGuide6, editorLineHighlight, editorLineHighlightBorder, editorLineNumbers, editorMultiCursorPrimaryBackground, editorMultiCursorPrimaryForeground, editorMultiCursorSecondaryBackground, editorMultiCursorSecondaryForeground, editorOverviewRulerBackground, editorOverviewRulerBorder, editorRangeHighlight, editorUnnecessaryCodeOpacity, editorWhitespaces, overviewRulerError, overviewRulerInfo, overviewRulerRangeHighlight, overviewRulerWarning };

package/vscode/src/vs/editor/common/core/lineRange.d.ts

@@ -12,6 +12,7 @@ declare class LineRange {
      * @param lineRanges An array of sorted line ranges.
      */
     static joinMany(lineRanges: readonly (readonly LineRange[])[]): readonly LineRange[];
+    static join(lineRanges: LineRange[]): LineRange;
     static ofLength(startLineNumber: number, length: number): LineRange;
     /**
      * @internal

package/vscode/src/vs/editor/common/core/lineRange.js

@@ -42,6 +42,18 @@ class LineRange {
         }
         return result.ranges;
     }
+    static join(lineRanges) {
+        if (lineRanges.length === 0) {
+            throw new BugIndicatingError('lineRanges cannot be empty');
+        }
+        let startLineNumber = lineRanges[0].startLineNumber;
+        let endLineNumberExclusive = lineRanges[0].endLineNumberExclusive;
+        for (let i = 1; i < lineRanges.length; i++) {
+            startLineNumber = Math.min(startLineNumber, lineRanges[i].startLineNumber);
+            endLineNumberExclusive = Math.max(endLineNumberExclusive, lineRanges[i].endLineNumberExclusive);
+        }
+        return ( new LineRange(startLineNumber, endLineNumberExclusive));
+    }
     static ofLength(startLineNumber, length) {
         return ( new LineRange(startLineNumber, startLineNumber + length));
     }

package/vscode/src/vs/editor/common/core/positionToOffset.js

@@ -0,0 +1,43 @@
+import { findLastIdxMonotonous } from '../../../base/common/arraysFind.js';
+import { OffsetRange } from './offsetRange.js';
+import { Position } from './position.js';
+import { Range } from './range.js';
+import { TextLength } from './textLength.js';
+class PositionOffsetTransformer {
+    constructor(text) {
+        this.text = text;
+        this.lineStartOffsetByLineIdx = [];
+        this.lineStartOffsetByLineIdx.push(0);
+        for (let i = 0; i < text.length; i++) {
+            if (text.charAt(i) === '\n') {
+                this.lineStartOffsetByLineIdx.push(i + 1);
+            }
+        }
+    }
+    getOffset(position) {
+        return this.lineStartOffsetByLineIdx[position.lineNumber - 1] + position.column - 1;
+    }
+    getOffsetRange(range) {
+        return ( new OffsetRange(
+            this.getOffset(range.getStartPosition()),
+            this.getOffset(range.getEndPosition())
+        ));
+    }
+    getPosition(offset) {
+        const idx = findLastIdxMonotonous(this.lineStartOffsetByLineIdx, i => i <= offset);
+        const lineNumber = idx + 1;
+        const column = offset - this.lineStartOffsetByLineIdx[idx] + 1;
+        return ( new Position(lineNumber, column));
+    }
+    getRange(offsetRange) {
+        return Range.fromPositions(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
+    }
+    getTextLength(offsetRange) {
+        return TextLength.ofRange(this.getRange(offsetRange));
+    }
+    get textLength() {
+        const lineIdx = this.lineStartOffsetByLineIdx.length - 1;
+        return ( new TextLength(lineIdx, this.text.length - this.lineStartOffsetByLineIdx[lineIdx]));
+    }
+}
+export { PositionOffsetTransformer };

package/vscode/src/vs/editor/common/core/textEdit.js

@@ -0,0 +1,169 @@
+import { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';
+import { BugIndicatingError } from '../../../base/common/errors.js';
+import { Position } from './position.js';
+import { PositionOffsetTransformer } from './positionToOffset.js';
+import { Range } from './range.js';
+import { TextLength } from './textLength.js';
+class TextEdit {
+    constructor(edits) {
+        this.edits = edits;
+        assertFn(() => checkAdjacentItems(edits, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
+    }
+    normalize() {
+        const edits = [];
+        for (const edit of this.edits) {
+            if (edits.length > 0 && edits[edits.length - 1].range.getEndPosition().equals(edit.range.getStartPosition())) {
+                const last = edits[edits.length - 1];
+                edits[edits.length - 1] = ( new SingleTextEdit(last.range.plusRange(edit.range), last.text + edit.text));
+            }
+            else if (!edit.isEmpty) {
+                edits.push(edit);
+            }
+        }
+        return ( new TextEdit(edits));
+    }
+    mapPosition(position) {
+        let lineDelta = 0;
+        let curLine = 0;
+        let columnDeltaInCurLine = 0;
+        for (const edit of this.edits) {
+            const start = edit.range.getStartPosition();
+            const end = edit.range.getEndPosition();
+            if (position.isBeforeOrEqual(start)) {
+                break;
+            }
+            const len = TextLength.ofText(edit.text);
+            if (position.isBefore(end)) {
+                const startPos = ( new Position(
+                    start.lineNumber + lineDelta,
+                    start.column + (start.lineNumber + lineDelta === curLine ? columnDeltaInCurLine : 0)
+                ));
+                const endPos = len.addToPosition(startPos);
+                return rangeFromPositions(startPos, endPos);
+            }
+            lineDelta += len.lineCount - (edit.range.endLineNumber - edit.range.startLineNumber);
+            if (len.lineCount === 0) {
+                if (end.lineNumber !== start.lineNumber) {
+                    columnDeltaInCurLine += len.columnCount - (end.column - 1);
+                }
+                else {
+                    columnDeltaInCurLine += len.columnCount - (end.column - start.column);
+                }
+            }
+            else {
+                columnDeltaInCurLine = len.columnCount;
+            }
+            curLine = end.lineNumber + lineDelta;
+        }
+        return ( new Position(
+            position.lineNumber + lineDelta,
+            position.column + (position.lineNumber + lineDelta === curLine ? columnDeltaInCurLine : 0)
+        ));
+    }
+    mapRange(range) {
+        function getStart(p) {
+            return p instanceof Position ? p : p.getStartPosition();
+        }
+        function getEnd(p) {
+            return p instanceof Position ? p : p.getEndPosition();
+        }
+        const start = getStart(this.mapPosition(range.getStartPosition()));
+        const end = getEnd(this.mapPosition(range.getEndPosition()));
+        return rangeFromPositions(start, end);
+    }
+    inverseMapPosition(positionAfterEdit, doc) {
+        const reversed = this.inverse(doc);
+        return reversed.mapPosition(positionAfterEdit);
+    }
+    inverseMapRange(range, doc) {
+        const reversed = this.inverse(doc);
+        return reversed.mapRange(range);
+    }
+    apply(text) {
+        let result = '';
+        let lastEditEnd = ( new Position(1, 1));
+        for (const edit of this.edits) {
+            const editRange = edit.range;
+            const editStart = editRange.getStartPosition();
+            const editEnd = editRange.getEndPosition();
+            const r = rangeFromPositions(lastEditEnd, editStart);
+            if (!r.isEmpty()) {
+                result += text.getValueOfRange(r);
+            }
+            result += edit.text;
+            lastEditEnd = editEnd;
+        }
+        const r = rangeFromPositions(lastEditEnd, text.endPositionExclusive);
+        if (!r.isEmpty()) {
+            result += text.getValueOfRange(r);
+        }
+        return result;
+    }
+    applyToString(str) {
+        const strText = ( new StringText(str));
+        return this.apply(strText);
+    }
+    inverse(doc) {
+        const ranges = this.getNewRanges();
+        return ( new TextEdit(( this.edits.map((e, idx) => ( new SingleTextEdit(ranges[idx], doc.getValueOfRange(e.range)))))));
+    }
+    getNewRanges() {
+        const newRanges = [];
+        let previousEditEndLineNumber = 0;
+        let lineOffset = 0;
+        let columnOffset = 0;
+        for (const edit of this.edits) {
+            const textLength = TextLength.ofText(edit.text);
+            const newRangeStart = Position.lift({
+                lineNumber: edit.range.startLineNumber + lineOffset,
+                column: edit.range.startColumn + (edit.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)
+            });
+            const newRange = textLength.createRange(newRangeStart);
+            newRanges.push(newRange);
+            lineOffset = newRange.endLineNumber - edit.range.endLineNumber;
+            columnOffset = newRange.endColumn - edit.range.endColumn;
+            previousEditEndLineNumber = edit.range.endLineNumber;
+        }
+        return newRanges;
+    }
+}
+class SingleTextEdit {
+    constructor(range, text) {
+        this.range = range;
+        this.text = text;
+    }
+    get isEmpty() {
+        return this.range.isEmpty() && this.text.length === 0;
+    }
+    static equals(first, second) {
+        return first.range.equalsRange(second.range) && first.text === second.text;
+    }
+}
+function rangeFromPositions(start, end) {
+    if (!start.isBeforeOrEqual(end)) {
+        throw new BugIndicatingError('start must be before end');
+    }
+    return ( new Range(start.lineNumber, start.column, end.lineNumber, end.column));
+}
+class AbstractText {
+    get endPositionExclusive() {
+        return this.length.addToPosition(( new Position(1, 1)));
+    }
+    getValue() {
+        return this.getValueOfRange(this.length.toRange());
+    }
+}
+class StringText extends AbstractText {
+    constructor(value) {
+        super();
+        this.value = value;
+        this._t = ( new PositionOffsetTransformer(this.value));
+    }
+    getValueOfRange(range) {
+        return this._t.getOffsetRange(range).substring(this.value);
+    }
+    get length() {
+        return this._t.textLength;
+    }
+}
+export { AbstractText, SingleTextEdit, StringText, TextEdit };