@codingame/monaco-vscode-api 1.83.2 → 1.83.3-next.0

package/vscode/src/vs/workbench/common/configuration.js

@@ -1,21 +1,27 @@
 import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { IRemoteAgentService } from '../services/remote/common/remoteAgentService.js';
 import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+( Object.freeze({
+    'id': 'application',
+    'order': 100,
+    'title': localizeWithPath('vs/workbench/common/configuration', 'applicationConfigurationTitle', "Application"),
+    'type': 'object'
+}));
 const workbenchConfigurationNodeBase = ( Object.freeze({
     'id': 'workbench',
     'order': 7,
-    'title': ( localize('workbenchConfigurationTitle', "Workbench")),
+    'title': localizeWithPath('vs/workbench/common/configuration', 'workbenchConfigurationTitle', "Workbench"),
     'type': 'object',
 }));
 const securityConfigurationNodeBase = ( Object.freeze({
     'id': 'security',
     'scope': 1 ,
-    'title': ( localize('securityConfigurationTitle', "Security")),
+    'title': localizeWithPath('vs/workbench/common/configuration', 'securityConfigurationTitle', "Security"),
     'type': 'object',
     'order': 7
 }));
@@ -53,25 +59,16 @@ let DynamicWorkbenchConfigurationWorkbenchContribution = class DynamicWorkbenchC
                         'items': {
                             'type': 'string',
                             'pattern': '^[^\\\\]+$',
-                            'patternErrorMessage': ( localize(
-                                'security.allowedUNCHosts.patternErrorMessage',
-                                'UNC host names must not contain backslashes.'
-                            ))
+                            'patternErrorMessage': localizeWithPath('vs/workbench/common/configuration', 'security.allowedUNCHosts.patternErrorMessage', 'UNC host names must not contain backslashes.')
                         },
                         'default': [],
-                        'markdownDescription': ( localize(
-                            'security.allowedUNCHosts',
-                            'A set of UNC host names (without leading or trailing backslash, for example `192.168.0.1` or `my-server`) to allow without user confirmation. If a UNC host is being accessed that is not allowed via this setting or has not been acknowledged via user confirmation, an error will occur and the operation stopped. A restart is required when changing this setting. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
-                        )),
+                        'markdownDescription': localizeWithPath('vs/workbench/common/configuration', 'security.allowedUNCHosts', 'A set of UNC host names (without leading or trailing backslash, for example `192.168.0.1` or `my-server`) to allow without user confirmation. If a UNC host is being accessed that is not allowed via this setting or has not been acknowledged via user confirmation, an error will occur and the operation stopped. A restart is required when changing this setting. Find out more about this setting at https://aka.ms/vscode-windows-unc.'),
                         'scope': 2
                     },
                     'security.restrictUNCAccess': {
                         'type': 'boolean',
                         'default': true,
-                        'markdownDescription': ( localize(
-                            'security.restrictUNCAccess',
-                            'If enabled, only allows access to UNC host names that are allowed by the `#security.allowedUNCHosts#` setting or after user confirmation. Find out more about this setting at https://aka.ms/vscode-windows-unc.'
-                        )),
+                        'markdownDescription': localizeWithPath('vs/workbench/common/configuration', 'security.restrictUNCAccess', 'If enabled, only allows access to UNC host names that are allowed by the `#security.allowedUNCHosts#` setting or after user confirmation. Find out more about this setting at https://aka.ms/vscode-windows-unc.'),
                         'scope': 2
                     }
                 }

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { isEqual, basename, dirname, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
@@ -9,133 +9,315 @@ import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { DEFAULT_EDITOR_ASSOCIATION } from './editor.js';
 var ResourceContextKey_1;
-const WorkbenchStateContext = ( new RawContextKey('workbenchState', undefined, { type: 'string', description: ( localize(
+const WorkbenchStateContext = ( new RawContextKey(
     'workbenchState',
-    "The kind of workspace opened in the window, either 'empty' (no workspace), 'folder' (single folder) or 'workspace' (multi-root workspace)"
-)) }));
-const WorkspaceFolderCountContext = ( new RawContextKey('workspaceFolderCount', 0, ( localize('workspaceFolderCount', "The number of root folders in the workspace"))));
+    undefined,
+    { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'workbenchState', "The kind of workspace opened in the window, either 'empty' (no workspace), 'folder' (single folder) or 'workspace' (multi-root workspace)") }
+));
+const WorkspaceFolderCountContext = ( new RawContextKey(
+    'workspaceFolderCount',
+    0,
+    localizeWithPath('vs/workbench/common/contextkeys', 'workspaceFolderCount', "The number of root folders in the workspace")
+));
 const OpenFolderWorkspaceSupportContext = ( new RawContextKey('openFolderWorkspaceSupport', true, true));
 const EnterMultiRootWorkspaceSupportContext = ( new RawContextKey('enterMultiRootWorkspaceSupport', true, true));
 const EmptyWorkspaceSupportContext = ( new RawContextKey('emptyWorkspaceSupport', true, true));
