@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

package/vscode/src/vs/workbench/api/browser/mainThreadDebugService.js

@@ -1,385 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore, toDisposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IDebugService } from '../../contrib/debug/common/debug.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { AbstractDebugAdapter } from '../../contrib/debug/common/abstractDebugAdapter.js';
-import { isSessionAttach, convertToVSCPaths, convertToDAPaths } from '../../contrib/debug/common/debugUtils.js';
-import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
-let MainThreadDebugService = class MainThreadDebugService {
-    constructor(extHostContext, debugService) {
-        this.debugService = debugService;
-        this._toDispose = ( new DisposableStore());
-        this._debugAdaptersHandleCounter = 1;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDebugService));
-        const sessionListeners = ( new DisposableMap());
-        this._toDispose.add(sessionListeners);
-        this._toDispose.add(debugService.onDidNewSession(session => {
-            this._proxy.$acceptDebugSessionStarted(this.getSessionDto(session));
-            const store = sessionListeners.get(session);
-            store.add(session.onDidChangeName(name => {
-                this._proxy.$acceptDebugSessionNameChanged(this.getSessionDto(session), name);
-            }));
-        }));
-        this._toDispose.add(debugService.onWillNewSession(session => {
-            let store = sessionListeners.get(session);
-            if (!store) {
-                store = ( new DisposableStore());
-                sessionListeners.set(session, store);
-            }
-            store.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
-        }));
-        this._toDispose.add(debugService.onDidEndSession(session => {
-            this._proxy.$acceptDebugSessionTerminated(this.getSessionDto(session));
-            this._sessions.delete(session.getId());
-            for (const [handle, value] of this._debugAdapters) {
-                if (value.session === session) {
-                    this._debugAdapters.delete(handle);
-                }
-            }
-            sessionListeners.deleteAndDispose(session);
-        }));
-        this._toDispose.add(debugService.getViewModel().onDidFocusSession(session => {
-            this._proxy.$acceptDebugSessionActiveChanged(this.getSessionDto(session));
-        }));
-        this._toDispose.add(toDisposable(() => {
-            for (const [handle, da] of this._debugAdapters) {
-                da.fireError(handle, ( new Error('Extension host shut down')));
-            }
-        }));
-        this._debugAdapters = ( new Map());
-        this._debugConfigurationProviders = ( new Map());
-        this._debugAdapterDescriptorFactories = ( new Map());
-        this._sessions = ( new Set());
-        this._toDispose.add(this.debugService.getViewModel().onDidFocusThread(({ thread, explicit, session }) => {
-            if (session) {
-                const dto = {
-                    kind: 'thread',
-                    threadId: thread?.threadId,
-                    sessionId: session.getId(),
-                };
-                this._proxy.$acceptStackFrameFocus(dto);
-            }
-        }));
-        this._toDispose.add(this.debugService.getViewModel().onDidFocusStackFrame(({ stackFrame, explicit, session }) => {
-            if (session) {
-                const dto = {
-                    kind: 'stackFrame',
-                    threadId: stackFrame?.thread.threadId,
-                    frameId: stackFrame?.frameId,
-                    sessionId: session.getId(),
-                };
-                this._proxy.$acceptStackFrameFocus(dto);
-            }
-        }));
-        this.sendBreakpointsAndListen();
-    }
-    sendBreakpointsAndListen() {
-        this._toDispose.add(this.debugService.getModel().onDidChangeBreakpoints(e => {
-            if (e && !e.sessionOnly) {
-                const delta = {};
-                if (e.added) {
-                    delta.added = this.convertToDto(e.added);
-                }
-                if (e.removed) {
-                    delta.removed = ( e.removed.map(x => x.getId()));
-                }
-                if (e.changed) {
-                    delta.changed = this.convertToDto(e.changed);
-                }
-                if (delta.added || delta.removed || delta.changed) {
-                    this._proxy.$acceptBreakpointsDelta(delta);
-                }
-            }
-        }));
-        const bps = this.debugService.getModel().getBreakpoints();
-        const fbps = this.debugService.getModel().getFunctionBreakpoints();
-        const dbps = this.debugService.getModel().getDataBreakpoints();
-        if (bps.length > 0 || fbps.length > 0) {
-            this._proxy.$acceptBreakpointsDelta({
-                added: this.convertToDto(bps).concat(this.convertToDto(fbps)).concat(this.convertToDto(dbps))
-            });
-        }
-    }
-    dispose() {
-        this._toDispose.dispose();
-    }
-    createDebugAdapter(session) {
-        const handle = this._debugAdaptersHandleCounter++;
-        const da = ( new ExtensionHostDebugAdapter(this, handle, this._proxy, session));
-        this._debugAdapters.set(handle, da);
-        return da;
-    }
-    substituteVariables(folder, config) {
-        return Promise.resolve(this._proxy.$substituteVariables(folder ? folder.uri : undefined, config));
-    }
-    runInTerminal(args, sessionId) {
-        return this._proxy.$runInTerminal(args, sessionId);
-    }
-    $registerDebugTypes(debugTypes) {
-        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterFactory(debugTypes, this));
-    }
-    $registerBreakpoints(DTOs) {
-        for (const dto of DTOs) {
-            if (dto.type === 'sourceMulti') {
-                const rawbps = ( dto.lines.map(l => ({
-                    id: l.id,
-                    enabled: l.enabled,
-                    lineNumber: l.line + 1,
-                    column: l.character > 0 ? l.character + 1 : undefined,
-                    condition: l.condition,
-                    hitCondition: l.hitCondition,
-                    logMessage: l.logMessage
-                })));
-                this.debugService.addBreakpoints(URI.revive(dto.uri), rawbps);
-            }
-            else if (dto.type === 'function') {
-                this.debugService.addFunctionBreakpoint(dto.functionName, dto.id);
-            }
-            else if (dto.type === 'data') {
-                this.debugService.addDataBreakpoint(dto.label, dto.dataId, dto.canPersist, dto.accessTypes, dto.accessType);
-            }
-        }
-        return Promise.resolve();
-    }
-    $unregisterBreakpoints(breakpointIds, functionBreakpointIds, dataBreakpointIds) {
-        breakpointIds.forEach(id => this.debugService.removeBreakpoints(id));
-        functionBreakpointIds.forEach(id => this.debugService.removeFunctionBreakpoints(id));
-        dataBreakpointIds.forEach(id => this.debugService.removeDataBreakpoints(id));
-        return Promise.resolve();
-    }
-    $registerDebugConfigurationProvider(debugType, providerTriggerKind, hasProvide, hasResolve, hasResolve2, handle) {
-        const provider = {
-            type: debugType,
-            triggerKind: providerTriggerKind
-        };
-        if (hasProvide) {
-            provider.provideDebugConfigurations = (folder, token) => {
-                return this._proxy.$provideDebugConfigurations(handle, folder, token);
-            };
-        }
-        if (hasResolve) {
-            provider.resolveDebugConfiguration = (folder, config, token) => {
-                return this._proxy.$resolveDebugConfiguration(handle, folder, config, token);
-            };
-        }
-        if (hasResolve2) {
-            provider.resolveDebugConfigurationWithSubstitutedVariables = (folder, config, token) => {
-                return this._proxy.$resolveDebugConfigurationWithSubstitutedVariables(handle, folder, config, token);
-            };
-        }
-        this._debugConfigurationProviders.set(handle, provider);
-        this._toDispose.add(this.debugService.getConfigurationManager().registerDebugConfigurationProvider(provider));
-        return Promise.resolve(undefined);
-    }
-    $unregisterDebugConfigurationProvider(handle) {
-        const provider = this._debugConfigurationProviders.get(handle);
-        if (provider) {
-            this._debugConfigurationProviders.delete(handle);
-            this.debugService.getConfigurationManager().unregisterDebugConfigurationProvider(provider);
-        }
-    }
-    $registerDebugAdapterDescriptorFactory(debugType, handle) {
-        const provider = {
-            type: debugType,
-            createDebugAdapterDescriptor: session => {
-                return Promise.resolve(this._proxy.$provideDebugAdapter(handle, this.getSessionDto(session)));
-            }
-        };
-        this._debugAdapterDescriptorFactories.set(handle, provider);
-        this._toDispose.add(this.debugService.getAdapterManager().registerDebugAdapterDescriptorFactory(provider));
-        return Promise.resolve(undefined);
-    }
-    $unregisterDebugAdapterDescriptorFactory(handle) {
-        const provider = this._debugAdapterDescriptorFactories.get(handle);
-        if (provider) {
-            this._debugAdapterDescriptorFactories.delete(handle);
-            this.debugService.getAdapterManager().unregisterDebugAdapterDescriptorFactory(provider);
-        }
-    }
-    getSession(sessionId) {
-        if (sessionId) {
-            return this.debugService.getModel().getSession(sessionId, true);
-        }
-        return undefined;
-    }
-    async $startDebugging(folder, nameOrConfig, options) {
-        const folderUri = folder ? URI.revive(folder) : undefined;
-        const launch = this.debugService.getConfigurationManager().getLaunch(folderUri);
-        const parentSession = this.getSession(options.parentSessionID);
-        const saveBeforeStart = typeof options.suppressSaveBeforeStart === 'boolean' ? !options.suppressSaveBeforeStart : undefined;
-        const debugOptions = {
-            noDebug: options.noDebug,
-            parentSession,
-            lifecycleManagedByParent: options.lifecycleManagedByParent,
-            repl: options.repl,
-            compact: options.compact,
-            compoundRoot: parentSession?.compoundRoot,
-            saveBeforeRestart: saveBeforeStart,
-            suppressDebugStatusbar: options.suppressDebugStatusbar,
-            suppressDebugToolbar: options.suppressDebugToolbar,
-            suppressDebugView: options.suppressDebugView,
-        };
-        try {
-            return this.debugService.startDebugging(launch, nameOrConfig, debugOptions, saveBeforeStart);
-        }
-        catch (err) {
-            throw new ErrorNoTelemetry(err && err.message ? err.message : 'cannot start debugging');
-        }
-    }
-    $setDebugSessionName(sessionId, name) {
-        const session = this.debugService.getModel().getSession(sessionId);
-        session?.setName(name);
-    }
-    $customDebugAdapterRequest(sessionId, request, args) {
-        const session = this.debugService.getModel().getSession(sessionId, true);
-        if (session) {
-            return session.customRequest(request, args).then(response => {
-                if (response && response.success) {
-                    return response.body;
-                }
-                else {
-                    return Promise.reject(( new ErrorNoTelemetry(response ? response.message : 'custom request failed')));
-                }
-            });
-        }
-        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
-    }
-    $getDebugProtocolBreakpoint(sessionId, breakpoinId) {
-        const session = this.debugService.getModel().getSession(sessionId, true);
-        if (session) {
-            return Promise.resolve(session.getDebugProtocolBreakpoint(breakpoinId));
-        }
-        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
-    }
-    $stopDebugging(sessionId) {
-        if (sessionId) {
-            const session = this.debugService.getModel().getSession(sessionId, true);
-            if (session) {
-                return this.debugService.stopSession(session, isSessionAttach(session));
-            }
-        }
-        else {
-            return this.debugService.stopSession(undefined);
-        }
-        return Promise.reject(( new ErrorNoTelemetry('debug session not found')));
-    }
-    $appendDebugConsole(value) {
-        const session = this.debugService.getViewModel().focusedSession;
-        session?.appendToRepl({ output: value, sev: Severity.Warning });
-    }
-    $acceptDAMessage(handle, message) {
-        this.getDebugAdapter(handle).acceptMessage(convertToVSCPaths(message, false));
-    }
-    $acceptDAError(handle, name, message, stack) {
-        this.getDebugAdapter(handle).fireError(handle, ( new Error(`${name}: ${message}\n${stack}`)));
-    }
-    $acceptDAExit(handle, code, signal) {
-        this.getDebugAdapter(handle).fireExit(handle, code, signal);
-    }
-    getDebugAdapter(handle) {
-        const adapter = this._debugAdapters.get(handle);
-        if (!adapter) {
-            throw new Error('Invalid debug adapter');
-        }
-        return adapter;
-    }
-    $sessionCached(sessionID) {
-        this._sessions.add(sessionID);
-    }
-    getSessionDto(session) {
-        if (session) {
-            const sessionID = session.getId();
-            if (( this._sessions.has(sessionID))) {
-                return sessionID;
-            }
-            else {
-                return {
-                    id: sessionID,
-                    type: session.configuration.type,
-                    name: session.name,
-                    folderUri: session.root ? session.root.uri : undefined,
-                    configuration: session.configuration,
-                    parent: session.parentSession?.getId(),
-                };
-            }
-        }
-        return undefined;
-    }
-    convertToDto(bps) {
-        return ( bps.map(bp => {
-            if ('name' in bp) {
-                const fbp = bp;
-                return {
-                    type: 'function',
-                    id: fbp.getId(),
-                    enabled: fbp.enabled,
-                    condition: fbp.condition,
-                    hitCondition: fbp.hitCondition,
-                    logMessage: fbp.logMessage,
-                    functionName: fbp.name
-                };
-            }
-            else if ('dataId' in bp) {
-                const dbp = bp;
-                return {
-                    type: 'data',
-                    id: dbp.getId(),
-                    dataId: dbp.dataId,
-                    enabled: dbp.enabled,
-                    condition: dbp.condition,
-                    hitCondition: dbp.hitCondition,
-                    logMessage: dbp.logMessage,
-                    label: dbp.description,
-                    canPersist: dbp.canPersist
-                };
-            }
-            else {
-                const sbp = bp;
-                return {
-                    type: 'source',
-                    id: sbp.getId(),
-                    enabled: sbp.enabled,
-                    condition: sbp.condition,
-                    hitCondition: sbp.hitCondition,
-                    logMessage: sbp.logMessage,
-                    uri: sbp.uri,
-                    line: sbp.lineNumber > 0 ? sbp.lineNumber - 1 : 0,
-                    character: (typeof sbp.column === 'number' && sbp.column > 0) ? sbp.column - 1 : 0,
-                };
-            }
-        }));
-    }
-};
-MainThreadDebugService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDebugService),
-    ( __param(1, IDebugService))
-], MainThreadDebugService);
-class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
-    constructor(_ds, _handle, _proxy, session) {
-        super();
-        this._ds = _ds;
-        this._handle = _handle;
-        this._proxy = _proxy;
-        this.session = session;
-    }
-    fireError(handle, err) {
-        this._onError.fire(err);
-    }
-    fireExit(handle, code, signal) {
-        this._onExit.fire(code);
-    }
-    startSession() {
-        return Promise.resolve(this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this.session)));
-    }
-    sendMessage(message) {
-        this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, true));
-    }
-    async stopSession() {
-        await this.cancelPendingRequests();
-        return Promise.resolve(this._proxy.$stopDASession(this._handle));
-    }
-}
-export { MainThreadDebugService };

