@codingame/monaco-vscode-chat-service-override 22.1.8 → 23.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTimeline.js

@@ -1,435 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { equals, binarySearch2 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
-import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { DisposableStore, thenRegisterOrDispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { equals as equals$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
-import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
-import { ChatEditingModifiedNotebookEntry } from './chatEditingModifiedNotebookEntry.js';
-import { ChatEditingModifiedNotebookDiff } from './notebook/chatEditingModifiedNotebookDiff.js';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-import { derivedOpts, derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
-import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
-import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
-
-var ChatEditingTimeline_1;
-let ChatEditingTimeline = class ChatEditingTimeline {
-    static { ChatEditingTimeline_1 = this; }
-    static { this.POST_EDIT_STOP_ID = 'd19944f6-f46c-4e17-911b-79a8e843c7c0'; }
-    static createEmptySnapshot(undoStop) {
-        return {
-            stopId: undoStop,
-            entries: ( new ResourceMap()),
-        };
-    }
-    constructor(_editorWorkerService, _instantiationService, configurationService, _textModelService) {
-        this._editorWorkerService = _editorWorkerService;
-        this._instantiationService = _instantiationService;
-        this._textModelService = _textModelService;
-        this._linearHistory = observableValue(this, []);
-        this._linearHistoryIndex = observableValue(this, 0);
-        this._diffsBetweenStops = ( new Map());
-        this._fullDiffs = ( new Map());
-        this.requestDisablement = derivedOpts({ equalsFn: (a, b) => equals(a, b, equals$1) }, reader => {
-            const history = this._linearHistory.read(reader);
-            const index = this._linearHistoryIndex.read(reader);
-            const undoRequests = [];
-            for (const entry of history) {
-                if (!entry.requestId) ;
-                else if (entry.startIndex >= index) {
-                    undoRequests.push({ requestId: entry.requestId });
-                }
-                else if (entry.startIndex + entry.stops.length > index) {
-                    undoRequests.push({ requestId: entry.requestId, afterUndoStop: entry.stops[(index - 1) - entry.startIndex].stopId });
-                }
-            }
-            return undoRequests;
-        });
-        this._ignoreTrimWhitespaceObservable = observableConfigValue('diffEditor.ignoreTrimWhitespace', true, configurationService);
-        this.canUndo = derived(r => {
-            const linearHistoryIndex = this._linearHistoryIndex.read(r);
-            return linearHistoryIndex > 1;
-        });
-        this.canRedo = derived(r => {
-            const linearHistoryIndex = this._linearHistoryIndex.read(r);
-            return linearHistoryIndex < getMaxHistoryIndex(this._linearHistory.read(r));
-        });
-    }
-    restoreFromState(state, tx) {
-        this._linearHistory.set(state.history, tx);
-        this._linearHistoryIndex.set(state.index, tx);
-    }
-    getSnapshotForRestore(requestId, stopId) {
-        if (requestId === undefined) {
-            return undefined;
-        }
-        const stopRef = this.findEditStop(requestId, stopId);
-        if (!stopRef) {
-            return undefined;
-        }
-        const toIndex = stopRef.stop.stopId === undefined ? stopRef.historyIndex : stopRef.historyIndex + 1;
-        return {
-            stop: stopRef.stop,
-            apply: () => this._linearHistoryIndex.set(toIndex, undefined)
-        };
-    }
-    ensureEditInUndoStopMatches(requestId, undoStop, entry, next, tx) {
-        const history = this._linearHistory.get();
-        const snapIndex = history.findIndex((s) => s.requestId === requestId);
-        if (snapIndex === -1) {
-            return;
-        }
-        const snap = { ...history[snapIndex] };
-        let stopIndex = snap.stops.findIndex((s) => s.stopId === undoStop);
-        if (stopIndex === -1) {
-            return;
-        }
-        let linearHistoryIndexIncr = 0;
-        if (next) {
-            if (stopIndex === snap.stops.length - 1) {
-                if (snap.stops[stopIndex].stopId === ChatEditingTimeline_1.POST_EDIT_STOP_ID) {
-                    throw ( new Error('cannot duplicate post-edit stop'));
-                }
-                snap.stops = snap.stops.concat(ChatEditingTimeline_1.createEmptySnapshot(ChatEditingTimeline_1.POST_EDIT_STOP_ID));
-                linearHistoryIndexIncr++;
-            }
-            stopIndex++;
-        }
-        const stop = snap.stops[stopIndex];
-        if (entry.equalsSnapshot(stop.entries.get(entry.modifiedURI))) {
-            return;
-        }
-        const newMap = ( new ResourceMap(stop.entries));
-        newMap.set(entry.modifiedURI, entry.createSnapshot(requestId, stop.stopId));
-        const newStop = snap.stops.slice();
-        newStop[stopIndex] = { ...stop, entries: newMap };
-        snap.stops = newStop;
-        const newHistory = history.slice();
-        newHistory[snapIndex] = snap;
-        this._linearHistory.set(newHistory, tx);
-        if (linearHistoryIndexIncr) {
-            this._linearHistoryIndex.set(this._linearHistoryIndex.get() + linearHistoryIndexIncr, tx);
-        }
-    }
-    getUndoSnapshot() {
-        return this.getUndoRedoSnapshot(-1);
-    }
-    getRedoSnapshot() {
-        return this.getUndoRedoSnapshot(1);
-    }
-    getUndoRedoSnapshot(direction) {
-        let idx = this._linearHistoryIndex.get() - 1;
-        const max = getMaxHistoryIndex(this._linearHistory.get());
-        const startEntry = this.getHistoryEntryByLinearIndex(idx);
-        let entry = startEntry;
-        if (!startEntry) {
-            return undefined;
-        }
-        do {
-            idx += direction;
-            entry = this.getHistoryEntryByLinearIndex(idx);
-        } while (idx + direction < max &&
-            idx + direction >= 0 &&
-            entry &&
-            !(direction === -1 && entry.entry.requestId !== startEntry.entry.requestId) &&
-            !stopProvidesNewData(startEntry.stop, entry.stop));
-        if (entry) {
-            return { stop: entry.stop, apply: () => this._linearHistoryIndex.set(idx + 1, undefined) };
-        }
-        return undefined;
-    }
-    getStateForPersistence() {
-        return { history: this._linearHistory.get(), index: this._linearHistoryIndex.get() };
-    }
-    findSnapshot(requestId) {
-        return this._linearHistory.get().find((s) => s.requestId === requestId);
-    }
-    findEditStop(requestId, undoStop) {
-        const snapshot = this.findSnapshot(requestId);
-        if (!snapshot) {
-            return undefined;
-        }
-        const idx = snapshot.stops.findIndex((s) => s.stopId === undoStop);
-        return idx === -1 ? undefined : { stop: snapshot.stops[idx], snapshot, historyIndex: snapshot.startIndex + idx };
-    }
-    getHistoryEntryByLinearIndex(index) {
-        const history = this._linearHistory.get();
-        const searchedIndex = binarySearch2(history.length, (e) => history[e].startIndex - index);
-        const entry = history[searchedIndex < 0 ? (~searchedIndex) - 1 : searchedIndex];
-        if (!entry || index - entry.startIndex >= entry.stops.length) {
-            return undefined;
-        }
-        return {
-            entry,
-            stop: entry.stops[index - entry.startIndex]
-        };
-    }
-    pushSnapshot(requestId, undoStop, snapshot) {
-        const linearHistoryPtr = this._linearHistoryIndex.get();
-        const newLinearHistory = [];
-        for (const entry of this._linearHistory.get()) {
-            if (entry.startIndex >= linearHistoryPtr) {
-                break;
-            }
-            else if (linearHistoryPtr - entry.startIndex < entry.stops.length) {
-                newLinearHistory.push({ requestId: entry.requestId, stops: entry.stops.slice(0, linearHistoryPtr - entry.startIndex), startIndex: entry.startIndex });
-            }
-            else {
-                newLinearHistory.push(entry);
-            }
-        }
-        const lastEntry = newLinearHistory.at(-1);
-        if (requestId && lastEntry?.requestId === requestId) {
-            const hadPostEditStop = lastEntry.stops.at(-1)?.stopId === ChatEditingTimeline_1.POST_EDIT_STOP_ID && undoStop;
-            if (hadPostEditStop) {
-                const rebaseUri = (uri) => uri.with({ query: uri.query.replace(ChatEditingTimeline_1.POST_EDIT_STOP_ID, undoStop) });
-                for (const [uri, prev] of lastEntry.stops.at(-1).entries) {
-                    snapshot.entries.set(uri, { ...prev, snapshotUri: rebaseUri(prev.snapshotUri), resource: rebaseUri(prev.resource) });
-                }
-            }
-            newLinearHistory[newLinearHistory.length - 1] = {
-                ...lastEntry,
-                stops: [...(hadPostEditStop ? lastEntry.stops.slice(0, -1) : lastEntry.stops), snapshot]
-            };
-        }
-        else {
-            newLinearHistory.push({ requestId, startIndex: lastEntry ? lastEntry.startIndex + lastEntry.stops.length : 0, stops: [snapshot] });
-        }
-        transaction((tx) => {
-            const last = newLinearHistory[newLinearHistory.length - 1];
-            this._linearHistory.set(newLinearHistory, tx);
-            this._linearHistoryIndex.set(last.startIndex + last.stops.length, tx);
-        });
-    }
-    _entryDiffBetweenTextStops(entriesContent, modelUrisObservable) {
-        const modelRefsPromise = derived(this, (reader) => {
-            const modelUris = modelUrisObservable.read(reader);
-            if (!modelUris) {
-                return undefined;
-            }
-            const store = reader.store.add(( new DisposableStore()));
-            const promise = Promise.all(( modelUris.map(u => this._textModelService.createModelReference(u)))).then(refs => {
-                if (store.isDisposed) {
-                    refs.forEach(r => r.dispose());
-                }
-                else {
-                    refs.forEach(r => store.add(r));
-                }
-                return refs;
-            });
-            return ( new ObservablePromise(promise));
-        });
-        return derived((reader) => {
-            const refs2 = modelRefsPromise.read(reader)?.promiseResult.read(reader);
-            const refs = refs2?.data;
-            if (!refs) {
-                return;
-            }
-            const entries = entriesContent.read(reader);
-            if (entries?.before && ChatEditingModifiedNotebookEntry.canHandleSnapshot(entries.before)) {
-                const diffService = this._instantiationService.createInstance(ChatEditingModifiedNotebookDiff, entries.before, entries.after);
-                return ( new ObservablePromise(diffService.computeDiff()));
-            }
-            const ignoreTrimWhitespace = this._ignoreTrimWhitespaceObservable.read(reader);
-            const promise = this._computeDiff(refs[0].object.textEditorModel.uri, refs[1].object.textEditorModel.uri, ignoreTrimWhitespace);
-            return ( new ObservablePromise(promise));
-        });
-    }
-    _createDiffBetweenStopsObservable(uri, requestId, stopId) {
-        const entries = derivedOpts({
-            equalsFn: (a, b) => snapshotsEqualForDiff(a?.before, b?.before) && snapshotsEqualForDiff(a?.after, b?.after),
-        }, reader => {
-            const stops = requestId ?
-                getCurrentAndNextStop(requestId, stopId, this._linearHistory.read(reader)) :
-                getFirstAndLastStop(uri, this._linearHistory.read(reader));
-            if (!stops) {
-                return undefined;
-            }
-            const before = stops.current.get(uri);
-            const after = stops.next.get(uri);
-            if (!before || !after) {
-                return undefined;
-            }
-            return { before, after };
-        });
-        const modelUrisObservable = derivedOpts({ equalsFn: (a, b) => equals(a, b, isEqual) }, reader => {
-            const entriesValue = entries.read(reader);
-            if (!entriesValue) {
-                return undefined;
-            }
-            return [entriesValue.before.snapshotUri, entriesValue.after.snapshotUri];
-        });
-        const diff = this._entryDiffBetweenTextStops(entries, modelUrisObservable);
-        return derived(reader => {
-            return diff.read(reader)?.promiseResult.read(reader)?.data || undefined;
-        });
-    }
-    getEntryDiffBetweenStops(uri, requestId, stopId) {
-        if (requestId) {
-            const key = `${uri}\0${requestId}\0${stopId}`;
-            let observable = this._diffsBetweenStops.get(key);
-            if (!observable) {
-                observable = this._createDiffBetweenStopsObservable(uri, requestId, stopId);
-                this._diffsBetweenStops.set(key, observable);
-            }
-            return observable;
-        }
-        else {
-            const key = ( uri.toString());
-            let observable = this._fullDiffs.get(key);
-            if (!observable) {
-                observable = this._createDiffBetweenStopsObservable(uri, requestId, stopId);
-                this._fullDiffs.set(key, observable);
-            }
-            return observable;
-        }
-    }
-    getEntryDiffBetweenRequests(uri, startRequestId, stopRequestId) {
-        const snapshotUris = derivedOpts({ equalsFn: (a, b) => equals(a, b, isEqual) }, reader => {
-            const history = this._linearHistory.read(reader);
-            const firstSnapshotUri = this._getFirstSnapshotForUriAfterRequest(history, uri, startRequestId, true);
-            const lastSnapshotUri = this._getFirstSnapshotForUriAfterRequest(history, uri, stopRequestId, false);
-            return [firstSnapshotUri, lastSnapshotUri];
-        });
-        const modelRefs = derived((reader) => {
-            const snapshots = snapshotUris.read(reader);
-            const firstSnapshotUri = snapshots[0];
-            const lastSnapshotUri = snapshots[1];
-            if (!firstSnapshotUri || !lastSnapshotUri) {
-                return;
-            }
-            const store = ( new DisposableStore());
-            reader.store.add(store);
-            const referencesPromise = Promise.all(( [firstSnapshotUri, lastSnapshotUri].map(u => {
-                return thenRegisterOrDispose(this._textModelService.createModelReference(u), store);
-            })));
-            return ( new ObservablePromise(referencesPromise));
-        });
-        const diff = derived((reader) => {
-            const references = modelRefs.read(reader)?.promiseResult.read(reader);
-            const refs = references?.data;
-            if (!refs) {
-                return;
-            }
-            const ignoreTrimWhitespace = this._ignoreTrimWhitespaceObservable.read(reader);
-            const promise = this._computeDiff(refs[0].object.textEditorModel.uri, refs[1].object.textEditorModel.uri, ignoreTrimWhitespace);
-            return ( new ObservablePromise(promise));
-        });
-        return derived(reader => {
-            return diff.read(reader)?.promiseResult.read(reader)?.data || undefined;
-        });
-    }
-    _computeDiff(originalUri, modifiedUri, ignoreTrimWhitespace) {
-        return this._editorWorkerService.computeDiff(originalUri, modifiedUri, { ignoreTrimWhitespace, computeMoves: false, maxComputationTimeMs: 3000 }, 'advanced').then((diff) => {
-            const entryDiff = {
-                originalURI: originalUri,
-                modifiedURI: modifiedUri,
-                identical: !!diff?.identical,
-                quitEarly: !diff || diff.quitEarly,
-                added: 0,
-                removed: 0,
-            };
-            if (diff) {
-                for (const change of diff.changes) {
-                    entryDiff.removed += change.original.endLineNumberExclusive - change.original.startLineNumber;
-                    entryDiff.added += change.modified.endLineNumberExclusive - change.modified.startLineNumber;
-                }
-            }
-            return entryDiff;
-        });
-    }
-    _getFirstSnapshotForUriAfterRequest(history, uri, requestId, inclusive) {
-        const requestIndex = history.findIndex(s => s.requestId === requestId);
-        if (requestIndex === -1) {
-            return undefined;
-        }
-        const processedIndex = requestIndex + (inclusive ? 0 : 1);
-        for (let i = processedIndex; i < history.length; i++) {
-            const snapshot = history[i];
-            for (const stop of snapshot.stops) {
-                const entry = stop.entries.get(uri);
-                if (entry) {
-                    return entry.snapshotUri;
-                }
-            }
-        }
-        return uri;
-    }
-};
-ChatEditingTimeline = ChatEditingTimeline_1 = ( __decorate([
-    ( __param(0, IEditorWorkerService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, ITextModelService))
-], ChatEditingTimeline));
-function stopProvidesNewData(origin, target) {
-    return ( Iterable.some(
-        target.entries,
-        ([uri, e]) => origin.entries.get(uri)?.current !== e.current
-    ));
-}
-function getMaxHistoryIndex(history) {
-    const lastHistory = history.at(-1);
-    return lastHistory ? lastHistory.startIndex + lastHistory.stops.length : 0;
-}
-function snapshotsEqualForDiff(a, b) {
-    if (!a || !b) {
-        return a === b;
-    }
-    return isEqual(a.snapshotUri, b.snapshotUri) && a.current === b.current;
-}
-function getCurrentAndNextStop(requestId, stopId, history) {
-    const snapshotIndex = history.findIndex(s => s.requestId === requestId);
-    if (snapshotIndex === -1) {
-        return undefined;
-    }
-    const snapshot = history[snapshotIndex];
-    const stopIndex = snapshot.stops.findIndex(s => s.stopId === stopId);
-    if (stopIndex === -1) {
-        return undefined;
-    }
-    const currentStop = snapshot.stops[stopIndex];
-    const current = currentStop.entries;
-    const nextStop = stopIndex < snapshot.stops.length - 1
-        ? snapshot.stops[stopIndex + 1]
-        : undefined;
-    if (!nextStop) {
-        return undefined;
-    }
-    return { current, currentStopId: currentStop.stopId, next: nextStop.entries, nextStopId: nextStop.stopId };
-}
-function getFirstAndLastStop(uri, history) {
-    let firstStopWithUri;
-    for (const snapshot of history) {
-        const stop = snapshot.stops.find(s => ( s.entries.has(uri)));
-        if (stop) {
-            firstStopWithUri = stop;
-            break;
-        }
-    }
-    let lastStopWithUri;
-    let lastStopWithUriId;
-    for (let i = history.length - 1; i >= 0; i--) {
-        const snapshot = history[i];
-        const stop = findLast(snapshot.stops, s => ( s.entries.has(uri)));
-        if (stop) {
-            lastStopWithUri = stop.entries;
-            lastStopWithUriId = stop.stopId;
-            break;
-        }
-    }
-    if (!firstStopWithUri || !lastStopWithUri) {
-        return undefined;
-    }
-    return { current: firstStopWithUri.entries, currentStopId: firstStopWithUri.stopId, next: lastStopWithUri, nextStopId: lastStopWithUriId };
-}
-
-export { ChatEditingTimeline };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/chatEditingModifiedNotebookDiff.d.ts

@@ -1,14 +0,0 @@
-import { INotebookEditorModelResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service";
-import { INotebookLoggingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service";
-import { INotebookEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service";
-import { IEditSessionEntryDiff, ISnapshotEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
-export declare class ChatEditingModifiedNotebookDiff {
-    private readonly original;
-    private readonly modified;
-    private readonly notebookEditorWorkerService;
-    private readonly notebookLoggingService;
-    private readonly notebookEditorModelService;
-    static NewModelCounter: number;
-    constructor(original: ISnapshotEntry, modified: ISnapshotEntry, notebookEditorWorkerService: INotebookEditorWorkerService, notebookLoggingService: INotebookLoggingService, notebookEditorModelService: INotebookEditorModelResolverService);
-    computeDiff(): Promise<IEditSessionEntryDiff>;
-}

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/chatEditingModifiedNotebookDiff.js

@@ -1,67 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { computeDiff } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/common/notebookDiff';
-import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
-import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
-import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
-
-let ChatEditingModifiedNotebookDiff = class ChatEditingModifiedNotebookDiff {
-    static { this.NewModelCounter = 0; }
-    constructor(original, modified, notebookEditorWorkerService, notebookLoggingService, notebookEditorModelService) {
-        this.original = original;
-        this.modified = modified;
-        this.notebookEditorWorkerService = notebookEditorWorkerService;
-        this.notebookLoggingService = notebookLoggingService;
-        this.notebookEditorModelService = notebookEditorModelService;
-    }
-    async computeDiff() {
-        let added = 0;
-        let removed = 0;
-        const disposables = ( new DisposableStore());
-        try {
-            const [modifiedRef, originalRef] = await Promise.all([
-                this.notebookEditorModelService.resolve(this.modified.snapshotUri),
-                this.notebookEditorModelService.resolve(this.original.snapshotUri)
-            ]);
-            disposables.add(modifiedRef);
-            disposables.add(originalRef);
-            const notebookDiff = await this.notebookEditorWorkerService.computeDiff(this.original.snapshotUri, this.modified.snapshotUri);
-            const result = computeDiff(originalRef.object.notebook, modifiedRef.object.notebook, notebookDiff);
-            result.cellDiffInfo.forEach(diff => {
-                switch (diff.type) {
-                    case 'modified':
-                    case 'insert':
-                        added++;
-                        break;
-                    case 'delete':
-                        removed++;
-                        break;
-                    default:
-                        break;
-                }
-            });
-        }
-        catch (e) {
-            this.notebookLoggingService.error('Notebook Chat', 'Error computing diff:\n' + e);
-        }
-        finally {
-            disposables.dispose();
-        }
-        return {
-            added,
-            removed,
-            identical: added === 0 && removed === 0,
-            quitEarly: false,
-            modifiedURI: this.modified.snapshotUri,
-            originalURI: this.original.snapshotUri,
-        };
-    }
-};
-ChatEditingModifiedNotebookDiff = ( __decorate([
-    ( __param(2, INotebookEditorWorkerService)),
-    ( __param(3, INotebookLoggingService)),
-    ( __param(4, INotebookEditorModelResolverService))
-], ChatEditingModifiedNotebookDiff));
-
-export { ChatEditingModifiedNotebookDiff };

package/vscode/src/vs/workbench/contrib/chat/browser/chatPasteProviders.d.ts

@@ -1,49 +0,0 @@
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { IReadonlyVSDataTransfer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/dataTransfer";
-import { HierarchicalKind } from "@codingame/monaco-vscode-api/vscode/vs/base/common/hierarchicalKind";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
-import { DocumentPasteContext, DocumentPasteEditProvider, DocumentPasteEditsSession } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
-import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
-import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
-import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
-import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
-export declare class PasteImageProvider implements DocumentPasteEditProvider {
-    private readonly chatWidgetService;
-    private readonly extensionService;
-    private readonly fileService;
-    private readonly environmentService;
-    private readonly logService;
-    private readonly imagesFolder;
-    readonly kind: HierarchicalKind;
-    readonly providedPasteEditKinds: HierarchicalKind[];
-    readonly copyMimeTypes: never[];
-    readonly pasteMimeTypes: string[];
-    constructor(chatWidgetService: IChatWidgetService, extensionService: IExtensionService, fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService);
-    provideDocumentPasteEdits(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, context: DocumentPasteContext, token: CancellationToken): Promise<DocumentPasteEditsSession | undefined>;
-}
-export declare function isImage(array: Uint8Array): boolean;
-export declare class CopyTextProvider implements DocumentPasteEditProvider {
-    readonly providedPasteEditKinds: never[];
-    readonly copyMimeTypes: string[];
-    readonly pasteMimeTypes: never[];
-    prepareDocumentPaste(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<undefined | IReadonlyVSDataTransfer>;
-}
-export declare class PasteTextProvider implements DocumentPasteEditProvider {
-    private readonly chatWidgetService;
-    private readonly modelService;
-    readonly kind: HierarchicalKind;
-    readonly providedPasteEditKinds: HierarchicalKind[];
-    readonly copyMimeTypes: never[];
-    readonly pasteMimeTypes: string[];
-    constructor(chatWidgetService: IChatWidgetService, modelService: IModelService);
-    provideDocumentPasteEdits(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, _context: DocumentPasteContext, token: CancellationToken): Promise<DocumentPasteEditsSession | undefined>;
-}
-export declare class ChatPasteProvidersFeature extends Disposable {
-    constructor(instaService: IInstantiationService, languageFeaturesService: ILanguageFeaturesService, chatWidgetService: IChatWidgetService, extensionService: IExtensionService, fileService: IFileService, modelService: IModelService, environmentService: IEnvironmentService, logService: ILogService);
-}