-const DirtyWorkingCopiesContext = ( new RawContextKey('dirtyWorkingCopies', false, ( localize(
+const DirtyWorkingCopiesContext = ( new RawContextKey(
     'dirtyWorkingCopies',
-    "Whether there are any working copies with unsaved changes"
-))));
-const RemoteNameContext = ( new RawContextKey('remoteName', '', ( localize(
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'dirtyWorkingCopies', "Whether there are any working copies with unsaved changes")
+));
+const RemoteNameContext = ( new RawContextKey(
     'remoteName',
-    "The name of the remote the window is connected to or an empty string if not connected to any remote"
-))));
-const VirtualWorkspaceContext = ( new RawContextKey('virtualWorkspace', '', ( localize(
+    '',
+    localizeWithPath('vs/workbench/common/contextkeys', 'remoteName', "The name of the remote the window is connected to or an empty string if not connected to any remote")
+));
+const VirtualWorkspaceContext = ( new RawContextKey(
     'virtualWorkspace',
-    "The scheme of the current workspace is from a virtual file system or an empty string."
-))));
-const TemporaryWorkspaceContext = ( new RawContextKey('temporaryWorkspace', false, ( localize(
+    '',
+    localizeWithPath('vs/workbench/common/contextkeys', 'virtualWorkspace', "The scheme of the current workspace is from a virtual file system or an empty string.")
+));
+const TemporaryWorkspaceContext = ( new RawContextKey(
     'temporaryWorkspace',
-    "The scheme of the current workspace is from a temporary file system."
-))));
-const IsFullscreenContext = ( new RawContextKey('isFullscreen', false, ( localize('isFullscreen', "Whether the window is in fullscreen mode"))));
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'temporaryWorkspace', "The scheme of the current workspace is from a temporary file system.")
+));
+const IsFullscreenContext = ( new RawContextKey(
+    'isFullscreen',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'isFullscreen', "Whether the window is in fullscreen mode")
+));
 const HasWebFileSystemAccess = ( new RawContextKey('hasWebFileSystemAccess', false, true));