package/vscode/src/vs/workbench/api/browser/mainThreadDecorations.js

@@ -1,100 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IDecorationsService } from '../../services/decorations/common/decorations.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-class DecorationRequestsQueue {
-    constructor(_proxy, _handle) {
-        this._proxy = _proxy;
-        this._handle = _handle;
-        this._idPool = 0;
-        this._requests = ( new Map());
-        this._resolver = ( new Map());
-    }
-    enqueue(uri, token) {
-        const id = ++this._idPool;
-        const result = ( new Promise(resolve => {
-            this._requests.set(id, { id, uri });
-            this._resolver.set(id, resolve);
-            this._processQueue();
-        }));
-        const sub = token.onCancellationRequested(() => {
-            this._requests.delete(id);
-            this._resolver.delete(id);
-        });
-        return result.finally(() => sub.dispose());
-    }
-    _processQueue() {
-        if (typeof this._timer === 'number') {
-            return;
-        }
-        this._timer = setTimeout(() => {
-            const requests = this._requests;
-            const resolver = this._resolver;
-            this._proxy.$provideDecorations(this._handle, [...( requests.values())], CancellationToken.None).then(data => {
-                for (const [id, resolve] of resolver) {
-                    resolve(data[id]);
-                }
-            });
-            this._requests = ( new Map());
-            this._resolver = ( new Map());
-            this._timer = undefined;
-        }, 0);
-    }
-}
-let MainThreadDecorations = class MainThreadDecorations {
-    constructor(context, _decorationsService) {
-        this._decorationsService = _decorationsService;
-        this._provider = ( new Map());
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostDecorations));
-    }
-    dispose() {
-        this._provider.forEach(value => dispose(value));
-        this._provider.clear();
-    }
-    $registerDecorationProvider(handle, label) {
-        const emitter = ( new Emitter());
-        const queue = ( new DecorationRequestsQueue(this._proxy, handle));
-        const registration = this._decorationsService.registerDecorationsProvider({
-            label,
-            onDidChange: emitter.event,
-            provideDecorations: async (uri, token) => {
-                const data = await queue.enqueue(uri, token);
-                if (!data) {
-                    return undefined;
-                }
-                const [bubble, tooltip, letter, themeColor] = data;
-                return {
-                    weight: 10,
-                    bubble: bubble ?? false,
-                    color: themeColor?.id,
-                    tooltip,
-                    letter
-                };
-            }
-        });
-        this._provider.set(handle, [emitter, registration]);
-    }
-    $onDidChange(handle, resources) {
-        const provider = this._provider.get(handle);
-        if (provider) {
-            const [emitter] = provider;
-            emitter.fire(resources && ( resources.map(r => URI.revive(r))));
-        }
-    }
-    $unregisterDecorationProvider(handle) {
-        const provider = this._provider.get(handle);
-        if (provider) {
-            dispose(provider);
-            this._provider.delete(handle);
-        }
-    }
-};
-MainThreadDecorations = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDecorations),
-    ( __param(1, IDecorationsService))
-], MainThreadDecorations);
-export { MainThreadDecorations };

