@codingame/monaco-vscode-api 4.4.1 → 4.5.0-improve-code-splitting.1

package/vscode/src/vs/platform/terminal/common/capabilities/cwdDetectionCapability.js

@@ -1,29 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-class CwdDetectionCapability extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.type = 0 ;
-        this._cwd = '';
-        this._cwds = ( new Map());
-        this._onDidChangeCwd = this._register(( new Emitter()));
-        this.onDidChangeCwd = this._onDidChangeCwd.event;
-    }
-    get cwds() {
-        return Array.from(( this._cwds.keys()));
-    }
-    getCwd() {
-        return this._cwd;
-    }
-    updateCwd(cwd) {
-        const didChange = this._cwd !== cwd;
-        this._cwd = cwd;
-        const count = this._cwds.get(this._cwd) || 0;
-        this._cwds.delete(this._cwd);
-        this._cwds.set(this._cwd, count + 1);
-        if (didChange) {
-            this._onDidChangeCwd.fire(cwd);
-        }
-    }
-}
-export { CwdDetectionCapability };

package/vscode/src/vs/platform/terminal/common/capabilities/partialCommandDetectionCapability.js

@@ -1,48 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
-class PartialCommandDetectionCapability extends DisposableStore {
-    get commands() { return this._commands; }
-    constructor(_terminal) {
-        super();
-        this._terminal = _terminal;
-        this.type = 3 ;
-        this._commands = [];
-        this._onCommandFinished = this.add(( new Emitter()));
-        this.onCommandFinished = this._onCommandFinished.event;
-        this.add(this._terminal.onData(e => this._onData(e)));
-        this.add(this._terminal.parser.registerCsiHandler({ final: 'J' }, params => {
-            if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
-                this._clearCommandsInViewport();
-            }
-            return false;
-        }));
-    }
-    _onData(data) {
-        if (data === '\x0d') {
-            this._onEnter();
-        }
-    }
-    _onEnter() {
-        if (!this._terminal) {
-            return;
-        }
-        if (this._terminal.buffer.active.cursorX >= 2 ) {
-            const marker = this._terminal.registerMarker(0);
-            if (marker) {
-                this._commands.push(marker);
-                this._onCommandFinished.fire(marker);
-            }
-        }
-    }
-    _clearCommandsInViewport() {
-        let count = 0;
-        for (let i = this._commands.length - 1; i >= 0; i--) {
-            if (this._commands[i].line < this._terminal.buffer.active.baseY) {
-                break;
-            }
-            count++;
-        }
-        this._commands.splice(this._commands.length - count, count);
-    }
-}
-export { PartialCommandDetectionCapability };

package/vscode/src/vs/platform/terminal/common/capabilities/terminalCapabilityStore.js

