@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/editor/browser/widget/diffEditorWidget2/diffEditorWidget2.js

@@ -0,0 +1,369 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { h } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { findLast } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { observableValue, derived, keepAlive, waitForState } from 'monaco-editor/esm/vs/base/common/observable.js';
+import './style.css.js';
+import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { diffFullLineDeleteDecoration, diffFullLineAddDecoration, diffDeleteDecoration, diffAddDecoration } from './decorations.js';
+import { DiffEditorSash } from './diffEditorSash.js';
+import { ViewZoneAlignment } from './lineAlignment.js';
+import { OverviewRulerPart } from './overviewRulerPart.js';
+import { UnchangedRangesFeature } from './unchangedRanges.js';
+import { ObservableElementSizeObserver, applyObservableDecorations } from './utils.js';
+import { WorkerBasedDocumentDiffProvider } from 'monaco-editor/esm/vs/editor/browser/widget/workerBasedDocumentDiffProvider.js';
+import { EditorOptions, boolean, clampedFloat, clampedInt, stringSet } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { EditorType } from 'monaco-editor/esm/vs/editor/common/editorCommon.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { DelegatingEditor } from './delegatingEditorImpl.js';
+import { DiffModel } from './diffModel.js';
+const diffEditorDefaultOptions = {
+    enableSplitViewResizing: true,
+    splitViewDefaultRatio: 0.5,
+    renderSideBySide: true,
+    renderMarginRevertIcon: true,
+    maxComputationTime: 5000,
+    maxFileSize: 50,
+    ignoreTrimWhitespace: true,
+    renderIndicators: true,
+    originalEditable: false,
+    diffCodeLens: false,
+    renderOverviewRuler: true,
+    diffWordWrap: 'inherit',
+    diffAlgorithm: 'advanced',
+    accessibilityVerbose: false,
+    experimental: {
+        collapseUnchangedRegions: false,
+    }
+};
+let DiffEditorWidget2 = class DiffEditorWidget2 extends DelegatingEditor {
+    constructor(_domElement, options, codeEditorWidgetOptions, _parentContextKeyService, _parentInstantiationService, codeEditorService) {
+        super();
+        this._domElement = _domElement;
+        this._parentContextKeyService = _parentContextKeyService;
+        this._parentInstantiationService = _parentInstantiationService;
+        this.elements = h('div.monaco-diff-editor.side-by-side', { style: { position: 'relative', height: '100%' } }, [
+            h('div.editor.original@original', { style: { position: 'absolute', height: '100%' } }),
+            h('div.editor.modified@modified', { style: { position: 'absolute', height: '100%' } }),
+        ]);
+        this._model = observableValue('diffEditorModel', null);
+        this.onDidChangeModel = Event.fromObservableLight(this._model);
+        this._diffModel = observableValue('diffModel', null);
+        this._onDidContentSizeChange = this._register(( new Emitter()));
+        this.onDidContentSizeChange = this._onDidContentSizeChange.event;
+        this._contextKeyService = this._register(this._parentContextKeyService.createScoped(this._domElement));
+        this._instantiationService = this._parentInstantiationService.createChild(( new ServiceCollection([IContextKeyService, this._contextKeyService])));
+        this._isHandlingScrollEvent = false;
+        this._layoutInfo = derived('modifiedEditorLayoutInfo', (reader) => {
+            const width = this._rootSizeObserver.width.read(reader);
+            const height = this._rootSizeObserver.height.read(reader);
+            const sashLeft = this._sash.sashLeft.read(reader);
+            this.elements.original.style.width = sashLeft + 'px';
+            this.elements.original.style.left = '0px';
+            this.elements.modified.style.width = (width - sashLeft) + 'px';
+            this.elements.modified.style.left = sashLeft + 'px';
+            this._originalEditor.layout({ width: sashLeft, height: height });
+            this._modifiedEditor.layout({
+                width: width - sashLeft -
+                    (this._renderOverviewRuler.read(reader) ? OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH : 0),
+                height
+            });
+            return { modifiedEditor: this._modifiedEditor.getLayoutInfo() };
+        });
+        this._decorations = derived('decorations', (reader) => {
+            const diff = this._diffModel.read(reader)?.diff.read(reader);
+            if (!diff) {
+                return null;
+            }
+            const originalDecorations = [];
+            const modifiedDecorations = [];
+            for (const c of diff.changes) {
+                const fullRangeOriginal = c.originalRange.toInclusiveRange();
+                if (fullRangeOriginal) {
+                    originalDecorations.push({ range: fullRangeOriginal, options: diffFullLineDeleteDecoration });
+                }
+                const fullRangeModified = c.modifiedRange.toInclusiveRange();
+                if (fullRangeModified) {
+                    modifiedDecorations.push({ range: fullRangeModified, options: diffFullLineAddDecoration });
+                }
+                for (const i of c.innerChanges || []) {
+                    originalDecorations.push({ range: i.originalRange, options: diffDeleteDecoration });
+                    modifiedDecorations.push({ range: i.modifiedRange, options: diffAddDecoration });
+                }
+            }
+            return { originalDecorations, modifiedDecorations };
+        });
+        this.onDidUpdateDiff = e => {
+            return { dispose: () => { } };
+        };
+        codeEditorService.willCreateDiffEditor();
+        this._contextKeyService.createKey('isInDiffEditor', true);
+        this._contextKeyService.createKey('diffEditorVersion', 2);
+        this._contextKeyService.createKey('isInEmbeddedDiffEditor', typeof options.isInEmbeddedEditor !== 'undefined' ? options.isInEmbeddedEditor : false);
+        this._options = observableValue('options', validateDiffEditorOptions(options || {}, diffEditorDefaultOptions));
+        this._domElement.appendChild(this.elements.root);
+        this._rootSizeObserver = this._register(( new ObservableElementSizeObserver(this.elements.root, options.dimension)));
+        this._rootSizeObserver.setAutomaticLayout(options.automaticLayout ?? false);
+        this._originalEditor = this._createLeftHandSideEditor(options, codeEditorWidgetOptions.originalEditor || {});
+        this._modifiedEditor = this._createRightHandSideEditor(options, codeEditorWidgetOptions.modifiedEditor || {});
+        this._register(applyObservableDecorations(this._originalEditor, ( this._decorations.map(d => d?.originalDecorations || []))));
+        this._register(applyObservableDecorations(this._modifiedEditor, ( this._decorations.map(d => d?.modifiedDecorations || []))));
+        this._renderOverviewRuler = ( this._options.map(o => o.renderOverviewRuler));
+        this._sash = this._register(( new DiffEditorSash(( this._options.map(o => o.enableSplitViewResizing)), ( this._options.map(o => o.splitViewDefaultRatio)), this.elements.root, {
+            height: this._rootSizeObserver.height,
+            width: ( this._rootSizeObserver.width.map(
+                (w, reader) => w - (this._renderOverviewRuler.read(reader) ? OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH : 0)
+            )),
+        })));
+        this._register(( new UnchangedRangesFeature(this._originalEditor, this._modifiedEditor, this._diffModel)));
+        this._register(( new ViewZoneAlignment(this._originalEditor, this._modifiedEditor, this._diffModel)));
+        this._register(this._instantiationService.createInstance(OverviewRulerPart, this._originalEditor, this._modifiedEditor, this.elements.root, this._diffModel, this._rootSizeObserver.width, this._rootSizeObserver.height, ( this._layoutInfo.map(i => i.modifiedEditor)), this._renderOverviewRuler));
+        this._createDiffEditorContributions();
+        codeEditorService.addDiffEditor(this);
+        this._register(keepAlive(this._layoutInfo, true));
+    }
+    _createDiffEditorContributions() {
+        const contributions = EditorExtensionsRegistry.getDiffEditorContributions();
+        for (const desc of contributions) {
+            try {
+                this._register(this._instantiationService.createInstance(desc.ctor, this));
+            }
+            catch (err) {
+                onUnexpectedError(err);
+            }
+        }
+    }
+    _createLeftHandSideEditor(options, codeEditorWidgetOptions) {
+        const editor = this._createInnerEditor(this._instantiationService, this.elements.original, this._adjustOptionsForLeftHandSide(options), codeEditorWidgetOptions);
+        const isInDiffLeftEditorKey = this._contextKeyService.createKey('isInDiffLeftEditor', editor.hasWidgetFocus());
+        this._register(editor.onDidFocusEditorWidget(() => isInDiffLeftEditorKey.set(true)));
+        this._register(editor.onDidBlurEditorWidget(() => isInDiffLeftEditorKey.set(false)));
+        return editor;
+    }
+    _createRightHandSideEditor(options, codeEditorWidgetOptions) {
+        const editor = this._createInnerEditor(this._instantiationService, this.elements.modified, this._adjustOptionsForRightHandSide(options), codeEditorWidgetOptions);
+        const isInDiffRightEditorKey = this._contextKeyService.createKey('isInDiffRightEditor', editor.hasWidgetFocus());
+        this._register(editor.onDidFocusEditorWidget(() => isInDiffRightEditorKey.set(true)));
+        this._register(editor.onDidBlurEditorWidget(() => isInDiffRightEditorKey.set(false)));
+        return editor;
+    }
+    _createInnerEditor(instantiationService, container, options, editorWidgetOptions) {
+        const editor = instantiationService.createInstance(CodeEditorWidget, container, options, editorWidgetOptions);
+        this._register(editor.onDidContentSizeChange(e => {
+            const width = this._originalEditor.getContentWidth() + this._modifiedEditor.getContentWidth() + OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH;
+            const height = Math.max(this._modifiedEditor.getContentHeight(), this._originalEditor.getContentHeight());
+            this._onDidContentSizeChange.fire({
+                contentHeight: height,
+                contentWidth: width,
+                contentHeightChanged: e.contentHeightChanged,
+                contentWidthChanged: e.contentWidthChanged
+            });
+        }));
+        this._register(editor.onDidScrollChange((e) => {
+            if (this._isHandlingScrollEvent) {
+                return;
+            }
+            if (!e.scrollTopChanged && !e.scrollLeftChanged && !e.scrollHeightChanged) {
+                return;
+            }
+            this._isHandlingScrollEvent = true;
+            try {
+                const otherEditor = editor === this._originalEditor ? this._modifiedEditor : this._originalEditor;
+                otherEditor.setScrollPosition({
+                    scrollLeft: e.scrollLeft,
+                    scrollTop: e.scrollTop
+                });
+            }
+            finally {
+                this._isHandlingScrollEvent = false;
+            }
+        }));
+        return editor;
+    }
+    _adjustOptionsForLeftHandSide(options) {
+        const result = this._adjustOptionsForSubEditor(options);
+        if (!options.renderSideBySide) {
+            result.wordWrapOverride1 = 'off';
+            result.wordWrapOverride2 = 'off';
+        }
+        else {
+            result.wordWrapOverride1 = this._options.get().diffWordWrap;
+        }
+        if (options.originalAriaLabel) {
+            result.ariaLabel = options.originalAriaLabel;
+        }
+        result.ariaLabel = this._updateAriaLabel(result.ariaLabel);
+        result.readOnly = !options.originalEditable;
+        result.dropIntoEditor = { enabled: !result.readOnly };
+        result.extraEditorClassName = 'original-in-monaco-diff-editor';
+        return result;
+    }
+    _adjustOptionsForRightHandSide(options) {
+        const result = this._adjustOptionsForSubEditor(options);
+        if (options.modifiedAriaLabel) {
+            result.ariaLabel = options.modifiedAriaLabel;
+        }
+        result.ariaLabel = this._updateAriaLabel(result.ariaLabel);
+        result.wordWrapOverride1 = this._options.get().diffWordWrap;
+        result.revealHorizontalRightPadding = EditorOptions.revealHorizontalRightPadding.defaultValue + OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH;
+        result.scrollbar.verticalHasArrows = false;
+        result.extraEditorClassName = 'modified-in-monaco-diff-editor';
+        return result;
+    }
+    _adjustOptionsForSubEditor(options) {
+        const clonedOptions = {
+            ...options,
+            dimension: {
+                height: 0,
+                width: 0
+            },
+        };
+        clonedOptions.inDiffEditor = true;
+        clonedOptions.automaticLayout = false;
+        clonedOptions.scrollbar = { ...(clonedOptions.scrollbar || {}) };
+        clonedOptions.scrollbar.vertical = 'visible';
+        clonedOptions.folding = false;
+        clonedOptions.codeLens = this._options.get().diffCodeLens;
+        clonedOptions.fixedOverflowWidgets = true;
+        clonedOptions.minimap = { ...(clonedOptions.minimap || {}) };
+        clonedOptions.minimap.enabled = false;
+        return clonedOptions;
+    }
+    _updateAriaLabel(ariaLabel) {
+        const ariaNavigationTip = ( localize('diff-aria-navigation-tip', ' use Shift + F7 to navigate changes'));
+        if (this._options.get().accessibilityVerbose) {
+            return ariaLabel + ariaNavigationTip;
+        }
+        else if (ariaLabel) {
+            return ariaLabel.replaceAll(ariaNavigationTip, '');
+        }
+        return undefined;
+    }
+    get _targetEditor() { return this._modifiedEditor; }
+    getEditorType() { return EditorType.IDiffEditor; }
+    onVisible() {
+        this._originalEditor.onVisible();
+        this._modifiedEditor.onVisible();
+    }
+    onHide() {
+        this._originalEditor.onHide();
+        this._modifiedEditor.onHide();
+    }
+    layout(dimension) {
+        this._rootSizeObserver.observe(dimension);
+    }
+    hasTextFocus() {
+        return this._originalEditor.hasTextFocus() || this._modifiedEditor.hasTextFocus();
+    }
+    saveViewState() {
+        return null;
+    }
+    restoreViewState(state) {
+    }
+    getModel() { return this._model.get(); }
+    setModel(model) {
+        this._originalEditor.setModel(model ? model.original : null);
+        this._modifiedEditor.setModel(model ? model.modified : null);
+        this._model.set(model, undefined);
+        this._diffModel.set(model ? ( new DiffModel(model, ( this._options.map(o => o.ignoreTrimWhitespace)), ( this._options.map(o => o.maxComputationTime)), ( this._options.map(o => o.experimental.collapseUnchangedRegions)), this._instantiationService.createInstance(WorkerBasedDocumentDiffProvider, this._options.get()))) : null, undefined);
+    }
+    updateOptions(_newOptions) {
+        const newOptions = validateDiffEditorOptions(_newOptions, this._options.get());
+        this._options.set(newOptions, undefined);
+        this._modifiedEditor.updateOptions(this._adjustOptionsForRightHandSide(_newOptions));
+        this._originalEditor.updateOptions(this._adjustOptionsForLeftHandSide(_newOptions));
+    }
+    getContainerDomNode() { return this._domElement; }
+    getOriginalEditor() { return this._originalEditor; }
+    getModifiedEditor() { return this._modifiedEditor; }
+    setBoundarySashes(sashes) {
+        this._sash.setBoundarySashes(sashes);
+    }
+    get ignoreTrimWhitespace() {
+        return this._options.get().ignoreTrimWhitespace;
+    }
+    get maxComputationTime() {
+        return this._options.get().maxComputationTime;
+    }
+    get renderSideBySide() {
+        return this._options.get().renderSideBySide;
+    }
+    getLineChanges() {
+        return null;
+    }
+    getDiffComputationResult() {
+        return null;
+    }
+    getDiffLineInformationForOriginal(lineNumber) {
+        return null;
+    }
+    getDiffLineInformationForModified(lineNumber) {
+        return null;
+    }
+    _goTo(diff) {
+        this._modifiedEditor.setPosition(( new Position(diff.modifiedRange.startLineNumber, 1)));
+        this._modifiedEditor.revealRangeInCenter(diff.modifiedRange.toExclusiveRange());
+    }
+    goToDiff(target) {
+        const diffs = this._diffModel.get()?.diff.get()?.changes;
+        if (!diffs || diffs.length === 0) {
+            return;
+        }
+        const curLineNumber = this._modifiedEditor.getPosition().lineNumber;
+        let diff;
+        if (target === 'next') {
+            diff = diffs.find(d => d.modifiedRange.startLineNumber > curLineNumber) ?? diffs[0];
+        }
+        else {
+            diff = findLast(diffs, d => d.modifiedRange.startLineNumber < curLineNumber) ?? diffs[diffs.length - 1];
+        }
+        this._goTo(diff);
+    }
+    revealFirstDiff() {
+        const diffModel = this._diffModel.get();
+        if (!diffModel) {
+            return;
+        }
+        waitForState(diffModel.isDiffUpToDate, s => s).then(() => {
+            const diffs = diffModel.diff.get()?.changes;
+            if (!diffs || diffs.length === 0) {
+                return;
+            }
+            this._goTo(diffs[0]);
+        });
+    }
+};
+DiffEditorWidget2 = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ICodeEditorService))
+], DiffEditorWidget2));
+function validateDiffEditorOptions(options, defaults) {
+    return {
+        enableSplitViewResizing: boolean(options.enableSplitViewResizing, defaults.enableSplitViewResizing),
+        splitViewDefaultRatio: clampedFloat(options.splitViewDefaultRatio, 0.5, 0.1, 0.9),
+        renderSideBySide: boolean(options.renderSideBySide, defaults.renderSideBySide),
+        renderMarginRevertIcon: boolean(options.renderMarginRevertIcon, defaults.renderMarginRevertIcon),
+        maxComputationTime: clampedInt(options.maxComputationTime, defaults.maxComputationTime, 0, 1073741824 ),
+        maxFileSize: clampedInt(options.maxFileSize, defaults.maxFileSize, 0, 1073741824 ),
+        ignoreTrimWhitespace: boolean(options.ignoreTrimWhitespace, defaults.ignoreTrimWhitespace),
+        renderIndicators: boolean(options.renderIndicators, defaults.renderIndicators),
+        originalEditable: boolean(options.originalEditable, defaults.originalEditable),
+        diffCodeLens: boolean(options.diffCodeLens, defaults.diffCodeLens),
+        renderOverviewRuler: boolean(options.renderOverviewRuler, defaults.renderOverviewRuler),
+        diffWordWrap: stringSet(options.diffWordWrap, defaults.diffWordWrap, ['off', 'on', 'inherit']),
+        diffAlgorithm: stringSet(options.diffAlgorithm, defaults.diffAlgorithm, ['legacy', 'advanced'], { 'smart': 'legacy', 'experimental': 'advanced' }),
+        accessibilityVerbose: boolean(options.accessibilityVerbose, defaults.accessibilityVerbose),
+        experimental: {
+            collapseUnchangedRegions: boolean(options.experimental?.collapseUnchangedRegions, defaults.experimental.collapseUnchangedRegions),
+        },
+    };
+}
+export { DiffEditorWidget2 };

