@codingame/monaco-vscode-notebook-service-override 1.85.1

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.js

@@ -0,0 +1,217 @@
+import { LcsDiff } from 'monaco-editor/esm/vs/base/common/diff/diff.js';
+import { hash, numberHash, doHash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { PieceTreeTextBufferBuilder } from 'monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js';
+import { CellKind, NotebookCellsChangeType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { SearchParams } from 'monaco-editor/esm/vs/editor/common/model/textModelSearch.js';
+
+function bufferHash(buffer) {
+    let initialHashVal = numberHash(104579, 0);
+    for (let k = 0; k < buffer.buffer.length; k++) {
+        initialHashVal = doHash(buffer.buffer[k], initialHashVal);
+    }
+    return initialHashVal;
+}
+class MirrorCell {
+    get textBuffer() {
+        if (this._textBuffer) {
+            return this._textBuffer;
+        }
+        const builder = ( new PieceTreeTextBufferBuilder());
+        builder.acceptChunk(Array.isArray(this._source) ? this._source.join('\n') : this._source);
+        const bufferFactory = builder.finish(true);
+        this._textBuffer = bufferFactory.create(1 ).textBuffer;
+        return this._textBuffer;
+    }
+    primaryKey() {
+        if (this._primaryKey === undefined) {
+            this._primaryKey = hash(this.getValue());
+        }
+        return this._primaryKey;
+    }
+    constructor(handle, _source, language, cellKind, outputs, metadata, internalMetadata) {
+        this.handle = handle;
+        this._source = _source;
+        this.language = language;
+        this.cellKind = cellKind;
+        this.outputs = outputs;
+        this.metadata = metadata;
+        this.internalMetadata = internalMetadata;
+        this._primaryKey = null;
+        this._hash = null;
+    }
+    getFullModelRange() {
+        const lineCount = this.textBuffer.getLineCount();
+        return ( new Range(1, 1, lineCount, this.textBuffer.getLineLength(lineCount) + 1));
+    }
+    getValue() {
+        const fullRange = this.getFullModelRange();
+        return this.textBuffer.getValueInRange(fullRange, 1 );
+    }
+    getComparisonValue() {
+        if (this._primaryKey !== null) {
+            return this._primaryKey;
+        }
+        this._hash = hash([hash(this.language), hash(this.getValue()), this.metadata, this.internalMetadata, ( this.outputs.map(op => ({
+                outputs: ( op.outputs.map(output => ({
+                    mime: output.mime,
+                    data: bufferHash(output.data)
+                }))),
+                metadata: op.metadata
+            })))]);
+        return this._hash;
+    }
+    getHashValue() {
+        if (this._hash !== null) {
+            return this._hash;
+        }
+        this._hash = hash([hash(this.getValue()), this.language, this.metadata, this.internalMetadata]);
+        return this._hash;
+    }
+}
+class MirrorNotebookDocument {
+    constructor(uri, cells, metadata) {
+        this.uri = uri;
+        this.cells = cells;
+        this.metadata = metadata;
+    }
+    acceptModelChanged(event) {
+        event.rawEvents.forEach(e => {
+            if (e.kind === NotebookCellsChangeType.ModelChange) {
+                this._spliceNotebookCells(e.changes);
+            }
+            else if (e.kind === NotebookCellsChangeType.Move) {
+                const cells = this.cells.splice(e.index, 1);
+                this.cells.splice(e.newIdx, 0, ...cells);
+            }
+            else if (e.kind === NotebookCellsChangeType.Output) {
+                const cell = this.cells[e.index];
+                cell.outputs = e.outputs;
+            }
+            else if (e.kind === NotebookCellsChangeType.ChangeCellLanguage) {
+                this._assertIndex(e.index);
+                const cell = this.cells[e.index];
+                cell.language = e.language;
+            }
+            else if (e.kind === NotebookCellsChangeType.ChangeCellMetadata) {
+                this._assertIndex(e.index);
+                const cell = this.cells[e.index];
+                cell.metadata = e.metadata;
+            }
+            else if (e.kind === NotebookCellsChangeType.ChangeCellInternalMetadata) {
+                this._assertIndex(e.index);
+                const cell = this.cells[e.index];
+                cell.internalMetadata = e.internalMetadata;
+            }
+        });
+    }
+    _assertIndex(index) {
+        if (index < 0 || index >= this.cells.length) {
+            throw new Error(`Illegal index ${index}. Cells length: ${this.cells.length}`);
+        }
+    }
+    _spliceNotebookCells(splices) {
+        splices.reverse().forEach(splice => {
+            const cellDtos = splice[2];
+            const newCells = ( cellDtos.map(cell => {
+                return ( new MirrorCell(
+                    cell.handle,
+                    cell.source,
+                    cell.language,
+                    cell.cellKind,
+                    cell.outputs,
+                    cell.metadata
+                ));
+            }));
+            this.cells.splice(splice[0], splice[1], ...newCells);
+        });
+    }
+}
+class CellSequence {
+    constructor(textModel) {
+        this.textModel = textModel;
+    }
+    getElements() {
+        const hashValue = ( new Int32Array(this.textModel.cells.length));
+        for (let i = 0; i < this.textModel.cells.length; i++) {
+            hashValue[i] = this.textModel.cells[i].getComparisonValue();
+        }
+        return hashValue;
+    }
+    getCellHash(cell) {
+        const source = Array.isArray(cell.source) ? cell.source.join('\n') : cell.source;
+        const hashVal = hash([hash(source), cell.metadata]);
+        return hashVal;
+    }
+}
+class NotebookEditorSimpleWorker {
+    constructor() {
+        this._models = Object.create(null);
+    }
+    dispose() {
+    }
+    acceptNewModel(uri, data) {
+        this._models[uri] = ( new MirrorNotebookDocument(( URI.parse(uri)), ( data.cells.map(dto => ( new MirrorCell(
+            dto.handle,
+            dto.source,
+            dto.language,
+            dto.cellKind,
+            dto.outputs,
+            dto.metadata
+        )))), data.metadata));
+    }
+    acceptModelChanged(strURL, event) {
+        const model = this._models[strURL];
+        model?.acceptModelChanged(event);
+    }
+    acceptRemovedModel(strURL) {
+        if (!this._models[strURL]) {
+            return;
+        }
+        delete this._models[strURL];
+    }
+    computeDiff(originalUrl, modifiedUrl) {
+        const original = this._getModel(originalUrl);
+        const modified = this._getModel(modifiedUrl);
+        const diff = ( new LcsDiff(( new CellSequence(original)), ( new CellSequence(modified))));
+        const diffResult = diff.ComputeDiff(false);
+        return {
+            cellsDiff: diffResult,
+        };
+    }
+    canPromptRecommendation(modelUrl) {
+        const model = this._getModel(modelUrl);
+        const cells = model.cells;
+        for (let i = 0; i < cells.length; i++) {
+            const cell = cells[i];
+            if (cell.cellKind === CellKind.Markup) {
+                continue;
+            }
+            if (cell.language !== 'python') {
+                continue;
+            }
+            const lineCount = cell.textBuffer.getLineCount();
+            const maxLineCount = Math.min(lineCount, 20);
+            const range = ( new Range(1, 1, maxLineCount, cell.textBuffer.getLineLength(maxLineCount) + 1));
+            const searchParams = ( new SearchParams('import\\s*pandas|from\\s*pandas', true, false, null));
+            const searchData = searchParams.parseSearchRequest();
+            if (!searchData) {
+                continue;
+            }
+            const cellMatches = cell.textBuffer.findMatchesLineByLine(range, searchData, true, 1);
+            if (cellMatches.length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _getModel(uri) {
+        return this._models[uri];
+    }
+}
+function create(host) {
+    return ( new NotebookEditorSimpleWorker());
+}
+
+export { NotebookEditorSimpleWorker, create };

package/vscode/src/vs/workbench/services/workingCopy/common/abstractFileWorkingCopyManager.js

@@ -0,0 +1,89 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+
+let BaseFileWorkingCopyManager = class BaseFileWorkingCopyManager extends Disposable {
+    constructor(fileService, logService, workingCopyBackupService) {
+        super();
+        this.fileService = fileService;
+        this.logService = logService;
+        this.workingCopyBackupService = workingCopyBackupService;
+        this._onDidCreate = this._register(( new Emitter()));
+        this.onDidCreate = this._onDidCreate.event;
+        this.mapResourceToWorkingCopy = ( new ResourceMap());
+        this.mapResourceToDisposeListener = ( new ResourceMap());
+    }
+    has(resource) {
+        return ( this.mapResourceToWorkingCopy.has(resource));
+    }
+    add(resource, workingCopy) {
+        const knownWorkingCopy = this.get(resource);
+        if (knownWorkingCopy === workingCopy) {
+            return;
+        }
+        this.mapResourceToWorkingCopy.set(resource, workingCopy);
+        this.mapResourceToDisposeListener.get(resource)?.dispose();
+        this.mapResourceToDisposeListener.set(resource, workingCopy.onWillDispose(() => this.remove(resource)));
+        this._onDidCreate.fire(workingCopy);
+    }
+    remove(resource) {
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        if (disposeListener) {
+            dispose(disposeListener);
+            this.mapResourceToDisposeListener.delete(resource);
+        }
+        return this.mapResourceToWorkingCopy.delete(resource);
+    }
+    get workingCopies() {
+        return [...( this.mapResourceToWorkingCopy.values())];
+    }
+    get(resource) {
+        return this.mapResourceToWorkingCopy.get(resource);
+    }
+    dispose() {
+        super.dispose();
+        this.mapResourceToWorkingCopy.clear();
+        dispose(( this.mapResourceToDisposeListener.values()));
+        this.mapResourceToDisposeListener.clear();
+    }
+    async destroy() {
+        try {
+            await Promises.settled(( this.workingCopies.map(async (workingCopy) => {
+                if (workingCopy.isDirty()) {
+                    await this.saveWithFallback(workingCopy);
+                }
+            })));
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        dispose(( this.mapResourceToWorkingCopy.values()));
+        this.dispose();
+    }
+    async saveWithFallback(workingCopy) {
+        let saveSuccess = false;
+        try {
+            saveSuccess = await workingCopy.save();
+        }
+        catch (error) {
+        }
+        if (!saveSuccess || workingCopy.isDirty()) {
+            const backup = await this.workingCopyBackupService.resolve(workingCopy);
+            if (backup) {
+                await this.fileService.writeFile(workingCopy.resource, backup.value, { unlock: true });
+            }
+        }
+    }
+};
+BaseFileWorkingCopyManager = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IWorkingCopyBackupService))
+], BaseFileWorkingCopyManager));
+
+export { BaseFileWorkingCopyManager };

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.js

@@ -0,0 +1,372 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual, toLocalResource, basename, dirname, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { StoredFileWorkingCopyManager } from './storedFileWorkingCopyManager.js';
+import { UntitledFileWorkingCopy } from './untitledFileWorkingCopy.js';
+import { UntitledFileWorkingCopyManager } from './untitledFileWorkingCopyManager.js';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IElevatedFileService } from 'vscode/vscode/vs/workbench/services/files/common/elevatedFileService';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IDecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/common/decorations';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { listErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IFileDialogService, IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var FileWorkingCopyManager_1;
+let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
+    static { FileWorkingCopyManager_1 = this; }
+    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+        'fileWorkingCopyCreate.source',
+        "File Created"
+    ))); }
+    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localizeWithPath(
+        'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+        'fileWorkingCopyReplace.source',
+        "File Replaced"
+    ))); }
+    constructor(workingCopyTypeId, storedWorkingCopyModelFactory, untitledWorkingCopyModelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, fileDialogService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService, pathService, environmentService, dialogService, decorationsService) {
+        super();
+        this.workingCopyTypeId = workingCopyTypeId;
+        this.storedWorkingCopyModelFactory = storedWorkingCopyModelFactory;
+        this.untitledWorkingCopyModelFactory = untitledWorkingCopyModelFactory;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileDialogService = fileDialogService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.pathService = pathService;
+        this.environmentService = environmentService;
+        this.dialogService = dialogService;
+        this.decorationsService = decorationsService;
+        this.stored = this._register(( new StoredFileWorkingCopyManager(
+            this.workingCopyTypeId,
+            this.storedWorkingCopyModelFactory,
+            fileService,
+            lifecycleService,
+            labelService,
+            logService,
+            workingCopyFileService,
+            workingCopyBackupService,
+            uriIdentityService,
+            filesConfigurationService,
+            workingCopyService,
+            notificationService,
+            workingCopyEditorService,
+            editorService,
+            elevatedFileService
+        )));
+        this.untitled = this._register(( new UntitledFileWorkingCopyManager(
+            this.workingCopyTypeId,
+            this.untitledWorkingCopyModelFactory,
+            async (workingCopy, options) => {
+                const result = await this.saveAs(workingCopy.resource, undefined, options);
+                return result ? true : false;
+            },
+            fileService,
+            labelService,
+            logService,
+            workingCopyBackupService,
+            workingCopyService
+        )));
+        this.onDidCreate = Event.any(this.stored.onDidCreate, this.untitled.onDidCreate);
+        this.provideDecorations();
+    }
+    provideDecorations() {
+        const provider = this._register(new (class extends Disposable {
+            constructor(stored) {
+                super();
+                this.stored = stored;
+                this.label = ( localizeWithPath(
+                    'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                    'fileWorkingCopyDecorations',
+                    "File Working Copy Decorations"
+                ));
+                this._onDidChange = this._register(( new Emitter()));
+                this.onDidChange = this._onDidChange.event;
+                this.registerListeners();
+            }
+            registerListeners() {
+                this._register(this.stored.onDidResolve(workingCopy => {
+                    if (workingCopy.isReadonly() || workingCopy.hasState(4 )) {
+                        this._onDidChange.fire([workingCopy.resource]);
+                    }
+                }));
+                this._register(this.stored.onDidRemove(workingCopyUri => this._onDidChange.fire([workingCopyUri])));
+                this._register(this.stored.onDidChangeReadonly(workingCopy => this._onDidChange.fire([workingCopy.resource])));
+                this._register(this.stored.onDidChangeOrphaned(workingCopy => this._onDidChange.fire([workingCopy.resource])));
+            }
+            provideDecorations(uri) {
+                const workingCopy = this.stored.get(uri);
+                if (!workingCopy || workingCopy.isDisposed()) {
+                    return undefined;
+                }
+                const isReadonly = workingCopy.isReadonly();
+                const isOrphaned = workingCopy.hasState(4 );
+                if (isReadonly && isOrphaned) {
+                    return {
+                        color: listErrorForeground,
+                        letter: Codicon.lockSmall,
+                        strikethrough: true,
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                            'readonlyAndDeleted',
+                            "Deleted, Read-only"
+                        )),
+                    };
+                }
+                else if (isReadonly) {
+                    return {
+                        letter: Codicon.lockSmall,
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                            'readonly',
+                            "Read-only"
+                        )),
+                    };
+                }
+                else if (isOrphaned) {
+                    return {
+                        color: listErrorForeground,
+                        strikethrough: true,
+                        tooltip: ( localizeWithPath(
+                            'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                            'deleted',
+                            "Deleted"
+                        )),
+                    };
+                }
+                return undefined;
+            }
+        })(this.stored));
+        this._register(this.decorationsService.registerDecorationsProvider(provider));
+    }
+    get workingCopies() {
+        return [...this.stored.workingCopies, ...this.untitled.workingCopies];
+    }
+    get(resource) {
+        return this.stored.get(resource) ?? this.untitled.get(resource);
+    }
+    resolve(arg1, arg2) {
+        if (URI.isUri(arg1)) {
+            if (arg1.scheme === Schemas.untitled) {
+                return this.untitled.resolve({ untitledResource: arg1 });
+            }
+            else {
+                return this.stored.resolve(arg1, arg2);
+            }
+        }
+        return this.untitled.resolve(arg1);
+    }
+    async saveAs(source, target, options) {
+        if (!target) {
+            const workingCopy = this.get(source);
+            if (workingCopy instanceof UntitledFileWorkingCopy && workingCopy.hasAssociatedFilePath) {
+                target = await this.suggestSavePath(source);
+            }
+            else {
+                target = await this.fileDialogService.pickFileToSave(await this.suggestSavePath(options?.suggestedTarget ?? source), options?.availableFileSystems);
+            }
+        }
+        if (!target) {
+            return;
+        }
+        if (this.filesConfigurationService.isReadonly(target)) {
+            const confirmed = await this.confirmMakeWriteable(target);
+            if (!confirmed) {
+                return;
+            }
+            else {
+                this.filesConfigurationService.updateReadonly(target, false);
+            }
+        }
+        if (this.fileService.hasProvider(source) && isEqual(source, target)) {
+            return this.doSave(source, { ...options, force: true  });
+        }
+        if (this.fileService.hasProvider(source) && this.uriIdentityService.extUri.isEqual(source, target) && (await this.fileService.exists(source))) {
+            await this.workingCopyFileService.move([{ file: { source, target } }], CancellationToken.None);
+            return (await this.doSave(source, options)) ?? (await this.doSave(target, options));
+        }
+        return this.doSaveAs(source, target, options);
+    }
+    async doSave(resource, options) {
+        const storedFileWorkingCopy = this.stored.get(resource);
+        if (storedFileWorkingCopy) {
+            const success = await storedFileWorkingCopy.save(options);
+            if (success) {
+                return storedFileWorkingCopy;
+            }
+        }
+        return undefined;
+    }
+    async doSaveAs(source, target, options) {
+        let sourceContents;
+        const sourceWorkingCopy = this.get(source);
+        if (sourceWorkingCopy?.isResolved()) {
+            sourceContents = await sourceWorkingCopy.model.snapshot(CancellationToken.None);
+        }
+        else {
+            sourceContents = (await this.fileService.readFileStream(source)).value;
+        }
+        const { targetFileExists, targetStoredFileWorkingCopy } = await this.doResolveSaveTarget(source, target);
+        if (sourceWorkingCopy instanceof UntitledFileWorkingCopy &&
+            sourceWorkingCopy.hasAssociatedFilePath &&
+            targetFileExists &&
+            this.uriIdentityService.extUri.isEqual(target, toLocalResource(sourceWorkingCopy.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme))) {
+            const overwrite = await this.confirmOverwrite(target);
+            if (!overwrite) {
+                return undefined;
+            }
+        }
+        await targetStoredFileWorkingCopy.model?.update(sourceContents, CancellationToken.None);
+        if (!options?.source) {
+            options = {
+                ...options,
+                source: targetFileExists ? FileWorkingCopyManager_1.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE : FileWorkingCopyManager_1.FILE_WORKING_COPY_SAVE_CREATE_SOURCE
+            };
+        }
+        const success = await targetStoredFileWorkingCopy.save({ ...options, force: true  });
+        if (!success) {
+            return undefined;
+        }
+        try {
+            await sourceWorkingCopy?.revert();
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        return targetStoredFileWorkingCopy;
+    }
+    async doResolveSaveTarget(source, target) {
+        let targetFileExists = false;
+        let targetStoredFileWorkingCopy = this.stored.get(target);
+        if (targetStoredFileWorkingCopy?.isResolved()) {
+            targetFileExists = true;
+        }
+        else {
+            targetFileExists = await this.fileService.exists(target);
+            if (!targetFileExists) {
+                await this.workingCopyFileService.create([{ resource: target }], CancellationToken.None);
+            }
+            if (this.uriIdentityService.extUri.isEqual(source, target) && this.get(source)) {
+                targetStoredFileWorkingCopy = await this.stored.resolve(source);
+            }
+            else {
+                targetStoredFileWorkingCopy = await this.stored.resolve(target);
+            }
+        }
+        return { targetFileExists, targetStoredFileWorkingCopy };
+    }
+    async confirmOverwrite(resource) {
+        const { confirmed } = await this.dialogService.confirm({
+            type: 'warning',
+            message: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'confirmOverwrite',
+                "'{0}' already exists. Do you want to replace it?",
+                basename(resource)
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'overwriteIrreversible',
+                "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
+                basename(resource),
+                basename(dirname(resource))
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                { key: 'replaceButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Replace"
+            ))
+        });
+        return confirmed;
+    }
+    async confirmMakeWriteable(resource) {
+        const { confirmed } = await this.dialogService.confirm({
+            type: 'warning',
+            message: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'confirmMakeWriteable',
+                "'{0}' is marked as read-only. Do you want to save anyway?",
+                basename(resource)
+            )),
+            detail: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                'confirmMakeWriteableDetail',
+                "Paths can be configured as read-only via settings."
+            )),
+            primaryButton: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/fileWorkingCopyManager',
+                { key: 'makeWriteableButtonLabel', comment: ['&& denotes a mnemonic'] },
+                "&&Save Anyway"
+            ))
+        });
+        return confirmed;
+    }
+    async suggestSavePath(resource) {
+        if (this.fileService.hasProvider(resource)) {
+            return resource;
+        }
+        const workingCopy = this.get(resource);
+        if (workingCopy instanceof UntitledFileWorkingCopy && workingCopy.hasAssociatedFilePath) {
+            return toLocalResource(resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
+        }
+        const defaultFilePath = await this.fileDialogService.defaultFilePath();
+        if (workingCopy) {
+            const candidatePath = joinPath(defaultFilePath, workingCopy.name);
+            if (await this.pathService.hasValidBasename(candidatePath, workingCopy.name)) {
+                return candidatePath;
+            }
+        }
+        return joinPath(defaultFilePath, basename(resource));
+    }
+    async destroy() {
+        await Promises.settled([
+            this.stored.destroy(),
+            this.untitled.destroy()
+        ]);
+    }
+};
+FileWorkingCopyManager = FileWorkingCopyManager_1 = ( __decorate([
+    ( __param(3, IFileService)),
+    ( __param(4, ILifecycleService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IWorkingCopyFileService)),
+    ( __param(8, IWorkingCopyBackupService)),
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, IFileDialogService)),
+    ( __param(11, IFilesConfigurationService)),
+    ( __param(12, IWorkingCopyService)),
+    ( __param(13, INotificationService)),
+    ( __param(14, IWorkingCopyEditorService)),
+    ( __param(15, IEditorService)),
+    ( __param(16, IElevatedFileService)),
+    ( __param(17, IPathService)),
+    ( __param(18, IWorkbenchEnvironmentService)),
+    ( __param(19, IDialogService)),
+    ( __param(20, IDecorationsService))
+], FileWorkingCopyManager));
+
+export { FileWorkingCopyManager };