@codingame/monaco-vscode-api 21.6.0 → 22.0.1

package/vscode/src/vs/workbench/browser/actions/developerActions.js

@@ -37,13 +37,18 @@ import { IEditorService } from '../../services/editor/common/editorService.servi
 import product from '../../../platform/product/common/product.js';
 import { CommandsRegistry } from '../../../platform/commands/common/commands.js';
 import { IEnvironmentService } from '../../../platform/environment/common/environment.service.js';
+import { IProductService } from '../../../platform/product/common/productService.service.js';
+import { IDefaultAccountService } from '../../services/accounts/common/defaultAccount.service.js';
+import { IAuthenticationService } from '../../services/authentication/common/authentication.service.js';
+import { IAuthenticationAccessService } from '../../services/authentication/browser/authenticationAccessService.service.js';
+import { IPolicyService } from '../../../platform/policy/common/policy.service.js';
 
 registerCss(actions);
 class InspectContextKeysAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.inspectContextKeys',
-            title: ( localize2(2658, 'Inspect Context Keys')),
+            title: ( localize2(2664, 'Inspect Context Keys')),
             category: Categories.Developer,
             f1: true
         });
@@ -86,7 +91,7 @@ class ToggleScreencastModeAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.toggleScreencastMode',
-            title: ( localize2(2659, 'Toggle Screencast Mode')),
+            title: ( localize2(2665, 'Toggle Screencast Mode')),
             category: Categories.Developer,
             f1: true
         });
@@ -308,7 +313,7 @@ class LogStorageAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.logStorage',
-            title: ( localize2(2660, "Log Storage Database Contents")),
+            title: ( localize2(2666, "Log Storage Database Contents")),
             category: Categories.Developer,
             f1: true
         });
@@ -318,16 +323,16 @@ class LogStorageAction extends Action2 {
         const dialogService = accessor.get(IDialogService);
         storageService.log();
         dialogService.info(( localize(
-            2661,
+            2667,
             "The storage database contents have been logged to the developer tools."
-        )), ( localize(2662, "Open developer tools from the menu and select the Console tab.")));
+        )), ( localize(2668, "Open developer tools from the menu and select the Console tab.")));
     }
 }
 class LogWorkingCopiesAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.logWorkingCopies',
-            title: ( localize2(2663, "Log Working Copies")),
+            title: ( localize2(2669, "Log Working Copies")),
             category: Categories.Developer,
             f1: true
         });
@@ -355,7 +360,7 @@ class RemoveLargeStorageEntriesAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.removeLargeStorageDatabaseEntries',
-            title: ( localize2(2664, 'Remove Large Storage Database Entries...')),
+            title: ( localize2(2670, 'Remove Large Storage Database Entries...')),
             category: Categories.Developer,
             f1: true
         });
@@ -383,10 +388,10 @@ class RemoveLargeStorageEntriesAction extends Action2 {
                             label: key,
                             description: ByteSize.formatSize(value.length),
                             detail: ( localize(
-                                2665,
+                                2671,
                                 "Scope: {0}, Target: {1}",
-                                scope === StorageScope.APPLICATION ? ( localize(2666, "Global")) : scope === StorageScope.PROFILE ? ( localize(2667, "Profile")) : ( localize(2668, "Workspace")),
-                                target === StorageTarget.MACHINE ? ( localize(2669, "Machine")) : ( localize(2670, "User"))
+                                scope === StorageScope.APPLICATION ? ( localize(2672, "Global")) : scope === StorageScope.PROFILE ? ( localize(2673, "Profile")) : ( localize(2674, "Workspace")),
+                                target === StorageTarget.MACHINE ? ( localize(2675, "Machine")) : ( localize(2676, "User"))
                             )),
                         });
                     }
