@codingame/monaco-vscode-api 3.2.3 → 4.0.0

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

@@ -0,0 +1,154 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
+let SectionHeaderDetector = class SectionHeaderDetector extends Disposable {
+    static { this.ID = 'editor.sectionHeaderDetector'; }
+    constructor(editor, languageConfigurationService, editorWorkerService) {
+        super();
+        this.editor = editor;
+        this.languageConfigurationService = languageConfigurationService;
+        this.editorWorkerService = editorWorkerService;
+        this.decorations = this.editor.createDecorationsCollection();
+        this.options = this.createOptions(editor.getOption(73 ));
+        this.computePromise = null;
+        this.currentOccurrences = {};
+        this._register(editor.onDidChangeModel((e) => {
+            this.currentOccurrences = {};
+            this.options = this.createOptions(editor.getOption(73 ));
+            this.stop();
+            this.computeSectionHeaders.schedule(0);
+        }));
+        this._register(editor.onDidChangeModelLanguage((e) => {
+            this.currentOccurrences = {};
+            this.options = this.createOptions(editor.getOption(73 ));
+            this.stop();
+            this.computeSectionHeaders.schedule(0);
+        }));
+        this._register(languageConfigurationService.onDidChange((e) => {
+            const editorLanguageId = this.editor.getModel()?.getLanguageId();
+            if (editorLanguageId && e.affects(editorLanguageId)) {
+                this.currentOccurrences = {};
+                this.options = this.createOptions(editor.getOption(73 ));
+                this.stop();
+                this.computeSectionHeaders.schedule(0);
+            }
+        }));
+        this._register(editor.onDidChangeConfiguration(e => {
+            if (this.options && !e.hasChanged(73 )) {
+                return;
+            }
+            this.options = this.createOptions(editor.getOption(73 ));
+            this.updateDecorations([]);
+            this.stop();
+            this.computeSectionHeaders.schedule(0);
+        }));
+        this._register(this.editor.onDidChangeModelContent(e => {
+            this.computeSectionHeaders.schedule();
+        }));
+        this.computeSectionHeaders = this._register(( new RunOnceScheduler(() => {
+            this.findSectionHeaders();
+        }, 250)));
+        this.computeSectionHeaders.schedule(0);
+    }
+    createOptions(minimap) {
+        if (!minimap || !this.editor.hasModel()) {
+            return undefined;
+        }
+        const languageId = this.editor.getModel().getLanguageId();
+        if (!languageId) {
+            return undefined;
+        }
+        const commentsConfiguration = this.languageConfigurationService.getLanguageConfiguration(languageId).comments;
+        const foldingRules = this.languageConfigurationService.getLanguageConfiguration(languageId).foldingRules;
+        if (!commentsConfiguration && !foldingRules?.markers) {
+            return undefined;
+        }
+        return {
+            foldingRules,
+            findMarkSectionHeaders: minimap.showMarkSectionHeaders,
+            findRegionSectionHeaders: minimap.showRegionSectionHeaders,
+        };
+    }
+    findSectionHeaders() {
+        if (!this.editor.hasModel()
+            || (!this.options?.findMarkSectionHeaders && !this.options?.findRegionSectionHeaders)) {
+            return;
+        }
+        const model = this.editor.getModel();
+        if (model.isDisposed() || model.isTooLargeForSyncing()) {
+            return;
+        }
+        const modelVersionId = model.getVersionId();
+        this.editorWorkerService.findSectionHeaders(model.uri, this.options)
+            .then((sectionHeaders) => {
+            if (model.isDisposed() || model.getVersionId() !== modelVersionId) {
+                return;
+            }
+            this.updateDecorations(sectionHeaders);
+        });
+    }
+    updateDecorations(sectionHeaders) {
+        const model = this.editor.getModel();
+        if (model) {
+            sectionHeaders = sectionHeaders.filter((sectionHeader) => {
+                if (!sectionHeader.shouldBeInComments) {
+                    return true;
+                }
+                const validRange = model.validateRange(sectionHeader.range);
+                const tokens = model.tokenization.getLineTokens(validRange.startLineNumber);
+                const idx = tokens.findTokenIndexAtOffset(validRange.startColumn - 1);
+                const tokenType = tokens.getStandardTokenType(idx);
+                const languageId = tokens.getLanguageId(idx);
+                return (languageId === model.getLanguageId() && tokenType === 1) ;
+            });
+        }
+        const oldDecorations = ( ( Object.values(this.currentOccurrences)).map(occurrence => occurrence.decorationId));
+        const newDecorations = ( sectionHeaders.map(sectionHeader => decoration(sectionHeader)));
+        this.editor.changeDecorations((changeAccessor) => {
+            const decorations = changeAccessor.deltaDecorations(oldDecorations, newDecorations);
+            this.currentOccurrences = {};
+            for (let i = 0, len = decorations.length; i < len; i++) {
+                const occurrence = { sectionHeader: sectionHeaders[i], decorationId: decorations[i] };
+                this.currentOccurrences[occurrence.decorationId] = occurrence;
+            }
+        });
+    }
+    stop() {
+        this.computeSectionHeaders.cancel();
+        if (this.computePromise) {
+            this.computePromise.cancel();
+            this.computePromise = null;
+        }
+    }
+    dispose() {
+        super.dispose();
+        this.stop();
+        this.decorations.clear();
+    }
+};
+SectionHeaderDetector = ( __decorate([
+    ( __param(1, ILanguageConfigurationService)),
+    ( __param(2, IEditorWorkerService))
+], SectionHeaderDetector));
+function decoration(sectionHeader) {
+    return {
+        range: sectionHeader.range,
+        options: ModelDecorationOptions.createDynamic({
+            description: 'section-header',
+            stickiness: 3 ,
+            collapseOnReplaceEdit: true,
+            minimap: {
+                color: undefined,
+                position: 1 ,
+                sectionHeaderStyle: sectionHeader.hasSeparatorLine ? 2  : 1 ,
+                sectionHeaderText: sectionHeader.text,
+            },
+        })
+    };
+}
+registerEditorContribution(SectionHeaderDetector.ID, SectionHeaderDetector, 1 );
+export { SectionHeaderDetector };

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollModelProvider.js

