@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/platform/history/browser/contextScopedHistoryWidget.js

@@ -2,9 +2,10 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { FindInput } from '../../../base/browser/ui/findinput/findInput.js';
 import { ReplaceInput } from '../../../base/browser/ui/findinput/replaceInput.js';
 import { HistoryInputBox } from '../../../base/browser/ui/inputbox/inputBox.js';
+import { KeyCode, KeyMod as KeyMod$1 } from '../../../base/common/keyCodes.js';
 import { ContextKeyExpr, RawContextKey } from '../../contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
-import { KeybindingsRegistry } from '../../keybinding/common/keybindingsRegistry.js';
+import { KeybindingsRegistry, KeybindingWeight } from '../../keybinding/common/keybindingsRegistry.js';
 import { localizeWithPath } from '../../../nls.js';
 import { toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { isActiveElement } from '../../../base/browser/dom.js';
@@ -83,30 +84,30 @@ ContextScopedReplaceInput = ( (__decorate([
 ], ContextScopedReplaceInput)));
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: 'history.showPrevious',
-    weight: 200 ,
+    weight: KeybindingWeight.WorkbenchContrib,
     when: ( (ContextKeyExpr.and(
          (ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)),
          (ContextKeyExpr.equals(HistoryNavigationBackwardsEnablementContext, true)),
         ContextKeyExpr.not('isComposing'),
          (historyNavigationVisible.isEqualTo(false))
     ))),
-    primary: 16 ,
-    secondary: [512  | 16 ],
+    primary: KeyCode.UpArrow,
+    secondary: [KeyMod$1.Alt | KeyCode.UpArrow],
     handler: (accessor) => {
         lastFocusedWidget?.showPreviousValue();
     }
 });
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: 'history.showNext',
-    weight: 200 ,
+    weight: KeybindingWeight.WorkbenchContrib,
     when: ( (ContextKeyExpr.and(
          (ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)),
          (ContextKeyExpr.equals(HistoryNavigationForwardsEnablementContext, true)),
         ContextKeyExpr.not('isComposing'),
          (historyNavigationVisible.isEqualTo(false))
     ))),
-    primary: 18 ,
-    secondary: [512  | 18 ],
+    primary: KeyCode.DownArrow,
+    secondary: [KeyMod$1.Alt | KeyCode.DownArrow],
     handler: (accessor) => {
         lastFocusedWidget?.showNextValue();
     }

package/vscode/src/vs/platform/hover/browser/hover.js

