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

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

@@ -0,0 +1,179 @@
+import { ArrayQueue } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableSignalFromEvent, derived } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { autorunWithStore2 } from 'monaco-editor/esm/vs/base/common/observableImpl/autorun.js';
+import { joinCombine } from './utils.js';
+import { LineRange } from 'monaco-editor/esm/vs/editor/common/core/lineRange.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+class ViewZoneAlignment extends Disposable {
+    constructor(_originalEditor, _modifiedEditor, _diffModel) {
+        super();
+        this._originalEditor = _originalEditor;
+        this._modifiedEditor = _modifiedEditor;
+        this._diffModel = _diffModel;
+        let isChangingViewZones = false;
+        const origViewZonesChanged = observableSignalFromEvent('origViewZonesChanged', e => this._originalEditor.onDidChangeViewZones((args) => { if (!isChangingViewZones) {
+            e(args);
+        } }));
+        const modViewZonesChanged = observableSignalFromEvent('modViewZonesChanged', e => this._modifiedEditor.onDidChangeViewZones((args) => { if (!isChangingViewZones) {
+            e(args);
+        } }));
+        const alignmentViewZoneIdsOrig = ( new Set());
+        const alignmentViewZoneIdsMod = ( new Set());
+        const alignments = derived('alignments', (reader) => {
+            const diff = this._diffModel.read(reader)?.diff.read(reader);
+            if (!diff) {
+                return null;
+            }
+            origViewZonesChanged.read(reader);
+            modViewZonesChanged.read(reader);
+            return computeRangeAlignment(this._originalEditor, this._modifiedEditor, diff.changes, alignmentViewZoneIdsOrig, alignmentViewZoneIdsMod);
+        });
+        function createFakeLinesDiv() {
+            const r = document.createElement('div');
+            r.className = 'diagonal-fill';
+            return r;
+        }
+        const alignmentViewZones = derived('alignment viewzones', (reader) => {
+            const alignments_ = alignments.read(reader);
+            const origViewZones = [];
+            const modViewZones = [];
+            if (alignments_) {
+                for (const a of alignments_) {
+                    const delta = a.modifiedHeightInPx - a.originalHeightInPx;
+                    if (delta > 0) {
+                        origViewZones.push({
+                            afterLineNumber: a.originalRange.endLineNumberExclusive - 1,
+                            domNode: createFakeLinesDiv(),
+                            heightInPx: delta,
+                        });
+                    }
+                    else {
+                        modViewZones.push({
+                            afterLineNumber: a.modifiedRange.endLineNumberExclusive - 1,
+                            domNode: createFakeLinesDiv(),
+                            heightInPx: -delta,
+                        });
+                    }
+                }
+            }
+            return { orig: origViewZones, mod: modViewZones };
+        });
+        this._register(autorunWithStore2('alignment viewzones', (reader) => {
+            const alignmentViewZones_ = alignmentViewZones.read(reader);
+            isChangingViewZones = true;
+            this._originalEditor.changeViewZones((aOrig) => {
+                for (const id of alignmentViewZoneIdsOrig) {
+                    aOrig.removeZone(id);
+                }
+                alignmentViewZoneIdsOrig.clear();
+                for (const z of alignmentViewZones_.orig) {
+                    alignmentViewZoneIdsOrig.add(aOrig.addZone(z));
+                }
+            });
+            this._modifiedEditor.changeViewZones(aMod => {
+                for (const id of alignmentViewZoneIdsMod) {
+                    aMod.removeZone(id);
+                }
+                alignmentViewZoneIdsMod.clear();
+                for (const z of alignmentViewZones_.mod) {
+                    alignmentViewZoneIdsMod.add(aMod.addZone(z));
+                }
+            });
+            isChangingViewZones = false;
+        }));
+    }
+}
+function getAdditionalLineHeights(editor, viewZonesToIgnore) {
+    const viewZoneHeights = [];
+    const wrappingZoneHeights = [];
+    const hasWrapping = editor.getOption(141 ).wrappingColumn !== -1;
+    const coordinatesConverter = editor._getViewModel().coordinatesConverter;
+    if (hasWrapping) {
+        for (let i = 1; i <= editor.getModel().getLineCount(); i++) {
+            const lineCount = coordinatesConverter.getModelLineViewLineCount(i);
+            if (lineCount > 1) {
+                wrappingZoneHeights.push({ lineNumber: i, heightInPx: lineCount - 1 });
+            }
+        }
+    }
+    for (const w of editor.getWhitespaces()) {
+        if (( viewZonesToIgnore.has(w.id))) {
+            continue;
+        }
+        const modelLineNumber = coordinatesConverter.convertViewPositionToModelPosition(( new Position(w.afterLineNumber, 1))).lineNumber;
+        viewZoneHeights.push({ lineNumber: modelLineNumber, heightInPx: w.height });
+    }
+    const result = joinCombine(viewZoneHeights, wrappingZoneHeights, v => v.lineNumber, (v1, v2) => ({ lineNumber: v1.lineNumber, heightInPx: v1.heightInPx + v2.heightInPx }));
+    return result;
+}
+function computeRangeAlignment(originalEditor, modifiedEditor, diffs, originalEditorAlignmentViewZones, modifiedEditorAlignmentViewZones) {
+    const originalLineHeightOverrides = ( new ArrayQueue(getAdditionalLineHeights(originalEditor, originalEditorAlignmentViewZones)));
+    const modifiedLineHeightOverrides = ( new ArrayQueue(getAdditionalLineHeights(modifiedEditor, modifiedEditorAlignmentViewZones)));
+    const origLineHeight = originalEditor.getOption(64 );
+    const modLineHeight = modifiedEditor.getOption(64 );
+    const result = [];
+    let lastOriginalLineNumber = 0;
+    let lastModifiedLineNumber = 0;
+    function handleAlignmentsOutsideOfDiffs(untilOriginalLineNumberExclusive, untilModifiedLineNumberExclusive) {
+        while (true) {
+            let origNext = originalLineHeightOverrides.peek();
+            let modNext = modifiedLineHeightOverrides.peek();
+            if (origNext && origNext.lineNumber >= untilOriginalLineNumberExclusive) {
+                origNext = undefined;
+            }
+            if (modNext && modNext.lineNumber >= untilModifiedLineNumberExclusive) {
+                modNext = undefined;
+            }
+            if (!origNext && !modNext) {
+                break;
+            }
+            const distOrig = origNext ? origNext.lineNumber - lastOriginalLineNumber : Number.MAX_VALUE;
+            const distNext = modNext ? modNext.lineNumber - lastModifiedLineNumber : Number.MAX_VALUE;
+            if (distOrig < distNext) {
+                originalLineHeightOverrides.dequeue();
+                modNext = {
+                    lineNumber: origNext.lineNumber - lastOriginalLineNumber + lastModifiedLineNumber,
+                    heightInPx: 0,
+                };
+            }
+            else if (distOrig > distNext) {
+                modifiedLineHeightOverrides.dequeue();
+                origNext = {
+                    lineNumber: modNext.lineNumber - lastModifiedLineNumber + lastOriginalLineNumber,
+                    heightInPx: 0,
+                };
+            }
+            else {
+                originalLineHeightOverrides.dequeue();
+                modifiedLineHeightOverrides.dequeue();
+            }
+            result.push({
+                originalRange: LineRange.ofLength(origNext.lineNumber, 1),
+                modifiedRange: LineRange.ofLength(modNext.lineNumber, 1),
+                originalHeightInPx: origLineHeight + origNext.heightInPx,
+                modifiedHeightInPx: modLineHeight + modNext.heightInPx,
+            });
+        }
+    }
+    for (const c of diffs) {
+        handleAlignmentsOutsideOfDiffs(c.originalRange.startLineNumber, c.modifiedRange.startLineNumber);
+        const originalAdditionalHeight = originalLineHeightOverrides
+            .takeWhile(v => v.lineNumber < c.originalRange.endLineNumberExclusive)
+            ?.reduce((p, c) => p + c.heightInPx, 0) ?? 0;
+        const modifiedAdditionalHeight = modifiedLineHeightOverrides
+            .takeWhile(v => v.lineNumber < c.modifiedRange.endLineNumberExclusive)
+            ?.reduce((p, c) => p + c.heightInPx, 0) ?? 0;
+        result.push({
+            originalRange: c.originalRange,
+            modifiedRange: c.modifiedRange,
+            originalHeightInPx: c.originalRange.length * origLineHeight + originalAdditionalHeight,
+            modifiedHeightInPx: c.modifiedRange.length * modLineHeight + modifiedAdditionalHeight,
+        });
+        lastOriginalLineNumber = c.originalRange.endLineNumberExclusive;
+        lastModifiedLineNumber = c.modifiedRange.endLineNumberExclusive;
+    }
+    handleAlignmentsOutsideOfDiffs(Number.MAX_VALUE, Number.MAX_VALUE);
+    return result;
+}
+export { ViewZoneAlignment };

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