package/vscode/src/vs/workbench/api/browser/mainThreadDiagnostics.js

@@ -1,67 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-let MainThreadDiagnostics = class MainThreadDiagnostics {
-    constructor(extHostContext, _markerService, _uriIdentService) {
-        this._markerService = _markerService;
-        this._uriIdentService = _uriIdentService;
-        this._activeOwners = ( new Set());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDiagnostics));
-        this._markerListener = this._markerService.onMarkerChanged(this._forwardMarkers, this);
-    }
-    dispose() {
-        this._markerListener.dispose();
-        this._activeOwners.forEach(owner => this._markerService.changeAll(owner, []));
-        this._activeOwners.clear();
-    }
-    _forwardMarkers(resources) {
-        const data = [];
-        for (const resource of resources) {
-            const allMarkerData = this._markerService.read({ resource });
-            if (allMarkerData.length === 0) {
-                data.push([resource, []]);
-            }
-            else {
-                const forgeinMarkerData = allMarkerData.filter(marker => !( this._activeOwners.has(marker.owner)));
-                if (forgeinMarkerData.length > 0) {
-                    data.push([resource, forgeinMarkerData]);
-                }
-            }
-        }
-        if (data.length > 0) {
-            this._proxy.$acceptMarkersChange(data);
-        }
-    }
-    $changeMany(owner, entries) {
-        for (const entry of entries) {
-            const [uri, markers] = entry;
-            if (markers) {
-                for (const marker of markers) {
-                    if (marker.relatedInformation) {
-                        for (const relatedInformation of marker.relatedInformation) {
-                            relatedInformation.resource = URI.revive(relatedInformation.resource);
-                        }
-                    }
-                    if (marker.code && typeof marker.code !== 'string') {
-                        marker.code.target = URI.revive(marker.code.target);
-                    }
-                }
-            }
-            this._markerService.changeOne(owner, this._uriIdentService.asCanonicalUri(URI.revive(uri)), markers);
-        }
-        this._activeOwners.add(owner);
-    }
-    $clear(owner) {
-        this._markerService.changeAll(owner, []);
-        this._activeOwners.delete(owner);
-    }
-};
-MainThreadDiagnostics = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDiagnostics),
-    ( __param(1, IMarkerService)),
-    ( __param(2, IUriIdentityService))
-], MainThreadDiagnostics);
-export { MainThreadDiagnostics };

