@codingame/monaco-vscode-api 19.1.4 → 20.0.1

package/vscode/src/vs/editor/contrib/unicodeHighlighter/browser/bannerController.js

@@ -90,7 +90,7 @@ let Banner = class Banner extends Disposable {
         }
         const actionBarContainer = append(this.element, $('div.action-container'));
         this.actionBar = this._register(( new ActionBar(actionBarContainer)));
-        this.actionBar.push(this._register(( new Action('banner.close', ( localize(1592, "Close Banner")), ThemeIcon.asClassName(widgetClose), true, () => {
+        this.actionBar.push(this._register(( new Action('banner.close', ( localize(1604, "Close Banner")), ThemeIcon.asClassName(widgetClose), true, () => {
             if (typeof item.onClose === 'function') {
                 item.onClose();
             }

package/vscode/src/vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.d.ts

@@ -59,40 +59,40 @@ export declare class DisableHighlightingInCommentsAction extends EditorAction im
     static ID: string;
     readonly shortLabel: string;
     constructor();
-    run(accessor: ServicesAccessor | undefined, editor: ICodeEditor, args: any): Promise<void>;
+    run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): Promise<void>;
     runAction(configurationService: IConfigurationService): Promise<void>;
 }
 export declare class DisableHighlightingInStringsAction extends EditorAction implements IDisableUnicodeHighlightAction {
     static ID: string;
     readonly shortLabel: string;
     constructor();
-    run(accessor: ServicesAccessor | undefined, editor: ICodeEditor, args: any): Promise<void>;
+    run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): Promise<void>;
     runAction(configurationService: IConfigurationService): Promise<void>;
 }
 export declare class DisableHighlightingOfAmbiguousCharactersAction extends Action2 implements IDisableUnicodeHighlightAction {
     static ID: string;
     readonly shortLabel: string;
     constructor();
-    run(accessor: ServicesAccessor | undefined, editor: ICodeEditor, args: any): Promise<void>;
+    run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): Promise<void>;
     runAction(configurationService: IConfigurationService): Promise<void>;
 }
 export declare class DisableHighlightingOfInvisibleCharactersAction extends Action2 implements IDisableUnicodeHighlightAction {
     static ID: string;
     readonly shortLabel: string;
     constructor();
-    run(accessor: ServicesAccessor | undefined, editor: ICodeEditor, args: any): Promise<void>;
+    run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): Promise<void>;
     runAction(configurationService: IConfigurationService): Promise<void>;
 }
 export declare class DisableHighlightingOfNonBasicAsciiCharactersAction extends Action2 implements IDisableUnicodeHighlightAction {
     static ID: string;
     readonly shortLabel: string;
     constructor();
-    run(accessor: ServicesAccessor | undefined, editor: ICodeEditor, args: any): Promise<void>;
+    run(accessor: ServicesAccessor, editor: ICodeEditor, args: any): Promise<void>;
     runAction(configurationService: IConfigurationService): Promise<void>;
 }
 export declare class ShowExcludeOptions extends Action2 {
     static ID: string;
     constructor();
-    run(accessor: ServicesAccessor | undefined, args: any): Promise<void>;
+    run(accessor: ServicesAccessor, args: any): Promise<void>;
 }
 export {};

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

@@ -16,7 +16,6 @@ import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { UnicodeTextModelHighlighter, UnicodeHighlighterReasonKind } from '../../../common/services/unicodeTextModelHighlighter.js';
 import { IEditorWorkerService } from '../../../common/services/editorWorker.service.js';
 import { ILanguageService } from '../../../common/languages/language.service.js';
-import { isModelDecorationVisible, isModelDecorationInString, isModelDecorationInComment } from '../../../common/viewModel/viewModelDecorations.js';
 import { HoverAnchorType, HoverParticipantRegistry } from '../../hover/browser/hoverTypes.js';
 import { MarkdownHover, renderMarkdownHovers } from '../../hover/browser/markdownHoverParticipant.js';
 import { BannerController } from './bannerController.js';
@@ -30,9 +29,10 @@ import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js'
 import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.service.js';
 import { Action2, registerAction2 } from '../../../../platform/actions/common/actions.js';
 import { safeIntl } from '../../../../base/common/date.js';
+import { isModelDecorationVisible, isModelDecorationInString, isModelDecorationInComment } from '../../../common/viewModel/viewModelDecoration.js';
 
 registerCss(unicodeHighlighter);
-const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1593, 'Icon shown with a warning message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1605, 'Icon shown with a warning message in the extensions editor.')));
 let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
     static { this.ID = 'editor.contrib.unicodeHighlighter'; }
     constructor(_editor, _editorWorkerService, _workspaceTrustService, instantiationService) {
@@ -51,19 +51,19 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 let data;
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
-                        message: ( localize(1594, 'This document contains many non-basic ASCII unicode characters')),
+                        message: ( localize(1606, 'This document contains many non-basic ASCII unicode characters')),
                         command: ( new DisableHighlightingOfNonBasicAsciiCharactersAction()),
                     };
                 }
                 else if (state.ambiguousCharacterCount >= max) {
                     data = {
-                        message: ( localize(1595, 'This document contains many ambiguous unicode characters')),
+                        message: ( localize(1607, 'This document contains many ambiguous unicode characters')),
                         command: ( new DisableHighlightingOfAmbiguousCharactersAction()),
                     };
                 }
                 else if (state.invisibleCharacterCount >= max) {
                     data = {
-                        message: ( localize(1596, 'This document contains many invisible unicode characters')),
+                        message: ( localize(1608, 'This document contains many invisible unicode characters')),
                         command: ( new DisableHighlightingOfInvisibleCharactersAction()),
                     };
                 }
@@ -330,7 +330,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = ( localize(1597, 'Configure Unicode Highlight Options'));
+const configureUnicodeHighlightOptionsStr = ( localize(1609, 'Configure Unicode Highlight Options'));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _languageService, _openerService) {
         this._editor = _editor;
@@ -363,7 +363,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 case UnicodeHighlighterReasonKind.Ambiguous: {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
                         reason = ( localize(
-                            1598,
+                            1610,
                             'The character {0} could be confused with the ASCII character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -371,7 +371,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     }
                     else {
                         reason = ( localize(
-                            1599,
+                            1611,
                             'The character {0} could be confused with the character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -380,10 +380,10 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     break;
                 }
                 case UnicodeHighlighterReasonKind.Invisible:
-                    reason = ( localize(1600, 'The character {0} is invisible.', codePointStr));
+                    reason = ( localize(1612, 'The character {0} is invisible.', codePointStr));
                     break;
                 case UnicodeHighlighterReasonKind.NonBasicAscii:
-                    reason = ( localize(1601, 'The character {0} is not a basic ASCII character.', codePointStr));
+                    reason = ( localize(1613, 'The character {0} is not a basic ASCII character.', codePointStr));
                     break;
             }
             if (( existedReason.has(reason))) {
@@ -396,7 +396,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = ( localize(1602, 'Adjust settings'));
+            const adjustSettings = ( localize(1614, 'Adjust settings'));
             const uri = `command:${ShowExcludeOptions.ID}?${encodeURIComponent(JSON.stringify(adjustSettingsArgs))}`;
             const markdown = ( new MarkdownString('', true))
                 .appendMarkdown(reason)
@@ -468,13 +468,13 @@ class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize2(1603, "Disable highlighting of characters in comments")),
+            label: ( localize2(1615, "Disable highlighting of characters in comments")),
             precondition: undefined
         });
-        this.shortLabel = ( localize(1604, 'Disable Highlight In Comments'));
+        this.shortLabel = ( localize(1616, 'Disable Highlight In Comments'));
     }
     async run(accessor, editor, args) {
-        const configurationService = accessor?.get(IConfigurationService);
+        const configurationService = accessor.get(IConfigurationService);
         if (configurationService) {
             this.runAction(configurationService);
         }
@@ -488,13 +488,13 @@ class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize2(1605, "Disable highlighting of characters in strings")),
+            label: ( localize2(1617, "Disable highlighting of characters in strings")),
             precondition: undefined
         });
-        this.shortLabel = ( localize(1606, 'Disable Highlight In Strings'));
+        this.shortLabel = ( localize(1618, 'Disable Highlight In Strings'));
     }
     async run(accessor, editor, args) {
-        const configurationService = accessor?.get(IConfigurationService);
+        const configurationService = accessor.get(IConfigurationService);
         if (configurationService) {
             this.runAction(configurationService);
         }
@@ -508,14 +508,14 @@ class DisableHighlightingOfAmbiguousCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            title: ( localize2(1607, "Disable highlighting of ambiguous characters")),
+            title: ( localize2(1619, "Disable highlighting of ambiguous characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1608, 'Disable Ambiguous Highlight'));
+        this.shortLabel = ( localize(1620, 'Disable Ambiguous Highlight'));
     }
     async run(accessor, editor, args) {
-        const configurationService = accessor?.get(IConfigurationService);
+        const configurationService = accessor.get(IConfigurationService);
         if (configurationService) {
             this.runAction(configurationService);
         }
@@ -529,14 +529,14 @@ class DisableHighlightingOfInvisibleCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            title: ( localize2(1609, "Disable highlighting of invisible characters")),
+            title: ( localize2(1621, "Disable highlighting of invisible characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1610, 'Disable Invisible Highlight'));
+        this.shortLabel = ( localize(1622, 'Disable Invisible Highlight'));
     }
     async run(accessor, editor, args) {
-        const configurationService = accessor?.get(IConfigurationService);
+        const configurationService = accessor.get(IConfigurationService);
         if (configurationService) {
             this.runAction(configurationService);
         }
@@ -550,14 +550,14 @@ class DisableHighlightingOfNonBasicAsciiCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            title: ( localize2(1611, "Disable highlighting of non basic ASCII characters")),
+            title: ( localize2(1623, "Disable highlighting of non basic ASCII characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1612, 'Disable Non ASCII Highlight'));
+        this.shortLabel = ( localize(1624, 'Disable Non ASCII Highlight'));
     }
     async run(accessor, editor, args) {
-        const configurationService = accessor?.get(IConfigurationService);
+        const configurationService = accessor.get(IConfigurationService);
         if (configurationService) {
             this.runAction(configurationService);
         }
@@ -571,7 +571,7 @@ class ShowExcludeOptions extends Action2 {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            title: ( localize2(1613, "Show Exclude Options")),
+            title: ( localize2(1625, "Show Exclude Options")),
             precondition: undefined,
             f1: false,
         });
@@ -584,13 +584,13 @@ class ShowExcludeOptions extends Action2 {
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
                 return localize(
-                    1614,
+                    1626,
                     'Exclude {0} (invisible character) from being highlighted',
                     codePointToHex(codePoint)
                 );
             }
             return localize(
-                1615,
+                1627,
                 'Exclude {0} from being highlighted',
                 `${codePointToHex(codePoint)} "${char}"`
             );
@@ -600,7 +600,7 @@ class ShowExcludeOptions extends Action2 {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
                     label: ( localize(
-                        1616,
+                        1628,
                         "Allow unicode characters that are more common in the language \"{0}\".",
                         locale
                     )),

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

@@ -70,15 +70,15 @@ let UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extend
         try {
             this._isPresentingDialog = true;
             result = await this._dialogService.confirm({
-                title: ( localize(1617, "Unusual Line Terminators")),
-                message: ( localize(1618, "Detected unusual line terminators")),
+                title: ( localize(1629, "Unusual Line Terminators")),
+                message: ( localize(1630, "Detected unusual line terminators")),
                 detail: ( localize(
-                    1619,
+                    1631,
                     "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).\n\nIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.",
                     basename(model.uri)
                 )),
-                primaryButton: ( localize(1620, "&&Remove Unusual Line Terminators")),
-                cancelButton: ( localize(1621, "Ignore"))
+                primaryButton: ( localize(1632, "&&Remove Unusual Line Terminators")),
+                cancelButton: ( localize(1633, "Ignore"))
             });
         }
         finally {

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

@@ -20,36 +20,36 @@ import { themeColorFromId, registerThemingParticipant } from '../../../../platfo
 
 registerCss(highlightDecorations);
 const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, ( localize(
-    1622,
+    1634,
     'Background color of a symbol during read-access, like reading a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightStrongBackground', { dark: '#004972B8', light: '#0e639c40', hcDark: null, hcLight: null }, ( localize(
-    1623,
+    1635,
     'Background color of a symbol during write-access, like writing to a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightTextBackground', wordHighlightBackground, ( localize(
-    1624,
+    1636,
     'Background color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const wordHighlightBorder = registerColor('editor.wordHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    1625,
+    1637,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    1626,
+    1638,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(1627, "Border color of a textual occurrence for a symbol.")));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(1639, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', ( localize(
-    1628,
+    1640,
     'Overview ruler marker color for symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightStrongForeground = registerColor('editorOverviewRuler.wordHighlightStrongForeground', '#C0A0C0CC', ( localize(
-    1629,
+    1641,
     'Overview ruler marker color for write-access symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightTextForeground = registerColor('editorOverviewRuler.wordHighlightTextForeground', overviewRulerSelectionHighlightForeground, ( localize(
-    1630,
+    1642,
     'Overview ruler marker color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const _WRITE_OPTIONS = ModelDecorationOptions.register({

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

@@ -175,14 +175,16 @@ let WordHighlighter = class WordHighlighter {
             if (this.occurrencesHighlightEnablement === 'off') {
                 return;
             }
-            this.runDelayer.trigger(() => { this._onPositionChanged(e); });
+            this.runDelayer.trigger(() => { this._onPositionChanged(e); }).catch(err => {
+            });
         }));
         this.toUnhook.add(editor.onDidFocusEditorText((e) => {
             if (this.occurrencesHighlightEnablement === 'off') {
                 return;
             }
             if (!this.workerRequest) {
-                this.runDelayer.trigger(() => { this._run(); });
+                this.runDelayer.trigger(() => { this._run(); }).catch(err => {
+                });
             }
         }));
         this.toUnhook.add(editor.onDidChangeModelContent((e) => {
@@ -255,7 +257,8 @@ let WordHighlighter = class WordHighlighter {
             return;
         }
         this.runDelayer.cancel();
-        this.runDelayer.trigger(() => { this._run(false, delay); });
+        this.runDelayer.trigger(() => { this._run(false, delay); }).catch(err => {
+        });
     }
     trigger() {
         this.runDelayer.cancel();
@@ -715,7 +718,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: ( localize2(1631, "Go to Next Symbol Highlight")),
+            label: ( localize2(1643, "Go to Next Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -729,7 +732,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: ( localize2(1632, "Go to Previous Symbol Highlight")),
+            label: ( localize2(1644, "Go to Previous Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -743,7 +746,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: ( localize2(1633, "Trigger Symbol Highlight")),
+            label: ( localize2(1645, "Trigger Symbol Highlight")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

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

@@ -272,8 +272,8 @@ class DeleteWordCommand extends EditorCommand {
         this._wordNavigationType = opts.wordNavigationType;
     }
     runEditorCommand(accessor, editor, args) {
-        const languageConfigurationService = accessor.get(ILanguageConfigurationService);
-        if (!editor.hasModel()) {
+        const languageConfigurationService = accessor?.get(ILanguageConfigurationService);
+        if (!editor.hasModel() || !languageConfigurationService) {
             return;
         }
         const wordSeparators = getMapForWordSeparators(editor.getOption(EditorOption.wordSeparators), editor.getOption(EditorOption.wordSegmenterLocales));
@@ -399,7 +399,7 @@ class DeleteInsideWord extends EditorAction {
         super({
             id: 'deleteInsideWord',
             precondition: EditorContextKeys.writable,
-            label: ( localize2(1634, "Delete Word")),
+            label: ( localize2(1646, "Delete Word")),
         });
     }
     run(accessor, editor, args) {

package/vscode/src/vs/editor/editor.worker.start.d.ts

@@ -1,2 +1,2 @@
 import { IWorkerContext } from "./common/services/editorWebWorker.js";
-export declare function start<THost extends object, TClient extends object>(client: TClient): IWorkerContext<THost>;
+export declare function start<THost extends object, TClient extends object>(createClient: (ctx: IWorkerContext<THost>) => TClient): TClient;

package/vscode/src/vs/editor/editor.worker.start.js

@@ -3,25 +3,33 @@ import { initialize } from '../base/common/worker/webWorkerBootstrap.js';
 import { EditorWorker } from './common/services/editorWebWorker.js';
 import { EditorWorkerHost } from './common/services/editorWorkerHost.js';
 
-function start(client) {
-    const webWorkerServer = initialize(() => ( new EditorWorker(client)));
-    const editorWorkerHost = EditorWorkerHost.getChannel(webWorkerServer);
-    const host = ( new Proxy({}, {
-        get(target, prop, receiver) {
-            if (typeof prop !== 'string') {
-                throw ( new Error(`Not supported`));
+function start(createClient) {
+    let client;
+    const webWorkerServer = initialize((workerServer) => {
+        const editorWorkerHost = EditorWorkerHost.getChannel(workerServer);
+        const host = ( new Proxy({}, {
+            get(target, prop, receiver) {
+                if (prop === 'then') {
+                    return undefined;
+                }
+                if (typeof prop !== 'string') {
+                    throw ( new Error(`Not supported`));
+                }
+                return (...args) => {
+                    return editorWorkerHost.$fhr(prop, args);
+                };
             }
-            return (...args) => {
-                return editorWorkerHost.$fhr(prop, args);
-            };
-        }
-    }));
-    return {
-        host: host,
-        getMirrorModels: () => {
-            return webWorkerServer.requestHandler.getModels();
-        }
-    };
+        }));
+        const ctx = {
+            host: host,
+            getMirrorModels: () => {
+                return webWorkerServer.requestHandler.getModels();
+            }
+        };
+        client = createClient(ctx);
+        return ( new EditorWorker(client));
+    });
+    return client;
 }
 
 export { start };

package/vscode/src/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.d.ts

@@ -1,7 +1,7 @@
 import { Event } from "../../../../base/common/event.js";
 import { ICodeEditor, IOverlayWidget, IOverlayWidgetPosition } from "../../../browser/editorBrowser.js";
 import { IEditorContribution } from "../../../common/editorCommon.js";
-import { IQuickPickItem, IQuickPick, IInputBox, IQuickNavigateConfiguration, IPickOptions, QuickPickInput, IInputOptions, IQuickWidget } from "../../../../platform/quickinput/common/quickInput.js";
+import { IQuickPickItem, IQuickPick, IInputBox, IQuickNavigateConfiguration, IPickOptions, QuickPickInput, IInputOptions, IQuickWidget, IQuickTree, IQuickTreeItem } from "../../../../platform/quickinput/common/quickInput.js";
 import { IQuickInputService } from "../../../../platform/quickinput/common/quickInput.service.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
@@ -34,6 +34,7 @@ export declare class StandaloneQuickInputService implements IQuickInputService {
     }>;
     createInputBox(): IInputBox;
     createQuickWidget(): IQuickWidget;
+    createQuickTree<T extends IQuickTreeItem>(): IQuickTree<T>;
     focus(): void;
     toggle(): void;
     navigate(next: boolean, quickNavigate?: IQuickNavigateConfiguration | undefined): void;

package/vscode/src/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js

@@ -102,6 +102,9 @@ let StandaloneQuickInputService = class StandaloneQuickInputService {
     createQuickWidget() {
         return this.activeService.createQuickWidget();
     }
+    createQuickTree() {
+        return this.activeService.createQuickTree();
+    }
     focus() {
         return this.activeService.focus();
     }

package/vscode/src/vs/editor/standalone/browser/standaloneServices.js

@@ -199,6 +199,7 @@ class StandaloneEnvironmentService {
         this.debugExtensionHost = { port: null, break: false };
         this.isExtensionDevelopment = false;
         this.disableExtensions = false;
+        this.disableExperiments = false;
         this.enableExtensions = undefined;
         this.extensionDevelopmentLocationURI = undefined;
         this.extensionDevelopmentKind = undefined;

package/vscode/src/vs/platform/accessibility/browser/accessibleView.d.ts

@@ -1,5 +1,5 @@
 import { IKeyboardEvent } from "../../keybinding/common/keybinding.js";
-import { IPickerQuickAccessItem } from "@codingame/monaco-vscode-2726569c-a06b-5f25-b851-14311bef12fa-common/vscode/vs/platform/quickinput/browser/pickerQuickAccess";
+import { IPickerQuickAccessItem } from "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/platform/quickinput/browser/pickerQuickAccess";
 import { Event } from "../../../base/common/event.js";
 import { IAction } from "../../../base/common/actions.js";
 import { IQuickPickItem } from "../../quickinput/common/quickInput.js";