@codingame/monaco-vscode-api 22.1.8 → 23.0.0

package/vscode/src/vs/editor/common/config/editorZoom.d.ts

@@ -1,6 +1,6 @@
 import { Event } from "../../../base/common/event.js";
 export interface IEditorZoom {
-    onDidChangeZoomLevel: Event<number>;
+    readonly onDidChangeZoomLevel: Event<number>;
     getZoomLevel(): number;
     setZoomLevel(zoomLevel: number): void;
 }

package/vscode/src/vs/editor/common/config/fontInfo.d.ts

@@ -19,23 +19,7 @@ export declare class BareFontInfo {
     /**
      * @internal
      */
-    static createFromValidatedSettings(options: IValidatedEditorOptions, pixelRatio: number, ignoreEditorZoom: boolean): BareFontInfo;
-    /**
-     * @internal
-     */
-    static createFromRawSettings(opts: {
-        fontFamily?: string;
-        fontWeight?: string;
-        fontSize?: number;
-        fontLigatures?: boolean | string;
-        fontVariations?: boolean | string;
-        lineHeight?: number;
-        letterSpacing?: number;
-    }, pixelRatio: number, ignoreEditorZoom?: boolean): BareFontInfo;
-    /**
-     * @internal
-     */
-    private static _create;
+    static _create(fontFamily: string, fontWeight: string, fontSize: number, fontFeatureSettings: string, fontVariationSettings: string, lineHeight: number, letterSpacing: number, pixelRatio: number, ignoreEditorZoom: boolean): BareFontInfo;
     readonly pixelRatio: number;
     readonly fontFamily: string;
     readonly fontWeight: string;
@@ -106,3 +90,33 @@ export declare class FontInfo extends BareFontInfo {
      */
     equals(other: FontInfo): boolean;
 }
+/**
+ * @internal
+ */
+export declare const FONT_VARIATION_OFF = "normal";
+/**
+ * @internal
+ */
+export declare const FONT_VARIATION_TRANSLATE = "translate";
+/**
+ * @internal
+ */
+export declare const DEFAULT_WINDOWS_FONT_FAMILY = "Consolas, 'Courier New', monospace";
+/**
+ * @internal
+ */
+export declare const DEFAULT_MAC_FONT_FAMILY = "Menlo, Monaco, 'Courier New', monospace";
+/**
+ * @internal
+ */
+export declare const DEFAULT_LINUX_FONT_FAMILY = "'Droid Sans Mono', 'monospace', monospace";
+/**
+ * @internal
+ */
+export declare const EDITOR_FONT_DEFAULTS: {
+    fontFamily: string;
+    fontWeight: string;
+    fontSize: number;
+    lineHeight: number;
+    letterSpacing: number;
+};

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

@@ -1,31 +1,10 @@
 
-import { isMacintosh } from '../../../base/common/platform.js';
-import { EditorOption, EditorOptions, EditorFontVariations, EDITOR_FONT_DEFAULTS } from './editorOptions.js';
+import { isMacintosh, isWindows } from '../../../base/common/platform.js';
 import { EditorZoom } from './editorZoom.js';
 
 const GOLDEN_LINE_HEIGHT_RATIO = isMacintosh ? 1.5 : 1.35;
 const MINIMUM_LINE_HEIGHT = 8;
 class BareFontInfo {
-    static createFromValidatedSettings(options, pixelRatio, ignoreEditorZoom) {
-        const fontFamily = options.get(EditorOption.fontFamily);
-        const fontWeight = options.get(EditorOption.fontWeight);
-        const fontSize = options.get(EditorOption.fontSize);
-        const fontFeatureSettings = options.get(EditorOption.fontLigatures);
-        const fontVariationSettings = options.get(EditorOption.fontVariations);
-        const lineHeight = options.get(EditorOption.lineHeight);
-        const letterSpacing = options.get(EditorOption.letterSpacing);
-        return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
-    }
-    static createFromRawSettings(opts, pixelRatio, ignoreEditorZoom = false) {
-        const fontFamily = EditorOptions.fontFamily.validate(opts.fontFamily);
-        const fontWeight = EditorOptions.fontWeight.validate(opts.fontWeight);
-        const fontSize = EditorOptions.fontSize.validate(opts.fontSize);
-        const fontFeatureSettings = EditorOptions.fontLigatures2.validate(opts.fontLigatures);
-        const fontVariationSettings = EditorOptions.fontVariations.validate(opts.fontVariations);
-        const lineHeight = EditorOptions.lineHeight.validate(opts.lineHeight);
-        const letterSpacing = EditorOptions.letterSpacing.validate(opts.letterSpacing);
-        return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
-    }
     static _create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom) {
         if (lineHeight === 0) {
             lineHeight = GOLDEN_LINE_HEIGHT_RATIO * fontSize;
@@ -40,9 +19,9 @@ class BareFontInfo {
         const editorZoomLevelMultiplier = 1 + (ignoreEditorZoom ? 0 : EditorZoom.getZoomLevel() * 0.1);
         fontSize *= editorZoomLevelMultiplier;
         lineHeight *= editorZoomLevelMultiplier;
-        if (fontVariationSettings === EditorFontVariations.TRANSLATE) {
+        if (fontVariationSettings === FONT_VARIATION_TRANSLATE) {
             if (fontWeight === 'normal' || fontWeight === 'bold') {
-                fontVariationSettings = EditorFontVariations.OFF;
+                fontVariationSettings = FONT_VARIATION_OFF;
             }
             else {
                 const fontWeightAsNumber = parseInt(fontWeight, 10);
@@ -126,5 +105,17 @@ class FontInfo extends BareFontInfo {
             && this.maxDigitWidth === other.maxDigitWidth);
     }
 }
+const FONT_VARIATION_OFF = 'normal';
+const FONT_VARIATION_TRANSLATE = 'translate';
+const DEFAULT_WINDOWS_FONT_FAMILY = 'Consolas, \'Courier New\', monospace';
+const DEFAULT_MAC_FONT_FAMILY = 'Menlo, Monaco, \'Courier New\', monospace';
+const DEFAULT_LINUX_FONT_FAMILY = '\'Droid Sans Mono\', \'monospace\', monospace';
+const EDITOR_FONT_DEFAULTS = {
+    fontFamily: (isMacintosh ? DEFAULT_MAC_FONT_FAMILY : (isWindows ? DEFAULT_WINDOWS_FONT_FAMILY : DEFAULT_LINUX_FONT_FAMILY)),
+    fontWeight: 'normal',
+    fontSize: (isMacintosh ? 12 : 14),
+    lineHeight: 0,
+    letterSpacing: 0,
+};
 
-export { BareFontInfo, FontInfo, GOLDEN_LINE_HEIGHT_RATIO, MINIMUM_LINE_HEIGHT, SERIALIZED_FONT_INFO_VERSION };
+export { BareFontInfo, DEFAULT_LINUX_FONT_FAMILY, DEFAULT_MAC_FONT_FAMILY, DEFAULT_WINDOWS_FONT_FAMILY, EDITOR_FONT_DEFAULTS, FONT_VARIATION_OFF, FONT_VARIATION_TRANSLATE, FontInfo, GOLDEN_LINE_HEIGHT_RATIO, MINIMUM_LINE_HEIGHT, SERIALIZED_FONT_INFO_VERSION };

package/vscode/src/vs/editor/common/config/fontInfoFromSettings.d.ts

@@ -0,0 +1,11 @@
+import { IValidatedEditorOptions, BareFontInfo } from "./fontInfo.js";
+export declare function createBareFontInfoFromValidatedSettings(options: IValidatedEditorOptions, pixelRatio: number, ignoreEditorZoom: boolean): BareFontInfo;
+export declare function createBareFontInfoFromRawSettings(opts: {
+    fontFamily?: unknown;
+    fontWeight?: unknown;
+    fontSize?: unknown;
+    fontLigatures?: unknown;
+    fontVariations?: unknown;
+    lineHeight?: unknown;
+    letterSpacing?: unknown;
+}, pixelRatio: number, ignoreEditorZoom?: boolean): BareFontInfo;

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

@@ -0,0 +1,26 @@
+
+import { EditorOption, EditorOptions } from './editorOptions.js';
+import { BareFontInfo } from './fontInfo.js';
+
+function createBareFontInfoFromValidatedSettings(options, pixelRatio, ignoreEditorZoom) {
+    const fontFamily = options.get(EditorOption.fontFamily);
+    const fontWeight = options.get(EditorOption.fontWeight);
+    const fontSize = options.get(EditorOption.fontSize);
+    const fontFeatureSettings = options.get(EditorOption.fontLigatures);
+    const fontVariationSettings = options.get(EditorOption.fontVariations);
+    const lineHeight = options.get(EditorOption.lineHeight);
+    const letterSpacing = options.get(EditorOption.letterSpacing);
+    return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
+}
+function createBareFontInfoFromRawSettings(opts, pixelRatio, ignoreEditorZoom = false) {
+    const fontFamily = EditorOptions.fontFamily.validate(opts.fontFamily);
+    const fontWeight = EditorOptions.fontWeight.validate(opts.fontWeight);
+    const fontSize = EditorOptions.fontSize.validate(opts.fontSize);
+    const fontFeatureSettings = EditorOptions.fontLigatures2.validate(opts.fontLigatures);
+    const fontVariationSettings = EditorOptions.fontVariations.validate(opts.fontVariations);
+    const lineHeight = EditorOptions.lineHeight.validate(opts.lineHeight);
+    const letterSpacing = EditorOptions.letterSpacing.validate(opts.letterSpacing);
+    return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
+}
+
+export { createBareFontInfoFromRawSettings, createBareFontInfoFromValidatedSettings };

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

@@ -14,174 +14,174 @@ 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', null, ( localize(675, 'Background color for the highlight of line at the cursor position.')));
+const editorLineHighlight = registerColor('editor.lineHighlightBackground', null, ( localize(673, 'Background color for the highlight of line at the cursor position.')));
 const editorLineHighlightBorder = registerColor('editor.lineHighlightBorder', { dark: '#282828', light: '#eeeeee', hcDark: '#f38518', hcLight: contrastBorder }, ( localize(
- 676,
+ 674,
  'Background color for the border around the line at the cursor position.'
 )));
 const editorRangeHighlight = registerColor('editor.rangeHighlightBackground', { dark: '#ffffff0b', light: '#fdff0033', hcDark: null, hcLight: null }, ( localize(
- 677,
+ 675,
  'Background color of highlighted ranges, like by quick open and find features. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
-registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(678, 'Background color of the border around highlighted ranges.')));
+registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(676, 'Background color of the border around highlighted ranges.')));
 registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, ( localize(
- 679,
+ 677,
  'Background color of highlighted symbol, like for go to definition or go next/previous symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
-registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(680, 'Background color of the border around highlighted symbols.')));
-const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localize(681, 'Color of the editor cursor.')));
+registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(678, 'Background color of the border around highlighted symbols.')));
+const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, ( localize(679, 'Color of the editor cursor.')));
 const editorCursorBackground = registerColor('editorCursor.background', null, ( localize(
- 682,
+ 680,
  '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', editorCursorForeground, ( localize(
- 683,
+ 681,
  'Color of the primary editor cursor when multiple cursors are present.'
 )));
 const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', editorCursorBackground, ( localize(
- 684,
+ 682,
  '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', editorCursorForeground, ( localize(
- 685,
+ 683,
  'Color of secondary editor cursors when multiple cursors are present.'
 )));
 const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', editorCursorBackground, ( localize(
- 686,
+ 684,
  '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' }, ( localize(687, 'Color of whitespace characters in the editor.')));