@@ -0,0 +1,121 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { h, addStandardDisposableListener, EventType, addDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { createFastDomNode } from 'monaco-editor/esm/vs/base/browser/fastDomNode.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableFromEvent, derived, autorun } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { autorunWithStore2 } from 'monaco-editor/esm/vs/base/common/observableImpl/autorun.js';
+import { appendRemoveOnDispose } from './utils.js';
+import { OverviewRulerZone } from 'monaco-editor/esm/vs/editor/common/viewModel/overviewZoneManager.js';
+import { diffOverviewRulerInserted, diffInserted, defaultInsertColor, diffOverviewRulerRemoved, diffRemoved, defaultRemoveColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+let OverviewRulerPart = class OverviewRulerPart extends Disposable {
+    constructor(_originalEditor, _modifiedEditor, _rootElement, _diffModel, _rootWidth, _rootHeight, _modifiedEditorLayoutInfo, renderOverviewRuler, _themeService) {
+        super();
+        this._originalEditor = _originalEditor;
+        this._modifiedEditor = _modifiedEditor;
+        this._rootElement = _rootElement;
+        this._diffModel = _diffModel;
+        this._rootWidth = _rootWidth;
+        this._rootHeight = _rootHeight;
+        this._modifiedEditorLayoutInfo = _modifiedEditorLayoutInfo;
+        this.renderOverviewRuler = renderOverviewRuler;
+        this._themeService = _themeService;
+        const currentColorTheme = observableFromEvent(this._themeService.onDidColorThemeChange, () => this._themeService.getColorTheme());
+        const currentColors = derived('colors', reader => {
+            const theme = currentColorTheme.read(reader);
+            const insertColor = theme.getColor(diffOverviewRulerInserted) || ( (theme.getColor(diffInserted) || defaultInsertColor).transparent(2));
+            const removeColor = theme.getColor(diffOverviewRulerRemoved) || ( (theme.getColor(diffRemoved) || defaultRemoveColor).transparent(2));
+            return { insertColor, removeColor };
+        });
+        const scrollTopObservable = observableFromEvent(this._modifiedEditor.onDidScrollChange, () => this._modifiedEditor.getScrollTop());
+        const scrollHeightObservable = observableFromEvent(this._modifiedEditor.onDidScrollChange, () => this._modifiedEditor.getScrollHeight());
+        this._register(autorunWithStore2('create diff editor overview ruler if enabled', (reader, store) => {
+            if (!this.renderOverviewRuler.read(reader)) {
+                return;
+            }
+            const viewportDomElement = createFastDomNode(document.createElement('div'));
+            viewportDomElement.setClassName('diffViewport');
+            viewportDomElement.setPosition('absolute');
+            const diffOverviewRoot = h('div.diffOverview', {
+                style: { position: 'absolute', top: '0px', width: OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH + 'px' }
+            }).root;
+            store.add(appendRemoveOnDispose(diffOverviewRoot, viewportDomElement.domNode));
+            store.add(addStandardDisposableListener(diffOverviewRoot, EventType.POINTER_DOWN, (e) => {
+                this._modifiedEditor.delegateVerticalScrollbarPointerDown(e);
+            }));
+            store.add(addDisposableListener(diffOverviewRoot, EventType.MOUSE_WHEEL, (e) => {
+                this._modifiedEditor.delegateScrollFromMouseWheelEvent(e);
+            }, { passive: false }));
+            store.add(appendRemoveOnDispose(this._rootElement, diffOverviewRoot));
+            store.add(autorunWithStore2('recreate overview rules when model changes', (reader, store) => {
+                const m = this._diffModel.read(reader);
+                const originalOverviewRuler = this._originalEditor.createOverviewRuler('original diffOverviewRuler');
+                if (originalOverviewRuler) {
+                    store.add(originalOverviewRuler);
+                    store.add(appendRemoveOnDispose(diffOverviewRoot, originalOverviewRuler.getDomNode()));
+                }
+                const modifiedOverviewRuler = this._modifiedEditor.createOverviewRuler('modified diffOverviewRuler');
+                if (modifiedOverviewRuler) {
+                    store.add(modifiedOverviewRuler);
+                    store.add(appendRemoveOnDispose(diffOverviewRoot, modifiedOverviewRuler.getDomNode()));
+                }
+                if (!originalOverviewRuler || !modifiedOverviewRuler) {
+                    return;
+                }
+                store.add(autorun('set overview ruler zones', (reader) => {
+                    const colors = currentColors.read(reader);
+                    const diff = m?.diff.read(reader)?.changes;
+                    function createZones(ranges, color) {
+                        return ( ranges
+                            .filter(d => d.length > 0)
+                            .map(r => ( new OverviewRulerZone(r.startLineNumber, r.endLineNumberExclusive, r.length, ( color.toString())))));
+                    }
+                    originalOverviewRuler?.setZones(createZones(( (diff || []).map(d => d.originalRange)), colors.removeColor));
+                    modifiedOverviewRuler?.setZones(createZones(( (diff || []).map(d => d.modifiedRange)), colors.insertColor));
+                }));
+                store.add(autorun('layout overview ruler', (reader) => {
+                    const height = this._rootHeight.read(reader);
+                    const width = this._rootWidth.read(reader);
+                    const layoutInfo = this._modifiedEditorLayoutInfo.read(reader);
+                    if (layoutInfo) {
+                        const freeSpace = OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH - 2 * OverviewRulerPart.ONE_OVERVIEW_WIDTH;
+                        originalOverviewRuler.setLayout({
+                            top: 0,
+                            height: height,
+                            right: freeSpace + OverviewRulerPart.ONE_OVERVIEW_WIDTH,
+                            width: OverviewRulerPart.ONE_OVERVIEW_WIDTH,
+                        });
+                        modifiedOverviewRuler.setLayout({
+                            top: 0,
+                            height: height,
+                            right: 0,
+                            width: OverviewRulerPart.ONE_OVERVIEW_WIDTH,
+                        });
+                        const scrollTop = scrollTopObservable.read(reader);
+                        const scrollHeight = scrollHeightObservable.read(reader);
+                        const computedAvailableSize = Math.max(0, layoutInfo.height);
+                        const computedRepresentableSize = Math.max(0, computedAvailableSize - 2 * 0);
+                        const computedRatio = scrollHeight > 0 ? (computedRepresentableSize / scrollHeight) : 0;
+                        const computedSliderSize = Math.max(0, Math.floor(layoutInfo.height * computedRatio));
+                        const computedSliderPosition = Math.floor(scrollTop * computedRatio);
+                        viewportDomElement.setTop(computedSliderPosition);
+                        viewportDomElement.setHeight(computedSliderSize);
+                    }
+                    else {
+                        viewportDomElement.setTop(0);
+                        viewportDomElement.setHeight(0);
+                    }
+                    diffOverviewRoot.style.height = height + 'px';
+                    diffOverviewRoot.style.left = (width - OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH) + 'px';
+                    viewportDomElement.setWidth(OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH);
+                }));
+            }));
+        }));
+    }
+};
+OverviewRulerPart.ONE_OVERVIEW_WIDTH = 15;
+OverviewRulerPart.ENTIRE_DIFF_OVERVIEW_WIDTH = OverviewRulerPart.ONE_OVERVIEW_WIDTH * 2;
+OverviewRulerPart = ( __decorate([
+    ( __param(8, IThemeService))
+], OverviewRulerPart));
+export { OverviewRulerPart };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".diff-hidden-lines.showTop{margin:-5px 0}.diff-hidden-lines.showTop .top{mask:url(\"data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='20' height='7' viewBox='0 0 10 10' preserveAspectRatio='none'>       <polygon points='0,10 5,0 10,10' style='fill:white' />      </svg>\") repeat 0 0;-webkit-mask:url(\"data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='20' height='7' viewBox='0 0 10 10' preserveAspectRatio='none'>       <polygon points='0,10 5,0 10,10' style='fill:white' />      </svg>\") repeat 0 0}.diff-hidden-lines.showBottom .bottom,.diff-hidden-lines.showTop .top{background-color:var(--vscode-diffEditor-unchangedRegionBackground);height:7px}.diff-hidden-lines.showBottom .bottom{mask:url(\"data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='20' height='7' viewBox='0 0 10 10' preserveAspectRatio='none'>       <polygon points='0,0 5,10 10,0' style='fill:white' />      </svg>\") repeat 10px 0;-webkit-mask:url(\"data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='20' height='7' viewBox='0 0 10 10' preserveAspectRatio='none'>       <polygon points='0,0 5,10 10,0' style='fill:white' />      </svg>\") repeat 10px 0}.diff-hidden-lines .center{background:var(--vscode-diffEditor-unchangedRegionBackground);display:block;overflow:hidden;padding:0 3px;text-overflow:ellipsis;white-space:nowrap}.diff-hidden-lines .center>a,.diff-hidden-lines .center>span{user-select:none;-webkit-user-select:none;white-space:nowrap}.diff-hidden-lines .center>a{text-decoration:none}.diff-hidden-lines .center>a:hover{cursor:pointer}.diff-hidden-lines .center>a:hover,.diff-hidden-lines .center>a:hover .codicon{color:var(--vscode-editorLink-activeForeground)!important}.diff-hidden-lines .center .codicon{color:currentColor!important;color:var(--vscode-editorCodeLens-foreground);vertical-align:middle}.merge-editor-conflict-actions>a:hover .codicon:before{cursor:pointer}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,184 @@
+import { h, $, reset } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { renderLabelWithIcons } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabels.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { transaction, constObservable } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { autorunWithStore2, autorun } from 'monaco-editor/esm/vs/base/common/observableImpl/autorun.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+class UnchangedRangesFeature extends Disposable {
+    constructor(_originalEditor, _modifiedEditor, _diffModel) {
+        super();
+        this._originalEditor = _originalEditor;
+        this._modifiedEditor = _modifiedEditor;
+        this._diffModel = _diffModel;
+        const unchangedRegionViewZoneIdsOrig = [];
+        const unchangedRegionViewZoneIdsMod = [];
+        this._register(this._originalEditor.onDidChangeCursorPosition(e => {
+            const m = this._diffModel.get();
+            transaction(tx => {
+                for (const s of this._originalEditor.getSelections() || []) {
+                    m?.revealOriginalLine(s.getStartPosition().lineNumber, tx);
+                    m?.revealOriginalLine(s.getEndPosition().lineNumber, tx);
+                }
+            });
+        }));
+        this._register(this._modifiedEditor.onDidChangeCursorPosition(e => {
+            const m = this._diffModel.get();
+            transaction(tx => {
+                for (const s of this._modifiedEditor.getSelections() || []) {
+                    m?.revealModifiedLine(s.getStartPosition().lineNumber, tx);
+                    m?.revealModifiedLine(s.getEndPosition().lineNumber, tx);
+                }
+            });
+        }));
+        this._register(autorunWithStore2('update folded unchanged regions', (reader, store) => {
+            const unchangedRegions = this._diffModel.read(reader)?.unchangedRegions.read(reader);
+            if (!unchangedRegions) {
+                return;
+            }
+            this._originalEditor.changeViewZones((aOrig) => {
+                this._modifiedEditor.changeViewZones(aMod => {
+                    for (const id of unchangedRegionViewZoneIdsOrig) {
+                        aOrig.removeZone(id);
+                    }
+                    unchangedRegionViewZoneIdsOrig.length = 0;
+                    for (const id of unchangedRegionViewZoneIdsMod) {
+                        aMod.removeZone(id);
+                    }
+                    unchangedRegionViewZoneIdsMod.length = 0;
+                    for (const r of unchangedRegions) {
+                        const atTop = r.modifiedLineNumber !== 1;
+                        const atBottom = r.modifiedRange.endLineNumberExclusive !== this._modifiedEditor.getModel().getLineCount() + 1;
+                        const hiddenOriginalRange = r.getHiddenOriginalRange(reader);
+                        const hiddenModifiedRange = r.getHiddenModifiedRange(reader);
+                        if (hiddenOriginalRange.isEmpty) {
+                            continue;
+                        }
+                        store.add(( new CollapsedCodeActionsContentWidget(
+                            this._originalEditor,
+                            aOrig,
+                            hiddenOriginalRange.startLineNumber - 1,
+                            30,
+                            constObservable([
+                                {
+                                    text: `${hiddenOriginalRange.length} Lines Hidden`
+                                },
+                                {
+                                    text: '$(chevron-up) Show More',
+                                    async action() { r.showMoreAbove(undefined); },
+                                },
+                                {
+                                    text: '$(chevron-down) Show More',
+                                    async action() { r.showMoreBelow(undefined); },
+                                },
+                                {
+                                    text: '$(close) Show All',
+                                    async action() { r.showAll(undefined); },
+                                }
+                            ]),
+                            unchangedRegionViewZoneIdsOrig,
+                            atTop,
+                            atBottom
+                        )));
+                        store.add(( new CollapsedCodeActionsContentWidget(
+                            this._modifiedEditor,
+                            aMod,
+                            hiddenModifiedRange.startLineNumber - 1,
+                            30,
+                            constObservable([
+                                {
+                                    text: '$(chevron-up) Show More',
+                                    async action() { r.showMoreAbove(undefined); },
+                                },
+                                {
+                                    text: '$(chevron-down) Show More',
+                                    async action() { r.showMoreBelow(undefined); },
+                                },
+                                {
+                                    text: '$(close) Show All',
+                                    async action() { r.showAll(undefined); },
+                                }
+                            ]),
+                            unchangedRegionViewZoneIdsMod,
+                            atTop,
+                            atBottom
+                        )));
+                    }
+                });
+            });
+            this._originalEditor.setHiddenAreas(( unchangedRegions.map(r => r.getHiddenOriginalRange(reader).toInclusiveRange())).filter(isDefined));
+            this._modifiedEditor.setHiddenAreas(( unchangedRegions.map(r => r.getHiddenModifiedRange(reader).toInclusiveRange())).filter(isDefined));
+        }));
+    }
+}
+class FixedZoneWidget extends Disposable {
+    constructor(editor, viewZoneAccessor, afterLineNumber, height, viewZoneIdsToCleanUp) {
+        super();
+        this.editor = editor;
+        this.overlayWidgetId = `fixedZoneWidget-${FixedZoneWidget.counter++}`;
+        this.widgetDomNode = h('div.fixed-zone-widget').root;
+        this.overlayWidget = {
+            getId: () => this.overlayWidgetId,
+            getDomNode: () => this.widgetDomNode,
+            getPosition: () => null
+        };
+        this.viewZoneId = viewZoneAccessor.addZone({
+            domNode: document.createElement('div'),
+            afterLineNumber: afterLineNumber,
+            heightInPx: height,
+            onComputedHeight: (height) => {
+                this.widgetDomNode.style.height = `${height}px`;
+            },
+            onDomNodeTop: (top) => {
+                this.widgetDomNode.style.top = `${top}px`;
+            },
+            showInHiddenAreas: true,
+        });
+        viewZoneIdsToCleanUp.push(this.viewZoneId);
+        this.widgetDomNode.style.left = this.editor.getLayoutInfo().contentLeft + 'px';
+        this.editor.addOverlayWidget(this.overlayWidget);
+        this._register({
+            dispose: () => {
+                this.editor.removeOverlayWidget(this.overlayWidget);
+            },
+        });
+    }
+}
+FixedZoneWidget.counter = 0;
+class CollapsedCodeActionsContentWidget extends FixedZoneWidget {
+    constructor(editor, viewZoneAccessor, afterLineNumber, height, items, viewZoneIdsToCleanUp, showTopZigZag, showBottomZigZag) {
+        super(editor, viewZoneAccessor, afterLineNumber, height, viewZoneIdsToCleanUp);
+        this.showTopZigZag = showTopZigZag;
+        this.showBottomZigZag = showBottomZigZag;
+        this._domNode = h('div.diff-hidden-lines', { className: [this.showTopZigZag ? 'showTop' : '', this.showBottomZigZag ? 'showBottom' : ''].join(' ') }, [
+            h('div.top'),
+            h('div.center@content'),
+            h('div.bottom'),
+        ]);
+        this.widgetDomNode.appendChild(this._domNode.root);
+        this._register(autorun('update commands', (reader) => {
+            const i = items.read(reader);
+            this.setState(i);
+        }));
+    }
+    setState(items) {
+        const children = [];
+        let isFirst = true;
+        for (const item of items) {
+            if (isFirst) {
+                isFirst = false;
+            }
+            else {
+                children.push($('span', undefined, '\u00a0|\u00a0'));
+            }
+            const title = renderLabelWithIcons(item.text);
+            if (item.action) {
+                children.push($('a', { title: item.tooltip, role: 'button', onclick: () => item.action() }, ...title));
+            }
+            else {
+                children.push($('span', { title: item.tooltip }, ...title));
+            }
+        }
+        reset(this._domNode.content, ...children);
+    }
+}
+export { UnchangedRangesFeature };

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

@@ -0,0 +1,88 @@
+import { toDisposable, Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { autorun, observableValue, transaction } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { ElementSizeObserver } from 'monaco-editor/esm/vs/editor/browser/config/elementSizeObserver.js';
+function joinCombine(arr1, arr2, keySelector, combine) {
+    if (arr1.length === 0) {
+        return arr2;
+    }
+    if (arr2.length === 0) {
+        return arr1;
+    }
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < arr1.length && j < arr2.length) {
+        const val1 = arr1[i];
+        const val2 = arr2[j];
+        const key1 = keySelector(val1);
+        const key2 = keySelector(val2);
+        if (key1 < key2) {
+            result.push(val1);
+            i++;
+        }
+        else if (key1 > key2) {
+            result.push(val2);
+            j++;
+        }
+        else {
+            result.push(combine(val1, val2));
+            i++;
+            j++;
+        }
+    }
+    while (i < arr1.length) {
+        result.push(arr1[i]);
+        i++;
+    }
+    while (j < arr2.length) {
+        result.push(arr2[j]);
+        j++;
+    }
+    return result;
+}
+function applyObservableDecorations(editor, decorations) {
+    const d = ( new DisposableStore());
+    const decorationsCollection = editor.createDecorationsCollection();
+    d.add(autorun(`Apply decorations from ${decorations.debugName}`, reader => {
+        const d = decorations.read(reader);
+        decorationsCollection.set(d);
+    }));
+    d.add({
+        dispose: () => {
+            decorationsCollection.clear();
+        }
+    });
+    return d;
+}
+function appendRemoveOnDispose(parent, child) {
+    parent.appendChild(child);
+    return toDisposable(() => {
+        parent.removeChild(child);
+    });
+}
+class ObservableElementSizeObserver extends Disposable {
+    get width() { return this._width; }
+    get height() { return this._height; }
+    constructor(element, dimension) {
+        super();
+        this.elementSizeObserver = this._register(( new ElementSizeObserver(element, dimension)));
+        this._width = observableValue('width', this.elementSizeObserver.getWidth());
+        this._height = observableValue('height', this.elementSizeObserver.getHeight());
+        this._register(this.elementSizeObserver.onDidChange(e => transaction(tx => {
+            this._width.set(this.elementSizeObserver.getWidth(), tx);
+            this._height.set(this.elementSizeObserver.getHeight(), tx);
+        })));
+    }
+    observe(dimension) {
+        this.elementSizeObserver.observe(dimension);
+    }
+    setAutomaticLayout(automaticLayout) {
+        if (automaticLayout) {
+            this.elementSizeObserver.startObserving();
+        }
+        else {
+            this.elementSizeObserver.stopObserving();
+        }
+    }
+}
+export { ObservableElementSizeObserver, appendRemoveOnDispose, applyObservableDecorations, joinCombine };

package/dist/vscode/vs/platform/extensionManagement/common/extensionManagement.js

@@ -1,5 +1,42 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const EXTENSION_IDENTIFIER_PATTERN = '^([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$';
+function TargetPlatformToString(targetPlatform) {
+    switch (targetPlatform) {
+        case "win32-x64" : return 'Windows 64 bit';
+        case "win32-ia32" : return 'Windows 32 bit';
+        case "win32-arm64" : return 'Windows ARM';
+        case "linux-x64" : return 'Linux 64 bit';
+        case "linux-arm64" : return 'Linux ARM 64';
+        case "linux-armhf" : return 'Linux ARM';
+        case "alpine-x64" : return 'Alpine Linux 64 bit';
+        case "alpine-arm64" : return 'Alpine ARM 64';
+        case "darwin-x64" : return 'Mac';
+        case "darwin-arm64" : return 'Mac Silicon';
+        case "web" : return 'Web';
+        case "universal" : return "universal" ;
+        case "unknown" : return "unknown" ;
+        case "undefined" : return "undefined" ;
+    }
+}
 const IExtensionGalleryService = ( createDecorator('extensionGalleryService'));
+var ExtensionManagementErrorCode;
+( (function(ExtensionManagementErrorCode) {
+    ExtensionManagementErrorCode["Unsupported"] = "Unsupported";
+    ExtensionManagementErrorCode["Deprecated"] = "Deprecated";
+    ExtensionManagementErrorCode["Malicious"] = "Malicious";
+    ExtensionManagementErrorCode["Incompatible"] = "Incompatible";
+    ExtensionManagementErrorCode["IncompatiblePreRelease"] = "IncompatiblePreRelease";
+    ExtensionManagementErrorCode["IncompatibleTargetPlatform"] = "IncompatibleTargetPlatform";
+    ExtensionManagementErrorCode["ReleaseVersionNotFound"] = "ReleaseVersionNotFound";
+    ExtensionManagementErrorCode["Invalid"] = "Invalid";
+    ExtensionManagementErrorCode["Download"] = "Download";
+    ExtensionManagementErrorCode["Extract"] = "Extract";
+    ExtensionManagementErrorCode["Delete"] = "Delete";
+    ExtensionManagementErrorCode["Rename"] = "Rename";
+    ExtensionManagementErrorCode["CorruptZip"] = "CorruptZip";
+    ExtensionManagementErrorCode["IncompleteZip"] = "IncompleteZip";
+    ExtensionManagementErrorCode["Signature"] = "Signature";
+    ExtensionManagementErrorCode["Internal"] = "Internal";
+})(ExtensionManagementErrorCode || (ExtensionManagementErrorCode = {})));
 const IExtensionManagementService = ( createDecorator('extensionManagementService'));
-export { EXTENSION_IDENTIFIER_PATTERN, IExtensionGalleryService, IExtensionManagementService };
+export { EXTENSION_IDENTIFIER_PATTERN, ExtensionManagementErrorCode, IExtensionGalleryService, IExtensionManagementService, TargetPlatformToString };

package/dist/vscode/vs/platform/extensionManagement/common/extensionManagementUtil.js

@@ -1,4 +1,5 @@
 import { compareIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { UNDEFINED_PUBLISHER } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 function areSameExtensions(a, b) {
     if (a.uuid && b.uuid) {
         return a.uuid === b.uuid;
@@ -14,4 +15,7 @@ function getExtensionId(publisher, name) {
 function adoptToGalleryExtensionId(id) {
     return id.toLowerCase();
 }
-export { adoptToGalleryExtensionId, areSameExtensions, getExtensionId };
+function getGalleryExtensionId(publisher, name) {
+    return adoptToGalleryExtensionId(getExtensionId(publisher ?? UNDEFINED_PUBLISHER, name));
+}
+export { adoptToGalleryExtensionId, areSameExtensions, getExtensionId, getGalleryExtensionId };