@codingame/monaco-vscode-api 1.83.8 → 1.83.9

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

@@ -1,3 +1,7 @@
+import { joinPath, isEqualOrParent } from 'monaco-editor/esm/vs/base/common/resources.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { valid } from 'vscode-semver';
 const VERSION_REGEXP = /^(\^|>=)?((\d+)|x)\.((\d+)|x)\.((\d+)|x)(\-.*)?$/;
 const NOT_BEFORE_REGEXP = /^-(\d{4})(\d{2})(\d{2})$/;
 function isValidVersionStr(version) {
@@ -76,4 +80,305 @@ function normalizeVersion(version) {
         notBefore,
     };
 }
-export { isValidVersionStr, normalizeVersion, parseVersion };
+function isValidVersion(_inputVersion, _inputDate, _desiredVersion) {
+    let version;
+    if (typeof _inputVersion === 'string') {
+        version = normalizeVersion(parseVersion(_inputVersion));
+    }
+    else {
+        version = _inputVersion;
+    }
+    let productTs;
+    if (_inputDate instanceof Date) {
+        productTs = _inputDate.getTime();
+    }
+    else if (typeof _inputDate === 'string') {
+        productTs = ( new Date(_inputDate)).getTime();
+    }
+    let desiredVersion;
+    if (typeof _desiredVersion === 'string') {
+        desiredVersion = normalizeVersion(parseVersion(_desiredVersion));
+    }
+    else {
+        desiredVersion = _desiredVersion;
+    }
+    if (!version || !desiredVersion) {
+        return false;
+    }
+    const majorBase = version.majorBase;
+    const minorBase = version.minorBase;
+    const patchBase = version.patchBase;
+    let desiredMajorBase = desiredVersion.majorBase;
+    let desiredMinorBase = desiredVersion.minorBase;
+    let desiredPatchBase = desiredVersion.patchBase;
+    const desiredNotBefore = desiredVersion.notBefore;
+    let majorMustEqual = desiredVersion.majorMustEqual;
+    let minorMustEqual = desiredVersion.minorMustEqual;
+    let patchMustEqual = desiredVersion.patchMustEqual;
+    if (desiredVersion.isMinimum) {
+        if (majorBase > desiredMajorBase) {
+            return true;
+        }
+        if (majorBase < desiredMajorBase) {
+            return false;
+        }
+        if (minorBase > desiredMinorBase) {
+            return true;
+        }
+        if (minorBase < desiredMinorBase) {
+            return false;
+        }
+        if (productTs && productTs < desiredNotBefore) {
+            return false;
+        }
+        return patchBase >= desiredPatchBase;
+    }
+    if (majorBase === 1 && desiredMajorBase === 0 && (!majorMustEqual || !minorMustEqual || !patchMustEqual)) {
+        desiredMajorBase = 1;
+        desiredMinorBase = 0;
+        desiredPatchBase = 0;
+        majorMustEqual = true;
+        minorMustEqual = false;
+        patchMustEqual = false;
+    }
+    if (majorBase < desiredMajorBase) {
+        return false;
+    }
+    if (majorBase > desiredMajorBase) {
+        return (!majorMustEqual);
+    }
+    if (minorBase < desiredMinorBase) {
+        return false;
+    }
+    if (minorBase > desiredMinorBase) {
+        return (!minorMustEqual);
+    }
+    if (patchBase < desiredPatchBase) {
+        return false;
+    }
+    if (patchBase > desiredPatchBase) {
+        return (!patchMustEqual);
+    }
+    if (productTs && productTs < desiredNotBefore) {
+        return false;
+    }
+    return true;
+}
+function validateExtensionManifest(productVersion, productDate, extensionLocation, extensionManifest, extensionIsBuiltin) {
+    const validations = [];
+    if (typeof extensionManifest.publisher !== 'undefined' && typeof extensionManifest.publisher !== 'string') {
+        validations.push([Severity.Error, ( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'extensionDescription.publisher',
+            "property publisher must be of type `string`."
+        ))]);
+        return validations;
+    }
+    if (typeof extensionManifest.name !== 'string') {
+        validations.push([Severity.Error, ( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'extensionDescription.name',
+            "property `{0}` is mandatory and must be of type `string`",
+            'name'
+        ))]);
+        return validations;
+    }
+    if (typeof extensionManifest.version !== 'string') {
+        validations.push([Severity.Error, ( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'extensionDescription.version',
+            "property `{0}` is mandatory and must be of type `string`",
+            'version'
+        ))]);
+        return validations;
+    }
+    if (!extensionManifest.engines) {
+        validations.push([Severity.Error, ( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'extensionDescription.engines',
+            "property `{0}` is mandatory and must be of type `object`",
+            'engines'
+        ))]);
+        return validations;
+    }
+    if (typeof extensionManifest.engines.vscode !== 'string') {
+        validations.push([Severity.Error, ( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'extensionDescription.engines.vscode',
+            "property `{0}` is mandatory and must be of type `string`",
+            'engines.vscode'
+        ))]);
+        return validations;
+    }
+    if (typeof extensionManifest.extensionDependencies !== 'undefined') {
+        if (!isStringArray(extensionManifest.extensionDependencies)) {
+            validations.push([Severity.Error, ( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'extensionDescription.extensionDependencies',
+                "property `{0}` can be omitted or must be of type `string[]`",
+                'extensionDependencies'
+            ))]);
+            return validations;
+        }
+    }
+    if (typeof extensionManifest.activationEvents !== 'undefined') {
+        if (!isStringArray(extensionManifest.activationEvents)) {
+            validations.push([Severity.Error, ( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'extensionDescription.activationEvents1',
+                "property `{0}` can be omitted or must be of type `string[]`",
+                'activationEvents'
+            ))]);
+            return validations;
+        }
+        if (typeof extensionManifest.main === 'undefined' && typeof extensionManifest.browser === 'undefined') {
+            validations.push([Severity.Error, ( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'extensionDescription.activationEvents2',
+                "property `{0}` should be omitted if the extension doesn't have a `{1}` or `{2}` property.",
+                'activationEvents',
+                'main',
+                'browser'
+            ))]);
+            return validations;
+        }
+    }
+    if (typeof extensionManifest.extensionKind !== 'undefined') {
+        if (typeof extensionManifest.main === 'undefined') {
+            validations.push([Severity.Warning, ( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'extensionDescription.extensionKind',
+                "property `{0}` can be defined only if property `main` is also defined.",
+                'extensionKind'
+            ))]);
+        }
+    }
+    if (typeof extensionManifest.main !== 'undefined') {
+        if (typeof extensionManifest.main !== 'string') {
+            validations.push([Severity.Error, ( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'extensionDescription.main1',
+                "property `{0}` can be omitted or must be of type `string`",
+                'main'
+            ))]);
+            return validations;
+        }
+        else {
+            const mainLocation = joinPath(extensionLocation, extensionManifest.main);
+            if (!isEqualOrParent(mainLocation, extensionLocation)) {
+                validations.push([Severity.Warning, ( nls.localizeWithPath(
+                    'vs/platform/extensions/common/extensionValidator',
+                    'extensionDescription.main2',
+                    "Expected `main` ({0}) to be included inside extension's folder ({1}). This might make the extension non-portable.",
+                    mainLocation.path,
+                    extensionLocation.path
+                ))]);
+            }
+        }
+    }
+    if (typeof extensionManifest.browser !== 'undefined') {
+        if (typeof extensionManifest.browser !== 'string') {
+            validations.push([Severity.Error, ( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'extensionDescription.browser1',
+                "property `{0}` can be omitted or must be of type `string`",
+                'browser'
+            ))]);
+            return validations;
+        }
+        else {
+            const browserLocation = joinPath(extensionLocation, extensionManifest.browser);
+            if (!isEqualOrParent(browserLocation, extensionLocation)) {
+                validations.push([Severity.Warning, ( nls.localizeWithPath(
+                    'vs/platform/extensions/common/extensionValidator',
+                    'extensionDescription.browser2',
+                    "Expected `browser` ({0}) to be included inside extension's folder ({1}). This might make the extension non-portable.",
+                    browserLocation.path,
+                    extensionLocation.path
+                ))]);
+            }
+        }
+    }
+    if (!valid(extensionManifest.version)) {
+        validations.push([Severity.Error, ( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'notSemver',
+            "Extension version is not semver compatible."
+        ))]);
+        return validations;
+    }
+    const notices = [];
+    const isValid = isValidExtensionVersion(productVersion, productDate, extensionManifest, extensionIsBuiltin, notices);
+    if (!isValid) {
+        for (const notice of notices) {
+            validations.push([Severity.Error, notice]);
+        }
+    }
+    return validations;
+}
+function isValidExtensionVersion(productVersion, productDate, extensionManifest, extensionIsBuiltin, notices) {
+    if (extensionIsBuiltin || (typeof extensionManifest.main === 'undefined' && typeof extensionManifest.browser === 'undefined')) {
+        return true;
+    }
+    return isVersionValid(productVersion, productDate, extensionManifest.engines.vscode, notices);
+}
+function isEngineValid(engine, version, date) {
+    return engine === '*' || isVersionValid(version, date, engine);
+}
+function isVersionValid(currentVersion, date, requestedVersion, notices = []) {
+    const desiredVersion = normalizeVersion(parseVersion(requestedVersion));
+    if (!desiredVersion) {
+        notices.push(( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'versionSyntax',
+            "Could not parse `engines.vscode` value {0}. Please use, for example: ^1.22.0, ^1.22.x, etc.",
+            requestedVersion
+        )));
+        return false;
+    }
+    if (desiredVersion.majorBase === 0) {
+        if (!desiredVersion.majorMustEqual || !desiredVersion.minorMustEqual) {
+            notices.push(( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'versionSpecificity1',
+                "Version specified in `engines.vscode` ({0}) is not specific enough. For vscode versions before 1.0.0, please define at a minimum the major and minor desired version. E.g. ^0.10.0, 0.10.x, 0.11.0, etc.",
+                requestedVersion
+            )));
+            return false;
+        }
+    }
+    else {
+        if (!desiredVersion.majorMustEqual) {
+            notices.push(( nls.localizeWithPath(
+                'vs/platform/extensions/common/extensionValidator',
+                'versionSpecificity2',
+                "Version specified in `engines.vscode` ({0}) is not specific enough. For vscode versions after 1.0.0, please define at a minimum the major desired version. E.g. ^1.10.0, 1.10.x, 1.x.x, 2.x.x, etc.",
+                requestedVersion
+            )));
+            return false;
+        }
+    }
+    if (!isValidVersion(currentVersion, date, desiredVersion)) {
+        notices.push(( nls.localizeWithPath(
+            'vs/platform/extensions/common/extensionValidator',
+            'versionMismatch',
+            "Extension is not compatible with Code {0}. Extension requires: {1}.",
+            currentVersion,
+            requestedVersion
+        )));
+        return false;
+    }
+    return true;
+}
+function isStringArray(arr) {
+    if (!Array.isArray(arr)) {
+        return false;
+    }
+    for (let i = 0, len = arr.length; i < len; i++) {
+        if (typeof arr[i] !== 'string') {
+            return false;
+        }
+    }
+    return true;
+}
+export { isEngineValid, isValidExtensionVersion, isValidVersion, isValidVersionStr, normalizeVersion, parseVersion, validateExtensionManifest };

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