-const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localize(688, 'Color of editor line numbers.')));
-const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, ( localize(689, 'Color of the editor indentation guides.')), false, ( localize(
- 690,
+const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, ( localize(685, 'Color of whitespace characters in the editor.')));
+const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, ( localize(686, 'Color of editor line numbers.')));
+const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, ( localize(687, 'Color of the editor indentation guides.')), false, ( localize(
+ 688,
  '\'editorIndentGuide.background\' is deprecated. Use \'editorIndentGuide.background1\' instead.'
 )));
-const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localize(691, 'Color of the active editor indentation guides.')), false, ( localize(
- 692,
+const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, ( localize(689, 'Color of the active editor indentation guides.')), false, ( localize(
+ 690,
  '\'editorIndentGuide.activeBackground\' is deprecated. Use \'editorIndentGuide.activeBackground1\' instead.'
 )));
-const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localize(693, 'Color of the editor indentation guides (1).')));
-const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localize(694, 'Color of the editor indentation guides (2).')));
-const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localize(695, 'Color of the editor indentation guides (3).')));
-const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localize(696, 'Color of the editor indentation guides (4).')));
-const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localize(697, 'Color of the editor indentation guides (5).')));
-const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localize(698, 'Color of the editor indentation guides (6).')));
-const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localize(699, 'Color of the active editor indentation guides (1).')));
-const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localize(700, 'Color of the active editor indentation guides (2).')));
-const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localize(701, 'Color of the active editor indentation guides (3).')));
-const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localize(702, 'Color of the active editor indentation guides (4).')));
-const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localize(703, 'Color of the active editor indentation guides (5).')));
-const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', ( localize(704, 'Color of the active editor indentation guides (6).')));
-const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(705, 'Color of editor active line number')), false, ( localize(
- 706,
+const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, ( localize(691, 'Color of the editor indentation guides (1).')));
+const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', ( localize(692, 'Color of the editor indentation guides (2).')));
+const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', ( localize(693, 'Color of the editor indentation guides (3).')));
+const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', ( localize(694, 'Color of the editor indentation guides (4).')));
+const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', ( localize(695, 'Color of the editor indentation guides (5).')));
+const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', ( localize(696, 'Color of the editor indentation guides (6).')));
+const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, ( localize(697, 'Color of the active editor indentation guides (1).')));
+const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', ( localize(698, 'Color of the active editor indentation guides (2).')));
+const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', ( localize(699, 'Color of the active editor indentation guides (3).')));
+const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', ( localize(700, 'Color of the active editor indentation guides (4).')));
+const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', ( localize(701, 'Color of the active editor indentation guides (5).')));
+const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', ( localize(702, 'Color of the active editor indentation guides (6).')));
+const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(703, 'Color of editor active line number')), false, ( localize(
+ 704,
  'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'
 )));
-registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localize(705, 'Color of editor active line number')));
+registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, ( localize(703, 'Color of editor active line number')));
 const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', null, ( localize(
- 707,
+ 705,
  'Color of the final editor line when editor.renderFinalNewline is set to dimmed.'
 )));
-const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localize(708, 'Color of the editor rulers.')));
-registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localize(709, 'Foreground color of editor CodeLens')));
-registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localize(710, 'Background color behind matching brackets')));
-registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localize(711, 'Color for matching brackets boxes')));
-const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localize(712, 'Color of the overview ruler border.')));
-const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localize(713, 'Background color of the editor overview ruler.')));
+const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, ( localize(706, 'Color of the editor rulers.')));
+registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, ( localize(707, 'Foreground color of editor CodeLens')));
+registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, ( localize(708, 'Background color behind matching brackets')));
+registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, ( localize(709, 'Color for matching brackets boxes')));
+const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, ( localize(710, 'Color of the overview ruler border.')));
+const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, ( localize(711, 'Background color of the editor overview ruler.')));
 registerColor('editorGutter.background', editorBackground, ( localize(
- 714,
+ 712,
  'Background color of the editor gutter. The gutter contains the glyph margins and the line numbers.'
 )));
-registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: ( ( Color.fromHex('#fff')).transparent(0.8)), hcLight: contrastBorder }, ( localize(715, 'Border color of unnecessary (unused) source code in the editor.')));
+registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: ( ( Color.fromHex('#fff')).transparent(0.8)), hcLight: contrastBorder }, ( localize(713, 'Border color of unnecessary (unused) source code in the editor.')));
 const editorUnnecessaryCodeOpacity = registerColor('editorUnnecessaryCode.opacity', { dark: ( Color.fromHex('#000a')), light: ( Color.fromHex('#0007')), hcDark: null, hcLight: null }, ( localize(
- 716,
+ 714,
  'Opacity of unnecessary (unused) source code in the editor. For example, "#000000c0" will render the code with 75% opacity. For high contrast themes, use the  \'editorUnnecessaryCode.border\' theme color to underline unnecessary code instead of fading it out.'
 )));
