@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/editor/contrib/hover/browser/markdownHoverParticipant.js

@@ -1,24 +1,27 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { trackFocus, append, $ as $$1 } from '../../../../base/browser/dom.js';
+import { addDisposableListener, EventType, append, $ as $$1 } from '../../../../base/browser/dom.js';
 import { asArray, compareBy, numberComparator } from '../../../../base/common/arrays.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { MarkdownString, isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
-import { INCREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
+import { DECREASE_HOVER_VERBOSITY_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';
+import { HoverAnchorType } from './hoverTypes.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 import { HoverVerbosityAction } from '../../../common/languages.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
-import { ClickAction, KeyDownAction } from '../../../../base/browser/ui/hover/hoverWidget.js';
+import { ClickAction, KeyDownAction, HoverPosition } from '../../../../base/browser/ui/hover/hoverWidget.js';
+import { KeyCode } from '../../../../base/common/keyCodes.js';
 import { WorkbenchHoverDelegate } from '../../../../platform/hover/browser/hover.js';
 import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 import { AsyncIterableObject } from '../../../../base/common/async.js';
@@ -37,7 +40,7 @@ class MarkdownHover {
         this.source = source;
     }
     isValidForHoverAnchor(anchor) {
-        return (anchor.type === 1
+        return (anchor.type === HoverAnchorType.Range
             && this.range.startColumn <= anchor.range.startColumn
             && this.range.endColumn >= anchor.range.endColumn);
     }
@@ -80,7 +83,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         );
     }
     computeSync(anchor, lineDecorations) {
-        if (!this._editor.hasModel() || anchor.type !== 1 ) {
+        if (!this._editor.hasModel() || anchor.type !== HoverAnchorType.Range) {
             return [];
         }
         const model = this._editor.getModel();
@@ -90,7 +93,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         let index = 1000;
         const lineLength = model.getLineLength(lineNumber);
         const languageId = model.getLanguageIdAtPosition(anchor.range.startLineNumber, anchor.range.startColumn);
-        const stopRenderingLineAfter = this._editor.getOption(117 );
+        const stopRenderingLineAfter = this._editor.getOption(EditorOption.stopRenderingLineAfter);
         const maxTokenizationLineLength = this._configurationService.getValue('editor.maxTokenizationLineLength', {
             overrideIdentifier: languageId
         });
@@ -136,7 +139,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         return result;
     }
     computeAsync(anchor, lineDecorations, token) {
-        if (!this._editor.hasModel() || anchor.type !== 1 ) {
+        if (!this._editor.hasModel() || anchor.type !== HoverAnchorType.Range) {
             return AsyncIterableObject.EMPTY;
         }
         const model = this._editor.getModel();
@@ -174,8 +177,17 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         )));
         return this._renderedHoverParts;
     }