-const EmbedderIdentifierContext = ( new RawContextKey('embedderIdentifier', undefined, ( localize(
+const EmbedderIdentifierContext = ( new RawContextKey(
     'embedderIdentifier',
-    'The identifier of the embedder according to the product service, if one is defined'
-))));
-const ActiveEditorDirtyContext = ( new RawContextKey('activeEditorIsDirty', false, ( localize('activeEditorIsDirty', "Whether the active editor has unsaved changes"))));
-const ActiveEditorPinnedContext = ( new RawContextKey('activeEditorIsNotPreview', false, ( localize(
+    undefined,
+    localizeWithPath('vs/workbench/common/contextkeys', 'embedderIdentifier', 'The identifier of the embedder according to the product service, if one is defined')
+));
+const ActiveEditorDirtyContext = ( new RawContextKey(
+    'activeEditorIsDirty',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorIsDirty', "Whether the active editor has unsaved changes")
+));
+const ActiveEditorPinnedContext = ( new RawContextKey(
     'activeEditorIsNotPreview',
-    "Whether the active editor is not in preview mode"
-))));
-const ActiveEditorFirstInGroupContext = ( new RawContextKey('activeEditorIsFirstInGroup', false, ( localize(
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorIsNotPreview', "Whether the active editor is not in preview mode")
+));
+const ActiveEditorFirstInGroupContext = ( new RawContextKey(
     'activeEditorIsFirstInGroup',
-    "Whether the active editor is the first one in its group"
-))));
-const ActiveEditorLastInGroupContext = ( new RawContextKey('activeEditorIsLastInGroup', false, ( localize(
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorIsFirstInGroup', "Whether the active editor is the first one in its group")
+));
+const ActiveEditorLastInGroupContext = ( new RawContextKey(
     'activeEditorIsLastInGroup',
-    "Whether the active editor is the last one in its group"
-))));
-const ActiveEditorStickyContext = ( new RawContextKey('activeEditorIsPinned', false, ( localize('activeEditorIsPinned', "Whether the active editor is pinned"))));
-const ActiveEditorReadonlyContext = ( new RawContextKey('activeEditorIsReadonly', false, ( localize('activeEditorIsReadonly', "Whether the active editor is read-only"))));
-const ActiveEditorCanToggleReadonlyContext = ( new RawContextKey('activeEditorCanToggleReadonly', true, ( localize(
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorIsLastInGroup', "Whether the active editor is the last one in its group")
+));
+const ActiveEditorStickyContext = ( new RawContextKey(
+    'activeEditorIsPinned',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorIsPinned', "Whether the active editor is pinned")
+));
+const ActiveEditorReadonlyContext = ( new RawContextKey(
+    'activeEditorIsReadonly',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorIsReadonly', "Whether the active editor is read-only")
+));
+const ActiveEditorCanToggleReadonlyContext = ( new RawContextKey(
     'activeEditorCanToggleReadonly',
-    "Whether the active editor can toggle between being read-only or writeable"
-))));
-const ActiveEditorCanRevertContext = ( new RawContextKey('activeEditorCanRevert', false, ( localize('activeEditorCanRevert', "Whether the active editor can revert"))));
+    true,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorCanToggleReadonly', "Whether the active editor can toggle between being read-only or writeable")
+));
+const ActiveEditorCanRevertContext = ( new RawContextKey(
+    'activeEditorCanRevert',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorCanRevert', "Whether the active editor can revert")
+));
 const ActiveEditorCanSplitInGroupContext = ( new RawContextKey('activeEditorCanSplitInGroup', true));