-registerColor('editorGhostText.border', { dark: null, light: null, hcDark: ( ( Color.fromHex('#fff')).transparent(0.8)), hcLight: ( ( Color.fromHex('#292929')).transparent(0.8)) }, ( localize(717, 'Border color of ghost text in the editor.')));
-const ghostTextForeground = registerColor('editorGhostText.foreground', { dark: ( Color.fromHex('#ffffff56')), light: ( Color.fromHex('#0007')), hcDark: null, hcLight: null }, ( localize(718, 'Foreground color of the ghost text in the editor.')));
-registerColor('editorGhostText.background', null, ( localize(719, 'Background color of the ghost text in the editor.')));
+registerColor('editorGhostText.border', { dark: null, light: null, hcDark: ( ( Color.fromHex('#fff')).transparent(0.8)), hcLight: ( ( Color.fromHex('#292929')).transparent(0.8)) }, ( localize(715, 'Border color of ghost text in the editor.')));
+const ghostTextForeground = registerColor('editorGhostText.foreground', { dark: ( Color.fromHex('#ffffff56')), light: ( Color.fromHex('#0007')), hcDark: null, hcLight: null }, ( localize(716, 'Foreground color of the ghost text in the editor.')));
+registerColor('editorGhostText.background', null, ( localize(717, 'Background color of the ghost text in the editor.')));
 const rulerRangeDefault = ( new Color(( new RGBA(0, 122, 204, 0.6))));
 const overviewRulerRangeHighlight = registerColor('editorOverviewRuler.rangeHighlightForeground', rulerRangeDefault, ( localize(
- 720,
+ 718,
  'Overview ruler marker color for range highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
-const overviewRulerError = registerColor('editorOverviewRuler.errorForeground', { dark: ( new Color(( new RGBA(255, 18, 18, 0.7)))), light: ( new Color(( new RGBA(255, 18, 18, 0.7)))), hcDark: ( new Color(( new RGBA(255, 50, 50, 1)))), hcLight: '#B5200D' }, ( localize(721, 'Overview ruler marker color for errors.')));
-const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localize(722, 'Overview ruler marker color for warnings.')));
-const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localize(723, 'Overview ruler marker color for infos.')));
+const overviewRulerError = registerColor('editorOverviewRuler.errorForeground', { dark: ( new Color(( new RGBA(255, 18, 18, 0.7)))), light: ( new Color(( new RGBA(255, 18, 18, 0.7)))), hcDark: ( new Color(( new RGBA(255, 50, 50, 1)))), hcLight: '#B5200D' }, ( localize(719, 'Overview ruler marker color for errors.')));
+const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, ( localize(720, 'Overview ruler marker color for warnings.')));
+const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, ( localize(721, 'Overview ruler marker color for infos.')));
 const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, ( localize(
- 724,
+ 722,
  'Foreground color of brackets (1). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, ( localize(
- 725,
+ 723,
  'Foreground color of brackets (2). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, ( localize(
- 726,
+ 724,
  'Foreground color of brackets (3). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', '#00000000', ( localize(
- 727,
+ 725,
  'Foreground color of brackets (4). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', ( localize(
- 728,
+ 726,
  'Foreground color of brackets (5). Requires enabling bracket pair colorization.'
 )));
 const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', ( localize(
- 729,
+ 727,
  'Foreground color of brackets (6). Requires enabling bracket pair colorization.'
 )));
