@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSession.d.ts

@@ -0,0 +1,199 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { ITextModel, IValidEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IRange, Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { DetailedLineRangeMapping, LineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
+import { IInlineChatSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatModel, IChatRequestModel, IChatTextEditGroupState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatAgent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IDocumentDiff } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/editor/common/diff/documentDiffProvider";
+export type TelemetryData = {
+    extension: string;
+    rounds: string;
+    undos: string;
+    unstashed: number;
+    edits: number;
+    finishedByEdit: boolean;
+    startTime: string;
+    endTime: string;
+    acceptedHunks: number;
+    discardedHunks: number;
+    responseTypes: string;
+};
+export type TelemetryDataClassification = {
+    owner: "jrieken";
+    comment: "Data about an interaction editor session";
+    extension: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The extension providing the data";
+    };
+    rounds: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Number of request that were made";
+    };
+    undos: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Requests that have been undone";
+    };
+    edits: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Did edits happen while the session was active";
+    };
+    unstashed: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "How often did this session become stashed and resumed";
+    };
+    finishedByEdit: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Did edits cause the session to terminate";
+    };
+    startTime: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "When the session started";
+    };
+    endTime: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "When the session ended";
+    };
+    acceptedHunks: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Number of accepted hunks";
+    };
+    discardedHunks: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Number of discarded hunks";
+    };
+    responseTypes: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Comma separated list of response types like edits, message, mixed";
+    };
+};
+export declare class SessionWholeRange {
+    private readonly _textModel;
+    private static readonly _options;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<this>;
+    private _decorationIds;
+    constructor(_textModel: ITextModel, wholeRange: IRange);
+    dispose(): void;
+    fixup(changes: readonly DetailedLineRangeMapping[]): void;
+    get trackedInitialRange(): Range;
+    get value(): Range;
+}
+export declare class Session {
+    readonly headless: boolean;
+    /**
+     * The URI of the document which is being EditorEdit
+     */
+    readonly targetUri: URI;
+    /**
+     * A copy of the document at the time the session was started
+     */
+    readonly textModel0: ITextModel;
+    /**
+     * The model of the editor
+     */
+    readonly textModelN: ITextModel;
+    readonly agent: IChatAgent;
+    readonly wholeRange: SessionWholeRange;
+    readonly hunkData: HunkData;
+    readonly chatModel: IChatModel;
+    private _isUnstashed;
+    private readonly _startTime;
+    private readonly _teldata;
+    private readonly _versionByRequest;
+    constructor(headless: boolean, 
+    /**
+     * The URI of the document which is being EditorEdit
+     */
+    targetUri: URI, 
+    /**
+     * A copy of the document at the time the session was started
+     */
+    textModel0: ITextModel, 
+    /**
+     * The model of the editor
+     */
+    textModelN: ITextModel, agent: IChatAgent, wholeRange: SessionWholeRange, hunkData: HunkData, chatModel: IChatModel, versionsByRequest?: [
+        string,
+        number
+    ][]);
+    get isUnstashed(): boolean;
+    markUnstashed(): void;
+    markModelVersion(request: IChatRequestModel): void;
+    get versionsByRequest(): [
+        string,
+        number
+    ][];
+    undoChangesUntil(requestId: string): Promise<boolean>;
+    get hasChangedText(): boolean;
+    asChangedText(changes: readonly LineRangeMapping[]): string | undefined;
+    recordExternalEditOccurred(didFinish: boolean): void;
+    asTelemetryData(): TelemetryData;
+}
+export declare class StashedSession {
+    private readonly _undoCancelEdits;
+    private readonly _sessionService;
+    private readonly _logService;
+    private readonly _listener;
+    private readonly _ctxHasStashedSession;
+    private _session;
+    constructor(editor: ICodeEditor, session: Session, _undoCancelEdits: IValidEditOperation[], contextKeyService: IContextKeyService, _sessionService: IInlineChatSessionService, _logService: ILogService);
+    dispose(): void;
+    unstash(): Session | undefined;
+}
+export declare class HunkData {
+    private readonly _editorWorkerService;
+    private readonly _textModel0;
+    private readonly _textModelN;
+    private static readonly _HUNK_TRACKED_RANGE;
+    private static readonly _HUNK_THRESHOLD;
+    private readonly _store;
+    private readonly _data;
+    private _ignoreChanges;
+    constructor(_editorWorkerService: IEditorWorkerService, _textModel0: ITextModel, _textModelN: ITextModel);
+    dispose(): void;
+    set ignoreTextModelNChanges(value: boolean);
+    get ignoreTextModelNChanges(): boolean;
+    private _mirrorChanges;
+    recompute(editState: IChatTextEditGroupState, diff?: IDocumentDiff | null): Promise<void>;
+    get size(): number;
+    get pending(): number;
+    private _discardEdits;
+    discardAll(): IValidEditOperation[];
+    getInfo(): HunkInformation[];
+}
+export declare enum HunkState {
+    Pending = 0,
+    Accepted = 1,
+    Rejected = 2
+}
+export interface HunkInformation {
+    /**
+     * The first element [0] is the whole modified range and subsequent elements are word-level changes
+     */
+    getRangesN(): Range[];
+    getRanges0(): Range[];
+    isInsertion(): boolean;
+    discardChanges(): void;
+    /**
+     * Accept the hunk. Applies the corresponding edits into textModel0
+     */
+    acceptChanges(): void;
+    getState(): HunkState;
+}

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSession.js