-const ActiveEditorContext = ( new RawContextKey('activeEditor', null, { type: 'string', description: ( localize('activeEditor', "The identifier of the active editor")) }));
-const ActiveEditorAvailableEditorIdsContext = ( new RawContextKey('activeEditorAvailableEditorIds', '', ( localize(
+const ActiveEditorContext = ( new RawContextKey(
+    'activeEditor',
+    null,
+    { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'activeEditor', "The identifier of the active editor") }
+));
+const ActiveEditorAvailableEditorIdsContext = ( new RawContextKey(
     'activeEditorAvailableEditorIds',
-    "The available editor identifiers that are usable for the active editor"
-))));
-const TextCompareEditorVisibleContext = ( new RawContextKey('textCompareEditorVisible', false, ( localize('textCompareEditorVisible', "Whether a text compare editor is visible"))));
-const TextCompareEditorActiveContext = ( new RawContextKey('textCompareEditorActive', false, ( localize('textCompareEditorActive', "Whether a text compare editor is active"))));
-const SideBySideEditorActiveContext = ( new RawContextKey('sideBySideEditorActive', false, ( localize('sideBySideEditorActive', "Whether a side by side editor is active"))));
-const EditorGroupEditorsCountContext = ( new RawContextKey('groupEditorsCount', 0, ( localize('groupEditorsCount', "The number of opened editor groups"))));
-const ActiveEditorGroupEmptyContext = ( new RawContextKey('activeEditorGroupEmpty', false, ( localize('activeEditorGroupEmpty', "Whether the active editor group is empty"))));
-const ActiveEditorGroupIndexContext = ( new RawContextKey('activeEditorGroupIndex', 0, ( localize('activeEditorGroupIndex', "The index of the active editor group"))));
-const ActiveEditorGroupLastContext = ( new RawContextKey('activeEditorGroupLast', false, ( localize(
+    '',
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorAvailableEditorIds', "The available editor identifiers that are usable for the active editor")
+));
+const TextCompareEditorVisibleContext = ( new RawContextKey(
+    'textCompareEditorVisible',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'textCompareEditorVisible', "Whether a text compare editor is visible")
+));
+const TextCompareEditorActiveContext = ( new RawContextKey(
+    'textCompareEditorActive',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'textCompareEditorActive', "Whether a text compare editor is active")
+));
+const SideBySideEditorActiveContext = ( new RawContextKey(
+    'sideBySideEditorActive',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'sideBySideEditorActive', "Whether a side by side editor is active")
+));
+const EditorGroupEditorsCountContext = ( new RawContextKey(
+    'groupEditorsCount',
+    0,
+    localizeWithPath('vs/workbench/common/contextkeys', 'groupEditorsCount', "The number of opened editor groups")
+));
+const ActiveEditorGroupEmptyContext = ( new RawContextKey(
+    'activeEditorGroupEmpty',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorGroupEmpty', "Whether the active editor group is empty")
+));
+const ActiveEditorGroupIndexContext = ( new RawContextKey(
+    'activeEditorGroupIndex',
+    0,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorGroupIndex', "The index of the active editor group")
+));
+const ActiveEditorGroupLastContext = ( new RawContextKey(
     'activeEditorGroupLast',
-    "Whether the active editor group is the last group"
-))));
-const ActiveEditorGroupLockedContext = ( new RawContextKey('activeEditorGroupLocked', false, ( localize('activeEditorGroupLocked', "Whether the active editor group is locked"))));
-const MultipleEditorGroupsContext = ( new RawContextKey('multipleEditorGroups', false, ( localize('multipleEditorGroups', "Whether there are multiple editor groups opened"))));
-const EditorsVisibleContext = ( new RawContextKey('editorIsOpen', false, ( localize('editorIsOpen', "Whether an editor is open"))));
-const InEditorZenModeContext = ( new RawContextKey('inZenMode', false, ( localize('inZenMode', "Whether Zen mode is enabled"))));
-const IsCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localize('isCenteredLayout', "Whether centered layout is enabled"))));
-const SplitEditorsVertically = ( new RawContextKey('splitEditorsVertically', false, ( localize('splitEditorsVertically', "Whether editors split vertically"))));
-const EditorAreaVisibleContext = ( new RawContextKey('editorAreaVisible', true, ( localize('editorAreaVisible', "Whether the editor area is visible"))));
-const EditorTabsVisibleContext = ( new RawContextKey('editorTabsVisible', true, ( localize('editorTabsVisible', "Whether editor tabs are visible"))));
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorGroupLast', "Whether the active editor group is the last group")
+));
+const ActiveEditorGroupLockedContext = ( new RawContextKey(
+    'activeEditorGroupLocked',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeEditorGroupLocked', "Whether the active editor group is locked")
+));
+const MultipleEditorGroupsContext = ( new RawContextKey(
+    'multipleEditorGroups',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'multipleEditorGroups', "Whether there are multiple editor groups opened")
+));
+const EditorsVisibleContext = ( new RawContextKey(
+    'editorIsOpen',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'editorIsOpen', "Whether an editor is open")
+));
+const InEditorZenModeContext = ( new RawContextKey(
+    'inZenMode',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'inZenMode', "Whether Zen mode is enabled")
+));
+const IsCenteredLayoutContext = ( new RawContextKey(
+    'isCenteredLayout',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'isCenteredLayout', "Whether centered layout is enabled")
+));
+const SplitEditorsVertically = ( new RawContextKey(
+    'splitEditorsVertically',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'splitEditorsVertically', "Whether editors split vertically")
+));
+const EditorAreaVisibleContext = ( new RawContextKey(
+    'editorAreaVisible',
+    true,
+    localizeWithPath('vs/workbench/common/contextkeys', 'editorAreaVisible', "Whether the editor area is visible")
+));
+const EditorTabsVisibleContext = ( new RawContextKey(
+    'editorTabsVisible',
+    true,
+    localizeWithPath('vs/workbench/common/contextkeys', 'editorTabsVisible', "Whether editor tabs are visible")
+));
 const EditorPinnedAndUnpinnedTabsContext = ( new RawContextKey('editorPinnedAndUnpinnedTabsVisible', false, true));