-    updateFocusedMarkdownHoverPartVerbosityLevel(action) {
-        this._renderedHoverParts?.updateFocusedHoverPartVerbosityLevel(action);
+    markdownHoverContentAtIndex(index) {
+        return this._renderedHoverParts?.markdownHoverContentAtIndex(index) ?? '';
+    }
+    focusedMarkdownHoverIndex() {
+        return this._renderedHoverParts?.focusedMarkdownHoverIndex() ?? 1;
+    }
+    doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) {
+        return this._renderedHoverParts?.doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) ?? false;
+    }
+    updateMarkdownHoverVerbosityLevel(action, index, focus) {
+        this._renderedHoverParts?.updateMarkdownHoverPartVerbosityLevel(action, index, focus);
     }
 };
 MarkdownHoverParticipant = ( (__decorate([
@@ -197,13 +209,17 @@ class MarkdownRenderedHoverParts extends Disposable {
         this._hoverService = _hoverService;
         this._configurationService = _configurationService;
         this._onFinishedRendering = _onFinishedRendering;
-        this._hoverFocusInfo = { hoverPartIndex: -1, focusRemains: false };
+        this._focusedHoverPartIndex = -1;
+        this._ongoingHoverOperations = ( (new Map()));
         this._renderedHoverParts = this._renderHoverParts(hoverParts, hoverPartsContainer, this._onFinishedRendering);
         this._register(toDisposable(() => {
             this._renderedHoverParts.forEach(renderedHoverPart => {
                 renderedHoverPart.disposables.dispose();
             });
         }));
+        this._register(toDisposable(() => {
+            this._ongoingHoverOperations.forEach(operation => { operation.tokenSource.dispose(true); });
+        }));
     }
     _renderHoverParts(hoverParts, hoverPartsContainer, onFinishedRendering) {
         hoverParts.sort(compareBy(hover => hover.ordinal, numberComparator));
@@ -229,18 +245,13 @@ class MarkdownRenderedHoverParts extends Disposable {
         renderedMarkdown.prepend(actionsContainer);
         disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Increase, canIncreaseVerbosity));
         disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Decrease, canDecreaseVerbosity));
-        const focusTracker = disposables.add(trackFocus(renderedMarkdown));
-        disposables.add(focusTracker.onDidFocus(() => {
-            this._hoverFocusInfo = {
-                hoverPartIndex,
-                focusRemains: true
-            };
+        this._register(addDisposableListener(renderedMarkdown, EventType.FOCUS_IN, (event) => {
+            event.stopPropagation();
+            this._focusedHoverPartIndex = hoverPartIndex;
         }));
-        disposables.add(focusTracker.onDidBlur(() => {
-            if (this._hoverFocusInfo?.focusRemains) {
-                this._hoverFocusInfo.focusRemains = false;
-                return;
-            }
+        this._register(addDisposableListener(renderedMarkdown, EventType.FOCUS_OUT, (event) => {
+            event.stopPropagation();
+            this._focusedHoverPartIndex = -1;
         }));
         return { renderedMarkdown, disposables, hoverSource };
     }
@@ -261,65 +272,79 @@ class MarkdownRenderedHoverParts extends Disposable {
         const hoverDelegate = ( (new WorkbenchHoverDelegate(
             'mouse',
             false,
-            { target: container, position: { hoverPosition: 0  } },
+            { target: container, position: { hoverPosition: HoverPosition.LEFT } },
             this._configurationService,
             this._hoverService
         )));
-        if (isActionIncrease) {
-            const kb = this._keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID);
-            store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ?
-                ( localizeWithPath(_moduleId, 5, "Increase Verbosity ({0})", kb.getLabel())) :
-                ( localizeWithPath(_moduleId, 6, "Increase Verbosity"))));
-        }
-        else {
-            const kb = this._keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID);
-            store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ?
-                ( localizeWithPath(_moduleId, 7, "Decrease Verbosity ({0})", kb.getLabel())) :
-                ( localizeWithPath(_moduleId, 8, "Decrease Verbosity"))));
-        }
+        store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, labelForHoverVerbosityAction(this._keybindingService, action)));
         if (!actionEnabled) {
             actionElement.classList.add('disabled');
             return store;
         }
         actionElement.classList.add('enabled');
-        const actionFunction = () => this.updateFocusedHoverPartVerbosityLevel(action);
+        const actionFunction = () => this.updateMarkdownHoverPartVerbosityLevel(action);
         store.add(( (new ClickAction(actionElement, actionFunction))));
-        store.add(( (new KeyDownAction(
-            actionElement,
-            actionFunction,
-            [3 , 10 ]
-        ))));
+        store.add(( (new KeyDownAction(actionElement, actionFunction, [KeyCode.Enter, KeyCode.Space]))));
         return store;
     }