@@ -10,6 +10,7 @@ import { ILanguageConfigurationService } from '../../../common/languages/languag
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { StickyModel, StickyElement, StickyRange } from './stickyScrollElement.js';
 import { Iterable } from '../../../../base/common/iterator.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 var ModelProvider;
 ( (function(ModelProvider) {
     ModelProvider["OUTLINE_MODEL"] = "outlineModel";
@@ -23,7 +24,7 @@ var Status;
     Status[Status["CANCELED"] = 2] = "CANCELED";
 })(Status || (Status = {})));
 let StickyModelProvider = class StickyModelProvider extends Disposable {
-    constructor(_editor, _languageConfigurationService, _languageFeaturesService, defaultModel) {
+    constructor(_editor, onProviderUpdate, _languageConfigurationService, _languageFeaturesService) {
         super();
         this._editor = _editor;
         this._languageConfigurationService = _languageConfigurationService;
@@ -32,31 +33,29 @@ let StickyModelProvider = class StickyModelProvider extends Disposable {
         this._modelPromise = null;
         this._updateScheduler = this._register(( new Delayer(300)));
         this._updateOperation = this._register(( new DisposableStore()));
-        const stickyModelFromCandidateOutlineProvider = ( new StickyModelFromCandidateOutlineProvider(_languageFeaturesService));
-        const stickyModelFromSyntaxFoldingProvider = ( new StickyModelFromCandidateSyntaxFoldingProvider(this._editor, _languageFeaturesService));
-        const stickyModelFromIndentationFoldingProvider = ( new StickyModelFromCandidateIndentationFoldingProvider(this._editor, _languageConfigurationService));
-        switch (defaultModel) {
+        switch (this._editor.getOption(115 ).defaultModel) {
             case ModelProvider.OUTLINE_MODEL:
-                this._modelProviders.push(stickyModelFromCandidateOutlineProvider);
-                this._modelProviders.push(stickyModelFromSyntaxFoldingProvider);
-                this._modelProviders.push(stickyModelFromIndentationFoldingProvider);
-                break;
+                this._modelProviders.push(( new StickyModelFromCandidateOutlineProvider(this._editor, _languageFeaturesService)));
             case ModelProvider.FOLDING_PROVIDER_MODEL:
-                this._modelProviders.push(stickyModelFromSyntaxFoldingProvider);
-                this._modelProviders.push(stickyModelFromIndentationFoldingProvider);
-                break;
+                this._modelProviders.push(( new StickyModelFromCandidateSyntaxFoldingProvider(this._editor, onProviderUpdate, _languageFeaturesService)));
             case ModelProvider.INDENTATION_MODEL:
-                this._modelProviders.push(stickyModelFromIndentationFoldingProvider);
+                this._modelProviders.push(( new StickyModelFromCandidateIndentationFoldingProvider(this._editor, _languageConfigurationService)));
                 break;
         }
     }
+    dispose() {
+        this._modelProviders.forEach(provider => provider.dispose());
+        this._updateOperation.clear();
+        this._cancelModelPromise();
+        super.dispose();
+    }
     _cancelModelPromise() {
         if (this._modelPromise) {
             this._modelPromise.cancel();
             this._modelPromise = null;
         }
     }
-    async update(textModel, textModelVersionId, token) {
+    async update(token) {
         this._updateOperation.clear();
         this._updateOperation.add({
             dispose: () => {
@@ -67,7 +66,7 @@ let StickyModelProvider = class StickyModelProvider extends Disposable {
         this._cancelModelPromise();
         return await this._updateScheduler.trigger(async () => {
             for (const modelProvider of this._modelProviders) {
-                const { statusPromise, modelPromise } = modelProvider.computeStickyModel(textModel, textModelVersionId, token);
+                const { statusPromise, modelPromise } = modelProvider.computeStickyModel(token);
                 this._modelPromise = modelPromise;
                 const status = await statusPromise;
                 if (this._modelPromise !== modelPromise) {
@@ -89,11 +88,13 @@ let StickyModelProvider = class StickyModelProvider extends Disposable {
     }
 };
 StickyModelProvider = ( __decorate([
-    ( __param(1, ILanguageConfigurationService)),
-    ( __param(2, ILanguageFeaturesService))
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ILanguageFeaturesService))
 ], StickyModelProvider));
-class StickyModelCandidateProvider {
-    constructor() {
+class StickyModelCandidateProvider extends Disposable {
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
         this._stickyModel = null;
     }
     get stickyModel() {
@@ -103,11 +104,11 @@ class StickyModelCandidateProvider {
         this._stickyModel = null;
         return Status.INVALID;
     }
-    computeStickyModel(textModel, modelVersionId, token) {
-        if (token.isCancellationRequested || !this.isProviderValid(textModel)) {
+    computeStickyModel(token) {
+        if (token.isCancellationRequested || !this.isProviderValid()) {
             return { statusPromise: this._invalid(), modelPromise: null };
         }
-        const providerModelPromise = createCancelablePromise(token => this.createModelFromProvider(textModel, modelVersionId, token));
+        const providerModelPromise = createCancelablePromise(token => this.createModelFromProvider(token));
         return {
             statusPromise: providerModelPromise.then(providerModel => {
                 if (!this.isModelValid(providerModel)) {
@@ -116,7 +117,7 @@ class StickyModelCandidateProvider {
                 if (token.isCancellationRequested) {
                     return Status.CANCELED;
                 }
-                this._stickyModel = this.createStickyModel(textModel, modelVersionId, token, providerModel);
+                this._stickyModel = this.createStickyModel(token, providerModel);
                 return Status.VALID;
             }).then(undefined, (err) => {
                 onUnexpectedError(err);
@@ -128,24 +129,22 @@ class StickyModelCandidateProvider {
     isModelValid(model) {
         return true;
     }
-    isProviderValid(textModel) {
+    isProviderValid() {
         return true;
     }
 }
 let StickyModelFromCandidateOutlineProvider = class StickyModelFromCandidateOutlineProvider extends StickyModelCandidateProvider {
-    constructor(_languageFeaturesService) {
-        super();
+    constructor(_editor, _languageFeaturesService) {
+        super(_editor);
         this._languageFeaturesService = _languageFeaturesService;
     }
-    get provider() {
-        return this._languageFeaturesService.documentSymbolProvider;
-    }
-    createModelFromProvider(textModel, modelVersionId, token) {
-        return OutlineModel.create(this._languageFeaturesService.documentSymbolProvider, textModel, token);
+    createModelFromProvider(token) {
+        return OutlineModel.create(this._languageFeaturesService.documentSymbolProvider, this._editor.getModel(), token);
     }
-    createStickyModel(textModel, modelVersionId, token, model) {
+    createStickyModel(token, model) {
         const { stickyOutlineElement, providerID } = this._stickyModelFromOutlineModel(model, this._stickyModel?.outlineProviderId);
-        return ( new StickyModel(textModel.uri, modelVersionId, stickyOutlineElement, providerID));
+        const textModel = this._editor.getModel();
+        return ( new StickyModel(textModel.uri, textModel.getVersionId(), stickyOutlineElement, providerID));
     }
     isModelValid(model) {
         return model && model.children.size > 0;
@@ -234,16 +233,17 @@ let StickyModelFromCandidateOutlineProvider = class StickyModelFromCandidateOutl
     }
 };
 StickyModelFromCandidateOutlineProvider = ( __decorate([
-    ( __param(0, ILanguageFeaturesService))
+    ( __param(1, ILanguageFeaturesService))
 ], StickyModelFromCandidateOutlineProvider));
 class StickyModelFromCandidateFoldingProvider extends StickyModelCandidateProvider {
     constructor(editor) {
-        super();
+        super(editor);
         this._foldingLimitReporter = ( new RangesLimitReporter(editor));
     }
-    createStickyModel(textModel, modelVersionId, token, model) {
+    createStickyModel(token, model) {
         const foldingElement = this._fromFoldingRegions(model);
-        return ( new StickyModel(textModel.uri, modelVersionId, foldingElement, undefined));
+        const textModel = this._editor.getModel();
+        return ( new StickyModel(textModel.uri, textModel.getVersionId(), foldingElement, undefined));
     }
     isModelValid(model) {
         return model !== null;
@@ -275,43 +275,42 @@ let StickyModelFromCandidateIndentationFoldingProvider = class StickyModelFromCa
     constructor(editor, _languageConfigurationService) {
         super(editor);
         this._languageConfigurationService = _languageConfigurationService;
+        this.provider = this._register(( new IndentRangeProvider(
+            editor.getModel(),
+            this._languageConfigurationService,
+            this._foldingLimitReporter
+        )));
     }
-    get provider() {
-        return null;
-    }
-    createModelFromProvider(textModel, modelVersionId, token) {
-        const provider = ( new IndentRangeProvider(textModel, this._languageConfigurationService, this._foldingLimitReporter));
-        return provider.compute(token);
+    async createModelFromProvider(token) {
+        return this.provider.compute(token);
     }
 };
 StickyModelFromCandidateIndentationFoldingProvider = ( __decorate([
     ( __param(1, ILanguageConfigurationService))
 ], StickyModelFromCandidateIndentationFoldingProvider));
 let StickyModelFromCandidateSyntaxFoldingProvider = class StickyModelFromCandidateSyntaxFoldingProvider extends StickyModelFromCandidateFoldingProvider {
-    constructor(editor, _languageFeaturesService) {
+    constructor(editor, onProviderUpdate, _languageFeaturesService) {
         super(editor);
         this._languageFeaturesService = _languageFeaturesService;
+        const selectedProviders = FoldingController.getFoldingRangeProviders(this._languageFeaturesService, editor.getModel());
+        if (selectedProviders.length > 0) {
+            this.provider = this._register(( new SyntaxRangeProvider(
+                editor.getModel(),
+                selectedProviders,
+                onProviderUpdate,
+                this._foldingLimitReporter,
+                undefined
+            )));
+        }
     }
-    get provider() {
-        return this._languageFeaturesService.foldingRangeProvider;
-    }
-    isProviderValid(textModel) {
-        const selectedProviders = FoldingController.getFoldingRangeProviders(this._languageFeaturesService, textModel);
-        return selectedProviders.length > 0;
+    isProviderValid() {
+        return this.provider !== undefined;
     }
-    createModelFromProvider(textModel, modelVersionId, token) {
-        const selectedProviders = FoldingController.getFoldingRangeProviders(this._languageFeaturesService, textModel);
-        const provider = ( new SyntaxRangeProvider(
-            textModel,
-            selectedProviders,
-            () => this.createModelFromProvider(textModel, modelVersionId, token),
-            this._foldingLimitReporter,
-            undefined
-        ));
-        return provider.compute(token);
+    async createModelFromProvider(token) {
+        return this.provider?.compute(token) ?? null;
     }
 };
 StickyModelFromCandidateSyntaxFoldingProvider = ( __decorate([
-    ( __param(1, ILanguageFeaturesService))
+    ( __param(2, ILanguageFeaturesService))
 ], StickyModelFromCandidateSyntaxFoldingProvider));
 export { StickyModelProvider };

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollProvider.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { RunOnceScheduler } from '../../../../base/common/async.js';
@@ -22,7 +22,6 @@ let StickyLineCandidateProvider = class StickyLineCandidateProvider extends Disp
         this._languageConfigurationService = _languageConfigurationService;
         this._onDidChangeStickyScroll = this._register(( new Emitter()));
         this.onDidChangeStickyScroll = this._onDidChangeStickyScroll.event;
-        this._options = null;
         this._model = null;
         this._cts = null;
         this._stickyModelProvider = null;
@@ -37,31 +36,43 @@ let StickyLineCandidateProvider = class StickyLineCandidateProvider extends Disp
         this.readConfiguration();
     }
     readConfiguration() {
-        this._stickyModelProvider = null;
         this._sessionStore.clear();
-        this._options = this._editor.getOption(115 );
-        if (!this._options.enabled) {
+        const options = this._editor.getOption(115 );
+        if (!options.enabled) {
             return;
         }
-        this._stickyModelProvider = this._sessionStore.add(( new StickyModelProvider(
-            this._editor,
-            this._languageConfigurationService,
-            this._languageFeaturesService,
-            this._options.defaultModel
-        )));
         this._sessionStore.add(this._editor.onDidChangeModel(() => {
             this._model = null;
+            this.updateStickyModelProvider();
             this._onDidChangeStickyScroll.fire();
             this.update();
         }));
         this._sessionStore.add(this._editor.onDidChangeHiddenAreas(() => this.update()));
         this._sessionStore.add(this._editor.onDidChangeModelContent(() => this._updateSoon.schedule()));
         this._sessionStore.add(this._languageFeaturesService.documentSymbolProvider.onDidChange(() => this.update()));
+        this._sessionStore.add(toDisposable(() => {
+            this._stickyModelProvider?.dispose();
+            this._stickyModelProvider = null;
+        }));
+        this.updateStickyModelProvider();
         this.update();
     }
     getVersionId() {
         return this._model?.version;
     }
+    updateStickyModelProvider() {
+        this._stickyModelProvider?.dispose();
+        this._stickyModelProvider = null;
+        const editor = this._editor;
+        if (editor.hasModel()) {
+            this._stickyModelProvider = ( new StickyModelProvider(
+                editor,
+                () => this._updateSoon.schedule(),
+                this._languageConfigurationService,
+                this._languageFeaturesService
+            ));
+        }
+    }
     async update() {
         this._cts?.dispose(true);
         this._cts = ( new CancellationTokenSource());
@@ -73,9 +84,7 @@ let StickyLineCandidateProvider = class StickyLineCandidateProvider extends Disp
             this._model = null;
             return;
         }
-        const textModel = this._editor.getModel();
-        const modelVersionId = textModel.getVersionId();
-        const model = await this._stickyModelProvider.update(textModel, modelVersionId, token);
+        const model = await this._stickyModelProvider.update(token);
         if (token.isCancellationRequested) {
             return;
         }

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollWidget.js

@@ -5,7 +5,7 @@ import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.j
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import './stickyScroll.css.js';
 import { getColumnOfNodeOffset } from '../../../browser/viewParts/lines/viewLine.js';
-import { EmbeddedCodeEditorWidget } from '../../../browser/widget/embeddedCodeEditorWidget.js';
+import { EmbeddedCodeEditorWidget } from '../../../browser/widget/codeEditor/embeddedCodeEditorWidget.js';
 import { Position } from '../../../common/core/position.js';
 import { StringBuilder } from '../../../common/core/stringBuilder.js';
 import { LineDecoration } from '../../../common/viewLayout/lineDecorations.js';

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidget.js

@@ -10,14 +10,24 @@ import { MutableDisposable, DisposableStore } from '../../../../base/common/life
 import { clamp } from '../../../../base/common/numbers.js';
 import { format } from '../../../../base/common/strings.js';
 import './media/suggest.css.js';
-import { EmbeddedCodeEditorWidget } from '../../../browser/widget/embeddedCodeEditorWidget.js';
+import { EmbeddedCodeEditorWidget } from '../../../browser/widget/codeEditor/embeddedCodeEditorWidget.js';
 import { SuggestWidgetStatus } from './suggestWidgetStatus.js';
 import '../../symbolIcons/browser/symbolIcons.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { registerColor, editorWidgetBackground, editorWidgetBorder, editorForeground, quickInputListFocusForeground, quickInputListFocusIconForeground, quickInputListFocusBackground, listHighlightForeground, listFocusHighlightForeground, transparent, activeContrastBorder } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerColor, transparent } from '../../../../platform/theme/common/colorUtils.js';
+import { activeContrastBorder } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorWidgetBackground, editorWidgetBorder, editorForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import { listHighlightForeground, listFocusHighlightForeground } from '../../../../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 { quickInputListFocusForeground, quickInputListFocusIconForeground, quickInputListFocusBackground } from '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
 import { isHighContrast } from '../../../../platform/theme/common/theme.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.js';
 import { ResizableHTMLElement } from '../../../../base/browser/ui/resizable/resizable.js';

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

@@ -1,6 +1,16 @@
 import './symbolIcons.css.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { registerColor, foreground } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerColor } from '../../../../platform/theme/common/colorUtils.js';
+import { foreground } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../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';
 registerColor('symbolIcon.arrayForeground', {
     dark: foreground,
     light: foreground,

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

@@ -1,7 +1,7 @@
 import { alert } from '../../../../base/browser/ui/aria/aria.js';
 import { TabFocus } from '../../../browser/config/tabFocus.js';
 import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
-import { registerAction2, Action2 } from '../../../../platform/actions/common/actions.js';
+import { Action2, registerAction2 } from '../../../../platform/actions/common/actions.js';
 class ToggleTabFocusModeAction extends Action2 {
     static { this.ID = 'editor.action.toggleTabFocusMode'; }
     constructor() {

package/vscode/src/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.js

@@ -1,9 +1,19 @@
 import './highlightDecorations.css.js';
-import { OverviewRulerLane, MinimapPosition } from '../../../common/model.js';
+import { OverviewRulerLane } from '../../../common/model.js';
 import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { DocumentHighlightKind } from '../../../common/languages.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { registerColor, activeContrastBorder, overviewRulerSelectionHighlightForeground, minimapSelectionOccurrenceHighlight, editorSelectionHighlight } from '../../../../platform/theme/common/colorRegistry.js';
+import { registerColor } from '../../../../platform/theme/common/colorUtils.js';
+import { activeContrastBorder } from '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { overviewRulerSelectionHighlightForeground, editorSelectionHighlight } 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 { minimapSelectionOccurrenceHighlight } from '../../../../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 { themeColorFromId, registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
 const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, ( localizeWithPath(
     'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
@@ -60,7 +70,7 @@ const _WRITE_OPTIONS = ModelDecorationOptions.register({
     },
     minimap: {
         color: themeColorFromId(minimapSelectionOccurrenceHighlight),
-        position: MinimapPosition.Inline
+        position: 1
     },
 });
 const _TEXT_OPTIONS = ModelDecorationOptions.register({
@@ -73,7 +83,7 @@ const _TEXT_OPTIONS = ModelDecorationOptions.register({
     },
     minimap: {
         color: themeColorFromId(minimapSelectionOccurrenceHighlight),
-        position: MinimapPosition.Inline
+        position: 1
     },
 });
 const _SELECTION_HIGHLIGHT_OPTIONS = ModelDecorationOptions.register({
@@ -86,7 +96,7 @@ const _SELECTION_HIGHLIGHT_OPTIONS = ModelDecorationOptions.register({
     },
     minimap: {
         color: themeColorFromId(minimapSelectionOccurrenceHighlight),
-        position: MinimapPosition.Inline
+        position: 1
     },
 });
 const _SELECTION_HIGHLIGHT_OPTIONS_NO_OVERVIEW = ModelDecorationOptions.register({
@@ -104,7 +114,7 @@ const _REGULAR_OPTIONS = ModelDecorationOptions.register({
     },
     minimap: {
         color: themeColorFromId(minimapSelectionOccurrenceHighlight),
-        position: MinimapPosition.Inline
+        position: 1
     },
 });
 function getHighlightDecorationOptions(kind) {

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

@@ -518,10 +518,10 @@ let WordHighlighter = class WordHighlighter {
     }
     computeWithModel(model, selection, word, otherModels) {
         if (!otherModels.length) {
-            return computeOccurencesAtPosition(this.providers, model, selection, word, this.editor.getOption(130 ));
+            return computeOccurencesAtPosition(this.providers, model, selection, word, this.editor.getOption(131 ));
         }
         else {
-            return computeOccurencesMultiModel(this.multiDocumentProviders, model, selection, word, this.editor.getOption(130 ), otherModels);
+            return computeOccurencesMultiModel(this.multiDocumentProviders, model, selection, word, this.editor.getOption(131 ), otherModels);
         }
     }
     _beginRenderDecorations() {