-const SideBarVisibleContext = ( new RawContextKey('sideBarVisible', false, ( localize('sideBarVisible', "Whether the sidebar is visible"))));
-const SidebarFocusContext = ( new RawContextKey('sideBarFocus', false, ( localize('sideBarFocus', "Whether the sidebar has keyboard focus"))));
-const ActiveViewletContext = ( new RawContextKey('activeViewlet', '', ( localize('activeViewlet', "The identifier of the active viewlet"))));
-const StatusBarFocused = ( new RawContextKey('statusBarFocused', false, ( localize('statusBarFocused', "Whether the status bar has keyboard focus"))));
-const BannerFocused = ( new RawContextKey('bannerFocused', false, ( localize('bannerFocused', "Whether the banner has keyboard focus"))));
-const NotificationFocusedContext = ( new RawContextKey('notificationFocus', true, ( localize('notificationFocus', "Whether a notification has keyboard focus"))));
-const NotificationsCenterVisibleContext = ( new RawContextKey('notificationCenterVisible', false, ( localize('notificationCenterVisible', "Whether the notifications center is visible"))));
-const NotificationsToastsVisibleContext = ( new RawContextKey('notificationToastsVisible', false, ( localize('notificationToastsVisible', "Whether a notification toast is visible"))));
-const ActiveAuxiliaryContext = ( new RawContextKey('activeAuxiliary', '', ( localize('activeAuxiliary', "The identifier of the active auxiliary panel"))));
-const AuxiliaryBarFocusContext = ( new RawContextKey('auxiliaryBarFocus', false, ( localize('auxiliaryBarFocus', "Whether the auxiliary bar has keyboard focus"))));
-const AuxiliaryBarVisibleContext = ( new RawContextKey('auxiliaryBarVisible', false, ( localize('auxiliaryBarVisible', "Whether the auxiliary bar is visible"))));
-const ActivePanelContext = ( new RawContextKey('activePanel', '', ( localize('activePanel', "The identifier of the active panel"))));
-const PanelFocusContext = ( new RawContextKey('panelFocus', false, ( localize('panelFocus', "Whether the panel has keyboard focus"))));
-const PanelPositionContext = ( new RawContextKey('panelPosition', 'bottom', ( localize('panelPosition', "The position of the panel, always 'bottom'"))));
-const PanelAlignmentContext = ( new RawContextKey('panelAlignment', 'center', ( localize(
+const SideBarVisibleContext = ( new RawContextKey(
+    'sideBarVisible',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'sideBarVisible', "Whether the sidebar is visible")
+));
+const SidebarFocusContext = ( new RawContextKey(
+    'sideBarFocus',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'sideBarFocus', "Whether the sidebar has keyboard focus")
+));
+const ActiveViewletContext = ( new RawContextKey(
+    'activeViewlet',
+    '',
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeViewlet', "The identifier of the active viewlet")
+));
+const StatusBarFocused = ( new RawContextKey(
+    'statusBarFocused',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'statusBarFocused', "Whether the status bar has keyboard focus")
+));
+const BannerFocused = ( new RawContextKey(
+    'bannerFocused',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'bannerFocused', "Whether the banner has keyboard focus")
+));
+const NotificationFocusedContext = ( new RawContextKey(
+    'notificationFocus',
+    true,
+    localizeWithPath('vs/workbench/common/contextkeys', 'notificationFocus', "Whether a notification has keyboard focus")
+));
+const NotificationsCenterVisibleContext = ( new RawContextKey(
+    'notificationCenterVisible',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'notificationCenterVisible', "Whether the notifications center is visible")
+));
+const NotificationsToastsVisibleContext = ( new RawContextKey(
+    'notificationToastsVisible',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'notificationToastsVisible', "Whether a notification toast is visible")
+));
+const ActiveAuxiliaryContext = ( new RawContextKey(
+    'activeAuxiliary',
+    '',
+    localizeWithPath('vs/workbench/common/contextkeys', 'activeAuxiliary', "The identifier of the active auxiliary panel")
+));
+const AuxiliaryBarFocusContext = ( new RawContextKey(
+    'auxiliaryBarFocus',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'auxiliaryBarFocus', "Whether the auxiliary bar has keyboard focus")
+));
+const AuxiliaryBarVisibleContext = ( new RawContextKey(
+    'auxiliaryBarVisible',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'auxiliaryBarVisible', "Whether the auxiliary bar is visible")
+));
+const ActivePanelContext = ( new RawContextKey(
+    'activePanel',
+    '',
+    localizeWithPath('vs/workbench/common/contextkeys', 'activePanel', "The identifier of the active panel")
+));
+const PanelFocusContext = ( new RawContextKey(
+    'panelFocus',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'panelFocus', "Whether the panel has keyboard focus")
+));
+const PanelPositionContext = ( new RawContextKey(
+    'panelPosition',
+    'bottom',
+    localizeWithPath('vs/workbench/common/contextkeys', 'panelPosition', "The position of the panel, always 'bottom'")
+));
+const PanelAlignmentContext = ( new RawContextKey(
     'panelAlignment',
-    "The alignment of the panel, either 'center', 'left', 'right' or 'justify'"
-))));
-const PanelVisibleContext = ( new RawContextKey('panelVisible', false, ( localize('panelVisible', "Whether the panel is visible"))));
-const PanelMaximizedContext = ( new RawContextKey('panelMaximized', false, ( localize('panelMaximized', "Whether the panel is maximized"))));
-const FocusedViewContext = ( new RawContextKey('focusedView', '', ( localize('focusedView', "The identifier of the view that has keyboard focus"))));
+    'center',
+    localizeWithPath('vs/workbench/common/contextkeys', 'panelAlignment', "The alignment of the panel, either 'center', 'left', 'right' or 'justify'")
+));
+const PanelVisibleContext = ( new RawContextKey(
+    'panelVisible',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'panelVisible', "Whether the panel is visible")
+));
+const PanelMaximizedContext = ( new RawContextKey(
+    'panelMaximized',
+    false,
+    localizeWithPath('vs/workbench/common/contextkeys', 'panelMaximized', "Whether the panel is maximized")
+));
+const FocusedViewContext = ( new RawContextKey(
+    'focusedView',
+    '',
+    localizeWithPath('vs/workbench/common/contextkeys', 'focusedView', "The identifier of the view that has keyboard focus")
+));
 function getVisbileViewContextKey(viewId) { return `view.${viewId}.visible`; }
 function getEnabledViewContainerContextKey(viewContainerId) { return `viewContainer.${viewContainerId}.enabled`; }
 let ResourceContextKey = class ResourceContextKey {
     static { ResourceContextKey_1 = this; }
-    static { this.Scheme = ( new RawContextKey('resourceScheme', undefined, { type: 'string', description: ( localize('resourceScheme', "The scheme of the resource")) })); }
+    static { this.Scheme = ( new RawContextKey(
+        'resourceScheme',
+        undefined,
+        { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'resourceScheme', "The scheme of the resource") }
+    )); }
     static { this.Filename = ( new RawContextKey(
         'resourceFilename',
         undefined,
-        { type: 'string', description: ( localize('resourceFilename', "The file name of the resource")) }
+        { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'resourceFilename', "The file name of the resource") }
     )); }
     static { this.Dirname = ( new RawContextKey(
         'resourceDirname',
         undefined,
-        { type: 'string', description: ( localize('resourceDirname', "The folder name the resource is contained in")) }
+        { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'resourceDirname', "The folder name the resource is contained in") }
+    )); }
+    static { this.Path = ( new RawContextKey(
+        'resourcePath',
+        undefined,
+        { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'resourcePath', "The full path of the resource") }
+    )); }
+    static { this.LangId = ( new RawContextKey(
+        'resourceLangId',
+        undefined,
+        { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'resourceLangId', "The language identifier of the resource") }
+    )); }
+    static { this.Resource = ( new RawContextKey(
+        'resource',
+        undefined,
+        { type: 'URI', description: localizeWithPath('vs/workbench/common/contextkeys', 'resource', "The full value of the resource including scheme and path") }
     )); }