-    async updateFocusedHoverPartVerbosityLevel(action) {
+    async updateMarkdownHoverPartVerbosityLevel(action, index = -1, focus = true) {
         const model = this._editor.getModel();
         if (!model) {
             return;
         }
-        const hoverFocusedPartIndex = this._hoverFocusInfo.hoverPartIndex;
-        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(hoverFocusedPartIndex);
+        const indexOfInterest = index !== -1 ? index : this._focusedHoverPartIndex;
+        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(indexOfInterest);
         if (!hoverRenderedPart || !hoverRenderedPart.hoverSource?.supportsVerbosityAction(action)) {
             return;
         }
-        const hoverPosition = hoverRenderedPart.hoverSource.hoverPosition;
-        const hoverProvider = hoverRenderedPart.hoverSource.hoverProvider;
-        const hover = hoverRenderedPart.hoverSource.hover;
-        const hoverContext = { verbosityRequest: { action, previousHover: hover } };
-        let newHover;
+        const hoverSource = hoverRenderedPart.hoverSource;
+        const newHover = await this._fetchHover(hoverSource, model, action);
+        if (!newHover) {
+            return;
+        }
+        const newHoverSource = ( (new HoverSource(newHover, hoverSource.hoverProvider, hoverSource.hoverPosition)));
+        const newHoverRenderedPart = this._renderHoverPart(indexOfInterest, newHover.contents, newHoverSource, this._onFinishedRendering);
+        this._replaceRenderedHoverPartAtIndex(indexOfInterest, newHoverRenderedPart);
+        if (focus) {
+            this._focusOnHoverPartWithIndex(indexOfInterest);
+        }
+        this._onFinishedRendering();
+    }
+    markdownHoverContentAtIndex(index) {
+        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(index);
+        return hoverRenderedPart?.renderedMarkdown.innerText ?? '';
+    }
+    focusedMarkdownHoverIndex() {
+        return this._focusedHoverPartIndex;
+    }
+    doesMarkdownHoverAtIndexSupportVerbosityAction(index, action) {
+        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(index);
+        if (!hoverRenderedPart || !hoverRenderedPart.hoverSource?.supportsVerbosityAction(action)) {
+            return false;
+        }
+        return true;
+    }
+    async _fetchHover(hoverSource, model, action) {
+        let verbosityDelta = action === HoverVerbosityAction.Increase ? 1 : -1;
+        const provider = hoverSource.hoverProvider;
+        const ongoingHoverOperation = this._ongoingHoverOperations.get(provider);
+        if (ongoingHoverOperation) {
+            ongoingHoverOperation.tokenSource.cancel();
+            verbosityDelta += ongoingHoverOperation.verbosityDelta;
+        }
+        const tokenSource = ( (new CancellationTokenSource()));
+        this._ongoingHoverOperations.set(provider, { verbosityDelta, tokenSource });
+        const context = { verbosityRequest: { verbosityDelta, previousHover: hoverSource.hover } };
+        let hover;
         try {
-            newHover = await Promise.resolve(hoverProvider.provideHover(model, hoverPosition, CancellationToken.None, hoverContext));
+            hover = await Promise.resolve(provider.provideHover(model, hoverSource.hoverPosition, tokenSource.token, context));
         }
         catch (e) {
             onUnexpectedExternalError(e);
         }
-        if (!newHover) {
-            return;
-        }
-        const hoverSource = ( (new HoverSource(newHover, hoverProvider, hoverPosition)));
-        const renderedHoverPart = this._renderHoverPart(hoverFocusedPartIndex, newHover.contents, hoverSource, this._onFinishedRendering);
-        this._replaceRenderedHoverPartAtIndex(hoverFocusedPartIndex, renderedHoverPart);
-        this._focusOnHoverPartWithIndex(hoverFocusedPartIndex);
-        this._onFinishedRendering();
+        tokenSource.dispose();
+        this._ongoingHoverOperations.delete(provider);
+        return hover;
     }
     _replaceRenderedHoverPartAtIndex(index, renderedHoverPart) {
         if (index >= this._renderHoverParts.length || index < 0) {
@@ -333,7 +358,6 @@ class MarkdownRenderedHoverParts extends Disposable {
     }
     _focusOnHoverPartWithIndex(index) {
         this._renderedHoverParts[index].renderedMarkdown.focus();
-        this._hoverFocusInfo.focusRemains = true;
     }
     _getRenderedHoverPartAtIndex(index) {
         return this._renderedHoverParts[index];
@@ -366,4 +390,20 @@ function renderMarkdownInContainer(editor, container, markdownStrings, languageS
     }
     return store;
 }
-export { MarkdownHover, MarkdownHoverParticipant, renderMarkdownHovers };
+function labelForHoverVerbosityAction(keybindingService, action) {
+    switch (action) {
+        case HoverVerbosityAction.Increase: {
+            const kb = keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID);
+            return kb ?
+                ( localizeWithPath(_moduleId, 5, "Increase Hover Verbosity ({0})", kb.getLabel())) :
+                ( localizeWithPath(_moduleId, 6, "Increase Hover Verbosity"));
+        }
+        case HoverVerbosityAction.Decrease: {
+            const kb = keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID);
+            return kb ?
+                ( localizeWithPath(_moduleId, 7, "Decrease Hover Verbosity ({0})", kb.getLabel())) :
+                ( localizeWithPath(_moduleId, 8, "Decrease Hover Verbosity"));
+        }
+    }
+}
+export { MarkdownHover, MarkdownHoverParticipant, labelForHoverVerbosityAction, renderMarkdownHovers };

package/vscode/src/vs/editor/contrib/hover/browser/markerHoverParticipant.js

@@ -5,13 +5,16 @@ import { disposableTimeout, createCancelablePromise } from '../../../../base/com
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { basename } from '../../../../base/common/resources.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 import { Range } from '../../../common/core/range.js';
+import { CodeActionTriggerType } from '../../../common/languages.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { IMarkerDecorationsService } from '../../../common/services/markerDecorations.js';
 import { quickFixCommandId, getCodeActions } from '../../codeAction/browser/codeAction.js';
 import { CodeActionController } from '../../codeAction/browser/codeActionController.js';
 import { CodeActionKind, CodeActionTriggerSource } from '../../codeAction/common/types.js';
 import { MarkerController, NextMarkerAction } from '../../gotoError/browser/gotoError.js';
+import { HoverAnchorType } from './hoverTypes.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { MarkerSeverity, IMarkerData } from '../../../../platform/markers/common/markers.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
@@ -25,13 +28,13 @@ class MarkerHover {
         this.marker = marker;
     }
     isValidForHoverAnchor(anchor) {
-        return (anchor.type === 1
+        return (anchor.type === HoverAnchorType.Range
             && this.range.startColumn <= anchor.range.startColumn
             && this.range.endColumn >= anchor.range.endColumn);
     }
 }
 const markerCodeActionTrigger = {
-    type: 1 ,
+    type: CodeActionTriggerType.Invoke,
     filter: { include: CodeActionKind.QuickFix },
     triggerAction: CodeActionTriggerSource.QuickFixHover
 };
@@ -45,7 +48,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
         this.recentMarkerCodeActionsInfo = undefined;
     }
     computeSync(anchor, lineDecorations) {
-        if (!this._editor.hasModel() || anchor.type !== 1  && !anchor.supportsMarkerHover) {
+        if (!this._editor.hasModel() || anchor.type !== HoverAnchorType.Range && !anchor.supportsMarkerHover) {
             return [];
         }
         const model = this._editor.getModel();
@@ -154,7 +157,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                 });
             }
         }