package/dist/vscode/vs/editor/browser/widget/diffEditorWidget2/diffModel.js

@@ -0,0 +1,247 @@
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableValue, derived, observableSignal, observableSignalFromEvent, transaction } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { autorunWithStore2 } from 'monaco-editor/esm/vs/base/common/observableImpl/autorun.js';
+import { LineRange } from 'monaco-editor/esm/vs/editor/common/core/lineRange.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { LineRangeMapping, RangeMapping } from 'monaco-editor/esm/vs/editor/common/diff/linesDiffComputer.js';
+import { lineRangeMappingFromRangeMappings } from 'monaco-editor/esm/vs/editor/common/diff/standardLinesDiffComputer.js';
+import { TextEditInfo } from 'monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/beforeEditPositionMapper.js';
+import { combineTextEditInfos } from 'monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/combineTextEditInfos.js';
+import { positionToLength, lengthOfRange, lengthAdd, lengthDiffNonNegative, lengthToPosition, lengthZero } from 'monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/length.js';
+class DiffModel extends Disposable {
+    constructor(model, ignoreTrimWhitespace, maxComputationTimeMs, hideUnchangedRegions, documentDiffProvider) {
+        super();
+        this.hideUnchangedRegions = hideUnchangedRegions;
+        this._isDiffUpToDate = observableValue('isDiffUpToDate', false);
+        this.isDiffUpToDate = this._isDiffUpToDate;
+        this._diff = observableValue('diff', undefined);
+        this.diff = this._diff;
+        this._unchangedRegions = observableValue('unchangedRegion', { regions: [], originalDecorationIds: [], modifiedDecorationIds: [] });
+        this.unchangedRegions = derived('unchangedRegions', r => this.hideUnchangedRegions.read(r) ? this._unchangedRegions.read(r).regions : []);
+        const contentChangedSignal = observableSignal('contentChangedSignal');
+        const debouncer = this._register(( new RunOnceScheduler(() => contentChangedSignal.trigger(undefined), 200)));
+        this._register(model.modified.onDidChangeContent((e) => {
+            const diff = this._diff.get();
+            if (!diff) {
+                return;
+            }
+            const textEdits = TextEditInfo.fromModelContentChanges(e.changes);
+            this._diff.set(applyModifiedEdits(diff, textEdits, model.original, model.modified), undefined);
+            debouncer.schedule();
+        }));
+        this._register(model.original.onDidChangeContent((e) => {
+            const diff = this._diff.get();
+            if (!diff) {
+                return;
+            }
+            const textEdits = TextEditInfo.fromModelContentChanges(e.changes);
+            this._diff.set(applyOriginalEdits(diff, textEdits, model.original, model.modified), undefined);
+            debouncer.schedule();
+        }));
+        const documentDiffProviderOptionChanged = observableSignalFromEvent('documentDiffProviderOptionChanged', documentDiffProvider.onDidChange);
+        this._register(autorunWithStore2('compute diff', async (reader, store) => {
+            debouncer.cancel();
+            contentChangedSignal.read(reader);
+            documentDiffProviderOptionChanged.read(reader);
+            const ignoreTrimWhitespaceVal = ignoreTrimWhitespace.read(reader);
+            const maxComputationTimeMsVal = maxComputationTimeMs.read(reader);
+            this._isDiffUpToDate.set(false, undefined);
+            let originalTextEditInfos = [];
+            store.add(model.original.onDidChangeContent((e) => {
+                const edits = TextEditInfo.fromModelContentChanges(e.changes);
+                originalTextEditInfos = combineTextEditInfos(originalTextEditInfos, edits);
+            }));
+            let modifiedTextEditInfos = [];
+            store.add(model.modified.onDidChangeContent((e) => {
+                const edits = TextEditInfo.fromModelContentChanges(e.changes);
+                modifiedTextEditInfos = combineTextEditInfos(modifiedTextEditInfos, edits);
+            }));
+            let result = await documentDiffProvider.computeDiff(model.original, model.modified, {
+                ignoreTrimWhitespace: ignoreTrimWhitespaceVal,
+                maxComputationTimeMs: maxComputationTimeMsVal,
+            });
+            result = applyOriginalEdits(result, originalTextEditInfos, model.original, model.modified);
+            result = applyModifiedEdits(result, modifiedTextEditInfos, model.original, model.modified);
+            const newUnchangedRegions = UnchangedRegion.fromDiffs(result.changes, model.original.getLineCount(), model.modified.getLineCount());
+            const lastUnchangedRegions = this._unchangedRegions.get();
+            const lastUnchangedRegionsOrigRanges = ( ( lastUnchangedRegions.originalDecorationIds
+                .map(id => model.original.getDecorationRange(id)))
+                .filter(r => !!r)
+                .map(r => LineRange.fromRange(r)));
+            const lastUnchangedRegionsModRanges = ( ( lastUnchangedRegions.modifiedDecorationIds
+                .map(id => model.modified.getDecorationRange(id)))
+                .filter(r => !!r)
+                .map(r => LineRange.fromRange(r)));
+            for (const r of newUnchangedRegions) {
+                for (let i = 0; i < lastUnchangedRegions.regions.length; i++) {
+                    if (r.originalRange.intersectsStrict(lastUnchangedRegionsOrigRanges[i])
+                        && r.modifiedRange.intersectsStrict(lastUnchangedRegionsModRanges[i])) {
+                        r.setState(lastUnchangedRegions.regions[i].visibleLineCountTop.get(), lastUnchangedRegions.regions[i].visibleLineCountBottom.get(), undefined);
+                        break;
+                    }
+                }
+            }
+            const originalDecorationIds = model.original.deltaDecorations(lastUnchangedRegions.originalDecorationIds, ( newUnchangedRegions.map(
+                r => ({ range: r.originalRange.toInclusiveRange(), options: { description: 'unchanged' } })
+            )));
+            const modifiedDecorationIds = model.modified.deltaDecorations(lastUnchangedRegions.modifiedDecorationIds, ( newUnchangedRegions.map(
+                r => ({ range: r.modifiedRange.toInclusiveRange(), options: { description: 'unchanged' } })
+            )));
+            transaction(tx => {
+                this._diff.set(result, tx);
+                this._isDiffUpToDate.set(true, tx);
+                this._unchangedRegions.set({
+                    regions: newUnchangedRegions,
+                    originalDecorationIds,
+                    modifiedDecorationIds
+                }, tx);
+            });
+        }));
+    }
+    revealModifiedLine(lineNumber, tx) {
+        const unchangedRegions = this._unchangedRegions.get().regions;
+        for (const r of unchangedRegions) {
+            if (r.getHiddenModifiedRange(undefined).contains(lineNumber)) {
+                r.showAll(tx);
+                return;
+            }
+        }
+    }
+    revealOriginalLine(lineNumber, tx) {
+        const unchangedRegions = this._unchangedRegions.get().regions;
+        for (const r of unchangedRegions) {
+            if (r.getHiddenOriginalRange(undefined).contains(lineNumber)) {
+                r.showAll(tx);
+                return;
+            }
+        }
+    }
+}
+class UnchangedRegion {
+    static fromDiffs(changes, originalLineCount, modifiedLineCount) {
+        const inversedMappings = LineRangeMapping.inverse(changes, originalLineCount, modifiedLineCount);
+        const result = [];
+        const minHiddenLineCount = 3;
+        const minContext = 3;
+        for (const mapping of inversedMappings) {
+            let origStart = mapping.originalRange.startLineNumber;
+            let modStart = mapping.modifiedRange.startLineNumber;
+            let length = mapping.originalRange.length;
+            if (origStart === 1 && length > minContext + minHiddenLineCount) {
+                length -= minContext;
+                result.push(( new UnchangedRegion(origStart, modStart, length, 0, 0)));
+            }
+            else if (origStart + length === originalLineCount + 1 && length > minContext + minHiddenLineCount) {
+                origStart += minContext;
+                modStart += minContext;
+                length -= minContext;
+                result.push(( new UnchangedRegion(origStart, modStart, length, 0, 0)));
+            }
+            else if (length > minContext * 2 + minHiddenLineCount) {
+                origStart += minContext;
+                modStart += minContext;
+                length -= minContext * 2;
+                result.push(( new UnchangedRegion(origStart, modStart, length, 0, 0)));
+            }
+        }
+        return result;
+    }
+    get originalRange() {
+        return LineRange.ofLength(this.originalLineNumber, this.lineCount);
+    }
+    get modifiedRange() {
+        return LineRange.ofLength(this.modifiedLineNumber, this.lineCount);
+    }
+    constructor(originalLineNumber, modifiedLineNumber, lineCount, visibleLineCountTop, visibleLineCountBottom) {
+        this.originalLineNumber = originalLineNumber;
+        this.modifiedLineNumber = modifiedLineNumber;
+        this.lineCount = lineCount;
+        this._visibleLineCountTop = observableValue('visibleLineCountTop', 0);
+        this.visibleLineCountTop = this._visibleLineCountTop;
+        this._visibleLineCountBottom = observableValue('visibleLineCountBottom', 0);
+        this.visibleLineCountBottom = this._visibleLineCountBottom;
+        this._visibleLineCountTop.set(visibleLineCountTop, undefined);
+        this._visibleLineCountBottom.set(visibleLineCountBottom, undefined);
+    }
+    getHiddenOriginalRange(reader) {
+        return LineRange.ofLength(this.originalLineNumber + this._visibleLineCountTop.read(reader), this.lineCount - this._visibleLineCountTop.read(reader) - this._visibleLineCountBottom.read(reader));
+    }
+    getHiddenModifiedRange(reader) {
+        return LineRange.ofLength(this.modifiedLineNumber + this._visibleLineCountTop.read(reader), this.lineCount - this._visibleLineCountTop.read(reader) - this._visibleLineCountBottom.read(reader));
+    }
+    showMoreAbove(tx) {
+        const maxVisibleLineCountTop = this.lineCount - this._visibleLineCountBottom.get();
+        this._visibleLineCountTop.set(Math.min(this._visibleLineCountTop.get() + 10, maxVisibleLineCountTop), tx);
+    }
+    showMoreBelow(tx) {
+        const maxVisibleLineCountBottom = this.lineCount - this._visibleLineCountTop.get();
+        this._visibleLineCountBottom.set(Math.min(this._visibleLineCountBottom.get() + 10, maxVisibleLineCountBottom), tx);
+    }
+    showAll(tx) {
+        this._visibleLineCountBottom.set(this.lineCount - this._visibleLineCountTop.get(), tx);
+    }
+    setState(visibleLineCountTop, visibleLineCountBottom, tx) {
+        visibleLineCountTop = Math.min(visibleLineCountTop, this.lineCount);
+        visibleLineCountBottom = Math.min(visibleLineCountBottom, this.lineCount - visibleLineCountTop);
+        this._visibleLineCountTop.set(visibleLineCountTop, tx);
+        this._visibleLineCountBottom.set(visibleLineCountBottom, tx);
+    }
+}
+function applyOriginalEdits(diff, textEdits, originalTextModel, modifiedTextModel) {
+    if (textEdits.length === 0) {
+        return diff;
+    }
+    const diffTextEdits = diff.changes.flatMap(c => ( c.innerChanges.map(c => ( new TextEditInfo(
+        positionToLength(c.modifiedRange.getStartPosition()),
+        positionToLength(c.modifiedRange.getEndPosition()),
+        lengthOfRange(c.originalRange).toLength()
+    )))));
+    const combined = combineTextEditInfos(diffTextEdits, textEdits);
+    let lastModifiedEndOffset = lengthZero;
+    let lastOriginalEndOffset = lengthZero;
+    const rangeMappings = ( combined.map(c => {
+        const originalStartOffset = lengthAdd(lastOriginalEndOffset, lengthDiffNonNegative(lastModifiedEndOffset, c.startOffset));
+        lastModifiedEndOffset = c.endOffset;
+        lastOriginalEndOffset = lengthAdd(originalStartOffset, c.newLength);
+        return ( new RangeMapping(
+            Range.fromPositions(lengthToPosition(originalStartOffset), lengthToPosition(lastOriginalEndOffset)),
+            Range.fromPositions(lengthToPosition(c.startOffset), lengthToPosition(c.endOffset))
+        ));
+    }));
+    const changes = lineRangeMappingFromRangeMappings(rangeMappings, originalTextModel.getLinesContent(), modifiedTextModel.getLinesContent());
+    return {
+        identical: false,
+        quitEarly: false,
+        changes,
+    };
+}
+function applyModifiedEdits(diff, textEdits, originalTextModel, modifiedTextModel) {
+    if (textEdits.length === 0) {
+        return diff;
+    }
+    const diffTextEdits = diff.changes.flatMap(c => ( c.innerChanges.map(c => ( new TextEditInfo(
+        positionToLength(c.originalRange.getStartPosition()),
+        positionToLength(c.originalRange.getEndPosition()),
+        lengthOfRange(c.modifiedRange).toLength()
+    )))));
+    const combined = combineTextEditInfos(diffTextEdits, textEdits);
+    let lastOriginalEndOffset = lengthZero;
+    let lastModifiedEndOffset = lengthZero;
+    const rangeMappings = ( combined.map(c => {
+        const modifiedStartOffset = lengthAdd(lastModifiedEndOffset, lengthDiffNonNegative(lastOriginalEndOffset, c.startOffset));
+        lastOriginalEndOffset = c.endOffset;
+        lastModifiedEndOffset = lengthAdd(modifiedStartOffset, c.newLength);
+        return ( new RangeMapping(
+            Range.fromPositions(lengthToPosition(c.startOffset), lengthToPosition(c.endOffset)),
+            Range.fromPositions(lengthToPosition(modifiedStartOffset), lengthToPosition(lastModifiedEndOffset))
+        ));
+    }));
+    const changes = lineRangeMappingFromRangeMappings(rangeMappings, originalTextModel.getLinesContent(), modifiedTextModel.getLinesContent());
+    return {
+        identical: false,
+        quitEarly: false,
+        changes,
+    };
+}
+export { DiffModel, UnchangedRegion };