-    static { this.Path = ( new RawContextKey('resourcePath', undefined, { type: 'string', description: ( localize('resourcePath', "The full path of the resource")) })); }
-    static { this.LangId = ( new RawContextKey('resourceLangId', undefined, { type: 'string', description: ( localize('resourceLangId', "The language identifier of the resource")) })); }
-    static { this.Resource = ( new RawContextKey('resource', undefined, { type: 'URI', description: ( localize('resource', "The full value of the resource including scheme and path")) })); }
     static { this.Extension = ( new RawContextKey(
         'resourceExtname',
         undefined,
-        { type: 'string', description: ( localize('resourceExtname', "The extension name of the resource")) }
+        { type: 'string', description: localizeWithPath('vs/workbench/common/contextkeys', 'resourceExtname', "The extension name of the resource") }
+    )); }
+    static { this.HasResource = ( new RawContextKey(
+        'resourceSet',
+        undefined,
+        { type: 'boolean', description: localizeWithPath('vs/workbench/common/contextkeys', 'resourceSet', "Whether a resource is present or not") }
     )); }
-    static { this.HasResource = ( new RawContextKey('resourceSet', undefined, { type: 'boolean', description: ( localize('resourceSet', "Whether a resource is present or not")) })); }
     static { this.IsFileSystemResource = ( new RawContextKey(
         'isFileSystemResource',
         undefined,
-        { type: 'boolean', description: ( localize(
-            'isFileSystemResource',
-            "Whether the resource is backed by a file system provider"
-        )) }
+        { type: 'boolean', description: localizeWithPath('vs/workbench/common/contextkeys', 'isFileSystemResource', "Whether the resource is backed by a file system provider") }
     )); }
     constructor(_contextKeyService, _fileService, _languageService, _modelService) {
         this._contextKeyService = _contextKeyService;

package/vscode/src/vs/workbench/common/editor/diffEditorInput.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { SideBySideEditorInput } from './sideBySideEditorInput.js';
 import { BINARY_DIFF_EDITOR_ID, TEXT_DIFF_EDITOR_ID, isResourceDiffEditorInput } from '../editor.js';
 import { BaseTextEditorModel } from './textEditorModel.js';
@@ -41,7 +41,7 @@ let DiffEditorInput = class DiffEditorInput extends SideBySideEditorInput {
         else {
             const originalName = this.original.getName();
             const modifiedName = this.modified.getName();
-            name = ( localize('sideBySideLabels', "{0} ↔ {1}", originalName, modifiedName));
+            name = localizeWithPath('vs/workbench/common/editor/diffEditorInput', 'sideBySideLabels', "{0} ↔ {1}", originalName, modifiedName);
             forceDescription = originalName === modifiedName;
         }
         let shortDescription;

package/vscode/src/vs/workbench/common/editor/sideBySideEditorInput.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { isResourceDiffEditorInput, isResourceSideBySideEditorInput, isResourceMergeEditorInput, isEditorInput, findViewStateForEditor, isResourceEditorInput, isDiffEditorInput } from '../editor.js';
 import { EditorInput } from './editorInput.js';
 import { IEditorService } from '../../services/editor/common/editorService.js';
@@ -59,12 +59,7 @@ let SideBySideEditorInput = class SideBySideEditorInput extends EditorInput {
         if (this.hasIdenticalSides) {
             return this.primary.getName();
         }
-        return ( localize(
-            'sideBySideLabels',
-            "{0} - {1}",
-            this.secondary.getName(),
-            this.primary.getName()
-        ));
+        return localizeWithPath('vs/workbench/common/editor/sideBySideEditorInput', 'sideBySideLabels', "{0} - {1}", this.secondary.getName(), this.primary.getName());
     }
     getPreferredName() {
         return this.preferredName;

package/vscode/src/vs/workbench/common/editor/textEditorModel.js

@@ -7,7 +7,7 @@ import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/langua
 import { LanguageDetectionLanguageEventSource, ILanguageDetectionService } from '../../services/languageDetection/common/languageDetectionWorkerService.js';
 import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 var BaseTextEditorModel_1;
 let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
     static { BaseTextEditorModel_1 = this; }
@@ -87,11 +87,7 @@ let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
         if (lang && lang !== prevLang && !this.isDisposed()) {
             this.setLanguageIdInternal(lang, LanguageDetectionLanguageEventSource);
             const languageName = this.languageService.getLanguageName(lang);
-            this.accessibilityService.alert(( localize(
-                'languageAutoDetected',
-                "Language {0} was automatically detected and set as the language mode.",
-                languageName ?? lang
-            )));
+            this.accessibilityService.alert(localizeWithPath('vs/workbench/common/editor/textEditorModel', 'languageAutoDetected', "Language {0} was automatically detected and set as the language mode.", languageName ?? lang));
         }
     }
     createTextEditorModel(value, resource, preferredLanguageId) {

package/vscode/src/vs/workbench/common/editor.js

@@ -1,4 +1,4 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { toDisposable, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
@@ -15,8 +15,8 @@ const EditorExtensions = {
 };
 const DEFAULT_EDITOR_ASSOCIATION = {
     id: 'default',
-    displayName: ( localize('promptOpenWith.defaultEditor.displayName', "Text Editor")),
-    providerDisplayName: ( localize('builtinProviderDisplayName', "Built-in"))
+    displayName: localizeWithPath('vs/workbench/common/editor', 'promptOpenWith.defaultEditor.displayName', "Text Editor"),
+    providerDisplayName: localizeWithPath('vs/workbench/common/editor', 'builtinProviderDisplayName', "Built-in")
 };
 const SIDE_BY_SIDE_EDITOR_ID = 'workbench.editor.sidebysideEditor';
 const TEXT_DIFF_EDITOR_ID = 'workbench.editors.textDiffEditor';
@@ -111,7 +111,7 @@ function isDiffEditorInput(editor) {
 function createTooLargeFileError(group, input, options, message, preferencesService) {
     return createEditorOpenError(message, [
         toAction({
-            id: 'workbench.action.openLargeFile', label: ( localize('openLargeFile', "Open Anyway")), run: () => {
+            id: 'workbench.action.openLargeFile', label: localizeWithPath('vs/workbench/common/editor', 'openLargeFile', "Open Anyway"), run: () => {
                 const fileEditorOptions = {
                     ...options,
                     limits: {
@@ -122,7 +122,7 @@ function createTooLargeFileError(group, input, options, message, preferencesServ
             }
         }),
         toAction({
-            id: 'workbench.action.configureEditorLargeFileConfirmation', label: ( localize('configureEditorLargeFileConfirmation', "Configure Limit")), run: () => {
+            id: 'workbench.action.configureEditorLargeFileConfirmation', label: localizeWithPath('vs/workbench/common/editor', 'configureEditorLargeFileConfirmation', "Configure Limit"), run: () => {
                 return preferencesService.openUserSettings({ query: 'workbench.editorLargeFileConfirmation' });
             }
         }),