@codingame/monaco-vscode-api 17.1.1 → 17.1.3

package/lifecycle.js

@@ -3,7 +3,7 @@ import { Registry } from './vscode/src/vs/platform/registry/common/platform.js';
 import { Extensions } from './vscode/src/vs/workbench/common/contributions.js';
 import { LifecyclePhase } from './vscode/src/vs/workbench/services/lifecycle/common/lifecycle.js';
 import { ILifecycleService } from './vscode/src/vs/workbench/services/lifecycle/common/lifecycle.service.js';
-import './vscode/src/vs/platform/instantiation/common/instantiation.js';
+import { IInstantiationService } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 import { Barrier, timeout, RunOnceScheduler, _runWhenIdle } from './vscode/src/vs/base/common/async.js';
 import { Emitter } from './vscode/src/vs/base/common/event.js';
 import { EditorExtensions } from './vscode/src/vs/workbench/common/editor.js';
@@ -14,6 +14,7 @@ import { setHoverDelegateFactory } from './vscode/src/vs/base/browser/ui/hover/h
 import { setBaseLayerHoverDelegate } from './vscode/src/vs/base/browser/ui/hover/hoverDelegate2.js';
 import { WorkbenchHoverDelegate } from './vscode/src/vs/platform/hover/browser/hover.js';
 import { IHoverService } from './vscode/src/vs/platform/hover/browser/hover.service.js';
+import { WorkbenchContextKeysHandler } from './vscode/src/vs/workbench/browser/contextkeys.js';
 
 const layoutEmitter = new Emitter();
 const onLayout = layoutEmitter.event;
@@ -55,6 +56,7 @@ async function startup(instantiationService) {
         const lifecycleService = accessor.get(ILifecycleService);
         Registry.as(Extensions.Workbench).start(accessor);
         Registry.as(EditorExtensions.EditorFactory).start(accessor);
+        accessor.get(IInstantiationService).createInstance(WorkbenchContextKeysHandler);
         layoutEmitter.fire(accessor);
         renderWorkbenchEmitter.fire(accessor);
         await Promise.race([accessor.get(IWorkbenchLayoutService).whenRestored, timeout(2000)]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "17.1.1",
+  "version": "17.1.3",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -15,14 +15,15 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-base-service-override": "17.1.1",
-    "@codingame/monaco-vscode-environment-service-override": "17.1.1",
-    "@codingame/monaco-vscode-extensions-service-override": "17.1.1",
-    "@codingame/monaco-vscode-files-service-override": "17.1.1",
-    "@codingame/monaco-vscode-host-service-override": "17.1.1",
-    "@codingame/monaco-vscode-layout-service-override": "17.1.1",
-    "@codingame/monaco-vscode-quickaccess-service-override": "17.1.1",
+    "@codingame/monaco-vscode-base-service-override": "17.1.3",
+    "@codingame/monaco-vscode-environment-service-override": "17.1.3",
+    "@codingame/monaco-vscode-extensions-service-override": "17.1.3",
+    "@codingame/monaco-vscode-files-service-override": "17.1.3",
+    "@codingame/monaco-vscode-host-service-override": "17.1.3",
+    "@codingame/monaco-vscode-layout-service-override": "17.1.3",
+    "@codingame/monaco-vscode-quickaccess-service-override": "17.1.3",
     "@vscode/iconv-lite-umd": "0.7.0",
+    "dompurify": "3.2.6",
     "jschardet": "3.1.4",
     "marked": "14.0.0"
   },

package/services.d.ts

@@ -97,8 +97,8 @@ export { ILocaleService } from "./vscode/src/vs/workbench/services/localization/
 export { NoOpNotification, NoOpProgress } from "./vscode/src/vs/platform/notification/common/notification.js";
 export { NotificationsFilter, NotificationPriority, NeverShowAgainScope } from "./vscode/src/vs/platform/notification/common/notification.js";
 export type { NotificationMessage, INotificationProperties, INeverShowAgainOptions, INotification, INotificationActions, INotificationProgress, INotificationProgressProperties, INotificationHandle, IPromptChoice, IPromptChoiceWithMenu, IPromptOptions, IStatusMessageOptions } from "./vscode/src/vs/platform/notification/common/notification.js";
-export type { IDialogArgs, DialogType, IDialogResult, IConfirmDialogArgs, IInputDialogArgs, IPromptDialogArgs, IBaseDialogOptions, ICheckbox, ICheckboxResult, IConfirmation, IConfirmationResult, IInput, IInputResult, IInputElement, IPrompt, IPromptResult, IPromptBaseButton, IPromptButton, IPromptCancelButton, IPromptResultWithCancel, IPromptWithCustomCancel, IPromptWithDefaultCancel } from "@codingame/monaco-vscode-bed2b49f-41ae-5ed2-b61a-1105500a3f8a-common/vscode/vs/platform/dialogs/common/dialogs";
-export type { IDialogHandler, ICustomDialogOptions, ICustomDialogMarkdown } from "@codingame/monaco-vscode-bed2b49f-41ae-5ed2-b61a-1105500a3f8a-common/vscode/vs/platform/dialogs/common/dialogs";
+export type { IDialogArgs, DialogType, IDialogResult, IConfirmDialogArgs, IInputDialogArgs, IPromptDialogArgs, IBaseDialogOptions, ICheckbox, ICheckboxResult, IConfirmation, IConfirmationResult, IInput, IInputResult, IInputElement, IPrompt, IPromptResult, IPromptBaseButton, IPromptButton, IPromptCancelButton, IPromptResultWithCancel, IPromptWithCustomCancel, IPromptWithDefaultCancel } from "@codingame/monaco-vscode-0f262ee3-cace-5644-818e-eba5fe007685-common/vscode/vs/platform/dialogs/common/dialogs";
+export type { IDialogHandler, ICustomDialogOptions, ICustomDialogMarkdown } from "@codingame/monaco-vscode-0f262ee3-cace-5644-818e-eba5fe007685-common/vscode/vs/platform/dialogs/common/dialogs";
 export type { IMarkdownString, MarkdownStringTrustedOptions } from "./vscode/src/vs/base/common/htmlContent.js";
 export { IActivityService } from "./vscode/src/vs/workbench/services/activity/common/activity.service.js";
 export type { IBadge } from "@codingame/monaco-vscode-a7c9ae3c-16d2-5d17-86b2-981be7094566-common/vscode/vs/workbench/services/activity/common/activity";

package/services.js

@@ -182,10 +182,10 @@ export { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/k
 export { ISecretStorageService } from './vscode/src/vs/platform/secrets/common/secrets.service.js';
 export { ConfigurationTarget } from './vscode/src/vs/platform/configuration/common/configuration.js';
 
-if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "1.100.2-71b00727-b59a-4f1f-85a0-4d406e3dda87") {
-    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"1.100.2-71b00727-b59a-4f1f-85a0-4d406e3dda87"}, ${window.monacoVscodeApiBuildId} is already loaded`);
+if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "1.100.3-02a8a23b-6340-4b94-ae7b-d6a8042935e8") {
+    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"1.100.3-02a8a23b-6340-4b94-ae7b-d6a8042935e8"}, ${window.monacoVscodeApiBuildId} is already loaded`);
 }
