@codingame/monaco-vscode-api 21.6.0 → 22.0.1

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -408,7 +408,7 @@ function createMenuHide(menu, command, states) {
     const title = typeof command.title === 'string' ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localize(1737, 'Hide \'{0}\'', title)),
+        label: ( localize(1740, 'Hide \'{0}\'', title)),
         run() { states.updateHidden(menu, id, true); }
     });
     const toggle = toAction({
@@ -426,7 +426,7 @@ function createMenuHide(menu, command, states) {
 function createConfigureKeybindingAction(commandService, keybindingService, commandId, when = undefined, enabled = true) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: ( localize(1738, "Configure Keybinding")),
+        label: ( localize(1741, "Configure Keybinding")),
         enabled,
         run() {
             const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);

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

@@ -33,6 +33,10 @@ export declare enum Filters {
      * Client Id which is used as primary unit for the experimentation.
      */
     ClientId = "X-MSEdge-ClientId",
+    /**
+     * Developer Device Id which can be used as an alternate unit for experimentation.
+     */
+    DeveloperDeviceId = "X-VSCode-DevDeviceId",
     /**
      * Extension header.
      */
@@ -55,8 +59,9 @@ export declare class AssignmentFilterProvider implements IExperimentationFilterP
     private version;
     private appName;
     private machineId;
+    private devDeviceId;
     private targetPopulation;
-    constructor(version: string, appName: string, machineId: string, targetPopulation: TargetPopulation);
+    constructor(version: string, appName: string, machineId: string, devDeviceId: string, targetPopulation: TargetPopulation);
     /**
      * Returns a version string that can be parsed by the TAS client.
      * The tas client cannot handle suffixes lke "-insider"

package/vscode/src/vs/platform/clipboard/browser/clipboardService.js

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { isSafari, isWebkitWebView } from '../../../base/browser/browser.js';
-import { onDidRegisterWindow, addDisposableListener, getActiveWindow, getActiveDocument, $, isHTMLElement } from '../../../base/browser/dom.js';
+import { onDidRegisterWindow, addDisposableListener, getActiveWindow, getActiveDocument, getActiveElement, $, isHTMLElement } from '../../../base/browser/dom.js';
 import { mainWindow } from '../../../base/browser/window.js';
 import { DeferredPromise } from '../../../base/common/async.js';
 import { Event } from '../../../base/common/event.js';
@@ -97,7 +97,7 @@ let BrowserClipboardService = class BrowserClipboardService extends Disposable {
     fallbackWriteText(text) {
         this.logService.trace('BrowserClipboardService#fallbackWriteText');
         const activeDocument = getActiveDocument();
-        const activeElement = activeDocument.activeElement;
+        const activeElement = getActiveElement();
         const textArea = activeDocument.body.appendChild($('textarea', { 'aria-hidden': true }));
         textArea.style.height = '1px';
         textArea.style.width = '1px';

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -48,7 +48,7 @@ class ConfigurationRegistry extends Disposable {
         this.configurationDefaultsOverrides = ( new Map());
         this.defaultLanguageConfigurationOverridesNode = {
             id: 'defaultOverrides',
-            title: ( localize(1739, "Default Language Configuration Overrides")),
+            title: ( localize(1742, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -197,7 +197,7 @@ class ConfigurationRegistry extends Disposable {
             type: 'object',
             default: newDefaultOverride.value,
             description: ( localize(
-                1740,
+                1743,
                 "Configure settings to be overridden for {0}.",
                 getLanguageTagSettingPlainKey(key)
             )),
@@ -478,8 +478,8 @@ class ConfigurationRegistry extends Disposable {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: 'object',
-                description: ( localize(1741, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1742, "This setting does not support per-language configuration.")),
+                description: ( localize(1744, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1745, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId,
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -495,8 +495,8 @@ class ConfigurationRegistry extends Disposable {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: 'object',
-            description: ( localize(1741, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1742, "This setting does not support per-language configuration.")),
+            description: ( localize(1744, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1745, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId,
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -572,25 +572,25 @@ const configurationRegistry = ( new ConfigurationRegistry());
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema) {
     if (!property.trim()) {
-        return localize(1743, "Cannot register an empty property");
+        return localize(1746, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1744,
+            1747,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         );
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
         return localize(
-            1745,
+            1748,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1746,
+            1749,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.d.ts

@@ -45,7 +45,9 @@ export declare abstract class AbstractContextKeyService extends Disposable imple
 export declare class ContextKeyService extends AbstractContextKeyService implements IContextKeyService {
     private _lastContextId;
     private readonly _contexts;
+    private inputFocusedContext;
     constructor(configurationService: IConfigurationService);
+    private updateInputContextKeys;
     getContextValuesContainer(contextId: number): Context;
     createChildContext(parentContextId?: number): number;
     disposeContext(contextId: number): void;

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.js

@@ -1,8 +1,8 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { PauseableEmitter } from '../../../base/common/event.js';
+import { PauseableEmitter, Event } from '../../../base/common/event.js';
 import { Iterable } from '../../../base/common/iterator.js';
-import { Disposable, MutableDisposable } from '../../../base/common/lifecycle.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { MarshalledId } from '../../../base/common/marshallingIds.js';
 import { distinct, cloneAndChange } from '../../../base/common/objects.js';
 import { TernarySearchTree } from '../../../base/common/ternarySearchTree.js';
@@ -13,6 +13,9 @@ import { ConfigurationTarget } from '../../configuration/common/configuration.js
 import { IConfigurationService } from '../../configuration/common/configuration.service.js';
 import { RawContextKey } from '../common/contextkey.js';
 import { IContextKeyService } from '../common/contextkey.service.js';
+import { InputFocusedContext } from '../common/contextkeys.js';
+import { mainWindow } from '../../../base/browser/window.js';
+import { onDidRegisterWindow, addDisposableListener, EventType, getActiveElement, isEditableElement, trackFocus, getActiveWindow } from '../../../base/browser/dom.js';
 
 const KEYBINDING_CONTEXT_ATTR = 'data-keybinding-context';
 class Context {
@@ -302,8 +305,34 @@ let ContextKeyService = class ContextKeyService extends AbstractContextKeyServic
         super(0);
         this._contexts = ( new Map());
         this._lastContextId = 0;
+        this.inputFocusedContext = InputFocusedContext.bindTo(this);
         const myContext = this._register(( new ConfigAwareContextValuesContainer(this._myContextId, configurationService, this._onDidChangeContext)));
         this._contexts.set(this._myContextId, myContext);
+        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 }));
+    }
+    updateInputContextKeys(ownerDocument, disposables) {
+        function activeElementIsInput() {
+            const activeElement = getActiveElement(ownerDocument);
+            return !!activeElement && isEditableElement(activeElement);
+        }
+        const isInputFocused = activeElementIsInput();
+        this.inputFocusedContext.set(isInputFocused);
+        if (isInputFocused) {
+            const activeElement = getActiveElement(ownerDocument);
+            const tracker = disposables.add(trackFocus(activeElement));
+            Event.once(tracker.onDidBlur)(() => {
+                if (getActiveWindow().document === ownerDocument) {
+                    this.inputFocusedContext.set(activeElementIsInput());
+                }
+                tracker.dispose();
+            }, undefined, disposables);
+        }
     }
     getContextValuesContainer(contextId) {
         if (this._isDisposed) {
@@ -487,7 +516,7 @@ CommandsRegistry.registerCommand({
         return [...RawContextKey.all()].sort((a, b) => a.key.localeCompare(b.key));
     },
     metadata: {
-        description: ( localize(1747, "A command that returns information about context keys")),
+        description: ( localize(1750, "A command that returns information about context keys")),
         args: []
     }
 });

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

@@ -47,17 +47,17 @@ var ContextKeyExprType;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localize(1748, "Empty context key expression"));
+const errorEmptyString = ( localize(1751, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    1749,
+    1752,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localize(1750, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(1751, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(1752, "Unexpected token"));
-const hintUnexpectedToken = ( localize(1753, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(1754, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(1755, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(1753, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(1754, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(1755, "Unexpected token"));
+const hintUnexpectedToken = ( localize(1756, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(1757, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(1758, "Did you forget to put a context key?"));
 class Parser {
     static { this._parseError = ( new Error()); }
     get lexingErrors() {
@@ -369,7 +369,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localize(1756, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(1759, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({ message, offset, lexeme, additionalInfo });
@@ -447,8 +447,8 @@ function validateWhenClauses(whenClauses) {
         if (parser.lexingErrors.length > 0) {
             return (parser.lexingErrors.map((se) => ({
                 errorMessage: se.additionalInfo ?
-                    ( localize(1757, "Unexpected token. Hint: {0}", se.additionalInfo)) :
-                    ( localize(1758, "Unexpected token.")),
+                    ( localize(1760, "Unexpected token. Hint: {0}", se.additionalInfo)) :
+                    ( localize(1761, "Unexpected token.")),
                 offset: se.offset,
                 length: se.lexeme.length,
             })));

package/vscode/src/vs/platform/contextkey/common/contextkeys.d.ts

@@ -8,6 +8,5 @@ export declare const IsIOSContext: RawContextKey<boolean>;
 export declare const IsMobileContext: RawContextKey<boolean>;
 export declare const IsDevelopmentContext: RawContextKey<boolean>;
 export declare const ProductQualityContext: RawContextKey<string>;
-export declare const IsSimulationContext: RawContextKey<boolean>;
 export declare const InputFocusedContextKey = "inputFocus";
 export declare const InputFocusedContext: RawContextKey<boolean>;

package/vscode/src/vs/platform/contextkey/common/contextkeys.js

@@ -3,17 +3,16 @@ import { isMacintosh, isLinux, isWindows, isWeb, isIOS, isMobile } from '../../.
 import { localize } from '../../../nls.js';
 import { RawContextKey } from './contextkey.js';
 
-const IsMacContext = ( new RawContextKey('isMac', isMacintosh, ( localize(1759, "Whether the operating system is macOS"))));
-const IsLinuxContext = ( new RawContextKey('isLinux', isLinux, ( localize(1760, "Whether the operating system is Linux"))));
-const IsWindowsContext = ( new RawContextKey('isWindows', isWindows, ( localize(1761, "Whether the operating system is Windows"))));
-const IsWebContext = ( new RawContextKey('isWeb', isWeb, ( localize(1762, "Whether the platform is a web browser"))));
-const IsMacNativeContext = ( new RawContextKey('isMacNative', isMacintosh && !isWeb, ( localize(1763, "Whether the operating system is macOS on a non-browser platform"))));
-const IsIOSContext = ( new RawContextKey('isIOS', isIOS, ( localize(1764, "Whether the operating system is iOS"))));
-const IsMobileContext = ( new RawContextKey('isMobile', isMobile, ( localize(1765, "Whether the platform is a mobile web browser"))));
+const IsMacContext = ( new RawContextKey('isMac', isMacintosh, ( localize(1762, "Whether the operating system is macOS"))));
+const IsLinuxContext = ( new RawContextKey('isLinux', isLinux, ( localize(1763, "Whether the operating system is Linux"))));
+const IsWindowsContext = ( new RawContextKey('isWindows', isWindows, ( localize(1764, "Whether the operating system is Windows"))));
+const IsWebContext = ( new RawContextKey('isWeb', isWeb, ( localize(1765, "Whether the platform is a web browser"))));
+const IsMacNativeContext = ( new RawContextKey('isMacNative', isMacintosh && !isWeb, ( localize(1766, "Whether the operating system is macOS on a non-browser platform"))));
+const IsIOSContext = ( new RawContextKey('isIOS', isIOS, ( localize(1767, "Whether the operating system is iOS"))));
+const IsMobileContext = ( new RawContextKey('isMobile', isMobile, ( localize(1768, "Whether the platform is a mobile web browser"))));
 const IsDevelopmentContext = ( new RawContextKey('isDevelopment', false, true));
-const ProductQualityContext = ( new RawContextKey('productQualityType', '', ( localize(1766, "Quality type of VS Code"))));
-const IsSimulationContext = ( new RawContextKey('isSimulation', false, ( localize(1767, "Whether the application runs in simulation mode"))));
+const ProductQualityContext = ( new RawContextKey('productQualityType', '', ( localize(1769, "Quality type of VS Code"))));
 const InputFocusedContextKey = 'inputFocus';
-const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1768, "Whether keyboard focus is inside an input box"))));
+const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1770, "Whether keyboard focus is inside an input box"))));
 
-export { InputFocusedContext, InputFocusedContextKey, IsDevelopmentContext, IsIOSContext, IsLinuxContext, IsMacContext, IsMacNativeContext, IsMobileContext, IsSimulationContext, IsWebContext, IsWindowsContext, ProductQualityContext };
+export { InputFocusedContext, InputFocusedContextKey, IsDevelopmentContext, IsIOSContext, IsLinuxContext, IsMacContext, IsMacNativeContext, IsMobileContext, IsWebContext, IsWindowsContext, ProductQualityContext };

package/vscode/src/vs/platform/contextkey/common/scanner.js

@@ -30,18 +30,18 @@ var TokenType;
 function hintDidYouMean(...meant) {
     switch (meant.length) {
         case 1:
-            return localize(1769, "Did you mean {0}?", meant[0]);
+            return localize(1771, "Did you mean {0}?", meant[0]);
         case 2:
-            return localize(1770, "Did you mean {0} or {1}?", meant[0], meant[1]);
+            return localize(1772, "Did you mean {0} or {1}?", meant[0], meant[1]);
         case 3:
-            return localize(1771, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
+            return localize(1773, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
         default:
             return undefined;
     }
 }
-const hintDidYouForgetToOpenOrCloseQuote = ( localize(1772, "Did you forget to open or close the quote?"));
+const hintDidYouForgetToOpenOrCloseQuote = ( localize(1774, "Did you forget to open or close the quote?"));
 const hintDidYouForgetToEscapeSlash = ( localize(
-    1773,
+    1775,
     "Did you forget to escape the '/' (slash) character? Put two backslashes before it to escape, e.g., '\\\\/\'."
 ));
 class Scanner {

package/vscode/src/vs/platform/dataChannel/browser/forwardingTelemetryService.d.ts

@@ -0,0 +1,32 @@
+import { ClassifiedEvent, OmitMetadata, IGDPRProperty, StrictPropertyCheck } from "../../telemetry/common/gdprTypings.js";
+import { ITelemetryData, TelemetryLevel } from "../../telemetry/common/telemetry.js";
+import { ITelemetryService } from "../../telemetry/common/telemetry.service.js";
+import { IDataChannelService } from "../common/dataChannel.service.js";
+export declare class InterceptingTelemetryService implements ITelemetryService {
+    private readonly _baseService;
+    private readonly _intercept;
+    _serviceBrand: undefined;
+    constructor(_baseService: ITelemetryService, _intercept: (eventName: string, data?: ITelemetryData) => void);
+    get telemetryLevel(): TelemetryLevel;
+    get sessionId(): string;
+    get machineId(): string;
+    get sqmId(): string;
+    get devDeviceId(): string;
+    get firstSessionDate(): string;
+    get msftInternal(): boolean | undefined;
+    get sendErrorTelemetry(): boolean;
+    publicLog(eventName: string, data?: ITelemetryData): void;
+    publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+    publicLogError(errorEventName: string, data?: ITelemetryData): void;
+    publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+    setExperimentProperty(name: string, value: string): void;
+}
+export interface IEditTelemetryData {
+    eventName: string;
+    data: Record<string, unknown>;
+}
+export declare class DataChannelForwardingTelemetryService extends InterceptingTelemetryService {
+    constructor(telemetryService: ITelemetryService, dataChannelService: IDataChannelService);
+}
+export declare function forwardToChannelIf(value: boolean): Record<string, unknown>;
+export declare function isCopilotLikeExtension(extensionId: string | undefined): boolean;

package/vscode/src/vs/platform/dataChannel/browser/forwardingTelemetryService.js

@@ -0,0 +1,86 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+import { IDataChannelService } from '../common/dataChannel.service.js';
+
+class InterceptingTelemetryService {
+    constructor(_baseService, _intercept) {
+        this._baseService = _baseService;
+        this._intercept = _intercept;
+    }
+    get telemetryLevel() {
+        return this._baseService.telemetryLevel;
+    }
+    get sessionId() {
+        return this._baseService.sessionId;
+    }
+    get machineId() {
+        return this._baseService.machineId;
+    }
+    get sqmId() {
+        return this._baseService.sqmId;
+    }
+    get devDeviceId() {
+        return this._baseService.devDeviceId;
+    }
+    get firstSessionDate() {
+        return this._baseService.firstSessionDate;
+    }
+    get msftInternal() {
+        return this._baseService.msftInternal;
+    }
+    get sendErrorTelemetry() {
+        return this._baseService.sendErrorTelemetry;
+    }
+    publicLog(eventName, data) {
+        this._intercept(eventName, data);
+        this._baseService.publicLog(eventName, data);
+    }
+    publicLog2(eventName, data) {
+        this._intercept(eventName, data);
+        this._baseService.publicLog2(eventName, data);
+    }
+    publicLogError(errorEventName, data) {
+        this._intercept(errorEventName, data);
+        this._baseService.publicLogError(errorEventName, data);
+    }
+    publicLogError2(eventName, data) {
+        this._intercept(eventName, data);
+        this._baseService.publicLogError2(eventName, data);
+    }
+    setExperimentProperty(name, value) {
+        this._baseService.setExperimentProperty(name, value);
+    }
+}
+let DataChannelForwardingTelemetryService = class DataChannelForwardingTelemetryService extends InterceptingTelemetryService {
+    constructor(telemetryService, dataChannelService) {
+        super(telemetryService, (eventName, data) => {
+            let forward = true;
+            if (data && shouldForwardToChannel in data) {
+                forward = Boolean(data[shouldForwardToChannel]);
+            }
+            if (forward) {
+                dataChannelService.getDataChannel('editTelemetry').sendData({ eventName, data: data });
+            }
+        });
+    }
+};
+DataChannelForwardingTelemetryService = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IDataChannelService))
+], DataChannelForwardingTelemetryService));
+const shouldForwardToChannel = Symbol('shouldForwardToChannel');
+function forwardToChannelIf(value) {
+    return {
+        [shouldForwardToChannel]: value
+    };
+}
+function isCopilotLikeExtension(extensionId) {
+    if (!extensionId) {
+        return false;
+    }
+    const extIdLowerCase = extensionId.toLowerCase();
+    return extIdLowerCase === 'github.copilot' || extIdLowerCase === 'github.copilot-chat';
+}
+
+export { DataChannelForwardingTelemetryService, InterceptingTelemetryService, forwardToChannelIf, isCopilotLikeExtension };

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

@@ -1,6 +1,6 @@
 import { Event } from "../../../base/common/event.js";
 import { URI } from "../../../base/common/uri.js";
-import { IConfirmation, IConfirmationResult, IPromptWithCustomCancel, IPromptResultWithCancel, IPromptWithDefaultCancel, IPromptResult, IPrompt, IInput, IInputResult, type ConfirmResult, type IOpenDialogOptions, type IPickAndOpenOptions, type ISaveDialogOptions } from "@codingame/monaco-vscode-23b6fb38-5e58-5886-b34b-27abc4f5df02-common/vscode/vs/platform/dialogs/common/dialogs";
+import { IConfirmation, IConfirmationResult, IPromptWithCustomCancel, IPromptResultWithCancel, IPromptWithDefaultCancel, IPromptResult, IPrompt, IInput, IInputResult, type ConfirmResult, type IOpenDialogOptions, type IPickAndOpenOptions, type ISaveDialogOptions } from "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common/vscode/vs/platform/dialogs/common/dialogs";
 export declare const IDialogService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IDialogService>;
 /**
 * A service to bring up modal dialogs.

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

@@ -184,7 +184,7 @@ async function extractFileListData(accessor, files) {
         if (file) {
             if (file.size > 100 * ByteSize.MB) {
                 dialogService.warn(( localize(
-                    1780,
+                    1782,
                     "File is too large to open as untitled editor. Please upload it first into the file explorer and then try again."
                 )));
                 continue;

package/vscode/src/vs/platform/environment/common/argv.d.ts

@@ -23,6 +23,7 @@ export interface NativeParsedArgs {
         maximize?: boolean;
         "reuse-window"?: boolean;
         "new-window"?: boolean;
+        profile?: string;
         help?: boolean;
     };
     _: string[];

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

@@ -40,7 +40,6 @@ export interface IEnvironmentService {
     disableExperiments: boolean;
     serviceMachineIdResource: URI;
     policyFile?: URI;
-    isSimulation?: boolean;
 }
 export declare const INativeEnvironmentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<INativeEnvironmentService>;
 /**

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

@@ -268,39 +268,39 @@ async function computeSize(location, fileService) {
     }
     return stat.size ?? 0;
 }
-const ExtensionsLocalizedLabel = ( localize2(1801, "Extensions"));
-const PreferencesLocalizedLabel = ( localize2(1802, 'Preferences'));
+const ExtensionsLocalizedLabel = ( localize2(1803, "Extensions"));
+const PreferencesLocalizedLabel = ( localize2(1804, 'Preferences'));
 const AllowedExtensionsConfigKey = 'extensions.allowed';
 const VerifyExtensionSignatureConfigKey = 'extensions.verifySignature';
 ( Registry.as(Extensions.Configuration))
     .registerConfiguration({
     id: 'extensions',
     order: 30,
-    title: ( localize(1803, "Extensions")),
+    title: ( localize(1805, "Extensions")),
     type: 'object',
     properties: {
         [AllowedExtensionsConfigKey]: {
             type: 'object',
             markdownDescription: ( localize(
-                1804,
+                1806,
                 "Specify a list of extensions that are allowed to use. This helps maintain a secure and consistent development environment by restricting the use of unauthorized extensions. For more information on how to configure this setting, please visit the [Configure Allowed Extensions](https://code.visualstudio.com/docs/setup/enterprise#_configure-allowed-extensions) section."
             )),
             default: '*',
             defaultSnippets: [{
                     body: {},
-                    description: ( localize(1805, "No extensions are allowed.")),
+                    description: ( localize(1807, "No extensions are allowed.")),
                 }, {
                     body: {
                         '*': true
                     },
-                    description: ( localize(1806, "All extensions are allowed.")),
+                    description: ( localize(1808, "All extensions are allowed.")),
                 }],
             scope: ConfigurationScope.APPLICATION,
             policy: {
                 name: 'AllowedExtensions',
                 minimumVersion: '1.96',
                 description: ( localize(
-                    1807,
+                    1809,
                     "Specify a list of extensions that are allowed to use. This helps maintain a secure and consistent development environment by restricting the use of unauthorized extensions. More information: https://code.visualstudio.com/docs/setup/enterprise#_configure-allowed-extensions"
                 )),
             },
@@ -311,11 +311,11 @@ const VerifyExtensionSignatureConfigKey = 'extensions.verifySignature';
                         {
                             type: ['boolean', 'string'],
                             enum: [true, false, 'stable'],
-                            description: ( localize(1808, "Allow or disallow the extension.")),
+                            description: ( localize(1810, "Allow or disallow the extension.")),
                             enumDescriptions: [
-                                ( localize(1809, "Extension is allowed.")),
-                                ( localize(1810, "Extension is not allowed.")),
-                                ( localize(1811, "Allow only stable versions of the extension.")),
+                                ( localize(1811, "Extension is allowed.")),
+                                ( localize(1812, "Extension is not allowed.")),
+                                ( localize(1813, "Allow only stable versions of the extension.")),
                             ],
                         },
                         {
@@ -324,7 +324,7 @@ const VerifyExtensionSignatureConfigKey = 'extensions.verifySignature';
                                 type: 'string',
                             },
                             description: ( localize(
-                                1812,
+                                1814,
                                 "Allow or disallow specific versions of the extension. To specifcy a platform specific version, use the format `platform@1.2.3`, e.g. `win32-x64@1.2.3`. Supported platforms are `win32-x64`, `win32-arm64`, `linux-x64`, `linux-arm64`, `linux-armhf`, `alpine-x64`, `alpine-arm64`, `darwin-x64`, `darwin-arm64`"
                             )),
                         },
@@ -333,20 +333,20 @@ const VerifyExtensionSignatureConfigKey = 'extensions.verifySignature';
                 '([a-z0-9A-Z][a-z0-9-A-Z]*)$': {
                     type: ['boolean', 'string'],
                     enum: [true, false, 'stable'],
-                    description: ( localize(1813, "Allow or disallow all extensions from the publisher.")),
+                    description: ( localize(1815, "Allow or disallow all extensions from the publisher.")),
                     enumDescriptions: [
-                        ( localize(1814, "All extensions from the publisher are allowed.")),
-                        ( localize(1815, "All extensions from the publisher are not allowed.")),
-                        ( localize(1816, "Allow only stable versions of the extensions from the publisher.")),
+                        ( localize(1816, "All extensions from the publisher are allowed.")),
+                        ( localize(1817, "All extensions from the publisher are not allowed.")),
+                        ( localize(1818, "Allow only stable versions of the extensions from the publisher.")),
                     ],
                 },
                 '\\*': {
                     type: 'boolean',
                     enum: [true, false],
-                    description: ( localize(1817, "Allow or disallow all extensions.")),
+                    description: ( localize(1819, "Allow or disallow all extensions.")),
                     enumDescriptions: [
-                        ( localize(1818, "Allow all extensions.")),
-                        ( localize(1819, "Disallow all extensions."))
+                        ( localize(1820, "Allow all extensions.")),
+                        ( localize(1821, "Disallow all extensions."))
                     ],
                 }
             }

package/vscode/src/vs/platform/extensionManagement/common/extensionNls.js

@@ -28,7 +28,7 @@ function replaceNLStrings(logger, extensionManifest, messages, originalMessages)
                 const originalMessage = typeof original === 'string' ? original : original?.message;
                 if (!message) {
                     if (!originalMessage) {
-                        logger.warn(`[${extensionManifest.name}]: ${( localize(1851, "Couldn't find message for key {0}.", messageKey))}`);
+                        logger.warn(`[${extensionManifest.name}]: ${( localize(1853, "Couldn't find message for key {0}.", messageKey))}`);
                     }
                     return;
                 }