@@ -402,10 +407,10 @@ class RemoveLargeStorageEntriesAction extends Action2 {
             picker.ok = false;
             picker.customButton = true;
             picker.hideCheckAll = true;
-            picker.customLabel = ( localize(2671, "Remove"));
-            picker.placeholder = ( localize(2672, "Select large entries to remove from storage"));
+            picker.customLabel = ( localize(2677, "Remove"));
+            picker.placeholder = ( localize(2678, "Select large entries to remove from storage"));
             if (items.length === 0) {
-                picker.description = ( localize(2673, "There are no large storage entries to remove."));
+                picker.description = ( localize(2679, "There are no large storage entries to remove."));
             }
             picker.show();
             disposables.add(picker.onDidCustom(() => {
@@ -420,15 +425,15 @@ class RemoveLargeStorageEntriesAction extends Action2 {
         const { confirmed } = await dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                2674,
+                2680,
                 "Do you want to remove the selected storage entries from the database?"
             )),
             detail: ( localize(
-                2675,
+                2681,
                 "{0}\n\nThis action is irreversible and may result in data loss!",
                 ( selectedItems.map(item => item.label)).join('\n')
             )),
-            primaryButton: ( localize(2676, "&&Remove"))
+            primaryButton: ( localize(2682, "&&Remove"))
         });
         if (!confirmed) {
             return;
@@ -450,7 +455,7 @@ class StartTrackDisposables extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.startTrackDisposables',
-            title: ( localize2(2677, 'Start Tracking Disposables')),
+            title: ( localize2(2683, 'Start Tracking Disposables')),
             category: Categories.Developer,
             f1: true,
             precondition: ( ContextKeyExpr.and(( ( DisposablesSnapshotStateContext.isEqualTo('pending')).negate()), ( ( DisposablesSnapshotStateContext.isEqualTo('started')).negate())))
@@ -468,7 +473,7 @@ class SnapshotTrackedDisposables extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.snapshotTrackedDisposables',
-            title: ( localize2(2678, 'Snapshot Tracked Disposables')),
+            title: ( localize2(2684, 'Snapshot Tracked Disposables')),
             category: Categories.Developer,
             f1: true,
             precondition: ( DisposablesSnapshotStateContext.isEqualTo('started'))
@@ -486,7 +491,7 @@ class StopTrackDisposables extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.stopTrackDisposables',
-            title: ( localize2(2679, 'Stop Tracking Disposables')),
+            title: ( localize2(2685, 'Stop Tracking Disposables')),
             category: Categories.Developer,
             f1: true,
             precondition: ( DisposablesSnapshotStateContext.isEqualTo('pending'))
@@ -513,11 +518,237 @@ class StopTrackDisposables extends Action2 {
         trackedDisposables.clear();
     }
 }
+class PolicyDiagnosticsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.showPolicyDiagnostics',
+            title: ( localize2(2686, 'Policy Diagnostics')),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const configurationService = accessor.get(IConfigurationService);
+        const productService = accessor.get(IProductService);
+        const defaultAccountService = accessor.get(IDefaultAccountService);
+        const authenticationService = accessor.get(IAuthenticationService);
+        const authenticationAccessService = accessor.get(IAuthenticationAccessService);
+        const policyService = accessor.get(IPolicyService);
+        const configurationRegistry = ( Registry.as(Extensions.Configuration));
+        let content = '# VS Code Policy Diagnostics\n\n';
+        content += '*WARNING: This file may contain sensitive information.*\n\n';
+        content += '## System Information\n\n';
+        content += '| Property | Value |\n';
+        content += '|----------|-------|\n';
+        content += `| Generated | ${( new Date()).toISOString()} |\n`;
+        content += `| Product | ${productService.nameLong} ${productService.version} |\n`;
+        content += `| Commit | ${productService.commit || 'n/a'} |\n\n`;
+        content += '## Account Information\n\n';
+        try {
+            const account = await defaultAccountService.getDefaultAccount();
+            const sensitiveKeys = ['sessionId', 'analytics_tracking_id'];
+            if (account) {
+                let username = 'Unknown';
+                let accountLabel = 'Unknown';
+                try {
+                    const providerIds = authenticationService.getProviderIds();
+                    for (const providerId of providerIds) {
+                        const sessions = await authenticationService.getSessions(providerId);
+                        const matchingSession = sessions.find(session => session.id === account.sessionId);
+                        if (matchingSession) {
+                            username = matchingSession.account.id;
+                            accountLabel = matchingSession.account.label;
+                            break;
+                        }
+                    }
+                }
+                catch (error) {
+                }
+                content += '### Default Account Summary\n\n';
+                content += `**Account ID/Username**: ${username}\n\n`;
+                content += `**Account Label**: ${accountLabel}\n\n`;
+                content += '### Detailed Account Properties\n\n';
+                content += '| Property | Value |\n';
+                content += '|----------|-------|\n';
+                for (const [key, value] of Object.entries(account)) {
+                    if (value !== undefined && value !== null) {
+                        let displayValue;
+                        if (sensitiveKeys.includes(key)) {
+                            displayValue = '***';
+                        }
+                        else if (typeof value === 'object') {
+                            displayValue = JSON.stringify(value);
+                        }
+                        else {
+                            displayValue = String(value);
+                        }
+                        content += `| ${key} | ${displayValue} |\n`;
+                    }
+                }
+                content += '\n';
+            }
+            else {
+                content += '*No default account configured*\n\n';
+            }
+        }
+        catch (error) {
+            content += `*Error retrieving account information: ${error}*\n\n`;
+        }
+        content += '## Policy-Controlled Settings\n\n';
+        const policyConfigurations = configurationRegistry.getPolicyConfigurations();
+        const configurationProperties = configurationRegistry.getConfigurationProperties();
+        const excludedProperties = configurationRegistry.getExcludedConfigurationProperties();
+        if (policyConfigurations.size > 0) {
+            const appliedPolicy = [];
+            const notAppliedPolicy = [];
+            for (const [policyName, settingKey] of policyConfigurations) {
+                const property = configurationProperties[settingKey] ?? excludedProperties[settingKey];
+                if (property) {
+                    const inspectValue = configurationService.inspect(settingKey);
+                    const settingInfo = {
+                        name: policyName,
+                        key: settingKey,
+                        property,
+                        inspection: inspectValue
+                    };
+                    if (inspectValue.policyValue !== undefined) {
+                        appliedPolicy.push(settingInfo);
+                    }
+                    else {
+                        notAppliedPolicy.push(settingInfo);
+                    }
+                }
+            }
+            const policySourceMemo = ( new Map());
+            const getPolicySource = (policyName) => {
+                if (( policySourceMemo.has(policyName))) {
+                    return policySourceMemo.get(policyName);
+                }
+                try {
+                    const policyServiceConstructorName = policyService.constructor.name;
+                    if (policyServiceConstructorName === 'MultiplexPolicyService') {
+                        const multiplexService = policyService;
+                        if (multiplexService.policyServices) {
+                            const componentServices = multiplexService.policyServices;
+                            for (const service of componentServices) {
+                                if (service.getPolicyValue && service.getPolicyValue(policyName) !== undefined) {
+                                    policySourceMemo.set(policyName, service.constructor.name);
+                                    return service.constructor.name;
+                                }
+                            }
+                        }
+                    }
+                    return '';
+                }
+                catch {
+                    return 'Unknown';
+                }
+            };
+            content += '### Applied Policy\n\n';
+            appliedPolicy.sort((a, b) => getPolicySource(a.name).localeCompare(getPolicySource(b.name)) || a.name.localeCompare(b.name));
+            if (appliedPolicy.length > 0) {
+                content += '| Setting Key | Policy Name | Policy Source | Default Value | Current Value | Policy Value |\n';
+                content += '|-------------|-------------|---------------|---------------|---------------|-------------|\n';
+                for (const setting of appliedPolicy) {
+                    const defaultValue = JSON.stringify(setting.property.default);
+                    const currentValue = JSON.stringify(setting.inspection.value);
+                    const policyValue = JSON.stringify(setting.inspection.policyValue);
+                    const policySource = getPolicySource(setting.name);
+                    content += `| ${setting.key} | ${setting.name} | ${policySource} | \`${defaultValue}\` | \`${currentValue}\` | \`${policyValue}\` |\n`;
+                }
+                content += '\n';
+            }
+            else {
+                content += '*No settings are currently controlled by policies*\n\n';
+            }
+            content += '###  Non-applied Policy\n\n';
+            if (notAppliedPolicy.length > 0) {
+                content += '| Setting Key | Policy Name  \n';
+                content += '|-------------|-------------|\n';
+                for (const setting of notAppliedPolicy) {
+                    content += `| ${setting.key} | ${setting.name}|\n`;
+                }
+                content += '\n';
+            }
+            else {
+                content += '*All policy-controllable settings are currently being enforced*\n\n';
+            }
+        }
+        else {
+            content += '*No policy-controlled settings found*\n\n';
+        }
+        content += '## Authentication Information\n\n';
+        try {
+            const providerIds = authenticationService.getProviderIds();
+            if (providerIds.length > 0) {
+                content += '### Authentication Providers\n\n';
+                content += '| Provider ID | Sessions | Accounts |\n';
+                content += '|-------------|----------|----------|\n';
+                for (const providerId of providerIds) {
+                    try {
+                        const sessions = await authenticationService.getSessions(providerId);
+                        const accounts = ( sessions.map(session => session.account));
+                        const uniqueAccounts = Array.from(( new Set(( accounts.map(account => account.label)))));
+                        content += `| ${providerId} | ${sessions.length} | ${uniqueAccounts.join(', ') || 'None'} |\n`;
+                    }
+                    catch (error) {
+                        content += `| ${providerId} | Error | ${error} |\n`;
+                    }
+                }
+                content += '\n';
+                content += '### Detailed Session Information\n\n';
+                for (const providerId of providerIds) {
+                    try {
+                        const sessions = await authenticationService.getSessions(providerId);
+                        if (sessions.length > 0) {
+                            content += `#### ${providerId}\n\n`;
+                            content += '| Account | Scopes | Extensions with Access |\n';
+                            content += '|---------|--------|------------------------|\n';
+                            for (const session of sessions) {
+                                const accountName = session.account.label;
+                                const scopes = session.scopes.join(', ') || 'Default';
+                                try {
+                                    const allowedExtensions = authenticationAccessService.readAllowedExtensions(providerId, accountName);
+                                    const extensionNames = ( allowedExtensions
+                                        .filter(ext => ext.allowed !== false)
+                                        .map(ext => `${ext.name}${ext.trusted ? ' (trusted)' : ''}`))
+                                        .join(', ') || 'None';
+                                    content += `| ${accountName} | ${scopes} | ${extensionNames} |\n`;
+                                }
+                                catch (error) {
+                                    content += `| ${accountName} | ${scopes} | Error: ${error} |\n`;
+                                }
+                            }
+                            content += '\n';
+                        }
+                    }
+                    catch (error) {
+                        content += `#### ${providerId}\n*Error retrieving sessions: ${error}*\n\n`;
+                    }
+                }
+            }
+            else {
+                content += '*No authentication providers found*\n\n';
+            }
+        }
+        catch (error) {
+            content += `*Error retrieving authentication information: ${error}*\n\n`;
+        }
+        await editorService.openEditor({
+            resource: undefined,
+            contents: content,
+            languageId: 'markdown',
+            options: { pinned: true, }
+        });
+    }
+}
 registerAction2(InspectContextKeysAction);
 registerAction2(ToggleScreencastModeAction);
 registerAction2(LogStorageAction);
 registerAction2(LogWorkingCopiesAction);
 registerAction2(RemoveLargeStorageEntriesAction);