@@ -1,94 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-class TerminalCapabilityStore extends Disposable {
-    constructor() {
-        super(...arguments);
-        this._map = ( new Map());
-        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
-        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
-        this._onDidAddCapabilityType = this._register(( new Emitter()));
-        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
-        this._onDidRemoveCapability = this._register(( new Emitter()));
-        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
-        this._onDidAddCapability = this._register(( new Emitter()));
-        this.onDidAddCapability = this._onDidAddCapability.event;
-    }
-    get items() {
-        return ( this._map.keys());
-    }
-    add(capability, impl) {
-        this._map.set(capability, impl);
-        this._onDidAddCapabilityType.fire(capability);
-        this._onDidAddCapability.fire({ id: capability, capability: impl });
-    }
-    get(capability) {
-        return this._map.get(capability);
-    }
-    remove(capability) {
-        const impl = this._map.get(capability);
-        if (!impl) {
-            return;
-        }
-        this._map.delete(capability);
-        this._onDidRemoveCapabilityType.fire(capability);
-        this._onDidAddCapability.fire({ id: capability, capability: impl });
-    }
-    has(capability) {
-        return ( this._map.has(capability));
-    }
-}
-class TerminalCapabilityStoreMultiplexer extends Disposable {
-    constructor() {
-        super(...arguments);
-        this._stores = [];
-        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
-        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
-        this._onDidAddCapabilityType = this._register(( new Emitter()));
-        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
-        this._onDidRemoveCapability = this._register(( new Emitter()));
-        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
-        this._onDidAddCapability = this._register(( new Emitter()));
-        this.onDidAddCapability = this._onDidAddCapability.event;
-    }
-    get items() {
-        return this._items();
-    }
-    *_items() {
-        for (const store of this._stores) {
-            for (const c of store.items) {
-                yield c;
-            }
-        }
-    }
-    has(capability) {
-        for (const store of this._stores) {
-            for (const c of store.items) {
-                if (c === capability) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    get(capability) {
-        for (const store of this._stores) {
-            const c = store.get(capability);
-            if (c) {
-                return c;
-            }
-        }
-        return undefined;
-    }
-    add(store) {
-        this._stores.push(store);
-        for (const capability of store.items) {
-            this._onDidAddCapabilityType.fire(capability);
-            this._onDidAddCapability.fire({ id: capability, capability: store.get(capability) });
-        }
-        this._register(store.onDidAddCapabilityType(e => this._onDidAddCapabilityType.fire(e)));
-        this._register(store.onDidAddCapability(e => this._onDidAddCapability.fire(e)));
-        this._register(store.onDidRemoveCapabilityType(e => this._onDidRemoveCapabilityType.fire(e)));
-        this._register(store.onDidRemoveCapability(e => this._onDidRemoveCapability.fire(e)));
-    }
-}
-export { TerminalCapabilityStore, TerminalCapabilityStoreMultiplexer };

package/vscode/src/vs/platform/terminal/common/terminalEnvironment.js

@@ -1,40 +0,0 @@
-import { OS } from '../../../base/common/platform.js';
-function escapeNonWindowsPath(path) {
-    let newPath = path;
-    if (newPath.includes('\\')) {
-        newPath = newPath.replace(/\\/g, '\\\\');
-    }
-    const bannedChars = /[\`\$\|\&\>\~\#\!\^\*\;\<\"\']/g;
-    newPath = newPath.replace(bannedChars, '');
-    return `'${newPath}'`;
-}
-function collapseTildePath(path, userHome, separator) {
-    if (!path) {
-        return '';
-    }
-    if (!userHome) {
-        return path;
-    }
-    if (userHome.match(/[\/\\]$/)) {
-        userHome = userHome.slice(0, userHome.length - 1);
-    }
-    const normalizedPath = path.replace(/\\/g, '/').toLowerCase();
-    const normalizedUserHome = userHome.replace(/\\/g, '/').toLowerCase();
-    if (!normalizedPath.includes(normalizedUserHome)) {
-        return path;
-    }
-    return `~${separator}${path.slice(userHome.length + 1)}`;
-}
-function sanitizeCwd(cwd) {
-    if (cwd.match(/^['"].*['"]$/)) {
-        cwd = cwd.substring(1, cwd.length - 1);
-    }
-    if (OS === 1  && cwd && cwd[1] === ':') {
-        return cwd[0].toUpperCase() + cwd.substring(1);
-    }
-    return cwd;
-}
-function shouldUseEnvironmentVariableCollection(slc) {
-    return !slc.strictEnv;
-}
-export { collapseTildePath, escapeNonWindowsPath, sanitizeCwd, shouldUseEnvironmentVariableCollection };

package/vscode/src/vs/platform/terminal/common/xterm/shellIntegrationAddon.js

@@ -1,319 +0,0 @@
-import { Disposable, toDisposable, dispose } from '../../../../base/common/lifecycle.js';
-import { TerminalCapabilityStore } from '../capabilities/terminalCapabilityStore.js';
-import { CommandDetectionCapability } from '../capabilities/commandDetectionCapability.js';
-import { CwdDetectionCapability } from '../capabilities/cwdDetectionCapability.js';
-import { PartialCommandDetectionCapability } from '../capabilities/partialCommandDetectionCapability.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { BufferMarkCapability } from '../capabilities/bufferMarkCapability.js';
-import { URI } from '../../../../base/common/uri.js';
-import { sanitizeCwd } from '../terminalEnvironment.js';
-class ShellIntegrationAddon extends Disposable {
-    get status() { return this._status; }
-    constructor(_nonce, _disableTelemetry, _telemetryService, _logService) {
-        super();
-        this._nonce = _nonce;
-        this._disableTelemetry = _disableTelemetry;
-        this._telemetryService = _telemetryService;
-        this._logService = _logService;
-        this.capabilities = this._register(( new TerminalCapabilityStore()));
-        this._hasUpdatedTelemetry = false;
-        this._commonProtocolDisposables = [];
-        this._status = 0 ;
-        this._onDidChangeStatus = ( new Emitter());
-        this.onDidChangeStatus = this._onDidChangeStatus.event;
-        this._register(toDisposable(() => {
-            this._clearActivationTimeout();
-            this._disposeCommonProtocol();
-        }));
-    }
-    _disposeCommonProtocol() {
-        dispose(this._commonProtocolDisposables);
-        this._commonProtocolDisposables.length = 0;
-    }
-    activate(xterm) {
-        this._terminal = xterm;
-        this.capabilities.add(3 , this._register(( new PartialCommandDetectionCapability(this._terminal))));
-        this._register(xterm.parser.registerOscHandler(633 , data => this._handleVSCodeSequence(data)));
-        this._register(xterm.parser.registerOscHandler(1337 , data => this._doHandleITermSequence(data)));
-        this._commonProtocolDisposables.push(xterm.parser.registerOscHandler(133 , data => this._handleFinalTermSequence(data)));
-        this._register(xterm.parser.registerOscHandler(7 , data => this._doHandleSetCwd(data)));
-        this._register(xterm.parser.registerOscHandler(9 , data => this._doHandleSetWindowsFriendlyCwd(data)));
-        this._ensureCapabilitiesOrAddFailureTelemetry();
-    }
-    getMarkerId(terminal, vscodeMarkerId) {
-        this._createOrGetBufferMarkDetection(terminal).getMark(vscodeMarkerId);
-    }
-    _handleFinalTermSequence(data) {
-        const didHandle = this._doHandleFinalTermSequence(data);
-        if (this._status === 0 ) {
-            this._status = 1 ;
-            this._onDidChangeStatus.fire(this._status);
-        }
-        return didHandle;
-    }
-    _doHandleFinalTermSequence(data) {
-        if (!this._terminal) {
-            return false;
-        }
-        const [command, ...args] = data.split(';');
-        switch (command) {
-            case 'A':
-                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
-                return true;
-            case 'B':
-                this._createOrGetCommandDetection(this._terminal).handleCommandStart({ ignoreCommandLine: true });
-                return true;
-            case 'C':
-                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
-                return true;
-            case 'D': {
-                const exitCode = args.length === 1 ? parseInt(args[0]) : undefined;
-                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
-                return true;
-            }
-        }
-        return false;
-    }
-    _handleVSCodeSequence(data) {
-        const didHandle = this._doHandleVSCodeSequence(data);
-        if (!this._hasUpdatedTelemetry && didHandle) {
-            this._telemetryService?.publicLog2('terminal/shellIntegrationActivationSucceeded');
-            this._hasUpdatedTelemetry = true;
-            this._clearActivationTimeout();
-        }
-        if (this._status !== 2 ) {
-            this._status = 2 ;
-            this._onDidChangeStatus.fire(this._status);
-        }
-        return didHandle;
-    }
-    async _ensureCapabilitiesOrAddFailureTelemetry() {
-        if (!this._telemetryService || this._disableTelemetry) {
-            return;
-        }
-        this._activationTimeout = setTimeout(() => {
-            if (!this.capabilities.get(2 ) && !this.capabilities.get(0 )) {
-                this._telemetryService?.publicLog2('terminal/shellIntegrationActivationTimeout');
-                this._logService.warn('Shell integration failed to add capabilities within 10 seconds');
-            }
-            this._hasUpdatedTelemetry = true;
-        }, 10000);
-    }
-    _clearActivationTimeout() {
-        if (this._activationTimeout !== undefined) {
-            clearTimeout(this._activationTimeout);
-            this._activationTimeout = undefined;
-        }
-    }
-    _doHandleVSCodeSequence(data) {
-        if (!this._terminal) {
-            return false;
-        }
-        const argsIndex = data.indexOf(';');
-        const sequenceCommand = argsIndex === -1 ? data : data.substring(0, argsIndex);
-        const args = argsIndex === -1 ? [] : data.substring(argsIndex + 1).split(';');
-        switch (sequenceCommand) {
-            case "A" :
-                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
-                return true;
-            case "B" :
-                this._createOrGetCommandDetection(this._terminal).handleCommandStart();
-                return true;
-            case "C" :
-                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
-                return true;
-            case "D" : {
-                const arg0 = args[0];
-                const exitCode = arg0 !== undefined ? parseInt(arg0) : undefined;
-                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
-                return true;
-            }
-            case "E" : {
-                const arg0 = args[0];
-                const arg1 = args[1];
-                let commandLine;
-                if (arg0 !== undefined) {
-                    commandLine = deserializeMessage(arg0);
-                }
-                else {
-                    commandLine = '';
-                }
-                this._createOrGetCommandDetection(this._terminal).setCommandLine(commandLine, arg1 === this._nonce);
-                return true;
-            }
-            case "F" : {
-                this._createOrGetCommandDetection(this._terminal).handleContinuationStart();
-                return true;
-            }
-            case "G" : {
-                this._createOrGetCommandDetection(this._terminal).handleContinuationEnd();
-                return true;
-            }
-            case "H" : {
-                this._createOrGetCommandDetection(this._terminal).handleRightPromptStart();
-                return true;
-            }
-            case "I" : {
-                this._createOrGetCommandDetection(this._terminal).handleRightPromptEnd();
-                return true;
-            }
-            case "P" : {
-                const arg0 = args[0];
-                const deserialized = arg0 !== undefined ? deserializeMessage(arg0) : '';
-                const { key, value } = parseKeyValueAssignment(deserialized);
-                if (value === undefined) {
-                    return true;
-                }
-                switch (key) {
-                    case 'Cwd': {
-                        this._updateCwd(value);
-                        return true;
-                    }
-                    case 'IsWindows': {
-                        this._createOrGetCommandDetection(this._terminal).setIsWindowsPty(value === 'True' ? true : false);
-                        return true;
-                    }
-                    case 'Task': {
-                        this._createOrGetBufferMarkDetection(this._terminal);
-                        this.capabilities.get(2 )?.setIsCommandStorageDisabled();
-                        return true;
-                    }
-                }
-            }
-            case "SetMark" : {
-                this._createOrGetBufferMarkDetection(this._terminal).addMark(parseMarkSequence(args));
-                return true;
-            }
-        }
-        return false;
-    }
-    _updateCwd(value) {
-        value = sanitizeCwd(value);
-        this._createOrGetCwdDetection().updateCwd(value);
-        const commandDetection = this.capabilities.get(2 );
-        commandDetection?.setCwd(value);
-    }
-    _doHandleITermSequence(data) {
-        if (!this._terminal) {
-            return false;
-        }
-        const [command] = data.split(';');
-        switch (command) {
-            case "SetMark" : {
-                this._createOrGetBufferMarkDetection(this._terminal).addMark();
-            }
-            default: {
-                const { key, value } = parseKeyValueAssignment(command);
-                if (value === undefined) {
-                    return true;
-                }
-                switch (key) {
-                    case "CurrentDir" :
-                        this._updateCwd(value);
-                        return true;
-                }
-            }
-        }
-        return false;
-    }
-    _doHandleSetWindowsFriendlyCwd(data) {
-        if (!this._terminal) {
-            return false;
-        }
-        const [command, ...args] = data.split(';');
-        switch (command) {
-            case '9':
-                if (args.length) {
-                    this._updateCwd(args[0]);
-                }
-                return true;
-        }
-        return false;
-    }
-    _doHandleSetCwd(data) {
-        if (!this._terminal) {
-            return false;
-        }
-        const [command] = data.split(';');
-        if (command.match(/^file:\/\/.*\//)) {
-            const uri = ( URI.parse(command));
-            if (uri.path && uri.path.length > 0) {
-                this._updateCwd(uri.path);
-                return true;
-            }
-        }
-        return false;
-    }
-    serialize() {
-        if (!this._terminal || !( this.capabilities.has(2 ))) {
-            return {
-                isWindowsPty: false,
-                commands: []
-            };
-        }
-        const result = this._createOrGetCommandDetection(this._terminal).serialize();
-        return result;
-    }
-    deserialize(serialized) {
-        if (!this._terminal) {
-            throw new Error('Cannot restore commands before addon is activated');
-        }
-        this._createOrGetCommandDetection(this._terminal).deserialize(serialized);
-    }
-    _createOrGetCwdDetection() {
-        let cwdDetection = this.capabilities.get(0 );
-        if (!cwdDetection) {
-            cwdDetection = this._register(( new CwdDetectionCapability()));
-            this.capabilities.add(0 , cwdDetection);
-        }
-        return cwdDetection;
-    }
-    _createOrGetCommandDetection(terminal) {
-        let commandDetection = this.capabilities.get(2 );
-        if (!commandDetection) {
-            commandDetection = this._register(( new CommandDetectionCapability(terminal, this._logService)));
-            this.capabilities.add(2 , commandDetection);
-        }
-        return commandDetection;
-    }
-    _createOrGetBufferMarkDetection(terminal) {
-        let bufferMarkDetection = this.capabilities.get(4 );
-        if (!bufferMarkDetection) {
-            bufferMarkDetection = this._register(( new BufferMarkCapability(terminal)));
-            this.capabilities.add(4 , bufferMarkDetection);
-        }
-        return bufferMarkDetection;
-    }
-}
-function deserializeMessage(message) {
-    return message.replaceAll(
-    /\\(\\|x([0-9a-f]{2}))/gi,
-    (_match, op, hex) => hex ? String.fromCharCode(parseInt(hex, 16)) : op);
-}
-function parseKeyValueAssignment(message) {
-    const separatorIndex = message.indexOf('=');
-    if (separatorIndex === -1) {
-        return { key: message, value: undefined };
-    }
-    return {
-        key: message.substring(0, separatorIndex),
-        value: message.substring(1 + separatorIndex)
-    };
-}
-function parseMarkSequence(sequence) {
-    let id = undefined;
-    let hidden = false;
-    for (const property of sequence) {
-        if (property === undefined) {
-            continue;
-        }
-        if (property === 'Hidden') {
-            hidden = true;
-        }
-        if (property.startsWith('Id=')) {
-            id = property.substring(3);
-        }
-    }
-    return { id, hidden };
-}
-export { ShellIntegrationAddon, deserializeMessage, parseKeyValueAssignment, parseMarkSequence };

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

@@ -1,38 +0,0 @@
-import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
-import { URI } from '../../../base/common/uri.js';
-import { IExtUri } from '../../../base/common/resources.js';
-
-declare const IUriIdentityService: ServiceIdentifier<IUriIdentityService>;
-interface IUriIdentityService {
-    readonly _serviceBrand: undefined;
-    /**
-     * Uri extensions that are aware of casing.
-     */
-    readonly extUri: IExtUri;
-    /**
-     * Returns a canonical uri for the given resource. Different uris can point to the same
-     * resource. That's because of casing or missing normalization, e.g the following uris
-     * are different but refer to the same document (because windows paths are not case-sensitive)
-     *
-     * ```txt
-     * file:///c:/foo/bar.txt
-     * file:///c:/FOO/BAR.txt
-     * ```
-     *
-     * This function should be invoked when feeding uris into the system that represent the truth,
-     * e.g document uris or marker-to-document associations etc. This function should NOT be called
-     * to pretty print a label nor to sanitize a uri.
-     *
-     * Samples:
-     *
-     * | in | out | |
-     * |---|---|---|
-     * | `file:///foo/bar/../bar` | `file:///foo/bar` | n/a |
-     * | `file:///foo/bar/../bar#frag` | `file:///foo/bar#frag` | keep fragment |
-     * | `file:///foo/BAR` | `file:///foo/bar` | assume ignore case |
-     * | `file:///foo/bar/../BAR?q=2` | `file:///foo/BAR?q=2` | query makes it a different document |
-     */
-    asCanonicalUri(uri: URI): URI;
-}
-
-export { IUriIdentityService };

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

@@ -1,65 +0,0 @@
-import { Emitter } from '../../../base/common/event.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { reviveProfile } from './userDataProfile.js';
-import '../../../base/common/path.js';
-import '../../../base/common/platform.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 };