-const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: ( new Color(( new RGBA(255, 18, 18, 0.8)))), light: ( new Color(( new RGBA(255, 18, 18, 0.8)))), hcDark: ( new Color(( new RGBA(255, 50, 50, 1)))), hcLight: '#B5200D' }, ( localize(730, 'Foreground color of unexpected brackets.')));
+const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: ( new Color(( new RGBA(255, 18, 18, 0.8)))), light: ( new Color(( new RGBA(255, 18, 18, 0.8)))), hcDark: ( new Color(( new RGBA(255, 50, 50, 1)))), hcLight: '#B5200D' }, ( localize(728, 'Foreground color of unexpected brackets.')));
 const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', ( localize(
- 731,
+ 729,
  'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', ( localize(
- 732,
+ 730,
  'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', '#00000000', ( localize(
- 733,
+ 731,
  'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', '#00000000', ( localize(
- 734,
+ 732,
  'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', '#00000000', ( localize(
- 735,
+ 733,
  'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', '#00000000', ( localize(
- 736,
+ 734,
  'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', '#00000000', ( localize(
- 737,
+ 735,
  'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', '#00000000', ( localize(
- 738,
+ 736,
  'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', '#00000000', ( localize(
- 739,
+ 737,
  'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', '#00000000', ( localize(
- 740,
+ 738,
  'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', '#00000000', ( localize(
- 741,
+ 739,
  'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'
 )));
 const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', '#00000000', ( localize(
- 742,
+ 740,
  'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'
 )));
-registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localize(743, 'Border color used to highlight unicode characters.')));
-registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localize(744, 'Background color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.border', editorWarningForeground, ( localize(741, 'Border color used to highlight unicode characters.')));
+registerColor('editorUnicodeHighlight.background', editorWarningBackground, ( localize(742, 'Background color used to highlight unicode characters.')));
 registerThemingParticipant((theme, collector) => {
     const background = theme.getColor(editorBackground);
     const lineHighlight = theme.getColor(editorLineHighlight);

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

@@ -85,6 +85,6 @@ export declare class Position {
     /**
      * Test if `obj` is an `IPosition`.
      */
-    static isIPosition(obj: any): obj is IPosition;
+    static isIPosition(obj: unknown): obj is IPosition;
     toJSON(): IPosition;
 }

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

@@ -72,7 +72,7 @@ class Position {
         return ( new Position(pos.lineNumber, pos.column));
     }
     static isIPosition(obj) {
-        return (obj
+        return (!!obj
             && (typeof obj.lineNumber === 'number')
             && (typeof obj.column === 'number'));
     }

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

@@ -163,7 +163,7 @@ export declare class Range {
     /**
      * Test if `obj` is an `IRange`.
      */
-    static isIRange(obj: any): obj is IRange;
+    static isIRange(obj: unknown): obj is IRange;
     /**
      * Test if the two ranges are touching in any way.
      */

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

@@ -236,7 +236,7 @@ class Range {
         ));
     }
     static isIRange(obj) {
-        return (obj
+        return (!!obj
             && (typeof obj.startLineNumber === 'number')
             && (typeof obj.startColumn === 'number')
             && (typeof obj.endLineNumber === 'number')

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

@@ -108,7 +108,7 @@ export declare class Selection extends Range {
     /**
      * Test if `obj` is an `ISelection`.
      */
-    static isISelection(obj: any): obj is ISelection;
+    static isISelection(obj: unknown): obj is ISelection;
     /**
      * Create with a direction.
      */

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

@@ -98,7 +98,7 @@ class Selection extends Range {
         return true;
     }
     static isISelection(obj) {
-        return (obj
+        return (!!obj
             && (typeof obj.selectionStartLineNumber === 'number')
             && (typeof obj.selectionStartColumn === 'number')
             && (typeof obj.positionLineNumber === 'number')

package/vscode/src/vs/editor/common/core/text/abstractText.d.ts

@@ -1,9 +1,9 @@
 import { Position } from "../position.js";
-import { PositionOffsetTransformer } from "./positionToOffsetImpl.js";
 import { Range } from "../range.js";
 import { LineRange } from "../ranges/lineRange.js";
-import { TextLength } from "./textLength.js";
 import { OffsetRange } from "../ranges/offsetRange.js";
+import { TextLength } from "./textLength.js";
+import { PositionOffsetTransformer } from "./positionToOffsetImpl.js";
 export declare abstract class AbstractText {
     abstract getValueOfRange(range: Range): string;
     abstract readonly length: TextLength;
@@ -36,4 +36,5 @@ export declare class StringText extends AbstractText {
     constructor(value: string);
     getValueOfRange(range: Range): string;
     get length(): TextLength;
+    getTransformer(): PositionOffsetTransformer;
 }

package/vscode/src/vs/editor/common/core/text/abstractText.js

@@ -2,9 +2,9 @@
 import { assert } from '../../../../base/common/assert.js';
 import { splitLines } from '../../../../base/common/strings.js';
 import { Position } from '../position.js';
-import { PositionOffsetTransformer } from './positionToOffsetImpl.js';
 import { Range } from '../range.js';
 import { TextLength } from './textLength.js';
+import { PositionOffsetTransformer } from './positionToOffsetImpl.js';
 
 class AbstractText {
     constructor() {
@@ -91,6 +91,9 @@ class StringText extends AbstractText {
     get length() {
         return this._t.textLength;
     }
+    getTransformer() {
+        return this._t;
+    }
 }
 
 export { AbstractText, ArrayText, LineBasedText, StringText };

package/vscode/src/vs/editor/common/cursor/cursorMoveCommands.d.ts

@@ -88,6 +88,7 @@ export declare namespace CursorMove {
         select?: boolean;
         by?: string;
         value?: number;
+        noHistory?: boolean;
     }
     function parse(args: Partial<RawArguments>): ParsedArguments | null;
     interface ParsedArguments {
@@ -95,6 +96,7 @@ export declare namespace CursorMove {
         unit: Unit;
         select: boolean;
         value: number;
+        noHistory: boolean;
     }
     interface SimpleMoveArguments {
         direction: SimpleMoveDirection;

package/vscode/src/vs/editor/common/cursor/cursorMoveCommands.js

@@ -483,6 +483,9 @@ var CursorMove;
         if (!isUndefined(cursorMoveArg.value) && !isNumber(cursorMoveArg.value)) {
             return false;
         }
+        if (!isUndefined(cursorMoveArg.noHistory) && !isBoolean(cursorMoveArg.noHistory)) {
+            return false;
+        }
         return true;
     };
     CursorMove.metadata = {
@@ -504,6 +507,7 @@ var CursorMove;
 						\`\`\`
 					* 'value': Number of units to move. Default is '1'.
 					* 'select': If 'true' makes the selection. Default is 'false'.
+					* 'noHistory': If 'true' does not add the movement to navigation history. Default is 'false'.
 				`,
                 constraint: isCursorMoveArgs,
                 schema: {
@@ -525,6 +529,10 @@ var CursorMove;
                         'select': {
                             'type': 'boolean',
                             'default': false
+                        },
+                        'noHistory': {
+                            'type': 'boolean',
+                            'default': false
                         }
                     }
                 }
@@ -627,7 +635,8 @@ var CursorMove;
             direction: direction,
             unit: unit,
             select: (!!args.select),
-            value: (args.value || 1)
+            value: (args.value || 1),
+            noHistory: (!!args.noHistory)
         };
     }
     CursorMove.parse = parse;

package/vscode/src/vs/editor/common/cursor/cursorWordOperations.js

@@ -606,10 +606,18 @@ class WordOperations {
                 startColumn = prevWord.start + 1;
                 endColumn = prevWord.end + 1;
             }
+            else if (prevWord && prevWord.wordType === WordType.Separator && prevWord.start <= position.column - 1 && position.column - 1 < prevWord.end) {
+                startColumn = prevWord.start + 1;
+                endColumn = prevWord.end + 1;
+            }
             else if (nextWord && nextWord.wordType === WordType.Regular && nextWord.start <= position.column - 1 && position.column - 1 <= nextWord.end) {
                 startColumn = nextWord.start + 1;
                 endColumn = nextWord.end + 1;
             }
+            else if (nextWord && nextWord.wordType === WordType.Separator && nextWord.start <= position.column - 1 && position.column - 1 < nextWord.end) {
+                startColumn = nextWord.start + 1;
+                endColumn = nextWord.end + 1;
+            }
             else {
                 if (prevWord) {
                     startColumn = prevWord.end + 1;