-        if (!this._editor.getOption(91 )) {
+        if (!this._editor.getOption(EditorOption.readOnly)) {
             const quickfixPlaceholderElement = context.statusBar.append($('div'));
             if (this.recentMarkerCodeActionsInfo) {
                 if (IMarkerData.makeKey(this.recentMarkerCodeActionsInfo.marker) === IMarkerData.makeKey(markerHover.marker)) {

package/vscode/src/vs/editor/contrib/hover/browser/resizableContentWidget.js

@@ -1,5 +1,7 @@
 import { ResizableHTMLElement } from '../../../../base/browser/ui/resizable/resizable.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
+import { ContentWidgetPositionPreference } from '../../../browser/editorBrowser.js';
+import { EditorOption } from '../../../common/config/editorOptions.js';
 import { Position } from '../../../common/core/position.js';
 import { Dimension, getDomNodePagePosition, getClientArea } from '../../../../base/browser/dom.js';
 const TOP_HEIGHT = 30;
@@ -65,13 +67,13 @@ class ResizableContentWidget extends Disposable {
         const maxHeight = Math.min(Math.max(maxHeightAbove, maxHeightBelow), widgetHeight);
         const height = Math.min(widgetHeight, maxHeight);
         let renderingAbove;
-        if (this._editor.getOption(60 ).above) {
-            renderingAbove = height <= maxHeightAbove ? 1  : 2 ;
+        if (this._editor.getOption(EditorOption.hover).above) {
+            renderingAbove = height <= maxHeightAbove ? ContentWidgetPositionPreference.ABOVE : ContentWidgetPositionPreference.BELOW;
         }
         else {
-            renderingAbove = height <= maxHeightBelow ? 2  : 1 ;
+            renderingAbove = height <= maxHeightBelow ? ContentWidgetPositionPreference.BELOW : ContentWidgetPositionPreference.ABOVE;
         }
-        if (renderingAbove === 1 ) {
+        if (renderingAbove === ContentWidgetPositionPreference.ABOVE) {
             this._resizableNode.enableSashes(true, true, false, false);
         }
         else {

package/vscode/src/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.js

@@ -1,14 +1,16 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { createCancelablePromise, timeout } from '../../../../base/common/async.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
-import { EditorState } from '../../editorState/browser/editorState.js';
-import { registerEditorContribution, registerEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
+import { EditorState, CodeEditorStateFlag } from '../../editorState/browser/editorState.js';
+import { registerEditorContribution, registerEditorAction, EditorContributionInstantiation, EditorAction } from '../../../browser/editorExtensions.js';
 import { Range } from '../../../common/core/range.js';
 import { Selection } from '../../../common/core/selection.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
 import { localizeWithPath } from '../../../../nls.js';
+import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { InPlaceReplaceCommand } from './inPlaceReplaceCommand.js';
 import './inPlaceReplace.css.js';
 var InPlaceReplaceController_1;
@@ -41,10 +43,7 @@ let InPlaceReplaceController = class InPlaceReplaceController {
         if (selection.startLineNumber !== selection.endLineNumber) {
             return undefined;
         }
-        const state = ( (new EditorState(
-            this.editor,
-            1  | 4
-        )));
+        const state = ( (new EditorState(this.editor, CodeEditorStateFlag.Value | CodeEditorStateFlag.Position)));
         const modelURI = model.uri;
         if (!this.editorWorkerService.canNavigateValueSet(modelURI)) {
             return Promise.resolve(undefined);
@@ -100,8 +99,8 @@ class InPlaceReplaceUp extends EditorAction {
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
-                primary: 2048  | 1024  | 87 ,
-                weight: 100
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Comma,
+                weight: KeybindingWeight.EditorContrib
             }
         });
     }
@@ -122,8 +121,8 @@ class InPlaceReplaceDown extends EditorAction {
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
-                primary: 2048  | 1024  | 89 ,
-                weight: 100
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Period,
+                weight: KeybindingWeight.EditorContrib
             }
         });
     }
@@ -135,6 +134,6 @@ class InPlaceReplaceDown extends EditorAction {
         return controller.run(this.id, true);
     }
 }
-registerEditorContribution(InPlaceReplaceController.ID, InPlaceReplaceController, 4 );
+registerEditorContribution(InPlaceReplaceController.ID, InPlaceReplaceController, EditorContributionInstantiation.Lazy);
 registerEditorAction(InPlaceReplaceUp);
 registerEditorAction(InPlaceReplaceDown);

package/vscode/src/vs/editor/contrib/indentation/browser/indentation.js

@@ -1,17 +1,21 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
 import { getLeadingWhitespace } from '../../../../base/common/strings.js';
-import { EditorAction, registerEditorContribution, registerEditorAction } from '../../../browser/editorExtensions.js';
+import { EditorAction, registerEditorContribution, registerEditorAction, EditorContributionInstantiation } from '../../../browser/editorExtensions.js';
 import { ShiftCommand } from '../../../common/commands/shiftCommand.js';
+import { EditorOption, EditorAutoIndentStrategy } from '../../../common/config/editorOptions.js';
 import { Range } from '../../../common/core/range.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { StandardTokenType } from '../../../common/encodedTokenAttributes.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
+import { IndentConsts } from '../../../common/languages/supports/indentRules.js';
 import { IModelService } from '../../../common/services/model.js';
 import { getSpaceCnt, generateIndent } from '../common/indentUtils.js';
 import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { getGoodIndentForLine, getIndentMetadata } from '../../../common/languages/autoIndent.js';
 import { getReindentEditOperations } from '../common/indentation.js';
+import { getStandardTokenTypeAtPosition } from '../../../common/tokens/lineTokens.js';
 const _moduleId = "vs/editor/contrib/indentation/browser/indentation";
 class IndentationToSpacesAction extends EditorAction {
     static { this.ID = 'editor.action.indentationToSpaces'; }
@@ -314,7 +318,7 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
     }
     update() {
         this.callOnModel.clear();
-        if (this.editor.getOption(12 ) < 4  || this.editor.getOption(55 )) {
+        if (this.editor.getOption(EditorOption.autoIndent) < EditorAutoIndentStrategy.Full || this.editor.getOption(EditorOption.formatOnPaste)) {
             return;
         }
         if (!this.editor.hasModel()) {
@@ -333,10 +337,13 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
         if (!model) {
             return;
         }
+        if (isStartOrEndInString(model, range)) {
+            return;
+        }
         if (!model.tokenization.isCheapToTokenize(range.getStartPosition().lineNumber)) {
             return;
         }
-        const autoIndent = this.editor.getOption(12 );
+        const autoIndent = this.editor.getOption(EditorOption.autoIndent);
         const { tabSize, indentSize, insertSpaces } = model.getOptions();
         const textEdits = [];
         const indentConverter = {
@@ -375,7 +382,7 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
                 }
                 else {
                     const indentMetadata = getIndentMetadata(model, startLineNumber, this._languageConfigurationService);
-                    if (indentMetadata === 0 || indentMetadata === 8 ) {
+                    if (indentMetadata === 0 || indentMetadata === IndentConsts.UNINDENT_MASK) {
                         return;
                     }
                 }
@@ -449,7 +456,7 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
         const tokens = model.tokenization.getLineTokens(lineNumber);
         if (tokens.getCount() > 0) {
             const firstNonWhitespaceTokenIndex = tokens.findTokenIndexAtOffset(nonWhitespaceColumn);
-            if (firstNonWhitespaceTokenIndex >= 0 && tokens.getStandardTokenType(firstNonWhitespaceTokenIndex) === 1 ) {
+            if (firstNonWhitespaceTokenIndex >= 0 && tokens.getStandardTokenType(firstNonWhitespaceTokenIndex) === StandardTokenType.Comment) {
                 return true;
             }
         }
@@ -463,6 +470,13 @@ let AutoIndentOnPaste = class AutoIndentOnPaste {
 AutoIndentOnPaste = ( (__decorate([
     ( (__param(1, ILanguageConfigurationService)))
 ], AutoIndentOnPaste)));
+function isStartOrEndInString(model, range) {
+    const isPositionInString = (position) => {
+        const tokenType = getStandardTokenTypeAtPosition(model, position);
+        return tokenType === StandardTokenType.String;
+    };
+    return isPositionInString(range.getStartPosition()) || isPositionInString(range.getEndPosition());
+}
 function getIndentationEditOperations(model, builder, tabSize, tabsToSpaces) {
     if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
         return;
@@ -516,7 +530,7 @@ class IndentationToTabsCommand {
         return helper.getTrackedSelection(this.selectionId);
     }
 }
-registerEditorContribution(AutoIndentOnPaste.ID, AutoIndentOnPaste, 2 );
+registerEditorContribution(AutoIndentOnPaste.ID, AutoIndentOnPaste, EditorContributionInstantiation.BeforeFirstInteraction);
 registerEditorAction(IndentationToSpacesAction);
 registerEditorAction(IndentationToTabsAction);
 registerEditorAction(IndentUsingTabs);

package/vscode/src/vs/editor/contrib/indentation/common/indentation.js

@@ -3,21 +3,20 @@ import { ShiftCommand } from '../../../common/commands/shiftCommand.js';
 import { EditOperation } from '../../../common/core/editOperation.js';
 import { normalizeIndentation } from '../../../common/core/indentation.js';
 import { Selection } from '../../../common/core/selection.js';
-function getReindentEditOperations(model, languageConfigurationService, startLineNumber, endLineNumber, inheritedIndent) {
+import { StandardTokenType } from '../../../common/encodedTokenAttributes.js';
+import { ProcessedIndentRulesSupport } from '../../../common/languages/supports/indentationLineProcessor.js';
+function getReindentEditOperations(model, languageConfigurationService, startLineNumber, endLineNumber) {
     if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
         return [];
     }
-    const indentationRules = languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).indentationRules;
-    if (!indentationRules) {
+    const indentationRulesSupport = languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).indentRulesSupport;
+    if (!indentationRulesSupport) {
         return [];
     }
+    const processedIndentRulesSupport = ( new ProcessedIndentRulesSupport(model, indentationRulesSupport, languageConfigurationService));
     endLineNumber = Math.min(endLineNumber, model.getLineCount());
     while (startLineNumber <= endLineNumber) {
-        if (!indentationRules.unIndentedLinePattern) {
-            break;
-        }
-        const text = model.getLineContent(startLineNumber);
-        if (!indentationRules.unIndentedLinePattern.test(text)) {
+        if (!processedIndentRulesSupport.shouldIgnore(startLineNumber)) {
             break;
         }
         startLineNumber++;
@@ -35,40 +34,39 @@ function getReindentEditOperations(model, languageConfigurationService, startLin
         return ShiftCommand.unshiftIndent(indentation, indentation.length + count, tabSize, indentSize, insertSpaces);
     };
     const indentEdits = [];
-    let globalIndent;
     const currentLineText = model.getLineContent(startLineNumber);
-    let adjustedLineContent = currentLineText;
-    {
-        globalIndent = getLeadingWhitespace(currentLineText);
-    }
+    let globalIndent = getLeadingWhitespace(currentLineText);
     let idealIndentForNextLine = globalIndent;
-    if (indentationRules.increaseIndentPattern && indentationRules.increaseIndentPattern.test(adjustedLineContent)) {
+    if (processedIndentRulesSupport.shouldIncrease(startLineNumber)) {
         idealIndentForNextLine = shiftIndent(idealIndentForNextLine);
         globalIndent = shiftIndent(globalIndent);
     }
-    else if (indentationRules.indentNextLinePattern && indentationRules.indentNextLinePattern.test(adjustedLineContent)) {
+    else if (processedIndentRulesSupport.shouldIndentNextLine(startLineNumber)) {
         idealIndentForNextLine = shiftIndent(idealIndentForNextLine);
     }
     startLineNumber++;
     for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+        if (doesLineStartWithString(model, lineNumber)) {
+            continue;
+        }
         const text = model.getLineContent(lineNumber);
         const oldIndentation = getLeadingWhitespace(text);
-        const adjustedLineContent = idealIndentForNextLine + text.substring(oldIndentation.length);
-        if (indentationRules.decreaseIndentPattern && indentationRules.decreaseIndentPattern.test(adjustedLineContent)) {
+        const currentIdealIndent = idealIndentForNextLine;
+        if (processedIndentRulesSupport.shouldDecrease(lineNumber, currentIdealIndent)) {
             idealIndentForNextLine = unshiftIndent(idealIndentForNextLine);
             globalIndent = unshiftIndent(globalIndent);
         }
         if (oldIndentation !== idealIndentForNextLine) {
             indentEdits.push(EditOperation.replaceMove(( new Selection(lineNumber, 1, lineNumber, oldIndentation.length + 1)), normalizeIndentation(idealIndentForNextLine, indentSize, insertSpaces)));
         }
-        if (indentationRules.unIndentedLinePattern && indentationRules.unIndentedLinePattern.test(text)) {
+        if (processedIndentRulesSupport.shouldIgnore(lineNumber)) {
             continue;
         }
-        else if (indentationRules.increaseIndentPattern && indentationRules.increaseIndentPattern.test(adjustedLineContent)) {
+        else if (processedIndentRulesSupport.shouldIncrease(lineNumber, currentIdealIndent)) {
             globalIndent = shiftIndent(globalIndent);
             idealIndentForNextLine = globalIndent;
         }
-        else if (indentationRules.indentNextLinePattern && indentationRules.indentNextLinePattern.test(adjustedLineContent)) {
+        else if (processedIndentRulesSupport.shouldIndentNextLine(lineNumber, currentIdealIndent)) {
             idealIndentForNextLine = shiftIndent(idealIndentForNextLine);
         }
         else {
@@ -77,4 +75,11 @@ function getReindentEditOperations(model, languageConfigurationService, startLin
     }
     return indentEdits;
 }
+function doesLineStartWithString(model, lineNumber) {
+    if (!model.tokenization.isCheapToTokenize(lineNumber)) {
+        return false;
+    }
+    const lineTokens = model.tokenization.getLineTokens(lineNumber);
+    return lineTokens.getStandardTokenType(0) === StandardTokenType.String;
+}
 export { getReindentEditOperations };

package/vscode/src/vs/editor/contrib/inlayHints/browser/inlayHintsContribution.js

@@ -1,6 +1,6 @@
-import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { registerEditorContribution, EditorContributionInstantiation } from '../../../browser/editorExtensions.js';
 import { HoverParticipantRegistry } from '../../hover/browser/hoverTypes.js';
 import { InlayHintsController } from './inlayHintsController.js';
 import { InlayHintsHover } from './inlayHintsHover.js';
-registerEditorContribution(InlayHintsController.ID, InlayHintsController, 1 );
+registerEditorContribution(InlayHintsController.ID, InlayHintsController, EditorContributionInstantiation.AfterFirstRender);
 HoverParticipantRegistry.register(InlayHintsHover);