@@ -0,0 +1,482 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { TrackedRangeStickiness } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { CTX_INLINE_CHAT_HAS_STASHED_SESSION } from '../common/inlineChat.js';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { ModelDecorationOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
+import { DetailedLineRangeMapping } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping';
+import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { coalesceInPlace } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+
+var HunkData_1;
+class SessionWholeRange {
+    static { this._options = ModelDecorationOptions.register({ description: 'inlineChat/session/wholeRange' }); }
+    constructor(_textModel, wholeRange) {
+        this._textModel = _textModel;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._decorationIds = [];
+        this._decorationIds = _textModel.deltaDecorations([], [{ range: wholeRange, options: SessionWholeRange._options }]);
+    }
+    dispose() {
+        this._onDidChange.dispose();
+        if (!this._textModel.isDisposed()) {
+            this._textModel.deltaDecorations(this._decorationIds, []);
+        }
+    }
+    fixup(changes) {
+        const newDeco = [];
+        for (const { modified } of changes) {
+            const modifiedRange = this._textModel.validateRange(modified.isEmpty
+                ? ( new Range(
+                modified.startLineNumber,
+                1,
+                modified.startLineNumber,
+                Number.MAX_SAFE_INTEGER
+            ))
+                : ( new Range(
+                modified.startLineNumber,
+                1,
+                modified.endLineNumberExclusive - 1,
+                Number.MAX_SAFE_INTEGER
+            )));
+            newDeco.push({ range: modifiedRange, options: SessionWholeRange._options });
+        }
+        const [first, ...rest] = this._decorationIds;
+        const newIds = this._textModel.deltaDecorations(rest, newDeco);
+        this._decorationIds = [first].concat(newIds);
+        this._onDidChange.fire(this);
+    }
+    get trackedInitialRange() {
+        const [first] = this._decorationIds;
+        return this._textModel.getDecorationRange(first) ?? ( new Range(1, 1, 1, 1));
+    }
+    get value() {
+        let result;
+        for (const id of this._decorationIds) {
+            const range = this._textModel.getDecorationRange(id);
+            if (range) {
+                if (!result) {
+                    result = range;
+                }
+                else {
+                    result = Range.plusRange(result, range);
+                }
+            }
+        }
+        return result;
+    }
+}
+class Session {
+    constructor(headless,
+    targetUri,
+    textModel0,
+    textModelN, agent, wholeRange, hunkData, chatModel, versionsByRequest) {
+        this.headless = headless;
+        this.targetUri = targetUri;
+        this.textModel0 = textModel0;
+        this.textModelN = textModelN;
+        this.agent = agent;
+        this.wholeRange = wholeRange;
+        this.hunkData = hunkData;
+        this.chatModel = chatModel;
+        this._isUnstashed = false;
+        this._startTime = ( new Date());
+        this._versionByRequest = ( new Map());
+        this._teldata = {
+            extension: ExtensionIdentifier.toKey(agent.extensionId),
+            startTime: this._startTime.toISOString(),
+            endTime: this._startTime.toISOString(),
+            edits: 0,
+            finishedByEdit: false,
+            rounds: '',
+            undos: '',
+            unstashed: 0,
+            acceptedHunks: 0,
+            discardedHunks: 0,
+            responseTypes: ''
+        };
+        if (versionsByRequest) {
+            this._versionByRequest = ( new Map(versionsByRequest));
+        }
+    }
+    get isUnstashed() {
+        return this._isUnstashed;
+    }
+    markUnstashed() {
+        this._teldata.unstashed += 1;
+        this._isUnstashed = true;
+    }
+    markModelVersion(request) {
+        this._versionByRequest.set(request.id, this.textModelN.getAlternativeVersionId());
+    }
+    get versionsByRequest() {
+        return Array.from(this._versionByRequest);
+    }
+    async undoChangesUntil(requestId) {
+        const targetAltVersion = this._versionByRequest.get(requestId);
+        if (targetAltVersion === undefined) {
+            return false;
+        }
+        this.hunkData.ignoreTextModelNChanges = true;
+        try {
+            while (targetAltVersion < this.textModelN.getAlternativeVersionId() && this.textModelN.canUndo()) {
+                await this.textModelN.undo();
+            }
+        }
+        finally {
+            this.hunkData.ignoreTextModelNChanges = false;
+        }
+        return true;
+    }
+    get hasChangedText() {
+        return !this.textModel0.equalsTextBuffer(this.textModelN.getTextBuffer());
+    }
+    asChangedText(changes) {
+        if (changes.length === 0) {
+            return undefined;
+        }
+        let startLine = Number.MAX_VALUE;
+        let endLine = Number.MIN_VALUE;
+        for (const change of changes) {
+            startLine = Math.min(startLine, change.modified.startLineNumber);
+            endLine = Math.max(endLine, change.modified.endLineNumberExclusive);
+        }
+        return this.textModelN.getValueInRange(( new Range(startLine, 1, endLine, Number.MAX_VALUE)));
+    }
+    recordExternalEditOccurred(didFinish) {
+        this._teldata.edits += 1;
+        this._teldata.finishedByEdit = didFinish;
+    }
+    asTelemetryData() {
+        for (const item of this.hunkData.getInfo()) {
+            switch (item.getState()) {
+                case HunkState.Accepted:
+                    this._teldata.acceptedHunks += 1;
+                    break;
+                case HunkState.Rejected:
+                    this._teldata.discardedHunks += 1;
+                    break;
+            }
+        }
+        this._teldata.endTime = ( new Date()).toISOString();
+        return this._teldata;
+    }
+}
+let StashedSession = class StashedSession {
+    constructor(editor, session, _undoCancelEdits, contextKeyService, _sessionService, _logService) {
+        this._undoCancelEdits = _undoCancelEdits;
+        this._sessionService = _sessionService;
+        this._logService = _logService;
+        this._ctxHasStashedSession = CTX_INLINE_CHAT_HAS_STASHED_SESSION.bindTo(contextKeyService);
+        this._session = session;
+        this._ctxHasStashedSession.set(true);
+        this._listener = Event.once(Event.any(editor.onDidChangeCursorSelection, editor.onDidChangeModelContent, editor.onDidChangeModel, editor.onDidBlurEditorWidget))(() => {
+            this._session = undefined;
+            this._sessionService.releaseSession(session);
+            this._ctxHasStashedSession.reset();
+        });
+    }
+    dispose() {
+        this._listener.dispose();
+        this._ctxHasStashedSession.reset();
+        if (this._session) {
+            this._sessionService.releaseSession(this._session);
+        }
+    }
+    unstash() {
+        if (!this._session) {
+            return undefined;
+        }
+        this._listener.dispose();
+        const result = this._session;
+        result.markUnstashed();
+        result.hunkData.ignoreTextModelNChanges = true;
+        result.textModelN.pushEditOperations(null, this._undoCancelEdits, () => null);
+        result.hunkData.ignoreTextModelNChanges = false;
+        this._session = undefined;
+        this._logService.debug('[IE] Unstashed session');
+        return result;
+    }
+};
+StashedSession = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IInlineChatSessionService)),
+    ( __param(5, ILogService))
+], StashedSession));
+function lineRangeAsRange(lineRange, model) {
+    return lineRange.isEmpty
+        ? ( new Range(
+        lineRange.startLineNumber,
+        1,
+        lineRange.startLineNumber,
+        Number.MAX_SAFE_INTEGER
+    ))
+        : ( new Range(
+        lineRange.startLineNumber,
+        1,
+        lineRange.endLineNumberExclusive - 1,
+        Number.MAX_SAFE_INTEGER
+    ));
+}
+let HunkData = class HunkData {
+    static { HunkData_1 = this; }
+    static { this._HUNK_TRACKED_RANGE = ModelDecorationOptions.register({
+        description: 'inline-chat-hunk-tracked-range',
+        stickiness: TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges
+    }); }
+    static { this._HUNK_THRESHOLD = 8; }
+    constructor(_editorWorkerService, _textModel0, _textModelN) {
+        this._editorWorkerService = _editorWorkerService;
+        this._textModel0 = _textModel0;
+        this._textModelN = _textModelN;
+        this._store = ( new DisposableStore());
+        this._data = ( new Map());
+        this._ignoreChanges = false;
+        this._store.add(_textModelN.onDidChangeContent(e => {
+            if (!this._ignoreChanges) {
+                this._mirrorChanges(e);
+            }
+        }));
+    }
+    dispose() {
+        if (!this._textModelN.isDisposed()) {
+            this._textModelN.changeDecorations(accessor => {
+                for (const { textModelNDecorations } of ( this._data.values())) {
+                    textModelNDecorations.forEach(accessor.removeDecoration, accessor);
+                }
+            });
+        }
+        if (!this._textModel0.isDisposed()) {
+            this._textModel0.changeDecorations(accessor => {
+                for (const { textModel0Decorations } of ( this._data.values())) {
+                    textModel0Decorations.forEach(accessor.removeDecoration, accessor);
+                }
+            });
+        }
+        this._data.clear();
+        this._store.dispose();
+    }
+    set ignoreTextModelNChanges(value) {
+        this._ignoreChanges = value;
+    }
+    get ignoreTextModelNChanges() {
+        return this._ignoreChanges;
+    }
+    _mirrorChanges(event) {
+        const hunkRanges = [];
+        const ranges0 = [];
+        for (const entry of ( this._data.values())) {
+            if (entry.state === HunkState.Pending) {
+                for (let i = 1; i < entry.textModelNDecorations.length; i++) {
+                    const rangeN = this._textModelN.getDecorationRange(entry.textModelNDecorations[i]);
+                    const range0 = this._textModel0.getDecorationRange(entry.textModel0Decorations[i]);
+                    if (rangeN && range0) {
+                        hunkRanges.push({
+                            rangeN, range0,
+                            markAccepted: () => entry.state = HunkState.Accepted
+                        });
+                    }
+                }
+            }
+            else if (entry.state === HunkState.Accepted) {
+                for (let i = 1; i < entry.textModel0Decorations.length; i++) {
+                    const range = this._textModel0.getDecorationRange(entry.textModel0Decorations[i]);
+                    if (range) {
+                        ranges0.push(range);
+                    }
+                }
+            }
+        }
+        hunkRanges.sort((a, b) => Range.compareRangesUsingStarts(a.rangeN, b.rangeN));
+        ranges0.sort(Range.compareRangesUsingStarts);
+        const edits = [];
+        for (const change of event.changes) {
+            let isOverlapping = false;
+            let pendingChangesLen = 0;
+            for (const entry of hunkRanges) {
+                if (entry.rangeN.getEndPosition().isBefore(Range.getStartPosition(change.range))) {
+                    pendingChangesLen += this._textModelN.getValueLengthInRange(entry.rangeN);
+                    pendingChangesLen -= this._textModel0.getValueLengthInRange(entry.range0);
+                }
+                else if (Range.areIntersectingOrTouching(entry.rangeN, change.range)) {
+                    entry.markAccepted();
+                    isOverlapping = true;
+                    break;
+                }
+                else {
+                    break;
+                }
+            }
+            if (isOverlapping) {
+                continue;
+            }
+            const offset0 = change.rangeOffset - pendingChangesLen;
+            const start0 = this._textModel0.getPositionAt(offset0);
+            let acceptedChangesLen = 0;
+            for (const range of ranges0) {
+                if (range.getEndPosition().isBefore(start0)) {
+                    acceptedChangesLen += this._textModel0.getValueLengthInRange(range);
+                }
+            }
+            const start = this._textModel0.getPositionAt(offset0 + acceptedChangesLen);
+            const end = this._textModel0.getPositionAt(offset0 + acceptedChangesLen + change.rangeLength);
+            edits.push(EditOperation.replace(Range.fromPositions(start, end), change.text));
+        }
+        this._textModel0.pushEditOperations(null, edits, () => null);
+    }
+    async recompute(editState, diff) {
+        diff ??= await this._editorWorkerService.computeDiff(this._textModel0.uri, this._textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: Number.MAX_SAFE_INTEGER, computeMoves: false }, 'advanced');
+        let mergedChanges = [];
+        if (diff && diff.changes.length > 0) {
+            mergedChanges = [diff.changes[0]];
+            for (let i = 1; i < diff.changes.length; i++) {
+                const lastChange = mergedChanges[mergedChanges.length - 1];
+                const thisChange = diff.changes[i];
+                if (thisChange.modified.startLineNumber - lastChange.modified.endLineNumberExclusive <= HunkData_1._HUNK_THRESHOLD) {
+                    mergedChanges[mergedChanges.length - 1] = ( new DetailedLineRangeMapping(
+                        lastChange.original.join(thisChange.original),
+                        lastChange.modified.join(thisChange.modified),
+                        (lastChange.innerChanges ?? []).concat(thisChange.innerChanges ?? [])
+                    ));
+                }
+                else {
+                    mergedChanges.push(thisChange);
+                }
+            }
+        }
+        const hunks = ( mergedChanges.map(change => ( new RawHunk(change.original, change.modified, change.innerChanges ?? []))));
+        editState.applied = hunks.length;
+        this._textModelN.changeDecorations(accessorN => {
+            this._textModel0.changeDecorations(accessor0 => {
+                for (const { textModelNDecorations, textModel0Decorations } of ( this._data.values())) {
+                    textModelNDecorations.forEach(accessorN.removeDecoration, accessorN);
+                    textModel0Decorations.forEach(accessor0.removeDecoration, accessor0);
+                }
+                this._data.clear();
+                for (const hunk of hunks) {
+                    const textModelNDecorations = [];
+                    const textModel0Decorations = [];
+                    textModelNDecorations.push(accessorN.addDecoration(lineRangeAsRange(hunk.modified), HunkData_1._HUNK_TRACKED_RANGE));
+                    textModel0Decorations.push(accessor0.addDecoration(lineRangeAsRange(hunk.original), HunkData_1._HUNK_TRACKED_RANGE));
+                    for (const change of hunk.changes) {
+                        textModelNDecorations.push(accessorN.addDecoration(change.modifiedRange, HunkData_1._HUNK_TRACKED_RANGE));
+                        textModel0Decorations.push(accessor0.addDecoration(change.originalRange, HunkData_1._HUNK_TRACKED_RANGE));
+                    }
+                    this._data.set(hunk, {
+                        editState,
+                        textModelNDecorations,
+                        textModel0Decorations,
+                        state: HunkState.Pending
+                    });
+                }
+            });
+        });
+    }
+    get size() {
+        return this._data.size;
+    }
+    get pending() {
+        return Iterable.reduce(( this._data.values()), (r, { state }) => r + (state === HunkState.Pending ? 1 : 0), 0);
+    }
+    _discardEdits(item) {
+        const edits = [];
+        const rangesN = item.getRangesN();
+        const ranges0 = item.getRanges0();
+        for (let i = 1; i < rangesN.length; i++) {
+            const modifiedRange = rangesN[i];
+            const originalValue = this._textModel0.getValueInRange(ranges0[i]);
+            edits.push(EditOperation.replace(modifiedRange, originalValue));
+        }
+        return edits;
+    }
+    discardAll() {
+        const edits = [];
+        for (const item of this.getInfo()) {
+            if (item.getState() === HunkState.Pending) {
+                edits.push(this._discardEdits(item));
+            }
+        }
+        const undoEdits = [];
+        this._textModelN.pushEditOperations(null, edits.flat(), (_undoEdits) => {
+            undoEdits.push(_undoEdits);
+            return null;
+        });
+        return undoEdits.flat();
+    }
+    getInfo() {
+        const result = [];
+        for (const [hunk, data] of this._data.entries()) {
+            const item = {
+                getState: () => {
+                    return data.state;
+                },
+                isInsertion: () => {
+                    return hunk.original.isEmpty;
+                },
+                getRangesN: () => {
+                    const ranges = ( data.textModelNDecorations.map(id => this._textModelN.getDecorationRange(id)));
+                    coalesceInPlace(ranges);
+                    return ranges;
+                },
+                getRanges0: () => {
+                    const ranges = ( data.textModel0Decorations.map(id => this._textModel0.getDecorationRange(id)));
+                    coalesceInPlace(ranges);
+                    return ranges;
+                },
+                discardChanges: () => {
+                    if (data.state === HunkState.Pending) {
+                        const edits = this._discardEdits(item);
+                        this._textModelN.pushEditOperations(null, edits, () => null);
+                        data.state = HunkState.Rejected;
+                        if (data.editState.applied > 0) {
+                            data.editState.applied -= 1;
+                        }
+                    }
+                },
+                acceptChanges: () => {
+                    if (data.state === HunkState.Pending) {
+                        const edits = [];
+                        const rangesN = item.getRangesN();
+                        const ranges0 = item.getRanges0();
+                        for (let i = 1; i < ranges0.length; i++) {
+                            const originalRange = ranges0[i];
+                            const modifiedValue = this._textModelN.getValueInRange(rangesN[i]);
+                            edits.push(EditOperation.replace(originalRange, modifiedValue));
+                        }
+                        this._textModel0.pushEditOperations(null, edits, () => null);
+                        data.state = HunkState.Accepted;
+                    }
+                }
+            };
+            result.push(item);
+        }
+        return result;
+    }
+};
+HunkData = HunkData_1 = ( __decorate([
+    ( __param(0, IEditorWorkerService))
+], HunkData));
+class RawHunk {
+    constructor(original, modified, changes) {
+        this.original = original;
+        this.modified = modified;
+        this.changes = changes;
+    }
+}
+var HunkState;
+(function (HunkState) {
+    HunkState[HunkState["Pending"] = 0] = "Pending";
+    HunkState[HunkState["Accepted"] = 1] = "Accepted";
+    HunkState[HunkState["Rejected"] = 2] = "Rejected";
+})(HunkState || (HunkState = {}));
+
+export { HunkData, HunkState, Session, SessionWholeRange, StashedSession };