+registerAction2(PolicyDiagnosticsAction);
 if (!product.commit) {
     registerAction2(StartTrackDisposables);
     registerAction2(SnapshotTrackedDisposables);
@@ -527,7 +758,7 @@ const configurationRegistry = ( Registry.as(Extensions.Configuration));
 configurationRegistry.registerConfiguration({
     id: 'screencastMode',
     order: 9,
-    title: ( localize(2680, "Screencast Mode")),
+    title: ( localize(2687, "Screencast Mode")),
     type: 'object',
     properties: {
         'screencastMode.verticalOffset': {
@@ -536,7 +767,7 @@ configurationRegistry.registerConfiguration({
             minimum: 0,
             maximum: 90,
             description: ( localize(
-                2681,
+                2688,
                 "Controls the vertical offset of the screencast mode overlay from the bottom as a percentage of the workbench height."
             ))
         },
@@ -546,38 +777,38 @@ configurationRegistry.registerConfiguration({
             minimum: 20,
             maximum: 100,
             description: ( localize(
-                2682,
+                2689,
                 "Controls the font size (in pixels) of the screencast mode keyboard."
             ))
         },
         'screencastMode.keyboardOptions': {
             type: 'object',
-            description: ( localize(2683, "Options for customizing the keyboard overlay in screencast mode.")),
+            description: ( localize(2690, "Options for customizing the keyboard overlay in screencast mode.")),
             properties: {
                 'showKeys': {
                     type: 'boolean',
                     default: true,
-                    description: ( localize(2684, "Show raw keys."))
+                    description: ( localize(2691, "Show raw keys."))
                 },
                 'showKeybindings': {
                     type: 'boolean',
                     default: true,
-                    description: ( localize(2685, "Show keyboard shortcuts."))
+                    description: ( localize(2692, "Show keyboard shortcuts."))
                 },
                 'showCommands': {
                     type: 'boolean',
                     default: true,
-                    description: ( localize(2686, "Show command names."))
+                    description: ( localize(2693, "Show command names."))
                 },
                 'showCommandGroups': {
                     type: 'boolean',
                     default: false,
-                    description: ( localize(2687, "Show command group names, when commands are also shown."))
+                    description: ( localize(2694, "Show command group names, when commands are also shown."))
                 },
                 'showSingleEditorCursorMoves': {
                     type: 'boolean',
                     default: true,
-                    description: ( localize(2688, "Show single editor cursor move commands."))
+                    description: ( localize(2695, "Show single editor cursor move commands."))
                 }
             },
             default: {
@@ -595,7 +826,7 @@ configurationRegistry.registerConfiguration({
             minimum: 500,
             maximum: 5000,
             description: ( localize(
-                2689,
+                2696,
                 "Controls how long (in milliseconds) the keyboard overlay is shown in screencast mode."
             ))
         },
@@ -604,7 +835,7 @@ configurationRegistry.registerConfiguration({
             format: 'color-hex',
             default: '#FF0000',
             description: ( localize(
-                2690,
+                2697,
                 "Controls the color in hex (#RGB, #RGBA, #RRGGBB or #RRGGBBAA) of the mouse indicator in screencast mode."
             ))
         },
@@ -614,7 +845,7 @@ configurationRegistry.registerConfiguration({
             minimum: 20,
             maximum: 100,
             description: ( localize(
-                2691,
+                2698,
                 "Controls the size (in pixels) of the mouse indicator in screencast mode."
             ))
         },

package/vscode/src/vs/workbench/browser/actions/textInputActions.js

@@ -15,24 +15,24 @@ import { ILogService } from '../../../platform/log/common/log.service.js';
 
 function createTextInputActions(clipboardService, logService) {
     return [
-        toAction({ id: 'undo', label: ( localize(2836, "Undo")), run: () => getActiveDocument().execCommand('undo') }),
-        toAction({ id: 'redo', label: ( localize(2837, "Redo")), run: () => getActiveDocument().execCommand('redo') }),
+        toAction({ id: 'undo', label: ( localize(2843, "Undo")), run: () => getActiveDocument().execCommand('undo') }),
+        toAction({ id: 'redo', label: ( localize(2844, "Redo")), run: () => getActiveDocument().execCommand('redo') }),
         ( new Separator()),
         toAction({
-            id: 'editor.action.clipboardCutAction', label: ( localize(2838, "Cut")), run: () => {
+            id: 'editor.action.clipboardCutAction', label: ( localize(2845, "Cut")), run: () => {
                 logService.trace('TextInputActionsProvider#cut');
                 getActiveDocument().execCommand('cut');
             }
         }),
         toAction({
-            id: 'editor.action.clipboardCopyAction', label: ( localize(2839, "Copy")), run: () => {
+            id: 'editor.action.clipboardCopyAction', label: ( localize(2846, "Copy")), run: () => {
                 logService.trace('TextInputActionsProvider#copy');
                 getActiveDocument().execCommand('copy');
             }
         }),
         toAction({
             id: 'editor.action.clipboardPasteAction',
-            label: ( localize(2840, "Paste")),
+            label: ( localize(2847, "Paste")),
             run: async (element) => {
                 logService.trace('TextInputActionsProvider#paste');
                 const clipboardText = await clipboardService.readText();
@@ -47,7 +47,7 @@ function createTextInputActions(clipboardService, logService) {
             }
         }),
         ( new Separator()),
-        toAction({ id: 'editor.action.selectAll', label: ( localize(2841, "Select All")), run: () => getActiveDocument().execCommand('selectAll') })
+        toAction({ id: 'editor.action.selectAll', label: ( localize(2848, "Select All")), run: () => getActiveDocument().execCommand('selectAll') })
     ];
 }
 let TextInputActionsProvider = class TextInputActionsProvider extends Disposable {

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

@@ -1,14 +1,14 @@
 import { Disposable } from "../../base/common/lifecycle.js";
+import { IConfigurationService } from "../../platform/configuration/common/configuration.service.js";
 import { IContextKeyService } from "../../platform/contextkey/common/contextkey.service.js";
+import { IProductService } from "../../platform/product/common/productService.service.js";
+import { IWorkspaceContextService } from "../../platform/workspace/common/workspace.service.js";
 import { IEditorGroupsService } from "../services/editor/common/editorGroupsService.service.js";
-import { IConfigurationService } from "../../platform/configuration/common/configuration.service.js";
+import { IEditorService } from "../services/editor/common/editorService.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";
+import { IWorkingCopyService } from "../services/workingCopy/common/workingCopyService.service.js";
 export declare class WorkbenchContextKeysHandler extends Disposable {
     private readonly contextKeyService;
     private readonly contextService;
@@ -20,7 +20,6 @@ export declare class WorkbenchContextKeysHandler extends Disposable {
     private readonly layoutService;
     private readonly paneCompositeService;
     private readonly workingCopyService;
-    private inputFocusedContext;
     private dirtyWorkingCopiesContext;
     private activeEditorGroupEmpty;
     private activeEditorGroupIndex;
@@ -58,7 +57,6 @@ export declare class WorkbenchContextKeysHandler extends Disposable {
     private updateActiveEditorGroupContextKeys;
     private updateEditorGroupsContextKeys;
     private updateEditorAreaContextKeys;
-    private updateInputContextKeys;
     private updateWorkbenchStateContextKey;
     private updateWorkspaceFolderCountContextKey;
     private updateSplitEditorsVerticallyContext;

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

@@ -1,31 +1,29 @@
 
 import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
-import { Event } from '../../base/common/event.js';
-import { Disposable, MutableDisposable, DisposableStore } from '../../base/common/lifecycle.js';
+import { onDidChangeFullscreen, isFullscreen } from '../../base/browser/browser.js';
+import { mainWindow } from '../../base/browser/window.js';
+import { Disposable } from '../../base/common/lifecycle.js';
+import { isNative } from '../../base/common/platform.js';
+import { IConfigurationService } from '../../platform/configuration/common/configuration.service.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, IsSimulationContext, ProductQualityContext, InputFocusedContext } from '../../platform/contextkey/common/contextkeys.js';
+import { IsMacContext, IsLinuxContext, IsWindowsContext, IsWebContext, IsMacNativeContext, IsIOSContext, IsMobileContext, IsDevelopmentContext, ProductQualityContext } from '../../platform/contextkey/common/contextkeys.js';
+import { WebFileSystemAccess } from '../../platform/files/browser/webFileSystemAccess.js';
+import { IProductService } from '../../platform/product/common/productService.service.js';
+import { getRemoteName } from '../../platform/remote/common/remoteHosts.js';
+import { getTitleBarStyle } from '../../platform/window/common/window.js';
+import { getVirtualWorkspaceScheme } from '../../platform/workspace/common/virtualWorkspace.js';
+import { WorkbenchState, isTemporaryWorkspace } from '../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from '../../platform/workspace/common/workspace.service.js';
 import { RemoteNameContext, VirtualWorkspaceContext, TemporaryWorkspaceContext, HasWebFileSystemAccess, EmbedderIdentifierContext, InAutomationContext, 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, AuxiliaryBarMaximizedContext, IsSandboxWorkspaceContext } from '../common/contextkeys.js';
-import { onDidRegisterWindow, addDisposableListener, EventType, getActiveElement, 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 { IEditorService } from '../services/editor/common/editorService.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';
+import { IWorkingCopyService } from '../services/workingCopy/common/workingCopyService.service.js';
 
 let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disposable {
     constructor(contextKeyService, contextService, configurationService, environmentService, productService, editorGroupService, editorService, layoutService, paneCompositeService, workingCopyService) {
@@ -55,7 +53,6 @@ let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disp
         const isDevelopment = !this.environmentService.isBuilt || this.environmentService.isExtensionDevelopment;
         IsDevelopmentContext.bindTo(this.contextKeyService).set(isDevelopment);
         setConstant(IsDevelopmentContext.key, isDevelopment);
-        IsSimulationContext.bindTo(this.contextKeyService).set(!!this.environmentService.isSimulation);
         ProductQualityContext.bindTo(this.contextKeyService).set(this.productService.quality || '');
         EmbedderIdentifierContext.bindTo(this.contextKeyService).set(productService.embedderIdentifier);
         this.inAutomationContext = InAutomationContext.bindTo(this.contextKeyService);
@@ -68,7 +65,6 @@ let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disp
         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);
@@ -119,13 +115,6 @@ let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disp
         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 }) => {
-            const onFocusDisposables = disposables.add(( new MutableDisposable()));
-            disposables.add(addDisposableListener(window, EventType.FOCUS_IN, () => {
-                onFocusDisposables.value = ( new DisposableStore());
-                this.updateInputContextKeys(window.document, onFocusDisposables.value);
-            }, true));
-        }, { window: mainWindow, disposables: this._store }));
         this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateWorkbenchStateContextKey()));
         this._register(this.contextService.onDidChangeWorkspaceFolders(() => {
             this.updateWorkspaceFolderCountContextKey();
@@ -195,23 +184,6 @@ let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disp
     updateEditorAreaContextKeys() {
         this.editorTabsVisibleContext.set(this.editorGroupService.partOptions.showTabs === 'multiple');
     }
-    updateInputContextKeys(ownerDocument, disposables) {
-        function activeElementIsInput() {
-            const activeElement = getActiveElement(ownerDocument);
-            return !!activeElement && isEditableElement(activeElement);
-        }
-        const isInputFocused = activeElementIsInput();
-        this.inputFocusedContext.set(isInputFocused);
-        if (isInputFocused) {
-            const tracker = disposables.add(trackFocus(getActiveElement(ownerDocument)));
-            Event.once(tracker.onDidBlur)(() => {
-                if (getActiveWindow().document === ownerDocument) {
-                    this.inputFocusedContext.set(activeElementIsInput());
-                }
-                tracker.dispose();
-            }, undefined, disposables);
-        }
-    }
     updateWorkbenchStateContextKey() {
         this.workbenchStateContext.set(this.getWorkbenchStateString());
     }