-window.monacoVscodeApiBuildId = "1.100.2-71b00727-b59a-4f1f-85a0-4d406e3dda87";
+window.monacoVscodeApiBuildId = "1.100.3-02a8a23b-6340-4b94-ae7b-d6a8042935e8";
 async function initialize(overrides, container = document.body, configuration = {}, env) {
     checkServicesNotInitialized();
     injectCss(container);

package/vscode/src/vs/base/browser/dom.js

@@ -6,7 +6,7 @@ import { StandardMouseEvent } from './mouseEvent.js';
 import { _runWhenIdle, AbstractIdleValue, IntervalTimer, TimeoutTimer } from '../common/async.js';
 import { onUnexpectedError } from '../common/errors.js';
 import { Emitter, Event } from '../common/event.js';
-import purify from './dompurify/dompurify.js';
+import dompurify from 'dompurify';
 import { KeyCode } from '../common/keyCodes.js';
 import { DisposableStore, Disposable, toDisposable } from '../common/lifecycle.js';
 import { RemoteAuthorities, Schemas } from '../common/network.js';
@@ -1013,7 +1013,7 @@ function detectFullscreen(targetWindow) {
 }
 function hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, allowDataImages = false) {
     const anchor = document.createElement('a');
-    purify.addHook('afterSanitizeAttributes', (node) => {
+    dompurify.addHook('afterSanitizeAttributes', (node) => {
         for (const attr of ['href', 'src']) {
             if (node.hasAttribute(attr)) {
                 const attrValue = node.getAttribute(attr);
@@ -1031,7 +1031,7 @@ function hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, allowDataImages = fa
         }
     });
     return toDisposable(() => {
-        purify.removeHook('afterSanitizeAttributes');
+        dompurify.removeHook('afterSanitizeAttributes');
     });
 }
 const defaultSafeProtocols = [
@@ -1118,7 +1118,7 @@ const defaultDomPurifyConfig = ( Object.freeze({
 function safeInnerHtml(node, value, extraDomPurifyConfig) {
     const hook = hookDomPurifyHrefAndSrcSanitizer(defaultSafeProtocols);
     try {
-        const html = purify.sanitize(value, { ...defaultDomPurifyConfig, ...extraDomPurifyConfig });
+        const html = dompurify.sanitize(value, { ...defaultDomPurifyConfig, ...extraDomPurifyConfig });
         node.innerHTML = html;
     }
     finally {

package/vscode/src/vs/base/browser/markdownRenderer.js

@@ -15,7 +15,7 @@ import { resolvePath, dirname } from '../common/resources.js';
 import { escape } from '../common/strings.js';
 import { URI } from '../common/uri.js';
 import { reset, addDisposableListener, getWindow, $, isHTMLElement, hookDomPurifyHrefAndSrcSanitizer, basicMarkupHtmlTags } from './dom.js';
-import purify from './dompurify/dompurify.js';
+import dompurify from 'dompurify';
 import { DomEmitter } from './event.js';
 import { createElement } from './formattedTextRenderer.js';
 import { StandardKeyboardEvent } from './keyboardEvent.js';
@@ -394,7 +394,7 @@ function sanitizeRenderedMarkdown(options, renderedMarkdown) {
     }));
     store.add(hookDomPurifyHrefAndSrcSanitizer(allowedSchemes));
     try {
-        return purify.sanitize(renderedMarkdown, { ...config, RETURN_TRUSTED_TYPE: true });
+        return dompurify.sanitize(renderedMarkdown, { ...config, RETURN_TRUSTED_TYPE: true });
     }
     finally {
         store.dispose();
@@ -741,8 +741,8 @@ function completeTable(tokens) {
     return undefined;
 }
 function addDompurifyHook(hook, cb) {
-    purify.addHook(hook, cb);
-    return toDisposable(() => purify.removeHook(hook));
+    dompurify.addHook(hook, cb);
+    return toDisposable(() => dompurify.removeHook(hook));
 }
 
 export { allowedMarkdownAttr, fillInIncompleteTokens, renderMarkdown, renderMarkdownAsPlaintext, renderStringAsPlaintext };

package/vscode/src/vs/base/browser/ui/button/button.js

@@ -1,7 +1,7 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { EventType, addDisposableListener, EventHelper, trackFocus, reset, isActiveElement, $ } from '../../dom.js';
-import purify from '../../dompurify/dompurify.js';
+import dompurify from 'dompurify';
 import { StandardKeyboardEvent } from '../../keyboardEvent.js';
 import { renderMarkdown, renderStringAsPlaintext } from '../../markdownRenderer.js';
 import { Gesture, EventType as EventType$1 } from '../../touch.js';
@@ -157,7 +157,7 @@ class Button extends Disposable {
             rendered.dispose();
             const root = rendered.element.querySelector('p')?.innerHTML;
             if (root) {
-                const sanitized = purify.sanitize(root, { ADD_TAGS: ['b', 'i', 'u', 'code', 'span'], ALLOWED_ATTR: ['class'], RETURN_TRUSTED_TYPE: true });
+                const sanitized = dompurify.sanitize(root, { ADD_TAGS: ['b', 'i', 'u', 'code', 'span'], ALLOWED_ATTR: ['class'], RETURN_TRUSTED_TYPE: true });
                 labelElement.innerHTML = sanitized;
             }
             else {
@@ -466,7 +466,7 @@ class ButtonWithIcon extends Button {
             rendered.dispose();
             const root = rendered.element.querySelector('p')?.innerHTML;
             if (root) {
-                const sanitized = purify.sanitize(root, { ADD_TAGS: ['b', 'i', 'u', 'code', 'span'], ALLOWED_ATTR: ['class'], RETURN_TRUSTED_TYPE: true });
+                const sanitized = dompurify.sanitize(root, { ADD_TAGS: ['b', 'i', 'u', 'code', 'span'], ALLOWED_ATTR: ['class'], RETURN_TRUSTED_TYPE: true });
                 this._mdlabelElement.innerHTML = sanitized;
             }
             else {

package/vscode/src/vs/platform/dialogs/common/dialogs.service.d.ts

@@ -1,6 +1,6 @@
 import { Event } from "../../../base/common/event.js";
 import { URI } from "../../../base/common/uri.js";
-import { IConfirmation, IConfirmationResult, IPromptWithCustomCancel, IPromptResultWithCancel, IPromptWithDefaultCancel, IPromptResult, IPrompt, IInput, IInputResult, type ConfirmResult, type IOpenDialogOptions, type IPickAndOpenOptions, type ISaveDialogOptions } from "@codingame/monaco-vscode-bed2b49f-41ae-5ed2-b61a-1105500a3f8a-common/vscode/vs/platform/dialogs/common/dialogs";
+import { IConfirmation, IConfirmationResult, IPromptWithCustomCancel, IPromptResultWithCancel, IPromptWithDefaultCancel, IPromptResult, IPrompt, IInput, IInputResult, type ConfirmResult, type IOpenDialogOptions, type IPickAndOpenOptions, type ISaveDialogOptions } from "@codingame/monaco-vscode-0f262ee3-cace-5644-818e-eba5fe007685-common/vscode/vs/platform/dialogs/common/dialogs";
 export declare const IDialogService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IDialogService>;
 export interface IDialogService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/platform/label/common/label.service.d.ts

@@ -2,7 +2,7 @@ import { Event } from "../../../base/common/event.js";
 import { IDisposable } from "../../../base/common/lifecycle.js";
 import { URI } from "../../../base/common/uri.js";
 import { IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, IWorkspace } from "../../workspace/common/workspace.js";
-import { Verbosity, ResourceLabelFormatter, IFormatterChangeEvent } from "@codingame/monaco-vscode-2cbab29e-9393-5de6-b701-9a9555360b6b-common/vscode/vs/platform/label/common/label";
+import { Verbosity, ResourceLabelFormatter, IFormatterChangeEvent } from "@codingame/monaco-vscode-158b9837-fc78-5d9c-86f5-9134e4358643-common/vscode/vs/platform/label/common/label";
 export declare const ILabelService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ILabelService>;
 export interface ILabelService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/platform/native/common/native.d.ts

@@ -4,7 +4,7 @@ import { Event } from "../../../base/common/event.js";
 import { URI } from "../../../base/common/uri.js";
 import { MessageBoxOptions, MessageBoxReturnValue, OpenDevToolsOptions, OpenDialogOptions, OpenDialogReturnValue, SaveDialogOptions, SaveDialogReturnValue } from "../../../base/parts/sandbox/common/electronTypes.js";
 import { ISerializableCommandAction } from "../../action/common/action.js";
-import { INativeOpenDialogOptions } from "@codingame/monaco-vscode-bed2b49f-41ae-5ed2-b61a-1105500a3f8a-common/vscode/vs/platform/dialogs/common/dialogs";
+import { INativeOpenDialogOptions } from "@codingame/monaco-vscode-0f262ee3-cace-5644-818e-eba5fe007685-common/vscode/vs/platform/dialogs/common/dialogs";
 import { IV8Profile } from "../../profiling/common/profiling.js";
 import { AuthInfo, Credentials } from "../../request/common/request.js";
 import { IPartsSplash } from "../../theme/common/themeService.js";

package/vscode/src/vs/platform/product/common/product.js

@@ -4,9 +4,9 @@ import productJson from '../../../../../product.json.js';
 var product = {
   ...productJson,
   quality: 'stable',
-  version: '1.100.2',
-  commit: '848b80aeb52026648a8ff9f7c45a9b0a80641e2e',
-  date: '2025-05-20T09:24:53.245Z',
+  version: '1.100.3',
+  commit: '258e40fedc6cb8edf399a463ce3a9d32e7e1f6f3',
+  date: '2025-06-04T12:35:19.633Z',
   ...(globalThis._VSCODE_PRODUCT_JSON ?? {})
 };
 

package/vscode/src/vs/platform/userDataSync/common/userDataSync.service.d.ts

@@ -1,7 +1,7 @@
 import { VSBufferReadableStream } from "../../../base/common/buffer.js";
 import { IStringDictionary } from "../../../base/common/collections.js";
 import { Event } from "../../../base/common/event.js";
-import { FormattingOptions } from "@codingame/monaco-vscode-407531d3-fdae-5387-8c41-49ba0e9574b5-common/vscode/vs/base/common/jsonFormatter";
+import { FormattingOptions } from "@codingame/monaco-vscode-158b9837-fc78-5d9c-86f5-9134e4358643-common/vscode/vs/base/common/jsonFormatter";
 import { URI } from "../../../base/common/uri.js";
 import { IHeaders } from "@codingame/monaco-vscode-912ff6c1-e6aa-58cf-bd7f-50cf27bdb591-common/vscode/vs/base/parts/request/common/request";
 import { ILogService } from "../../log/common/log.service.js";

package/vscode/src/vs/platform/workspace/common/virtualWorkspace.d.ts

@@ -0,0 +1,10 @@
+import { URI } from "../../../base/common/uri.js";
+import { IWorkspace } from "./workspace.js";
+export declare function isVirtualResource(resource: URI): boolean;
+export declare function getVirtualWorkspaceLocation(workspace: IWorkspace): {
+    scheme: string;
+    authority: string;
+} | undefined;
+export declare function getVirtualWorkspaceScheme(workspace: IWorkspace): string | undefined;
+export declare function getVirtualWorkspaceAuthority(workspace: IWorkspace): string | undefined;
+export declare function isVirtualWorkspace(workspace: IWorkspace): boolean;

package/vscode/src/vs/platform/workspace/common/virtualWorkspace.js

@@ -0,0 +1,26 @@
+
+import { Schemas } from '../../../base/common/network.js';
+
+function isVirtualResource(resource) {
+    return resource.scheme !== Schemas.file && resource.scheme !== Schemas.vscodeRemote;
+}
+function getVirtualWorkspaceLocation(workspace) {
+    if (workspace.folders.length) {
+        return workspace.folders.every(f => isVirtualResource(f.uri)) ? workspace.folders[0].uri : undefined;
+    }
+    else if (workspace.configuration && isVirtualResource(workspace.configuration)) {
+        return workspace.configuration;
+    }
+    return undefined;
+}
+function getVirtualWorkspaceScheme(workspace) {
+    return getVirtualWorkspaceLocation(workspace)?.scheme;
+}
+function getVirtualWorkspaceAuthority(workspace) {
+    return getVirtualWorkspaceLocation(workspace)?.authority;
+}
+function isVirtualWorkspace(workspace) {
+    return getVirtualWorkspaceLocation(workspace) !== undefined;
+}
+
+export { getVirtualWorkspaceAuthority, getVirtualWorkspaceLocation, getVirtualWorkspaceScheme, isVirtualResource, isVirtualWorkspace };

package/vscode/src/vs/platform/workspaces/common/workspaces.service.d.ts

@@ -1,8 +1,8 @@
 import { Event } from "../../../base/common/event.js";
 import { URI } from "../../../base/common/uri.js";
-import { IWorkspaceBackupInfo, IFolderBackupInfo } from "@codingame/monaco-vscode-2cbab29e-9393-5de6-b701-9a9555360b6b-common/vscode/vs/platform/backup/common/backup";
+import { IWorkspaceBackupInfo, IFolderBackupInfo } from "@codingame/monaco-vscode-158b9837-fc78-5d9c-86f5-9134e4358643-common/vscode/vs/platform/backup/common/backup";
 import { IWorkspaceIdentifier } from "../../workspace/common/workspace.js";
-import { IEnterWorkspaceResult, IWorkspaceFolderCreationData, IRecent, IRecentlyOpened } from "@codingame/monaco-vscode-2cbab29e-9393-5de6-b701-9a9555360b6b-common/vscode/vs/platform/workspaces/common/workspaces";
+import { IEnterWorkspaceResult, IWorkspaceFolderCreationData, IRecent, IRecentlyOpened } from "@codingame/monaco-vscode-158b9837-fc78-5d9c-86f5-9134e4358643-common/vscode/vs/platform/workspaces/common/workspaces";
 export declare const IWorkspacesService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IWorkspacesService>;
 export interface IWorkspacesService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/api/common/extHost.protocol.d.ts

@@ -29,7 +29,7 @@ import { ConfigurationScope } from "../../../platform/configuration/common/confi
 import { IExtensionIdWithVersion } from "@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/vscode/vs/platform/extensionManagement/common/extensionStorage";
 import { ExtensionIdentifier, IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import * as files from "../../../platform/files/common/files.js";
-import { ResourceLabelFormatter } from "@codingame/monaco-vscode-2cbab29e-9393-5de6-b701-9a9555360b6b-common/vscode/vs/platform/label/common/label";
+import { ResourceLabelFormatter } from "@codingame/monaco-vscode-158b9837-fc78-5d9c-86f5-9134e4358643-common/vscode/vs/platform/label/common/label";
 import { ILoggerOptions, ILoggerResource, LogLevel } from "../../../platform/log/common/log.js";
 import { IMarkerData } from "../../../platform/markers/common/markers.js";
 import { IProgressOptions, IProgressStep } from "../../../platform/progress/common/progress.js";

package/vscode/src/vs/workbench/api/common/extHostLabelService.d.ts

@@ -1,4 +1,4 @@
-import { ResourceLabelFormatter } from "@codingame/monaco-vscode-2cbab29e-9393-5de6-b701-9a9555360b6b-common/vscode/vs/platform/label/common/label";
+import { ResourceLabelFormatter } from "@codingame/monaco-vscode-158b9837-fc78-5d9c-86f5-9134e4358643-common/vscode/vs/platform/label/common/label";
 import { IDisposable } from "../../../base/common/lifecycle.js";
 import { ExtHostLabelServiceShape, IMainContext } from "./extHost.protocol.js";
 export declare class ExtHostLabelService implements ExtHostLabelServiceShape {

package/vscode/src/vs/workbench/browser/contextkeys.d.ts

@@ -0,0 +1,67 @@
+import { Disposable } from "../../base/common/lifecycle.js";
+import { IContextKeyService } from "../../platform/contextkey/common/contextkey.service.js";
+import { IEditorGroupsService } from "../services/editor/common/editorGroupsService.service.js";
+import { IConfigurationService } from "../../platform/configuration/common/configuration.service.js";
+import { IWorkbenchEnvironmentService } from "../services/environment/common/environmentService.service.js";
+import { IWorkspaceContextService } from "../../platform/workspace/common/workspace.service.js";
+import { IWorkbenchLayoutService } from "../services/layout/browser/layoutService.service.js";
+import { IWorkingCopyService } from "../services/workingCopy/common/workingCopyService.service.js";
+import { IPaneCompositePartService } from "../services/panecomposite/browser/panecomposite.service.js";
+import { IProductService } from "../../platform/product/common/productService.service.js";
+import { IEditorService } from "../services/editor/common/editorService.service.js";
+export declare class WorkbenchContextKeysHandler extends Disposable {
+    private readonly contextKeyService;
+    private readonly contextService;
+    private readonly configurationService;
+    private readonly environmentService;
+    private readonly productService;
+    private readonly editorGroupService;
+    private readonly editorService;
+    private readonly layoutService;
+    private readonly paneCompositeService;
+    private readonly workingCopyService;
+    private inputFocusedContext;
+    private dirtyWorkingCopiesContext;
+    private activeEditorGroupEmpty;
+    private activeEditorGroupIndex;
+    private activeEditorGroupLast;
+    private activeEditorGroupLocked;
+    private multipleEditorGroupsContext;
+    private editorsVisibleContext;
+    private splitEditorsVerticallyContext;
+    private workbenchStateContext;
+    private workspaceFolderCountContext;
+    private openFolderWorkspaceSupportContext;
+    private enterMultiRootWorkspaceSupportContext;
+    private emptyWorkspaceSupportContext;
+    private virtualWorkspaceContext;
+    private temporaryWorkspaceContext;
+    private inZenModeContext;
+    private isMainWindowFullscreenContext;
+    private isAuxiliaryWindowFocusedContext;
+    private isMainEditorCenteredLayoutContext;
+    private sideBarVisibleContext;
+    private mainEditorAreaVisibleContext;
+    private panelPositionContext;
+    private panelVisibleContext;
+    private panelAlignmentContext;
+    private panelMaximizedContext;
+    private auxiliaryBarVisibleContext;
+    private editorTabsVisibleContext;
+    private titleAreaVisibleContext;
+    private titleBarStyleContext;
+    constructor(contextKeyService: IContextKeyService, contextService: IWorkspaceContextService, configurationService: IConfigurationService, environmentService: IWorkbenchEnvironmentService, productService: IProductService, editorGroupService: IEditorGroupsService, editorService: IEditorService, layoutService: IWorkbenchLayoutService, paneCompositeService: IPaneCompositePartService, workingCopyService: IWorkingCopyService);
+    private registerListeners;
+    private updateVisiblePanesContextKeys;
+    private updateActiveEditorGroupContextKeys;
+    private updateEditorGroupsContextKeys;
+    private updateEditorAreaContextKeys;
+    private updateInputContextKeys;
+    private updateWorkbenchStateContextKey;
+    private updateWorkspaceFolderCountContextKey;
+    private updateSplitEditorsVerticallyContext;
+    private getWorkbenchStateString;
+    private updateSideBarContextKeys;
+    private updateTitleBarContextKeys;
+    private updateWorkspaceContextKeys;
+}

package/vscode/src/vs/workbench/browser/contextkeys.js

@@ -0,0 +1,241 @@
+
+import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../base/common/event.js';
+import { Disposable } from '../../base/common/lifecycle.js';
+import { setConstant } from '../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../platform/contextkey/common/contextkey.service.js';
+import { IsMacContext, IsLinuxContext, IsWindowsContext, IsWebContext, IsMacNativeContext, IsIOSContext, IsMobileContext, IsDevelopmentContext, ProductQualityContext, InputFocusedContext } from '../../platform/contextkey/common/contextkeys.js';
+import { RemoteNameContext, VirtualWorkspaceContext, TemporaryWorkspaceContext, HasWebFileSystemAccess, EmbedderIdentifierContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, MultipleEditorGroupsContext, EditorsVisibleContext, DirtyWorkingCopiesContext, WorkbenchStateContext, WorkspaceFolderCountContext, OpenFolderWorkspaceSupportContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, SplitEditorsVertically, IsMainWindowFullscreenContext, IsAuxiliaryWindowFocusedContext, InEditorZenModeContext, IsMainEditorCenteredLayoutContext, MainEditorAreaVisibleContext, EditorTabsVisibleContext, SideBarVisibleContext, TitleBarVisibleContext, TitleBarStyleContext, PanelPositionContext, PanelVisibleContext, PanelMaximizedContext, PanelAlignmentContext, AuxiliaryBarVisibleContext } from '../common/contextkeys.js';
+import { onDidRegisterWindow, addDisposableListener, EventType, isEditableElement, trackFocus, getActiveWindow } from '../../base/browser/dom.js';
+import { preferredSideBySideGroupDirection, GroupDirection } from '../services/editor/common/editorGroupsService.js';
+import { IEditorGroupsService } from '../services/editor/common/editorGroupsService.service.js';
+import { IConfigurationService } from '../../platform/configuration/common/configuration.service.js';
+import { IWorkbenchEnvironmentService } from '../services/environment/common/environmentService.service.js';
+import { WorkbenchState, isTemporaryWorkspace } from '../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from '../../platform/workspace/common/workspace.service.js';
+import { positionToString, Parts } from '../services/layout/browser/layoutService.js';
+import { IWorkbenchLayoutService } from '../services/layout/browser/layoutService.service.js';
+import { getRemoteName } from '../../platform/remote/common/remoteHosts.js';
+import { getVirtualWorkspaceScheme } from '../../platform/workspace/common/virtualWorkspace.js';
+import { IWorkingCopyService } from '../services/workingCopy/common/workingCopyService.service.js';
+import { isNative } from '../../base/common/platform.js';
+import { IPaneCompositePartService } from '../services/panecomposite/browser/panecomposite.service.js';
+import { WebFileSystemAccess } from '../../platform/files/browser/webFileSystemAccess.js';
+import { IProductService } from '../../platform/product/common/productService.service.js';
+import { getTitleBarStyle } from '../../platform/window/common/window.js';
+import { mainWindow } from '../../base/browser/window.js';
+import { onDidChangeFullscreen, isFullscreen } from '../../base/browser/browser.js';
+import { IEditorService } from '../services/editor/common/editorService.service.js';
+
+let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disposable {
+    constructor(contextKeyService, contextService, configurationService, environmentService, productService, editorGroupService, editorService, layoutService, paneCompositeService, workingCopyService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.environmentService = environmentService;
+        this.productService = productService;
+        this.editorGroupService = editorGroupService;
+        this.editorService = editorService;
+        this.layoutService = layoutService;
+        this.paneCompositeService = paneCompositeService;
+        this.workingCopyService = workingCopyService;
+        IsMacContext.bindTo(this.contextKeyService);
+        IsLinuxContext.bindTo(this.contextKeyService);
+        IsWindowsContext.bindTo(this.contextKeyService);
+        IsWebContext.bindTo(this.contextKeyService);
+        IsMacNativeContext.bindTo(this.contextKeyService);
+        IsIOSContext.bindTo(this.contextKeyService);
+        IsMobileContext.bindTo(this.contextKeyService);
+        RemoteNameContext.bindTo(this.contextKeyService).set(getRemoteName(this.environmentService.remoteAuthority) || '');
+        this.virtualWorkspaceContext = VirtualWorkspaceContext.bindTo(this.contextKeyService);
+        this.temporaryWorkspaceContext = TemporaryWorkspaceContext.bindTo(this.contextKeyService);
+        this.updateWorkspaceContextKeys();
+        HasWebFileSystemAccess.bindTo(this.contextKeyService).set(WebFileSystemAccess.supported(mainWindow));
+        const isDevelopment = !this.environmentService.isBuilt || this.environmentService.isExtensionDevelopment;
+        IsDevelopmentContext.bindTo(this.contextKeyService).set(isDevelopment);
+        setConstant(IsDevelopmentContext.key, isDevelopment);
+        ProductQualityContext.bindTo(this.contextKeyService).set(this.productService.quality || '');
+        EmbedderIdentifierContext.bindTo(this.contextKeyService).set(productService.embedderIdentifier);
+        this.activeEditorGroupEmpty = ActiveEditorGroupEmptyContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupIndex = ActiveEditorGroupIndexContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupLast = ActiveEditorGroupLastContext.bindTo(this.contextKeyService);
+        this.activeEditorGroupLocked = ActiveEditorGroupLockedContext.bindTo(this.contextKeyService);
+        this.multipleEditorGroupsContext = MultipleEditorGroupsContext.bindTo(this.contextKeyService);
+        this.editorsVisibleContext = EditorsVisibleContext.bindTo(this.contextKeyService);
+        this.dirtyWorkingCopiesContext = DirtyWorkingCopiesContext.bindTo(this.contextKeyService);
+        this.dirtyWorkingCopiesContext.set(this.workingCopyService.hasDirty);
+        this.inputFocusedContext = InputFocusedContext.bindTo(this.contextKeyService);
+        this.workbenchStateContext = WorkbenchStateContext.bindTo(this.contextKeyService);
+        this.updateWorkbenchStateContextKey();
+        this.workspaceFolderCountContext = WorkspaceFolderCountContext.bindTo(this.contextKeyService);
+        this.updateWorkspaceFolderCountContextKey();
+        this.openFolderWorkspaceSupportContext = OpenFolderWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.openFolderWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.emptyWorkspaceSupportContext = EmptyWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.emptyWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.enterMultiRootWorkspaceSupportContext = EnterMultiRootWorkspaceSupportContext.bindTo(this.contextKeyService);
+        this.enterMultiRootWorkspaceSupportContext.set(isNative || typeof this.environmentService.remoteAuthority === 'string');
+        this.splitEditorsVerticallyContext = SplitEditorsVertically.bindTo(this.contextKeyService);
+        this.updateSplitEditorsVerticallyContext();
+        this.isMainWindowFullscreenContext = IsMainWindowFullscreenContext.bindTo(this.contextKeyService);
+        this.isAuxiliaryWindowFocusedContext = IsAuxiliaryWindowFocusedContext.bindTo(this.contextKeyService);
+        this.inZenModeContext = InEditorZenModeContext.bindTo(this.contextKeyService);
+        this.isMainEditorCenteredLayoutContext = IsMainEditorCenteredLayoutContext.bindTo(this.contextKeyService);
+        this.mainEditorAreaVisibleContext = MainEditorAreaVisibleContext.bindTo(this.contextKeyService);
+        this.editorTabsVisibleContext = EditorTabsVisibleContext.bindTo(this.contextKeyService);
+        this.sideBarVisibleContext = SideBarVisibleContext.bindTo(this.contextKeyService);
+        this.titleAreaVisibleContext = TitleBarVisibleContext.bindTo(this.contextKeyService);
+        this.titleBarStyleContext = TitleBarStyleContext.bindTo(this.contextKeyService);
+        this.updateTitleBarContextKeys();
+        this.panelPositionContext = PanelPositionContext.bindTo(this.contextKeyService);
+        this.panelPositionContext.set(positionToString(this.layoutService.getPanelPosition()));
+        this.panelVisibleContext = PanelVisibleContext.bindTo(this.contextKeyService);
+        this.panelVisibleContext.set(this.layoutService.isVisible(Parts.PANEL_PART));
+        this.panelMaximizedContext = PanelMaximizedContext.bindTo(this.contextKeyService);
+        this.panelMaximizedContext.set(this.layoutService.isPanelMaximized());
+        this.panelAlignmentContext = PanelAlignmentContext.bindTo(this.contextKeyService);
+        this.panelAlignmentContext.set(this.layoutService.getPanelAlignment());
+        this.auxiliaryBarVisibleContext = AuxiliaryBarVisibleContext.bindTo(this.contextKeyService);
+        this.auxiliaryBarVisibleContext.set(this.layoutService.isVisible(Parts.AUXILIARYBAR_PART));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.editorGroupService.whenReady.then(() => {
+            this.updateEditorAreaContextKeys();
+            this.updateActiveEditorGroupContextKeys();
+            this.updateVisiblePanesContextKeys();
+        });
+        this._register(this.editorService.onDidActiveEditorChange(() => this.updateActiveEditorGroupContextKeys()));
+        this._register(this.editorService.onDidVisibleEditorsChange(() => this.updateVisiblePanesContextKeys()));
+        this._register(this.editorGroupService.onDidAddGroup(() => this.updateEditorGroupsContextKeys()));
+        this._register(this.editorGroupService.onDidRemoveGroup(() => this.updateEditorGroupsContextKeys()));
+        this._register(this.editorGroupService.onDidChangeGroupIndex(() => this.updateActiveEditorGroupContextKeys()));
+        this._register(this.editorGroupService.onDidChangeGroupLocked(() => this.updateActiveEditorGroupContextKeys()));
+        this._register(this.editorGroupService.onDidChangeEditorPartOptions(() => this.updateEditorAreaContextKeys()));
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => disposables.add(addDisposableListener(window, EventType.FOCUS_IN, () => this.updateInputContextKeys(window.document, disposables), true)), { window: mainWindow, disposables: this._store }));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateWorkbenchStateContextKey()));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => {
+            this.updateWorkspaceFolderCountContextKey();
+            this.updateWorkspaceContextKeys();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('workbench.editor.openSideBySideDirection')) {
+                this.updateSplitEditorsVerticallyContext();
+            }
+        }));
+        this._register(this.layoutService.onDidChangeZenMode(enabled => this.inZenModeContext.set(enabled)));
+        this._register(this.layoutService.onDidChangeActiveContainer(() => this.isAuxiliaryWindowFocusedContext.set(this.layoutService.activeContainer !== this.layoutService.mainContainer)));
+        this._register(onDidChangeFullscreen(windowId => {
+            if (windowId === mainWindow.vscodeWindowId) {
+                this.isMainWindowFullscreenContext.set(isFullscreen(mainWindow));
+            }
+        }));
+        this._register(this.layoutService.onDidChangeMainEditorCenteredLayout(centered => this.isMainEditorCenteredLayoutContext.set(centered)));
+        this._register(this.layoutService.onDidChangePanelPosition(position => this.panelPositionContext.set(position)));
+        this._register(this.layoutService.onDidChangePanelAlignment(alignment => this.panelAlignmentContext.set(alignment)));
+        this._register(this.paneCompositeService.onDidPaneCompositeClose(() => this.updateSideBarContextKeys()));
+        this._register(this.paneCompositeService.onDidPaneCompositeOpen(() => this.updateSideBarContextKeys()));
+        this._register(this.layoutService.onDidChangePartVisibility(() => {
+            this.mainEditorAreaVisibleContext.set(this.layoutService.isVisible(Parts.EDITOR_PART, mainWindow));
+            this.panelVisibleContext.set(this.layoutService.isVisible(Parts.PANEL_PART));
+            this.panelMaximizedContext.set(this.layoutService.isPanelMaximized());
+            this.auxiliaryBarVisibleContext.set(this.layoutService.isVisible(Parts.AUXILIARYBAR_PART));
+            this.updateTitleBarContextKeys();
+        }));
+        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.dirtyWorkingCopiesContext.set(workingCopy.isDirty() || this.workingCopyService.hasDirty)));
+    }
+    updateVisiblePanesContextKeys() {
+        const visibleEditorPanes = this.editorService.visibleEditorPanes;
+        if (visibleEditorPanes.length > 0) {
+            this.editorsVisibleContext.set(true);
+        }
+        else {
+            this.editorsVisibleContext.reset();
+        }
+    }
+    updateActiveEditorGroupContextKeys() {
+        if (!this.editorService.activeEditor) {
+            this.activeEditorGroupEmpty.set(true);
+        }
+        else {
+            this.activeEditorGroupEmpty.reset();
+        }
+        const activeGroup = this.editorGroupService.activeGroup;
+        this.activeEditorGroupIndex.set(activeGroup.index + 1);
+        this.activeEditorGroupLocked.set(activeGroup.isLocked);
+        this.updateEditorGroupsContextKeys();
+    }
+    updateEditorGroupsContextKeys() {
+        const groupCount = this.editorGroupService.count;
+        if (groupCount > 1) {
+            this.multipleEditorGroupsContext.set(true);
+        }
+        else {
+            this.multipleEditorGroupsContext.reset();
+        }
+        const activeGroup = this.editorGroupService.activeGroup;
+        this.activeEditorGroupLast.set(activeGroup.index === groupCount - 1);
+    }
+    updateEditorAreaContextKeys() {
+        this.editorTabsVisibleContext.set(this.editorGroupService.partOptions.showTabs === 'multiple');
+    }
+    updateInputContextKeys(ownerDocument, disposables) {
+        function activeElementIsInput() {
+            return !!ownerDocument.activeElement && isEditableElement(ownerDocument.activeElement);
+        }
+        const isInputFocused = activeElementIsInput();
+        this.inputFocusedContext.set(isInputFocused);
+        if (isInputFocused) {
+            const tracker = disposables.add(trackFocus(ownerDocument.activeElement));
+            Event.once(tracker.onDidBlur)(() => {
+                if (getActiveWindow().document === ownerDocument) {
+                    this.inputFocusedContext.set(activeElementIsInput());
+                }
+                tracker.dispose();
+            }, undefined, disposables);
+        }
+    }
+    updateWorkbenchStateContextKey() {
+        this.workbenchStateContext.set(this.getWorkbenchStateString());
+    }
+    updateWorkspaceFolderCountContextKey() {
+        this.workspaceFolderCountContext.set(this.contextService.getWorkspace().folders.length);
+    }
+    updateSplitEditorsVerticallyContext() {
+        const direction = preferredSideBySideGroupDirection(this.configurationService);
+        this.splitEditorsVerticallyContext.set(direction === GroupDirection.DOWN);
+    }
+    getWorkbenchStateString() {
+        switch (this.contextService.getWorkbenchState()) {
+            case WorkbenchState.EMPTY: return 'empty';
+            case WorkbenchState.FOLDER: return 'folder';
+            case WorkbenchState.WORKSPACE: return 'workspace';
+        }
+    }
+    updateSideBarContextKeys() {
+        this.sideBarVisibleContext.set(this.layoutService.isVisible(Parts.SIDEBAR_PART));
+    }
+    updateTitleBarContextKeys() {
+        this.titleAreaVisibleContext.set(this.layoutService.isVisible(Parts.TITLEBAR_PART, mainWindow));
+        this.titleBarStyleContext.set(getTitleBarStyle(this.configurationService));
+    }
+    updateWorkspaceContextKeys() {
+        this.virtualWorkspaceContext.set(getVirtualWorkspaceScheme(this.contextService.getWorkspace()) || '');
+        this.temporaryWorkspaceContext.set(isTemporaryWorkspace(this.contextService.getWorkspace()));
+    }
+};
+WorkbenchContextKeysHandler = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, IProductService)),
+    ( __param(5, IEditorGroupsService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IWorkbenchLayoutService)),
+    ( __param(8, IPaneCompositePartService)),
+    ( __param(9, IWorkingCopyService))
+], WorkbenchContextKeysHandler));
+
+export { WorkbenchContextKeysHandler };