@@ -1,7 +1,8 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { IConfigurationService } from '../../configuration/common/configuration.service.js';
-import { addStandardDisposableListener } from '../../../base/browser/dom.js';
+import { isHTMLElement, addStandardDisposableListener } from '../../../base/browser/dom.js';
+import { KeyCode } from '../../../base/common/keyCodes.js';
 import { IHoverService } from './hover.service.js';
 let WorkbenchHoverDelegate = class WorkbenchHoverDelegate extends Disposable {
     get delay() {
@@ -30,15 +31,15 @@ let WorkbenchHoverDelegate = class WorkbenchHoverDelegate extends Disposable {
     showHover(options, focus) {
         const overrideOptions = typeof this.overrideOptions === 'function' ? this.overrideOptions(options, focus) : this.overrideOptions;
         this.hoverDisposables.clear();
-        const targets = options.target instanceof HTMLElement ? [options.target] : options.target.targetElements;
+        const targets = isHTMLElement(options.target) ? [options.target] : options.target.targetElements;
         for (const target of targets) {
             this.hoverDisposables.add(addStandardDisposableListener(target, 'keydown', (e) => {
-                if (e.equals(9 )) {
+                if (e.equals(KeyCode.Escape)) {
                     this.hoverService.hideHover();
                 }
             }));
         }
-        const id = options.content instanceof HTMLElement ? undefined : ( options.content.toString());
+        const id = isHTMLElement(options.content) ? undefined : ( options.content.toString());
         return this.hoverService.showHover({
             ...options,
             ...overrideOptions,

package/vscode/src/vs/platform/instantiation/common/extensions.js

@@ -1,5 +1,10 @@
 import { SyncDescriptor } from './descriptors.js';
 const _registry = [];
+var InstantiationType;
+( (function(InstantiationType) {
+    InstantiationType[InstantiationType["Eager"] = 0] = "Eager";
+    InstantiationType[InstantiationType["Delayed"] = 1] = "Delayed";
+})(InstantiationType || (InstantiationType = {})));
 function registerSingleton(id, ctorOrDescriptor, supportsDelayedInstantiation) {
     if (!(ctorOrDescriptor instanceof SyncDescriptor)) {
         ctorOrDescriptor = ( new SyncDescriptor(ctorOrDescriptor, [], Boolean(supportsDelayedInstantiation)));
@@ -9,4 +14,4 @@ function registerSingleton(id, ctorOrDescriptor, supportsDelayedInstantiation) {
 function getSingletonServiceDescriptors() {
     return _registry;
 }
-export { getSingletonServiceDescriptors, registerSingleton };
+export { InstantiationType, getSingletonServiceDescriptors, registerSingleton };

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

@@ -1,3 +1,4 @@
+import { DisposableStore } from '../../../base/common/lifecycle.js';
 import { SyncDescriptor0 } from './descriptors.js';
 import { ServiceCollection } from './serviceCollection.js';
 
@@ -30,8 +31,11 @@ interface IInstantiationService {
     /**
      * Creates a child of this service which inherits all current services
      * and adds/overwrites the given services.
+     *
+     * NOTE that the returned child is `disposable` and should be disposed when not used
+     * anymore. This will also dispose all the services that this service has created.
      */
-    createChild(services: ServiceCollection): IInstantiationService;
+    createChild(services: ServiceCollection, store?: DisposableStore): IInstantiationService;
     /**
      * Disposes this instantiation service.
      *

package/vscode/src/vs/platform/instantiation/common/instantiationService.js

@@ -44,15 +44,17 @@ class InstantiationService {
             throw ( new Error('InstantiationService has been disposed'));
         }
     }
-    createChild(services) {
+    createChild(services, store) {
         this._throwIfDisposed();
+        const that = this;
         const result = new (class extends InstantiationService {
             dispose() {
-                this._children.delete(result);
+                that._children.delete(result);
                 super.dispose();
             }
         })(services, this._strict, this, this._enableTracing);
         this._children.add(result);
+        store?.add(result);
         return result;
     }
     invokeFunction(fn, ...args) {
@@ -298,18 +300,25 @@ class InstantiationService {
         }
     }
 }
+var TraceType;
+( (function(TraceType) {
+    TraceType[TraceType["None"] = 0] = "None";
+    TraceType[TraceType["Creation"] = 1] = "Creation";
+    TraceType[TraceType["Invocation"] = 2] = "Invocation";
+    TraceType[TraceType["Branch"] = 3] = "Branch";
+})(TraceType || (TraceType = {})));
 class Trace {
     static { this.all = ( new Set()); }
     static { this._None = new (class extends Trace {
-        constructor() { super(0 , null); }
+        constructor() { super(TraceType.None, null); }
         stop() { }
         branch() { return this; }
     }); }
     static traceInvocation(_enableTracing, ctor) {
-        return !_enableTracing ? Trace._None : ( new Trace(2 , ctor.name || ( new Error()).stack.split('\n').slice(3, 4).join('\n')));
+        return !_enableTracing ? Trace._None : ( new Trace(TraceType.Invocation, ctor.name || ( new Error()).stack.split('\n').slice(3, 4).join('\n')));
     }
     static traceCreation(_enableTracing, ctor) {
-        return !_enableTracing ? Trace._None : ( new Trace(1 , ctor.name));
+        return !_enableTracing ? Trace._None : ( new Trace(TraceType.Creation, ctor.name));
     }
     static { this._totals = 0; }
     constructor(type, name) {
@@ -319,7 +328,7 @@ class Trace {
         this._dep = [];
     }
     branch(id, first) {
-        const child = ( new Trace(3 , ( id.toString())));
+        const child = ( new Trace(TraceType.Branch, ( id.toString())));
         this._dep.push([id, first, child]);
         return child;
     }
@@ -346,7 +355,7 @@ class Trace {
             return res.join('\n');
         }
         const lines = [
-            `${this.type === 1  ? 'CREATE' : 'CALL'} ${this.name}`,
+            `${this.type === TraceType.Creation ? 'CREATE' : 'CALL'} ${this.name}`,
             `${printChild(1, this)}`,
             `DONE, took ${dur.toFixed(2)}ms (grand total ${Trace._totals.toFixed(2)}ms)`
         ];

package/vscode/src/vs/platform/issue/common/issue.service.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+const IIssueMainService = ( createDecorator('issueService'));
+export { IIssueMainService };

package/vscode/src/vs/platform/keybinding/common/abstractKeybindingService.js

@@ -3,9 +3,10 @@ import { IntervalTimer, TimeoutTimer } from '../../../base/common/async.js';
 import { illegalState } from '../../../base/common/errors.js';
 import { Event, Emitter } from '../../../base/common/event.js';
 import { IME } from '../../../base/common/ime.js';
+import { KeyCode } from '../../../base/common/keyCodes.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { localizeWithPath } from '../../../nls.js';
-import { NoMatchingKb } from './keybindingResolver.js';
+import { NoMatchingKb, ResultKind } from './keybindingResolver.js';
 const _moduleId = "vs/platform/keybinding/common/abstractKeybindingService";
 const HIGH_FREQ_COMMANDS = /^(cursor|delete|undo|redo|tab|editor\.action\.clipboard)/;
 class AbstractKeybindingService extends Disposable {
@@ -213,7 +214,7 @@ class AbstractKeybindingService extends Disposable {
         const keypressLabel = userKeypress.getLabel();
         const resolveResult = this._getResolver().resolve(contextValue, currentChords, userPressedChord);
         switch (resolveResult.kind) {
-            case 0 : {
+            case ResultKind.NoMatchingKb: {
                 this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ No matching keybinding ]`);
                 if (this.inChordMode) {
                     const currentChordsLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
@@ -230,14 +231,14 @@ class AbstractKeybindingService extends Disposable {
                 }
                 return shouldPreventDefault;
             }
-            case 1 : {
+            case ResultKind.MoreChordsNeeded: {
                 this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ Several keybindings match - more chords needed ]`);
                 shouldPreventDefault = true;
                 this._expectAnotherChord(userPressedChord, keypressLabel);
                 this._log(this._currentChords.length === 1 ? `+ Entering multi-chord mode...` : `+ Continuing multi-chord mode...`);
                 return shouldPreventDefault;
             }
-            case 2 : {
+            case ResultKind.KbFound: {
                 this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ Will dispatch command ${resolveResult.commandId} ]`);
                 if (resolveResult.commandId === null || resolveResult.commandId === '') {
                     if (this.inChordMode) {
@@ -286,8 +287,8 @@ class AbstractKeybindingService extends Disposable {
         if (event.ctrlKey || event.metaKey) {
             return false;
         }
-        if (((event.keyCode >= 31  && event.keyCode <= 56) )
-            || ((event.keyCode >= 21  && event.keyCode <= 30) )) {
+        if ((event.keyCode >= KeyCode.KeyA && event.keyCode <= KeyCode.KeyZ)
+            || (event.keyCode >= KeyCode.Digit0 && event.keyCode <= KeyCode.Digit9)) {
             return true;
         }
         return false;

package/vscode/src/vs/platform/keybinding/common/keybindingResolver.js

@@ -1,8 +1,14 @@
-import { expressionsAreEqualWithConstantSubstitution, implies } from '../../contextkey/common/contextkey.js';
-const NoMatchingKb = { kind: 0  };
-const MoreChordsNeeded = { kind: 1  };
+import { ContextKeyExprType, expressionsAreEqualWithConstantSubstitution, implies } from '../../contextkey/common/contextkey.js';
+var ResultKind;
+( (function(ResultKind) {
+    ResultKind[ResultKind["NoMatchingKb"] = 0] = "NoMatchingKb";
+    ResultKind[ResultKind["MoreChordsNeeded"] = 1] = "MoreChordsNeeded";
+    ResultKind[ResultKind["KbFound"] = 2] = "KbFound";
+})(ResultKind || (ResultKind = {})));
+const NoMatchingKb = { kind: ResultKind.NoMatchingKb };
+const MoreChordsNeeded = { kind: ResultKind.MoreChordsNeeded };
 function KbFound(commandId, commandArgs, isBubble) {
-    return { kind: 2 , commandId, commandArgs, isBubble };
+    return { kind: ResultKind.KbFound, commandId, commandArgs, isBubble };
 }
 class KeybindingResolver {
     constructor(
@@ -26,7 +32,7 @@ class KeybindingResolver {
                 continue;
             }
             const when = k.when?.substituteConstants();
-            if (when && when.type === 0 ) {
+            if (when && when.type === ContextKeyExprType.False) {
                 continue;
             }
             this._addKeyPress(k.chords[0], k);
@@ -40,7 +46,7 @@ class KeybindingResolver {
                 }
             }
         }
-        if (when && when.type !== 1 ) {
+        if (when && when.type !== ContextKeyExprType.True) {
             if (!defaultKb.when) {
                 return false;
             }
@@ -155,10 +161,10 @@ class KeybindingResolver {
         }
     }
     static whenIsEntirelyIncluded(a, b) {
-        if (!b || b.type === 1 ) {
+        if (!b || b.type === ContextKeyExprType.True) {
             return true;
         }
-        if (!a || a.type === 1 ) {
+        if (!a || a.type === ContextKeyExprType.True) {
             return false;
         }
         return implies(a, b);
@@ -271,4 +277,4 @@ function printSourceExplanation(kb) {
         ? (kb.isBuiltinExtension ? `built-in extension ${kb.extensionId}` : `user extension ${kb.extensionId}`)
         : (kb.isDefault ? `built-in` : `user`));
 }
-export { KeybindingResolver, NoMatchingKb };
+export { KeybindingResolver, NoMatchingKb, ResultKind };

package/vscode/src/vs/platform/keybinding/common/keybindingsRegistry.d.ts

@@ -33,6 +33,9 @@ interface IKeybindingRule extends IKeybindings {
     id: string;
     weight: number;
     args?: any;
+    /**
+     * Keybinding is disabled if expression returns false.
+     */
     when?: ContextKeyExpression | null | undefined;
 }
 interface IExtensionKeybindingRule {

package/vscode/src/vs/platform/keybinding/common/keybindingsRegistry.js

@@ -1,9 +1,17 @@
 import { decodeKeybinding } from '../../../base/common/keybindings.js';
-import { OS } from '../../../base/common/platform.js';
+import { OS, OperatingSystem } from '../../../base/common/platform.js';
 import { CommandsRegistry } from '../../commands/common/commands.js';
 import { Registry } from '../../registry/common/platform.js';
 import { combinedDisposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { LinkedList } from '../../../base/common/linkedList.js';
+var KeybindingWeight;
+( (function(KeybindingWeight) {
+    KeybindingWeight[KeybindingWeight["EditorCore"] = 0] = "EditorCore";
+    KeybindingWeight[KeybindingWeight["EditorContrib"] = 100] = "EditorContrib";
+    KeybindingWeight[KeybindingWeight["WorkbenchContrib"] = 200] = "WorkbenchContrib";
+    KeybindingWeight[KeybindingWeight["BuiltinExtension"] = 300] = "BuiltinExtension";
+    KeybindingWeight[KeybindingWeight["ExternalExtension"] = 400] = "ExternalExtension";
+})(KeybindingWeight || (KeybindingWeight = {})));
 class KeybindingsRegistryImpl {
     constructor() {
         this._coreKeybindings = ( new LinkedList());
@@ -11,12 +19,12 @@ class KeybindingsRegistryImpl {
         this._cachedMergedKeybindings = null;
     }
     static bindToCurrentPlatform(kb) {
-        if (OS === 1 ) {
+        if (OS === OperatingSystem.Windows) {
             if (kb && kb.win) {
                 return kb.win;
             }
         }
-        else if (OS === 2 ) {
+        else if (OS === OperatingSystem.Macintosh) {
             if (kb && kb.mac) {
                 return kb.mac;
             }
@@ -115,4 +123,4 @@ function sorter(a, b) {
     }
     return a.weight2 - b.weight2;
 }
-export { Extensions, KeybindingsRegistry };
+export { Extensions, KeybindingWeight, KeybindingsRegistry };

package/vscode/src/vs/platform/keybinding/common/resolvedKeybindingItem.js

@@ -1,3 +1,4 @@
+import { CharCode } from '../../../base/common/charCode.js';
 class ResolvedKeybindingItem {
     constructor(resolvedKeybinding, command, commandArgs, when, isDefault, extensionId, isBuiltinExtension) {
         this._resolvedKeybindingItemBrand = undefined;
@@ -6,7 +7,7 @@ class ResolvedKeybindingItem {
         if (resolvedKeybinding && this.chords.length === 0) {
             this.chords = toEmptyArrayIfContainsNull(resolvedKeybinding.getSingleModifierDispatchChords());
         }
-        this.bubble = (command ? command.charCodeAt(0) === 94  : false);
+        this.bubble = (command ? command.charCodeAt(0) === CharCode.Caret : false);
         this.command = this.bubble ? command.substr(1) : command;
         this.commandArgs = commandArgs;
         this.when = when;

package/vscode/src/vs/platform/keybinding/common/usLayoutResolvedKeybinding.js

@@ -1,5 +1,6 @@
-import { KeyCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE } from '../../../base/common/keyCodes.js';
+import { KeyCode, KeyCodeUtils, ScanCode, IMMUTABLE_CODE_TO_KEY_CODE } from '../../../base/common/keyCodes.js';
 import { KeyCodeChord } from '../../../base/common/keybindings.js';
+import { OperatingSystem } from '../../../base/common/platform.js';
 import { BaseResolvedKeybinding } from './baseResolvedKeybinding.js';
 import { toEmptyArrayIfContainsNull } from './resolvedKeybindingItem.js';
 class USLayoutResolvedKeybinding extends BaseResolvedKeybinding {
@@ -7,15 +8,15 @@ class USLayoutResolvedKeybinding extends BaseResolvedKeybinding {
         super(os, chords);
     }
     _keyCodeToUILabel(keyCode) {
-        if (this._os === 2 ) {
+        if (this._os === OperatingSystem.Macintosh) {
             switch (keyCode) {
-                case 15 :
+                case KeyCode.LeftArrow:
                     return '←';
-                case 16 :
+                case KeyCode.UpArrow:
                     return '↑';
-                case 17 :
+                case KeyCode.RightArrow:
                     return '→';
-                case 18 :
+                case KeyCode.DownArrow:
                     return '↓';
             }
         }
@@ -70,77 +71,77 @@ class USLayoutResolvedKeybinding extends BaseResolvedKeybinding {
         return result;
     }
     _getSingleModifierChordDispatch(keybinding) {
-        if (keybinding.keyCode === 5  && !keybinding.shiftKey && !keybinding.altKey && !keybinding.metaKey) {
+        if (keybinding.keyCode === KeyCode.Ctrl && !keybinding.shiftKey && !keybinding.altKey && !keybinding.metaKey) {
             return 'ctrl';
         }
-        if (keybinding.keyCode === 4  && !keybinding.ctrlKey && !keybinding.altKey && !keybinding.metaKey) {
+        if (keybinding.keyCode === KeyCode.Shift && !keybinding.ctrlKey && !keybinding.altKey && !keybinding.metaKey) {
             return 'shift';
         }
-        if (keybinding.keyCode === 6  && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.metaKey) {
+        if (keybinding.keyCode === KeyCode.Alt && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.metaKey) {
             return 'alt';
         }
-        if (keybinding.keyCode === 57  && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.altKey) {
+        if (keybinding.keyCode === KeyCode.Meta && !keybinding.ctrlKey && !keybinding.shiftKey && !keybinding.altKey) {
             return 'meta';
         }
         return null;
     }
     static _scanCodeToKeyCode(scanCode) {
         const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
-        if (immutableKeyCode !== -1 ) {
+        if (immutableKeyCode !== KeyCode.DependsOnKbLayout) {
             return immutableKeyCode;
         }
         switch (scanCode) {
-            case 10 : return 31 ;
-            case 11 : return 32 ;
-            case 12 : return 33 ;
-            case 13 : return 34 ;
-            case 14 : return 35 ;
-            case 15 : return 36 ;
-            case 16 : return 37 ;
-            case 17 : return 38 ;
-            case 18 : return 39 ;
-            case 19 : return 40 ;
-            case 20 : return 41 ;
-            case 21 : return 42 ;
-            case 22 : return 43 ;
-            case 23 : return 44 ;
-            case 24 : return 45 ;
-            case 25 : return 46 ;
-            case 26 : return 47 ;
-            case 27 : return 48 ;
-            case 28 : return 49 ;
-            case 29 : return 50 ;
-            case 30 : return 51 ;
-            case 31 : return 52 ;
-            case 32 : return 53 ;
-            case 33 : return 54 ;
-            case 34 : return 55 ;
-            case 35 : return 56 ;
-            case 36 : return 22 ;
-            case 37 : return 23 ;
-            case 38 : return 24 ;
-            case 39 : return 25 ;
-            case 40 : return 26 ;
-            case 41 : return 27 ;
-            case 42 : return 28 ;
-            case 43 : return 29 ;
-            case 44 : return 30 ;
-            case 45 : return 21 ;
-            case 51 : return 88 ;
-            case 52 : return 86 ;
-            case 53 : return 92 ;
-            case 54 : return 94 ;
-            case 55 : return 93 ;
-            case 56 : return 0 ;
-            case 57 : return 85 ;
-            case 58 : return 95 ;
-            case 59 : return 91 ;
-            case 60 : return 87 ;
-            case 61 : return 89 ;
-            case 62 : return 90 ;
-            case 106 : return 97 ;
-        }
-        return 0 ;
+            case ScanCode.KeyA: return KeyCode.KeyA;
+            case ScanCode.KeyB: return KeyCode.KeyB;
+            case ScanCode.KeyC: return KeyCode.KeyC;
+            case ScanCode.KeyD: return KeyCode.KeyD;
+            case ScanCode.KeyE: return KeyCode.KeyE;
+            case ScanCode.KeyF: return KeyCode.KeyF;
+            case ScanCode.KeyG: return KeyCode.KeyG;
+            case ScanCode.KeyH: return KeyCode.KeyH;
+            case ScanCode.KeyI: return KeyCode.KeyI;
+            case ScanCode.KeyJ: return KeyCode.KeyJ;
+            case ScanCode.KeyK: return KeyCode.KeyK;
+            case ScanCode.KeyL: return KeyCode.KeyL;
+            case ScanCode.KeyM: return KeyCode.KeyM;
+            case ScanCode.KeyN: return KeyCode.KeyN;
+            case ScanCode.KeyO: return KeyCode.KeyO;
+            case ScanCode.KeyP: return KeyCode.KeyP;
+            case ScanCode.KeyQ: return KeyCode.KeyQ;
+            case ScanCode.KeyR: return KeyCode.KeyR;
+            case ScanCode.KeyS: return KeyCode.KeyS;
+            case ScanCode.KeyT: return KeyCode.KeyT;
+            case ScanCode.KeyU: return KeyCode.KeyU;
+            case ScanCode.KeyV: return KeyCode.KeyV;
+            case ScanCode.KeyW: return KeyCode.KeyW;
+            case ScanCode.KeyX: return KeyCode.KeyX;
+            case ScanCode.KeyY: return KeyCode.KeyY;
+            case ScanCode.KeyZ: return KeyCode.KeyZ;
+            case ScanCode.Digit1: return KeyCode.Digit1;
+            case ScanCode.Digit2: return KeyCode.Digit2;
+            case ScanCode.Digit3: return KeyCode.Digit3;
+            case ScanCode.Digit4: return KeyCode.Digit4;
+            case ScanCode.Digit5: return KeyCode.Digit5;
+            case ScanCode.Digit6: return KeyCode.Digit6;
+            case ScanCode.Digit7: return KeyCode.Digit7;
+            case ScanCode.Digit8: return KeyCode.Digit8;
+            case ScanCode.Digit9: return KeyCode.Digit9;
+            case ScanCode.Digit0: return KeyCode.Digit0;
+            case ScanCode.Minus: return KeyCode.Minus;
+            case ScanCode.Equal: return KeyCode.Equal;
+            case ScanCode.BracketLeft: return KeyCode.BracketLeft;
+            case ScanCode.BracketRight: return KeyCode.BracketRight;
+            case ScanCode.Backslash: return KeyCode.Backslash;
+            case ScanCode.IntlHash: return KeyCode.Unknown;
+            case ScanCode.Semicolon: return KeyCode.Semicolon;
+            case ScanCode.Quote: return KeyCode.Quote;
+            case ScanCode.Backquote: return KeyCode.Backquote;
+            case ScanCode.Comma: return KeyCode.Comma;
+            case ScanCode.Period: return KeyCode.Period;
+            case ScanCode.Slash: return KeyCode.Slash;
+            case ScanCode.IntlBackslash: return KeyCode.IntlBackslash;
+        }
+        return KeyCode.Unknown;
     }
     static _toKeyCodeChord(chord) {
         if (!chord) {
@@ -150,7 +151,7 @@ class USLayoutResolvedKeybinding extends BaseResolvedKeybinding {
             return chord;
         }
         const keyCode = this._scanCodeToKeyCode(chord.scanCode);
-        if (keyCode === 0 ) {
+        if (keyCode === KeyCode.Unknown) {
             return null;
         }
         return ( new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode));

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

@@ -0,0 +1,7 @@
+var Verbosity;
+( (function(Verbosity) {
+    Verbosity[Verbosity["SHORT"] = 0] = "SHORT";
+    Verbosity[Verbosity["MEDIUM"] = 1] = "MEDIUM";
+    Verbosity[Verbosity["LONG"] = 2] = "LONG";
+})(Verbosity || (Verbosity = {})));
+export { Verbosity };

package/vscode/src/vs/platform/languagePacks/common/localizedStrings.js

@@ -0,0 +1,11 @@
+import { localizeWithPath } from '../../../nls.js';
+const _moduleId = "vs/platform/languagePacks/common/localizedStrings";
+const open = ( localizeWithPath(_moduleId, 0, 'open'));
+const close = ( localizeWithPath(_moduleId, 1, 'close'));
+const find = ( localizeWithPath(_moduleId, 2, 'find'));
+var localizedStrings = {
+    open: open,
+    close: close,
+    find: find
+};
+export { localizedStrings as default };

package/vscode/src/vs/platform/list/browser/listService.js

@@ -18,6 +18,7 @@ import { InputFocusedContextKey } from '../../contextkey/common/contextkeys.js';
 import { IContextViewService } from '../../contextview/browser/contextView.service.js';
 import { IInstantiationService } from '../../instantiation/common/instantiation.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
+import { ResultKind } from '../../keybinding/common/keybindingResolver.js';
 import { Registry } from '../../registry/common/platform.js';
 import { getListStyles, defaultListStyles, defaultFindWidgetStyles } from '../../theme/browser/defaultStyles.js';
 import { IListService } from './listService.service.js';
@@ -569,12 +570,12 @@ function createKeyboardNavigationEventFilter(keybindingService) {
             return false;
         }
         const result = keybindingService.softDispatch(event, event.target);
-        if (result.kind === 1 ) {
+        if (result.kind === ResultKind.MoreChordsNeeded) {
             inMultiChord = true;
             return false;
         }
         inMultiChord = false;
-        return result.kind === 0 ;
+        return result.kind === ResultKind.NoMatchingKb;
     };
 }
 let WorkbenchObjectTree = class WorkbenchObjectTree extends ObjectTree {

package/vscode/src/vs/platform/markers/common/markerService.js

@@ -11,6 +11,7 @@ const unsupportedSchemas = ( new Set([
     Schemas.walkThrough,
     Schemas.walkThroughSnippet,
     Schemas.vscodeChatCodeBlock,
+    Schemas.vscodeCopilotBackingChatCodeBlock,
 ]));
 class DoubleResourceMap {
     constructor() {

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

@@ -1,6 +1,11 @@
 import Severity$1 from '../../../base/common/severity.js';
 import { localizeWithPath } from '../../../nls.js';
 const _moduleId = "vs/platform/markers/common/markers";
+var MarkerTag;
+( ((function(MarkerTag) {
+    MarkerTag[MarkerTag["Unnecessary"] = 1] = "Unnecessary";
+    MarkerTag[MarkerTag["Deprecated"] = 2] = "Deprecated";
+})(MarkerTag || (MarkerTag = {}))));
 var MarkerSeverity;
 ( ((function(MarkerSeverity) {
     MarkerSeverity[MarkerSeverity["Hint"] = 1] = "Hint";
@@ -107,4 +112,4 @@ var IMarkerData;
     }
     IMarkerData.makeKeyOptionalMessage = makeKeyOptionalMessage;
 })(IMarkerData || (IMarkerData = {}))));
-export { IMarkerData, MarkerSeverity };
+export { IMarkerData, MarkerSeverity, MarkerTag };

package/vscode/src/vs/platform/observable/common/platformObservableUtils.js

@@ -0,0 +1,19 @@
+import '../../../base/common/arrays.js';
+import '../../../base/common/observableInternal/derived.js';
+import { autorunOpts } from '../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent } from '../../../base/common/observableInternal/utils.js';
+import '../../../base/common/cancellation.js';
+function observableConfigValue(key, defaultValue, configurationService) {
+    return observableFromEvent((handleChange) => configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(key)) {
+            handleChange(e);
+        }
+    }), () => configurationService.getValue(key) ?? defaultValue);
+}
+function bindContextKey(key, service, computeValue) {
+    const boundKey = key.bindTo(service);
+    return autorunOpts({ debugName: () => `Set Context Key "${key.key}"` }, reader => {
+        boundKey.set(computeValue(reader));
+    });
+}
+export { bindContextKey, observableConfigValue };

package/vscode/src/vs/platform/opener/browser/link.js

@@ -4,6 +4,7 @@ import { DomEmitter } from '../../../base/browser/event.js';
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
 import { EventType, Gesture } from '../../../base/browser/touch.js';
 import { Event } from '../../../base/common/event.js';
+import { KeyCode } from '../../../base/common/keyCodes.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { IOpenerService } from '../common/opener.service.js';
 import './link.css.js';
@@ -62,7 +63,7 @@ let Link = class Link extends Disposable {
         const onClickEmitter = this._register(( new DomEmitter(this.el, 'click')));
         const onKeyPress = this._register(( new DomEmitter(this.el, 'keypress')));
         const onEnterPress = Event.chain(onKeyPress.event, $ => ( $.map(e => ( new StandardKeyboardEvent(e))))
-            .filter(e => e.keyCode === 3 ));
+            .filter(e => e.keyCode === KeyCode.Enter));
         const onTap = this._register(( new DomEmitter(this.el, EventType.Tap))).event;
         this._register(Gesture.addTarget(this.el));
         const onOpen = Event.any(onClickEmitter.event, onEnterPress, onTap);