package/vscode/src/vs/workbench/api/browser/mainThreadDialogs.js

@@ -1,66 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IFileDialogService } from '../../../platform/dialogs/common/dialogs.js';
-var MainThreadDialogs_1;
-let MainThreadDialogs = MainThreadDialogs_1 = class MainThreadDialogs {
-    constructor(context, _fileDialogService) {
-        this._fileDialogService = _fileDialogService;
-    }
-    dispose() {
-    }
-    async $showOpenDialog(options) {
-        const convertedOptions = MainThreadDialogs_1._convertOpenOptions(options);
-        if (!convertedOptions.defaultUri) {
-            convertedOptions.defaultUri = await this._fileDialogService.defaultFilePath();
-        }
-        return Promise.resolve(this._fileDialogService.showOpenDialog(convertedOptions));
-    }
-    async $showSaveDialog(options) {
-        const convertedOptions = MainThreadDialogs_1._convertSaveOptions(options);
-        if (!convertedOptions.defaultUri) {
-            convertedOptions.defaultUri = await this._fileDialogService.defaultFilePath();
-        }
-        return Promise.resolve(this._fileDialogService.showSaveDialog(convertedOptions));
-    }
-    static _convertOpenOptions(options) {
-        const result = {
-            openLabel: options?.openLabel || undefined,
-            canSelectFiles: options?.canSelectFiles || (!options?.canSelectFiles && !options?.canSelectFolders),
-            canSelectFolders: options?.canSelectFolders,
-            canSelectMany: options?.canSelectMany,
-            defaultUri: options?.defaultUri ? URI.revive(options.defaultUri) : undefined,
-            title: options?.title || undefined,
-            availableFileSystems: options?.allowUIResources ? [Schemas.vscodeRemote, Schemas.file] : []
-        };
-        if (options?.filters) {
-            result.filters = [];
-            for (const [key, value] of Object.entries(options.filters)) {
-                result.filters.push({ name: key, extensions: value });
-            }
-        }
-        return result;
-    }
-    static _convertSaveOptions(options) {
-        const result = {
-            defaultUri: options?.defaultUri ? URI.revive(options.defaultUri) : undefined,
-            saveLabel: options?.saveLabel || undefined,
-            title: options?.title || undefined
-        };
-        if (options?.filters) {
-            result.filters = [];
-            for (const [key, value] of Object.entries(options.filters)) {
-                result.filters.push({ name: key, extensions: value });
-            }
-        }
-        return result;
-    }
-};
-MainThreadDialogs = MainThreadDialogs_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDialogs),
-    ( __param(1, IFileDialogService))
-], MainThreadDialogs);
-export { MainThreadDialogs };