@codingame/monaco-vscode-api 16.1.1 → 17.1.0

package/vscode/src/vs/workbench/services/textfile/common/textfiles.d.ts

@@ -0,0 +1,165 @@
+import { URI } from "../../../../base/common/uri.js";
+import { Event } from "../../../../base/common/event.js";
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { ISaveOptions, IRevertOptions, SaveReason } from "../../../common/editor.js";
+import { IBaseFileStatWithMetadata, IFileStatWithMetadata, IWriteFileOptions, FileOperationError, IReadFileStreamOptions, IFileReadLimits } from "../../../../platform/files/common/files.js";
+import { ITextEditorModel } from "@codingame/monaco-vscode-model-service-override/vscode/vs/editor/common/services/resolverService";
+import { ITextBufferFactory, ITextModel, ITextSnapshot } from "../../../../editor/common/model.js";
+import { VSBuffer, VSBufferReadable } from "../../../../base/common/buffer.js";
+import { IWorkingCopy, IWorkingCopySaveEvent } from "@codingame/monaco-vscode-86d65fc6-30f9-5dca-9501-e249de688591-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { IProgress, IProgressStep } from "../../../../platform/progress/common/progress.js";
+export interface IReadTextFileEncodingOptions {
+    readonly encoding?: string;
+    readonly autoGuessEncoding?: boolean;
+    readonly candidateGuessEncodings?: string[];
+    readonly acceptTextOnly?: boolean;
+}
+export interface IReadTextFileOptions extends IReadTextFileEncodingOptions, IReadFileStreamOptions {
+}
+export interface IWriteTextFileOptions extends IWriteFileOptions {
+    readonly encoding?: string;
+    readonly writeElevated?: boolean;
+}
+export declare enum TextFileOperationResult {
+    FILE_IS_BINARY = 0
+}
+export declare class TextFileOperationError extends FileOperationError {
+    textFileOperationResult: TextFileOperationResult;
+    static isTextFileOperationError(obj: unknown): obj is TextFileOperationError;
+    readonly options?: IReadTextFileOptions & IWriteTextFileOptions;
+    constructor(message: string, textFileOperationResult: TextFileOperationResult, options?: IReadTextFileOptions & IWriteTextFileOptions);
+}
+export interface IResourceEncodings {
+    getPreferredReadEncoding(resource: URI): Promise<IResourceEncoding>;
+    getPreferredWriteEncoding(resource: URI, preferredEncoding?: string): Promise<IResourceEncoding>;
+}
+export interface IResourceEncoding {
+    readonly encoding: string;
+    readonly hasBOM: boolean;
+}
+export interface ISaveErrorHandler {
+    onSaveError(error: Error, model: ITextFileEditorModel, options: ITextFileSaveAsOptions): void;
+}
+export declare enum TextFileEditorModelState {
+    SAVED = 0,
+    DIRTY = 1,
+    PENDING_SAVE = 2,
+    CONFLICT = 3,
+    ORPHAN = 4,
+    ERROR = 5
+}
+export declare enum TextFileResolveReason {
+    EDITOR = 1,
+    REFERENCE = 2,
+    OTHER = 3
+}
+interface IBaseTextFileContent extends IBaseFileStatWithMetadata {
+    readonly encoding: string;
+}
+export interface ITextFileContent extends IBaseTextFileContent {
+    readonly value: string;
+}
+export interface ITextFileStreamContent extends IBaseTextFileContent {
+    readonly value: ITextBufferFactory;
+}
+export interface ITextFileEditorModelResolveOrCreateOptions extends ITextFileResolveOptions {
+    readonly languageId?: string;
+    readonly encoding?: string;
+    readonly reload?: {
+        readonly async: boolean;
+    };
+}
+export interface ITextFileSaveEvent extends ITextFileEditorModelSaveEvent {
+    readonly model: ITextFileEditorModel;
+}
+export interface ITextFileResolveEvent {
+    readonly model: ITextFileEditorModel;
+    readonly reason: TextFileResolveReason;
+}
+export interface ITextFileSaveParticipantContext {
+    readonly reason: SaveReason;
+    readonly savedFrom?: URI;
+}
+export interface ITextFileSaveParticipant {
+    readonly ordinal?: number;
+    participate(model: ITextFileEditorModel, context: ITextFileSaveParticipantContext, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+}
+export interface ITextFileEditorModelManager {
+    readonly onDidCreate: Event<ITextFileEditorModel>;
+    readonly onDidResolve: Event<ITextFileResolveEvent>;
+    readonly onDidChangeDirty: Event<ITextFileEditorModel>;
+    readonly onDidChangeReadonly: Event<ITextFileEditorModel>;
+    readonly onDidRemove: Event<URI>;
+    readonly onDidChangeOrphaned: Event<ITextFileEditorModel>;
+    readonly onDidChangeEncoding: Event<ITextFileEditorModel>;
+    readonly onDidSaveError: Event<ITextFileEditorModel>;
+    readonly onDidSave: Event<ITextFileSaveEvent>;
+    readonly onDidRevert: Event<ITextFileEditorModel>;
+    readonly models: ITextFileEditorModel[];
+    saveErrorHandler: ISaveErrorHandler;
+    get(resource: URI): ITextFileEditorModel | undefined;
+    resolve(resource: URI, options?: ITextFileEditorModelResolveOrCreateOptions): Promise<ITextFileEditorModel>;
+    addSaveParticipant(participant: ITextFileSaveParticipant): IDisposable;
+    runSaveParticipants(model: ITextFileEditorModel, context: ITextFileSaveParticipantContext, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+    canDispose(model: ITextFileEditorModel): true | Promise<true>;
+}
+export interface ITextFileSaveOptions extends ISaveOptions {
+    readonly writeUnlock?: boolean;
+    readonly writeElevated?: boolean;
+    readonly ignoreModifiedSince?: boolean;
+    readonly ignoreErrorHandler?: boolean;
+}
+export interface ITextFileSaveAsOptions extends ITextFileSaveOptions {
+    readonly from?: URI;
+    readonly suggestedTarget?: URI;
+}
+export interface ITextFileResolveOptions {
+    readonly contents?: ITextBufferFactory;
+    readonly forceReadFromFile?: boolean;
+    readonly allowBinary?: boolean;
+    readonly reason?: TextFileResolveReason;
+    readonly limits?: IFileReadLimits;
+}
+export declare enum EncodingMode {
+    Encode = 0,
+    Decode = 1
+}
+export interface IEncodingSupport {
+    getEncoding(): string | undefined;
+    setEncoding(encoding: string, mode: EncodingMode): Promise<void>;
+}
+export interface ILanguageSupport {
+    setLanguageId(languageId: string, source?: string): void;
+}
+export interface ITextFileEditorModelSaveEvent extends IWorkingCopySaveEvent {
+    readonly stat: IFileStatWithMetadata;
+}
+export interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, ILanguageSupport, IWorkingCopy {
+    readonly onDidSave: Event<ITextFileEditorModelSaveEvent>;
+    readonly onDidSaveError: Event<void>;
+    readonly onDidChangeOrphaned: Event<void>;
+    readonly onDidChangeReadonly: Event<void>;
+    readonly onDidChangeEncoding: Event<void>;
+    hasState(state: TextFileEditorModelState): boolean;
+    joinState(state: TextFileEditorModelState.PENDING_SAVE): Promise<void>;
+    updatePreferredEncoding(encoding: string | undefined): void;
+    save(options?: ITextFileSaveAsOptions): Promise<boolean>;
+    revert(options?: IRevertOptions): Promise<void>;
+    resolve(options?: ITextFileResolveOptions): Promise<void>;
+    isDirty(): this is IResolvedTextFileEditorModel;
+    getLanguageId(): string | undefined;
+    isResolved(): this is IResolvedTextFileEditorModel;
+}
+export declare function isTextFileEditorModel(model: ITextEditorModel): model is ITextFileEditorModel;
+export interface IResolvedTextFileEditorModel extends ITextFileEditorModel {
+    readonly textEditorModel: ITextModel;
+    createSnapshot(): ITextSnapshot;
+}
+export declare function snapshotToString(snapshot: ITextSnapshot): string;
+export declare function stringToSnapshot(value: string): ITextSnapshot;
+export declare function toBufferOrReadable(value: string): VSBuffer;
+export declare function toBufferOrReadable(value: ITextSnapshot): VSBufferReadable;
+export declare function toBufferOrReadable(value: string | ITextSnapshot): VSBuffer | VSBufferReadable;
+export declare function toBufferOrReadable(value: string | ITextSnapshot | undefined): VSBuffer | VSBufferReadable | undefined;
+export {};

package/vscode/src/vs/workbench/services/textfile/common/textfiles.js

@@ -0,0 +1,74 @@
+
+import { FileOperationError, FileOperationResult } from '../../../../platform/files/common/files.js';
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { isUndefinedOrNull, areFunctions } from '../../../../base/common/types.js';
+
+var TextFileOperationResult;
+(function (TextFileOperationResult) {
+    TextFileOperationResult[TextFileOperationResult["FILE_IS_BINARY"] = 0] = "FILE_IS_BINARY";
+})(TextFileOperationResult || (TextFileOperationResult = {}));
+class TextFileOperationError extends FileOperationError {
+    static isTextFileOperationError(obj) {
+        return obj instanceof Error && !isUndefinedOrNull(obj.textFileOperationResult);
+    }
+    constructor(message, textFileOperationResult, options) {
+        super(message, FileOperationResult.FILE_OTHER_ERROR);
+        this.textFileOperationResult = textFileOperationResult;
+        this.options = options;
+    }
+}
+var TextFileEditorModelState;
+(function (TextFileEditorModelState) {
+    TextFileEditorModelState[TextFileEditorModelState["SAVED"] = 0] = "SAVED";
+    TextFileEditorModelState[TextFileEditorModelState["DIRTY"] = 1] = "DIRTY";
+    TextFileEditorModelState[TextFileEditorModelState["PENDING_SAVE"] = 2] = "PENDING_SAVE";
+    TextFileEditorModelState[TextFileEditorModelState["CONFLICT"] = 3] = "CONFLICT";
+    TextFileEditorModelState[TextFileEditorModelState["ORPHAN"] = 4] = "ORPHAN";
+    TextFileEditorModelState[TextFileEditorModelState["ERROR"] = 5] = "ERROR";
+})(TextFileEditorModelState || (TextFileEditorModelState = {}));
+var TextFileResolveReason;
+(function (TextFileResolveReason) {
+    TextFileResolveReason[TextFileResolveReason["EDITOR"] = 1] = "EDITOR";
+    TextFileResolveReason[TextFileResolveReason["REFERENCE"] = 2] = "REFERENCE";
+    TextFileResolveReason[TextFileResolveReason["OTHER"] = 3] = "OTHER";
+})(TextFileResolveReason || (TextFileResolveReason = {}));
+var EncodingMode;
+(function (EncodingMode) {
+    EncodingMode[EncodingMode["Encode"] = 0] = "Encode";
+    EncodingMode[EncodingMode["Decode"] = 1] = "Decode";
+})(EncodingMode || (EncodingMode = {}));
+function isTextFileEditorModel(model) {
+    const candidate = model;
+    return areFunctions(candidate.setEncoding, candidate.getEncoding, candidate.save, candidate.revert, candidate.isDirty, candidate.getLanguageId);
+}
+function stringToSnapshot(value) {
+    let done = false;
+    return {
+        read() {
+            if (!done) {
+                done = true;
+                return value;
+            }
+            return null;
+        }
+    };
+}
+function toBufferOrReadable(value) {
+    if (typeof value === 'undefined') {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return VSBuffer.fromString(value);
+    }
+    return {
+        read: () => {
+            const chunk = value.read();
+            if (typeof chunk === 'string') {
+                return VSBuffer.fromString(chunk);
+            }
+            return null;
+        }
+    };
+}
+
+export { EncodingMode, TextFileEditorModelState, TextFileOperationError, TextFileOperationResult, TextFileResolveReason, isTextFileEditorModel, stringToSnapshot, toBufferOrReadable };

package/vscode/src/vs/workbench/services/textfile/common/textfiles.service.d.ts

@@ -7,7 +7,7 @@ import { IFileStatWithMetadata } from "../../../../platform/files/common/files.j
 import { IRevertOptions } from "../../../common/editor.js";
 import { IUntitledTextEditorModelManager } from "@codingame/monaco-vscode-view-common-service-override/vscode/vs/workbench/services/untitled/common/untitledTextEditorService";
 import { IFileOperationUndoRedoInfo } from "@codingame/monaco-vscode-base-service-override/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService";
-import { ITextFileEditorModelManager, IResourceEncodings, ITextFileSaveOptions, ITextFileSaveAsOptions, IReadTextFileOptions, ITextFileContent, ITextFileStreamContent, IWriteTextFileOptions, IReadTextFileEncodingOptions } from "@codingame/monaco-vscode-4893679b-56e5-52c5-a8fb-c366cce9660f-common/vscode/vs/workbench/services/textfile/common/textfiles";
+import { ITextFileEditorModelManager, IResourceEncodings, ITextFileSaveOptions, ITextFileSaveAsOptions, IReadTextFileOptions, ITextFileContent, ITextFileStreamContent, IWriteTextFileOptions, IReadTextFileEncodingOptions } from "./textfiles.js";
 export declare const ITextFileService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITextFileService>;
 export interface ITextFileService extends IDisposable {
     readonly _serviceBrand: undefined;
@@ -28,11 +28,21 @@ export interface ITextFileService extends IDisposable {
             overwrite?: boolean;
         };
     }[], undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
-    getEncoding(resource: URI): string;
     getEncodedReadable(resource: URI | undefined, value: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable>;
     getEncodedReadable(resource: URI | undefined, value: string, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable>;
     getEncodedReadable(resource: URI | undefined, value?: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable | undefined>;
     getEncodedReadable(resource: URI | undefined, value?: string, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable | undefined>;
     getEncodedReadable(resource: URI | undefined, value?: string | ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable | undefined>;
     getDecodedStream(resource: URI | undefined, value: VSBufferReadableStream, options?: IReadTextFileEncodingOptions): Promise<ReadableStream<string>>;
+    getEncoding(resource: URI): string;
+    resolveDecoding(resource: URI | undefined, options?: IReadTextFileEncodingOptions): Promise<{
+        preferredEncoding: string;
+        guessEncoding: boolean;
+        candidateGuessEncodings: string[];
+    }>;
+    resolveEncoding(resource: URI | undefined, options?: IWriteTextFileOptions): Promise<{
+        encoding: string;
+        addBOM: boolean;
+    }>;
+    validateDetectedEncoding(resource: URI | undefined, detectedEncoding: string, options?: IReadTextFileEncodingOptions): Promise<string>;
 }

package/vscode/src/vs/workbench/services/themes/common/colorExtensionPoint.js

@@ -28,30 +28,30 @@ const colorIdPattern = '^\\w+[.\\w+]*$';
 const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'colors',
     jsonSchema: {
-        description: ( localize(12493, 'Contributes extension defined themable colors')),
+        description: ( localize(12622, 'Contributes extension defined themable colors')),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 id: {
                     type: 'string',
-                    description: ( localize(12494, 'The identifier of the themable color')),
+                    description: ( localize(12623, 'The identifier of the themable color')),
                     pattern: colorIdPattern,
                     patternErrorMessage: ( localize(
-                        12495,
+                        12624,
                         'Identifiers must only contain letters, digits and dots and can not start with a dot'
                     )),
                 },
                 description: {
                     type: 'string',
-                    description: ( localize(12496, 'The description of the themable color')),
+                    description: ( localize(12625, 'The description of the themable color')),
                 },
                 defaults: {
                     type: 'object',
                     properties: {
                         light: {
                             description: ( localize(
-                                12497,
+                                12626,
                                 'The default color for light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
                             )),
                             type: 'string',
@@ -62,7 +62,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         },
                         dark: {
                             description: ( localize(
-                                12498,
+                                12627,
                                 'The default color for dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
                             )),
                             type: 'string',
@@ -73,7 +73,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         },
                         highContrast: {
                             description: ( localize(
-                                12499,
+                                12628,
                                 'The default color for high contrast dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `dark` color is used as default for high contrast dark themes.'
                             )),
                             type: 'string',
@@ -84,7 +84,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         },
                         highContrastLight: {
                             description: ( localize(
-                                12500,
+                                12629,
                                 'The default color for high contrast light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `light` color is used as default for high contrast light themes.'
                             )),
                             type: 'string',
@@ -107,7 +107,7 @@ class ColorExtensionPoint {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( localize(12501, "'configuration.colors' must be a array")));
+                    collector.error(( localize(12630, "'configuration.colors' must be a array")));
                     return;
                 }
                 const parseColorValue = (s, name) => {
@@ -120,7 +120,7 @@ class ColorExtensionPoint {
                         }
                     }
                     collector.error(( localize(
-                        12502,
+                        12631,
                         "{0} must be either a color value in hex (#RRGGBB[AA] or #RGB[A]) or the identifier of a themable color which provides the default.",
                         name
                     )));
@@ -128,19 +128,19 @@ class ColorExtensionPoint {
                 };
                 for (const colorContribution of extensionValue) {
                     if (typeof colorContribution.id !== 'string' || colorContribution.id.length === 0) {
-                        collector.error(( localize(12503, "'configuration.colors.id' must be defined and can not be empty")));
+                        collector.error(( localize(12632, "'configuration.colors.id' must be defined and can not be empty")));
                         return;
                     }
                     if (!colorContribution.id.match(colorIdPattern)) {
                         collector.error(( localize(
-                            12504,
+                            12633,
                             "'configuration.colors.id' must only contain letters, digits and dots and can not start with a dot"
                         )));
                         return;
                     }
                     if (typeof colorContribution.description !== 'string' || colorContribution.id.length === 0) {
                         collector.error(( localize(
-                            12505,
+                            12634,
                             "'configuration.colors.description' must be defined and can not be empty"
                         )));
                         return;
@@ -148,21 +148,21 @@ class ColorExtensionPoint {
                     const defaults = colorContribution.defaults;
                     if (!defaults || typeof defaults !== 'object' || typeof defaults.light !== 'string' || typeof defaults.dark !== 'string') {
                         collector.error(( localize(
-                            12506,
+                            12635,
                             "'configuration.colors.defaults' must be defined and must contain 'light' and 'dark'"
                         )));
                         return;
                     }
                     if (defaults.highContrast && typeof defaults.highContrast !== 'string') {
                         collector.error(( localize(
-                            12507,
+                            12636,
                             "If defined, 'configuration.colors.defaults.highContrast' must be a string."
                         )));
                         return;
                     }
                     if (defaults.highContrastLight && typeof defaults.highContrastLight !== 'string') {
                         collector.error(( localize(
-                            12508,
+                            12637,
                             "If defined, 'configuration.colors.defaults.highContrastLight' must be a string."
                         )));
                         return;
@@ -198,11 +198,11 @@ class ColorDataRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localize(12509, "ID")),
-            ( localize(12510, "Description")),
-            ( localize(12511, "Dark Default")),
-            ( localize(12512, "Light Default")),
-            ( localize(12513, "High Contrast Default")),
+            ( localize(12638, "ID")),
+            ( localize(12639, "Description")),
+            ( localize(12640, "Dark Default")),
+            ( localize(12641, "Light Default")),
+            ( localize(12642, "High Contrast Default")),
         ];
         const toColor = (colorReference) => colorReference[0] === '#' ? ( Color.fromHex(colorReference)) : undefined;
         const rows = ( colors.sort((a, b) => a.id.localeCompare(b.id))
@@ -226,7 +226,7 @@ class ColorDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions$1.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: 'colors',
-    label: ( localize(12514, "Colors")),
+    label: ( localize(12643, "Colors")),
     access: {
         canToggle: false
     },

package/vscode/src/vs/workbench/services/themes/common/iconExtensionPoint.js

@@ -16,13 +16,13 @@ const iconIdPattern = `^${ThemeIcon.iconNameSegment}(-${ThemeIcon.iconNameSegmen
 const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'icons',
     jsonSchema: {
-        description: ( localize(12573, 'Contributes extension defined themable icons')),
+        description: ( localize(12702, 'Contributes extension defined themable icons')),
         type: 'object',
         propertyNames: {
             pattern: iconIdPattern,
-            description: ( localize(12574, 'The identifier of the themable icon')),
+            description: ( localize(12703, 'The identifier of the themable icon')),
             patternErrorMessage: ( localize(
-                12575,
+                12704,
                 'Identifiers can only contain letters, digits and minuses and need to consist of at least two segments in the form `component-iconname`.'
             )),
         },
@@ -31,7 +31,7 @@ const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
             properties: {
                 description: {
                     type: 'string',
-                    description: ( localize(12576, 'The description of the themable icon')),
+                    description: ( localize(12705, 'The description of the themable icon')),
                 },
                 default: {
                     anyOf: [
@@ -40,11 +40,11 @@ const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                             type: 'object',
                             properties: {
                                 fontPath: {
-                                    description: ( localize(12577, 'The path of the icon font that defines the icon.')),
+                                    description: ( localize(12706, 'The path of the icon font that defines the icon.')),
                                     type: 'string'
                                 },
                                 fontCharacter: {
-                                    description: ( localize(12578, 'The character for the icon in the icon font.')),
+                                    description: ( localize(12707, 'The character for the icon in the icon font.')),
                                     type: 'string'
                                 }
                             },
@@ -53,7 +53,7 @@ const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         }
                     ],
                     description: ( localize(
-                        12579,
+                        12708,
                         'The default of the icon. Either a reference to an existing ThemeIcon or an icon in an icon font.'
                     )),
                 }
@@ -72,7 +72,7 @@ class IconExtensionPoint {
                 const collector = extension.collector;
                 if (!extensionValue || typeof extensionValue !== 'object') {
                     collector.error(( localize(
-                        12580,
+                        12709,
                         "'configuration.icons' must be an object with the icon names as properties."
                     )));
                     return;
@@ -80,7 +80,7 @@ class IconExtensionPoint {
                 for (const id in extensionValue) {
                     if (!id.match(iconIdPattern)) {
                         collector.error(( localize(
-                            12581,
+                            12710,
                             "'configuration.icons' keys represent the icon id and can only contain letter, digits and minuses. They need to consist of at least two segments in the form `component-iconname`."
                         )));
                         return;
@@ -88,7 +88,7 @@ class IconExtensionPoint {
                     const iconContribution = extensionValue[id];
                     if (typeof iconContribution.description !== 'string' || iconContribution.description.length === 0) {
                         collector.error(( localize(
-                            12582,
+                            12711,
                             "'configuration.icons.description' must be defined and can not be empty"
                         )));
                         return;
@@ -102,7 +102,7 @@ class IconExtensionPoint {
                         const format = formatMap[fileExt];
                         if (!format) {
                             collector.warn(( localize(
-                                12583,
+                                12712,
                                 "Expected `contributes.icons.default.fontPath` to have file extension 'woff', woff2' or 'ttf', is '{0}'.",
                                 fileExt
                             )));
@@ -114,7 +114,7 @@ class IconExtensionPoint {
                         const definition = iconRegistry.registerIconFont(fontId, { src: [{ location: iconFontLocation, format }] });
                         if (!isEqualOrParent(iconFontLocation, extensionLocation)) {
                             collector.warn(( localize(
-                                12584,
+                                12713,
                                 "Expected `contributes.icons.default.fontPath` ({0}) to be included inside extension's folder ({0}).",
                                 iconFontLocation.path,
                                 extensionLocation.path
@@ -131,7 +131,7 @@ class IconExtensionPoint {
                     }
                     else {
                         collector.error(( localize(
-                            12585,
+                            12714,
                             "'configuration.icons.default' must be either a reference to the id of an other theme icon (string) or a icon definition (object) with properties `fontPath` and `fontCharacter`."
                         )));
                     }

package/vscode/src/vs/workbench/services/userDataSync/common/userDataSync.js

@@ -8,15 +8,15 @@ import { Categories } from '../../../../platform/action/common/actionCommonCateg
 
 function getSyncAreaLabel(source) {
     switch (source) {
-        case SyncResource.Settings: return localize(12756, "Settings");
-        case SyncResource.Keybindings: return localize(12757, "Keyboard Shortcuts");
-        case SyncResource.Snippets: return localize(12758, "Snippets");
-        case SyncResource.Prompts: return localize(12759, "Prompts");
-        case SyncResource.Tasks: return localize(12760, "Tasks");
-        case SyncResource.Extensions: return localize(12761, "Extensions");
-        case SyncResource.GlobalState: return localize(12762, "UI State");
-        case SyncResource.Profiles: return localize(12763, "Profiles");
-        case SyncResource.WorkspaceState: return localize(12764, "Workspace State");
+        case SyncResource.Settings: return localize(12885, "Settings");
+        case SyncResource.Keybindings: return localize(12886, "Keyboard Shortcuts");
+        case SyncResource.Snippets: return localize(12887, "Snippets");
+        case SyncResource.Prompts: return localize(12888, "Prompts and Instructions");
+        case SyncResource.Tasks: return localize(12889, "Tasks");
+        case SyncResource.Extensions: return localize(12890, "Extensions");
+        case SyncResource.GlobalState: return localize(12891, "UI State");
+        case SyncResource.Profiles: return localize(12892, "Profiles");
+        case SyncResource.WorkspaceState: return localize(12893, "Workspace State");
     }
 }
 var AccountStatus;
@@ -25,8 +25,8 @@ var AccountStatus;
     AccountStatus["Unavailable"] = "unavailable";
     AccountStatus["Available"] = "available";
 })(AccountStatus || (AccountStatus = {}));
-const SYNC_TITLE = ( localize2(12765, "Settings Sync"));
-const SYNC_VIEW_ICON = registerIcon('settings-sync-view-icon', Codicon.sync, ( localize(12766, 'View icon of the Settings Sync view.')));
+const SYNC_TITLE = ( localize2(12894, "Settings Sync"));
+const SYNC_VIEW_ICON = registerIcon('settings-sync-view-icon', Codicon.sync, ( localize(12895, 'View icon of the Settings Sync view.')));
 const CONTEXT_SYNC_STATE = ( new RawContextKey('syncStatus', SyncStatus.Uninitialized));
 const CONTEXT_SYNC_ENABLEMENT = ( new RawContextKey('syncEnabled', false));
 const CONTEXT_ACCOUNT_STATE = ( new RawContextKey('userDataSyncAccountStatus', AccountStatus.Uninitialized));
@@ -39,7 +39,7 @@ const SYNC_VIEW_CONTAINER_ID = 'workbench.view.sync';
 const SYNC_CONFLICTS_VIEW_ID = 'workbench.views.sync.conflicts';
 const DOWNLOAD_ACTIVITY_ACTION_DESCRIPTOR = {
     id: 'workbench.userDataSync.actions.downloadSyncActivity',
-    title: ( localize2(12767, "Download Settings Sync Activity")),
+    title: ( localize2(12896, "Download Settings Sync Activity")),
     category: Categories.Developer,
     f1: true,
     precondition: ( ContextKeyExpr.and(( CONTEXT_ACCOUNT_STATE.isEqualTo(AccountStatus.Available)), ( CONTEXT_SYNC_STATE.notEqualsTo(SyncStatus.Uninitialized))))

package/vscode/src/vs/workbench/services/workspaces/common/workspaceEditing.service.d.ts

@@ -1,6 +1,6 @@
 import { URI } from "../../../../base/common/uri.js";
 import { IWorkspaceIdentifier } from "../../../../platform/workspace/common/workspace.js";
-import { IWorkspaceFolderCreationData } from "@codingame/monaco-vscode-7559b0be-bfa5-5fe6-b731-1973fe9fffa1-common/vscode/vs/platform/workspaces/common/workspaces";
+import { IWorkspaceFolderCreationData } from "@codingame/monaco-vscode-2cbab29e-9393-5de6-b701-9a9555360b6b-common/vscode/vs/platform/workspaces/common/workspaces";
 export declare const IWorkspaceEditingService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkspaceEditingService>;
 export interface IWorkspaceEditingService {
     readonly _serviceBrand: undefined;