@@ -1,6 +1,6 @@
 import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
 import { Event } from '../../../base/common/event.js';
-import { IDisposable } from '../../../base/common/lifecycle.js';
+import { IDisposable, Disposable } from '../../../base/common/lifecycle.js';
 import { URI } from '../../../base/common/uri.js';
 
 declare enum LogLevel {
@@ -147,5 +147,30 @@ interface ILoggerService {
      */
     getRegisteredLogger(resource: URI): ILoggerResource | undefined;
 }
+declare abstract class AbstractLogger extends Disposable implements ILogger {
+    private level;
+    private readonly _onDidChangeLogLevel;
+    readonly onDidChangeLogLevel: Event<LogLevel>;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    protected checkLogLevel(level: LogLevel): boolean;
+    abstract trace(message: string, ...args: any[]): void;
+    abstract debug(message: string, ...args: any[]): void;
+    abstract info(message: string, ...args: any[]): void;
+    abstract warn(message: string, ...args: any[]): void;
+    abstract error(message: string | Error, ...args: any[]): void;
+    abstract flush(): void;
+}
+declare class ConsoleLogger extends AbstractLogger implements ILogger {
+    private readonly useColors;
+    constructor(logLevel?: LogLevel, useColors?: boolean);
+    trace(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string | Error, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    dispose(): void;
+    flush(): void;
+}
 
-export { type DidChangeLoggersEvent, ILogService, type ILogger, type ILoggerOptions, type ILoggerResource, ILoggerService, LogLevel };
+export { AbstractLogger, ConsoleLogger, type DidChangeLoggersEvent, ILogService, type ILogger, type ILoggerOptions, type ILoggerResource, ILoggerService, LogLevel };

package/vscode/src/vs/platform/remote/common/remoteAgentConnection.d.ts

@@ -1,5 +1,13 @@
 import { CancelablePromise } from '../../../base/common/async.js';
+import { RemoteConnection } from './remoteAuthorityResolver.js';
 
+interface IAddress<T extends RemoteConnection = RemoteConnection> {
+    connectTo: T;
+    connectionToken: string | undefined;
+}
+interface IAddressProvider<T extends RemoteConnection = RemoteConnection> {
+    getAddress(): Promise<IAddress<T>>;
+}
 declare const enum PersistentConnectionEventType {
     ConnectionLost = 0,
     ReconnectionWait = 1,
@@ -46,4 +54,4 @@ declare class ReconnectionPermanentFailureEvent {
 }
 type PersistentConnectionEvent = ConnectionGainEvent | ConnectionLostEvent | ReconnectionWaitEvent | ReconnectionRunningEvent | ReconnectionPermanentFailureEvent;
 
-export { ConnectionGainEvent, ConnectionLostEvent, type PersistentConnectionEvent, PersistentConnectionEventType, ReconnectionPermanentFailureEvent, ReconnectionRunningEvent, ReconnectionWaitEvent };
+export { ConnectionGainEvent, ConnectionLostEvent, type IAddress, type IAddressProvider, type PersistentConnectionEvent, PersistentConnectionEventType, ReconnectionPermanentFailureEvent, ReconnectionRunningEvent, ReconnectionWaitEvent };

package/vscode/src/vs/platform/remote/common/remoteExtensionsScanner.js

@@ -1,3 +1,4 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const IRemoteExtensionsScannerService = ( createDecorator('IRemoteExtensionsScannerService'));
-export { IRemoteExtensionsScannerService };
+const RemoteExtensionsScannerChannelName = 'remoteExtensionsScanner';
+export { IRemoteExtensionsScannerService, RemoteExtensionsScannerChannelName };

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

@@ -1,3 +1,4 @@
+import { streamToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
@@ -47,4 +48,40 @@ class AbstractRequestService extends Disposable {
         }
     }
 }
-export { AbstractRequestService, IRequestService };
+function isSuccess(context) {
+    return (context.res.statusCode && context.res.statusCode >= 200 && context.res.statusCode < 300) || context.res.statusCode === 1223;
+}
+function hasNoContent(context) {
+    return context.res.statusCode === 204;
+}
+async function asText(context) {
+    if (hasNoContent(context)) {
+        return null;
+    }
+    const buffer = await streamToBuffer(context.stream);
+    return ( buffer.toString());
+}
+async function asTextOrError(context) {
+    if (!isSuccess(context)) {
+        throw new Error('Server returned ' + context.res.statusCode);
+    }
+    return asText(context);
+}
+async function asJson(context) {
+    if (!isSuccess(context)) {
+        throw new Error('Server returned ' + context.res.statusCode);
+    }
+    if (hasNoContent(context)) {
+        return null;
+    }
+    const buffer = await streamToBuffer(context.stream);
+    const str = ( buffer.toString());
+    try {
+        return JSON.parse(str);
+    }
+    catch (err) {
+        err.message += ':\n' + str;
+        throw err;
+    }
+}
+export { AbstractRequestService, IRequestService, asJson, asText, asTextOrError, hasNoContent, isSuccess };

package/vscode/src/vs/platform/telemetry/common/telemetryUtils.js

@@ -13,6 +13,7 @@ class NullEndpointTelemetryService {
     async publicLogError(_endpoint, _errorEventName, _data) {
     }
 }
+const telemetryLogId = 'telemetry';
 const extensionTelemetryLogChannelId = 'extensionTelemetryLog';
 function supportsTelemetry(productService, environmentService) {
     if (!environmentService.isBuilt && !environmentService.disableTelemetry) {
@@ -132,4 +133,4 @@ function cleanData(data, cleanUpPatterns) {
         return undefined;
     });
 }
-export { NullEndpointTelemetryService, TelemetryTrustedValue, cleanData, cleanRemoteAuthority, extensionTelemetryLogChannelId, getTelemetryLevel, isLoggingOnly, supportsTelemetry };
+export { NullEndpointTelemetryService, TelemetryTrustedValue, cleanData, cleanRemoteAuthority, extensionTelemetryLogChannelId, getTelemetryLevel, isLoggingOnly, supportsTelemetry, telemetryLogId };

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

@@ -1,5 +1,20 @@
+import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Event } from '../../../base/common/event.js';
+import { IDisposable } from '../../../base/common/lifecycle.js';
+import { URI } from '../../../base/common/uri.js';
+import { IAddressProvider } from '../../remote/common/remoteAgentConnection.js';
 import { TunnelPrivacy } from '../../remote/common/remoteAuthorityResolver.js';
 
+interface RemoteTunnel {
+    readonly tunnelRemotePort: number;
+    readonly tunnelRemoteHost: string;
+    readonly tunnelLocalPort?: number;
+    readonly localAddress: string;
+    readonly privacy: string;
+    readonly protocol?: string;
+    dispose(silent?: boolean): Promise<void>;
+}
 interface TunnelOptions {
     remoteAddress: {
         port: number;
@@ -11,6 +26,10 @@ interface TunnelOptions {
     privacy?: string;
     protocol?: string;
 }
+declare enum TunnelProtocol {
+    Http = "http",
+    Https = "https"
+}
 declare enum TunnelPrivacyId {
     ConstantPrivate = "constantPrivate",// private, and changing is unsupported
     Private = "private",
@@ -27,6 +46,9 @@ interface TunnelProviderFeatures {
     public?: boolean;
     privacyOptions: TunnelPrivacy[];
 }
+interface ITunnelProvider {
+    forwardPort(tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions): Promise<RemoteTunnel | string | undefined> | undefined;
+}
 declare enum ProvidedOnAutoForward {
     Notify = 1,
     OpenBrowser = 2,
@@ -39,5 +61,32 @@ interface ProvidedPortAttributes {
     port: number;
     autoForwardAction: ProvidedOnAutoForward;
 }
+interface PortAttributesProvider {
+    providePortAttributes(ports: number[], pid: number | undefined, commandLine: string | undefined, token: CancellationToken): Promise<ProvidedPortAttributes[]>;
+}
+
+declare const ITunnelService: ServiceIdentifier<ITunnelService>;
+interface ITunnelService {
+    readonly _serviceBrand: undefined;
+    readonly tunnels: Promise<readonly RemoteTunnel[]>;
+    readonly canChangePrivacy: boolean;
+    readonly privacyOptions: TunnelPrivacy[];
+    readonly onTunnelOpened: Event<RemoteTunnel>;
+    readonly onTunnelClosed: Event<{
+        host: string;
+        port: number;
+    }>;
+    readonly canElevate: boolean;
+    readonly hasTunnelProvider: boolean;
+    readonly onAddedTunnelProvider: Event<void>;
+    canTunnel(uri: URI): boolean;
+    openTunnel(addressProvider: IAddressProvider | undefined, remoteHost: string | undefined, remotePort: number, localHost?: string, localPort?: number, elevateIfNeeded?: boolean, privacy?: string, protocol?: string): Promise<RemoteTunnel | string | undefined> | undefined;
+    getExistingTunnel(remoteHost: string, remotePort: number): Promise<RemoteTunnel | string | undefined>;
+    setEnvironmentTunnel(remoteHost: string, remotePort: number, localAddress: string, privacy: string, protocol: string): void;
+    closeTunnel(remoteHost: string, remotePort: number): Promise<void>;
+    setTunnelProvider(provider: ITunnelProvider | undefined): IDisposable;
+    setTunnelFeatures(features: TunnelProviderFeatures): void;
+    isPortPrivileged(port: number): boolean;
+}
 
-export { ProvidedOnAutoForward, type ProvidedPortAttributes, type TunnelCreationOptions, type TunnelOptions, TunnelPrivacyId, type TunnelProviderFeatures };
+export { type ITunnelProvider, ITunnelService, type PortAttributesProvider, ProvidedOnAutoForward, type ProvidedPortAttributes, type RemoteTunnel, type TunnelCreationOptions, type TunnelOptions, TunnelPrivacyId, TunnelProtocol, type TunnelProviderFeatures };

package/vscode/src/vs/platform/userDataProfile/common/userDataProfileIpc.js

@@ -0,0 +1,63 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { reviveProfile } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+class UserDataProfilesService extends Disposable {
+    get defaultProfile() { return this.profiles[0]; }
+    get profiles() { return this._profiles; }
+    constructor(profiles, profilesHome, channel) {
+        super();
+        this.profilesHome = profilesHome;
+        this.channel = channel;
+        this._profiles = [];
+        this._onDidChangeProfiles = this._register(( new Emitter()));
+        this.onDidChangeProfiles = this._onDidChangeProfiles.event;
+        this.enabled = true;
+        this._profiles = ( profiles.map(profile => reviveProfile(profile, this.profilesHome.scheme)));
+        this._register(this.channel.listen('onDidChangeProfiles')(e => {
+            const added = ( e.added.map(profile => reviveProfile(profile, this.profilesHome.scheme)));
+            const removed = ( e.removed.map(profile => reviveProfile(profile, this.profilesHome.scheme)));
+            const updated = ( e.updated.map(profile => reviveProfile(profile, this.profilesHome.scheme)));
+            this._profiles = ( e.all.map(profile => reviveProfile(profile, this.profilesHome.scheme)));
+            this._onDidChangeProfiles.fire({ added, removed, updated, all: this.profiles });
+        }));
+        this.onDidResetWorkspaces = this.channel.listen('onDidResetWorkspaces');
+    }
+    setEnablement(enabled) {
+        this.enabled = enabled;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    async createNamedProfile(name, options, workspaceIdentifier) {
+        const result = await this.channel.call('createNamedProfile', [name, options, workspaceIdentifier]);
+        return reviveProfile(result, this.profilesHome.scheme);
+    }
+    async createProfile(id, name, options, workspaceIdentifier) {
+        const result = await this.channel.call('createProfile', [id, name, options, workspaceIdentifier]);
+        return reviveProfile(result, this.profilesHome.scheme);
+    }
+    async createTransientProfile(workspaceIdentifier) {
+        const result = await this.channel.call('createTransientProfile', [workspaceIdentifier]);
+        return reviveProfile(result, this.profilesHome.scheme);
+    }
+    async setProfileForWorkspace(workspaceIdentifier, profile) {
+        await this.channel.call('setProfileForWorkspace', [workspaceIdentifier, profile]);
+    }
+    removeProfile(profile) {
+        return this.channel.call('removeProfile', [profile]);
+    }
+    async updateProfile(profile, updateOptions) {
+        const result = await this.channel.call('updateProfile', [profile, updateOptions]);
+        return reviveProfile(result, this.profilesHome.scheme);
+    }
+    resetWorkspaces() {
+        return this.channel.call('resetWorkspaces');
+    }
+    cleanUp() {
+        return this.channel.call('cleanUp');
+    }
+    cleanUpTransientProfiles() {
+        return this.channel.call('cleanUpTransientProfiles');
+    }
+}
+export { UserDataProfilesService };

package/vscode/src/vs/platform/userDataSync/common/ignoredExtensions.js

@@ -0,0 +1,65 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IIgnoredExtensionsManagementService = ( createDecorator('IIgnoredExtensionsManagementService'));
+let IgnoredExtensionsManagementService = class IgnoredExtensionsManagementService {
+    constructor(configurationService) {
+        this.configurationService = configurationService;
+    }
+    hasToNeverSyncExtension(extensionId) {
+        const configuredIgnoredExtensions = this.getConfiguredIgnoredExtensions();
+        return configuredIgnoredExtensions.includes(extensionId.toLowerCase());
+    }
+    hasToAlwaysSyncExtension(extensionId) {
+        const configuredIgnoredExtensions = this.getConfiguredIgnoredExtensions();
+        return configuredIgnoredExtensions.includes(`-${extensionId.toLowerCase()}`);
+    }
+    updateIgnoredExtensions(ignoredExtensionId, ignore) {
+        let currentValue = ( [...this.configurationService.getValue('settingsSync.ignoredExtensions')].map(id => id.toLowerCase()));
+        currentValue = currentValue.filter(v => v !== ignoredExtensionId && v !== `-${ignoredExtensionId}`);
+        if (ignore) {
+            currentValue.push(ignoredExtensionId.toLowerCase());
+        }
+        return this.configurationService.updateValue('settingsSync.ignoredExtensions', currentValue.length ? currentValue : undefined, 2 );
+    }
+    updateSynchronizedExtensions(extensionId, sync) {
+        let currentValue = ( [...this.configurationService.getValue('settingsSync.ignoredExtensions')].map(id => id.toLowerCase()));
+        currentValue = currentValue.filter(v => v !== extensionId && v !== `-${extensionId}`);
+        if (sync) {
+            currentValue.push(`-${extensionId.toLowerCase()}`);
+        }
+        return this.configurationService.updateValue('settingsSync.ignoredExtensions', currentValue.length ? currentValue : undefined, 2 );
+    }
+    getIgnoredExtensions(installed) {
+        const defaultIgnoredExtensions = ( installed.filter(i => i.isMachineScoped).map(i => i.identifier.id.toLowerCase()));
+        const value = ( this.getConfiguredIgnoredExtensions().map(id => id.toLowerCase()));
+        const added = [], removed = [];
+        if (Array.isArray(value)) {
+            for (const key of value) {
+                if (key.startsWith('-')) {
+                    removed.push(key.substring(1));
+                }
+                else {
+                    added.push(key);
+                }
+            }
+        }
+        return distinct([...defaultIgnoredExtensions, ...added,].filter(setting => !removed.includes(setting)));
+    }
+    getConfiguredIgnoredExtensions() {
+        let userValue = this.configurationService.inspect('settingsSync.ignoredExtensions').userValue;
+        if (userValue !== undefined) {
+            return userValue;
+        }
+        userValue = this.configurationService.inspect('sync.ignoredExtensions').userValue;
+        if (userValue !== undefined) {
+            return userValue;
+        }
+        return ( (this.configurationService.getValue('settingsSync.ignoredExtensions') || []).map(id => id.toLowerCase()));
+    }
+};
+IgnoredExtensionsManagementService = ( __decorate([
+    ( __param(0, IConfigurationService))
+], IgnoredExtensionsManagementService));
+export { IIgnoredExtensionsManagementService, IgnoredExtensionsManagementService };

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

@@ -15,4 +15,5 @@ function getDefaultIgnoredSettings() {
 }
 const IUserDataSyncEnablementService = ( createDecorator('IUserDataSyncEnablementService'));
 const IUserDataSyncService = ( createDecorator('IUserDataSyncService'));
-export { IUserDataSyncEnablementService, IUserDataSyncService, getDefaultIgnoredSettings, getDisallowedIgnoredSettings };
+const IUserDataAutoSyncService = ( createDecorator('IUserDataAutoSyncService'));
+export { IUserDataAutoSyncService, IUserDataSyncEnablementService, IUserDataSyncService, getDefaultIgnoredSettings, getDisallowedIgnoredSettings };

package/vscode/src/vs/platform/userDataSync/common/userDataSyncAccount.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IUserDataSyncAccountService = ( createDecorator('IUserDataSyncAccountService'));
+export { IUserDataSyncAccountService };