claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/browser/widget/diffEditor/delegatingEditorImpl.js

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+export class DelegatingEditor extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._id = ++DelegatingEditor.idCounter;
+        this._onDidDispose = this._register(new Emitter());
+        this.onDidDispose = this._onDidDispose.event;
+        // #endregion
+    }
+    getId() { return this.getEditorType() + ':v2:' + this._id; }
+    // #region editorBrowser.IDiffEditor: Delegating to modified Editor
+    getVisibleColumnFromPosition(position) {
+        return this._targetEditor.getVisibleColumnFromPosition(position);
+    }
+    getPosition() {
+        return this._targetEditor.getPosition();
+    }
+    setPosition(position, source = 'api') {
+        this._targetEditor.setPosition(position, source);
+    }
+    revealLine(lineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLine(lineNumber, scrollType);
+    }
+    revealLineInCenter(lineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLineInCenter(lineNumber, scrollType);
+    }
+    revealLineInCenterIfOutsideViewport(lineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLineInCenterIfOutsideViewport(lineNumber, scrollType);
+    }
+    revealLineNearTop(lineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLineNearTop(lineNumber, scrollType);
+    }
+    revealPosition(position, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealPosition(position, scrollType);
+    }
+    revealPositionInCenter(position, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealPositionInCenter(position, scrollType);
+    }
+    revealPositionInCenterIfOutsideViewport(position, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealPositionInCenterIfOutsideViewport(position, scrollType);
+    }
+    revealPositionNearTop(position, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealPositionNearTop(position, scrollType);
+    }
+    getSelection() {
+        return this._targetEditor.getSelection();
+    }
+    getSelections() {
+        return this._targetEditor.getSelections();
+    }
+    setSelection(something, source = 'api') {
+        this._targetEditor.setSelection(something, source);
+    }
+    setSelections(ranges, source = 'api') {
+        this._targetEditor.setSelections(ranges, source);
+    }
+    revealLines(startLineNumber, endLineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLines(startLineNumber, endLineNumber, scrollType);
+    }
+    revealLinesInCenter(startLineNumber, endLineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLinesInCenter(startLineNumber, endLineNumber, scrollType);
+    }
+    revealLinesInCenterIfOutsideViewport(startLineNumber, endLineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLinesInCenterIfOutsideViewport(startLineNumber, endLineNumber, scrollType);
+    }
+    revealLinesNearTop(startLineNumber, endLineNumber, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealLinesNearTop(startLineNumber, endLineNumber, scrollType);
+    }
+    revealRange(range, scrollType = 0 /* ScrollType.Smooth */, revealVerticalInCenter = false, revealHorizontal = true) {
+        this._targetEditor.revealRange(range, scrollType, revealVerticalInCenter, revealHorizontal);
+    }
+    revealRangeInCenter(range, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealRangeInCenter(range, scrollType);
+    }
+    revealRangeInCenterIfOutsideViewport(range, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealRangeInCenterIfOutsideViewport(range, scrollType);
+    }
+    revealRangeNearTop(range, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealRangeNearTop(range, scrollType);
+    }
+    revealRangeNearTopIfOutsideViewport(range, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealRangeNearTopIfOutsideViewport(range, scrollType);
+    }
+    revealRangeAtTop(range, scrollType = 0 /* ScrollType.Smooth */) {
+        this._targetEditor.revealRangeAtTop(range, scrollType);
+    }
+    getSupportedActions() {
+        return this._targetEditor.getSupportedActions();
+    }
+    focus() {
+        this._targetEditor.focus();
+    }
+    trigger(source, handlerId, payload) {
+        this._targetEditor.trigger(source, handlerId, payload);
+    }
+    createDecorationsCollection(decorations) {
+        return this._targetEditor.createDecorationsCollection(decorations);
+    }
+    changeDecorations(callback) {
+        return this._targetEditor.changeDecorations(callback);
+    }
+}
+DelegatingEditor.idCounter = 0;

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/browser/widget/diffEditor/diffEditor.contribution.js

@@ -0,0 +1,274 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { getActiveElement } from '../../../../base/browser/dom.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { EditorAction2 } from '../../editorExtensions.js';
+import { ICodeEditorService } from '../../services/codeEditorService.js';
+import { DiffEditorWidget } from './diffEditorWidget.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { localize } from '../../../../nls.js';
+import { Action2, MenuId, MenuRegistry, registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { ContextKeyEqualsExpr, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+export class ToggleCollapseUnchangedRegions extends Action2 {
+    constructor() {
+        super({
+            id: 'diffEditor.toggleCollapseUnchangedRegions',
+            title: { value: localize('toggleCollapseUnchangedRegions', "Toggle Collapse Unchanged Regions"), original: 'Toggle Collapse Unchanged Regions' },
+            icon: Codicon.map,
+            toggled: ContextKeyExpr.has('config.diffEditor.hideUnchangedRegions.enabled'),
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+            menu: {
+                when: ContextKeyExpr.has('isInDiffEditor'),
+                id: MenuId.EditorTitle,
+                order: 22,
+                group: 'navigation',
+            },
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const newValue = !configurationService.getValue('diffEditor.hideUnchangedRegions.enabled');
+        configurationService.updateValue('diffEditor.hideUnchangedRegions.enabled', newValue);
+    }
+}
+registerAction2(ToggleCollapseUnchangedRegions);
+export class ToggleShowMovedCodeBlocks extends Action2 {
+    constructor() {
+        super({
+            id: 'diffEditor.toggleShowMovedCodeBlocks',
+            title: { value: localize('toggleShowMovedCodeBlocks', "Toggle Show Moved Code Blocks"), original: 'Toggle Show Moved Code Blocks' },
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const newValue = !configurationService.getValue('diffEditor.experimental.showMoves');
+        configurationService.updateValue('diffEditor.experimental.showMoves', newValue);
+    }
+}
+registerAction2(ToggleShowMovedCodeBlocks);
+export class ToggleUseInlineViewWhenSpaceIsLimited extends Action2 {
+    constructor() {
+        super({
+            id: 'diffEditor.toggleUseInlineViewWhenSpaceIsLimited',
+            title: { value: localize('toggleUseInlineViewWhenSpaceIsLimited', "Toggle Use Inline View When Space Is Limited"), original: 'Toggle Use Inline View When Space Is Limited' },
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const newValue = !configurationService.getValue('diffEditor.useInlineViewWhenSpaceIsLimited');
+        configurationService.updateValue('diffEditor.useInlineViewWhenSpaceIsLimited', newValue);
+    }
+}
+registerAction2(ToggleUseInlineViewWhenSpaceIsLimited);
+MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+    command: {
+        id: new ToggleUseInlineViewWhenSpaceIsLimited().desc.id,
+        title: localize('useInlineViewWhenSpaceIsLimited', "Use Inline View When Space Is Limited"),
+        toggled: ContextKeyExpr.has('config.diffEditor.useInlineViewWhenSpaceIsLimited'),
+        precondition: ContextKeyExpr.has('isInDiffEditor'),
+    },
+    order: 11,
+    group: '1_diff',
+    when: ContextKeyExpr.and(EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached, ContextKeyExpr.has('isInDiffEditor')),
+});
+MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+    command: {
+        id: new ToggleShowMovedCodeBlocks().desc.id,
+        title: localize('showMoves', "Show Moved Code Blocks"),
+        icon: Codicon.move,
+        toggled: ContextKeyEqualsExpr.create('config.diffEditor.experimental.showMoves', true),
+        precondition: ContextKeyExpr.has('isInDiffEditor'),
+    },
+    order: 10,
+    group: '1_diff',
+    when: ContextKeyExpr.has('isInDiffEditor'),
+});
+const diffEditorCategory = {
+    value: localize('diffEditor', 'Diff Editor'),
+    original: 'Diff Editor',
+};
+export class SwitchSide extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'diffEditor.switchSide',
+            title: { value: localize('switchSide', "Switch Side"), original: 'Switch Side' },
+            icon: Codicon.arrowSwap,
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+            f1: true,
+            category: diffEditorCategory,
+        });
+    }
+    runEditorCommand(accessor, editor, arg) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget) {
+            if (arg && arg.dryRun) {
+                return { destinationSelection: diffEditor.mapToOtherSide().destinationSelection };
+            }
+            else {
+                diffEditor.switchSide();
+            }
+        }
+        return undefined;
+    }
+}
+registerAction2(SwitchSide);
+export class ExitCompareMove extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'diffEditor.exitCompareMove',
+            title: { value: localize('exitCompareMove', "Exit Compare Move"), original: 'Exit Compare Move' },
+            icon: Codicon.close,
+            precondition: EditorContextKeys.comparingMovedCode,
+            f1: false,
+            category: diffEditorCategory,
+            keybinding: {
+                weight: 10000,
+                primary: 9 /* KeyCode.Escape */,
+            }
+        });
+    }
+    runEditorCommand(accessor, editor, ...args) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget) {
+            diffEditor.exitCompareMove();
+        }
+    }
+}
+registerAction2(ExitCompareMove);
+export class CollapseAllUnchangedRegions extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'diffEditor.collapseAllUnchangedRegions',
+            title: { value: localize('collapseAllUnchangedRegions', "Collapse All Unchanged Regions"), original: 'Collapse All Unchanged Regions' },
+            icon: Codicon.fold,
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+            f1: true,
+            category: diffEditorCategory,
+        });
+    }
+    runEditorCommand(accessor, editor, ...args) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget) {
+            diffEditor.collapseAllUnchangedRegions();
+        }
+    }
+}
+registerAction2(CollapseAllUnchangedRegions);
+export class ShowAllUnchangedRegions extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'diffEditor.showAllUnchangedRegions',
+            title: { value: localize('showAllUnchangedRegions', "Show All Unchanged Regions"), original: 'Show All Unchanged Regions' },
+            icon: Codicon.unfold,
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+            f1: true,
+            category: diffEditorCategory,
+        });
+    }
+    runEditorCommand(accessor, editor, ...args) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget) {
+            diffEditor.showAllUnchangedRegions();
+        }
+    }
+}
+registerAction2(ShowAllUnchangedRegions);
+const accessibleDiffViewerCategory = {
+    value: localize('accessibleDiffViewer', 'Accessible Diff Viewer'),
+    original: 'Accessible Diff Viewer',
+};
+export class AccessibleDiffViewerNext extends Action2 {
+    constructor() {
+        super({
+            id: AccessibleDiffViewerNext.id,
+            title: { value: localize('editor.action.accessibleDiffViewer.next', "Go to Next Difference"), original: 'Go to Next Difference' },
+            category: accessibleDiffViewerCategory,
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+            keybinding: {
+                primary: 65 /* KeyCode.F7 */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            f1: true,
+        });
+    }
+    run(accessor) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        diffEditor === null || diffEditor === void 0 ? void 0 : diffEditor.accessibleDiffViewerNext();
+    }
+}
+AccessibleDiffViewerNext.id = 'editor.action.accessibleDiffViewer.next';
+MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+    command: {
+        id: AccessibleDiffViewerNext.id,
+        title: localize('Open Accessible Diff Viewer', "Open Accessible Diff Viewer"),
+        precondition: ContextKeyExpr.has('isInDiffEditor'),
+    },
+    order: 10,
+    group: '2_diff',
+    when: ContextKeyExpr.and(EditorContextKeys.accessibleDiffViewerVisible.negate(), ContextKeyExpr.has('isInDiffEditor')),
+});
+export class AccessibleDiffViewerPrev extends Action2 {
+    constructor() {
+        super({
+            id: AccessibleDiffViewerPrev.id,
+            title: { value: localize('editor.action.accessibleDiffViewer.prev', "Go to Previous Difference"), original: 'Go to Previous Difference' },
+            category: accessibleDiffViewerCategory,
+            precondition: ContextKeyExpr.has('isInDiffEditor'),
+            keybinding: {
+                primary: 1024 /* KeyMod.Shift */ | 65 /* KeyCode.F7 */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            f1: true,
+        });
+    }
+    run(accessor) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        diffEditor === null || diffEditor === void 0 ? void 0 : diffEditor.accessibleDiffViewerPrev();
+    }
+}
+AccessibleDiffViewerPrev.id = 'editor.action.accessibleDiffViewer.prev';
+export function findFocusedDiffEditor(accessor) {
+    var _a;
+    const codeEditorService = accessor.get(ICodeEditorService);
+    const diffEditors = codeEditorService.listDiffEditors();
+    const activeCodeEditor = (_a = codeEditorService.getFocusedCodeEditor()) !== null && _a !== void 0 ? _a : codeEditorService.getActiveCodeEditor();
+    if (!activeCodeEditor) {
+        return null;
+    }
+    for (let i = 0, len = diffEditors.length; i < len; i++) {
+        const diffEditor = diffEditors[i];
+        if (diffEditor.getModifiedEditor().getId() === activeCodeEditor.getId() || diffEditor.getOriginalEditor().getId() === activeCodeEditor.getId()) {
+            return diffEditor;
+        }
+    }
+    const activeElement = getActiveElement();
+    if (activeElement) {
+        for (const d of diffEditors) {
+            const container = d.getContainerDomNode();
+            if (isElementOrParentOf(container, activeElement)) {
+                return d;
+            }
+        }
+    }
+    return null;
+}
+function isElementOrParentOf(elementOrParent, element) {
+    let e = element;
+    while (e) {
+        if (e === elementOrParent) {
+            return true;
+        }
+        e = e.parentElement;
+    }
+    return false;
+}
+CommandsRegistry.registerCommandAlias('editor.action.diffReview.next', AccessibleDiffViewerNext.id);
+registerAction2(AccessibleDiffViewerNext);
+CommandsRegistry.registerCommandAlias('editor.action.diffReview.prev', AccessibleDiffViewerPrev.id);
+registerAction2(AccessibleDiffViewerPrev);

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/browser/widget/diffEditor/diffEditorDecorations.js

@@ -0,0 +1,225 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { h } from '../../../../base/browser/dom.js';
+import { renderIcon } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { autorunWithStore, derived } from '../../../../base/common/observable.js';
+import { diffAddDecoration, diffAddDecorationEmpty, diffDeleteDecoration, diffDeleteDecorationEmpty, diffLineAddDecorationBackground, diffLineAddDecorationBackgroundWithIndicator, diffLineDeleteDecorationBackground, diffLineDeleteDecorationBackgroundWithIndicator, diffWholeLineAddDecoration, diffWholeLineDeleteDecoration } from './decorations.js';
+import { MovedBlocksLinesPart } from './movedBlocksLines.js';
+import { applyObservableDecorations } from './utils.js';
+import { LineRange, LineRangeSet } from '../../../common/core/lineRange.js';
+import { Range } from '../../../common/core/range.js';
+import { GlyphMarginLane } from '../../../common/model.js';
+import { localize } from '../../../../nls.js';
+export class DiffEditorDecorations extends Disposable {
+    constructor(_editors, _diffModel, _options, widget) {
+        super();
+        this._editors = _editors;
+        this._diffModel = _diffModel;
+        this._options = _options;
+        this._decorations = derived(this, (reader) => {
+            var _a;
+            const diff = (_a = this._diffModel.read(reader)) === null || _a === void 0 ? void 0 : _a.diff.read(reader);
+            if (!diff) {
+                return null;
+            }
+            const movedTextToCompare = this._diffModel.read(reader).movedTextToCompare.read(reader);
+            const renderIndicators = this._options.renderIndicators.read(reader);
+            const showEmptyDecorations = this._options.showEmptyDecorations.read(reader);
+            const originalDecorations = [];
+            const modifiedDecorations = [];
+            if (!movedTextToCompare) {
+                for (const m of diff.mappings) {
+                    if (!m.lineRangeMapping.original.isEmpty) {
+                        originalDecorations.push({ range: m.lineRangeMapping.original.toInclusiveRange(), options: renderIndicators ? diffLineDeleteDecorationBackgroundWithIndicator : diffLineDeleteDecorationBackground });
+                    }
+                    if (!m.lineRangeMapping.modified.isEmpty) {
+                        modifiedDecorations.push({ range: m.lineRangeMapping.modified.toInclusiveRange(), options: renderIndicators ? diffLineAddDecorationBackgroundWithIndicator : diffLineAddDecorationBackground });
+                    }
+                    if (m.lineRangeMapping.modified.isEmpty || m.lineRangeMapping.original.isEmpty) {
+                        if (!m.lineRangeMapping.original.isEmpty) {
+                            originalDecorations.push({ range: m.lineRangeMapping.original.toInclusiveRange(), options: diffWholeLineDeleteDecoration });
+                        }
+                        if (!m.lineRangeMapping.modified.isEmpty) {
+                            modifiedDecorations.push({ range: m.lineRangeMapping.modified.toInclusiveRange(), options: diffWholeLineAddDecoration });
+                        }
+                    }
+                    else {
+                        for (const i of m.lineRangeMapping.innerChanges || []) {
+                            // Don't show empty markers outside the line range
+                            if (m.lineRangeMapping.original.contains(i.originalRange.startLineNumber)) {
+                                originalDecorations.push({ range: i.originalRange, options: (i.originalRange.isEmpty() && showEmptyDecorations) ? diffDeleteDecorationEmpty : diffDeleteDecoration });
+                            }
+                            if (m.lineRangeMapping.modified.contains(i.modifiedRange.startLineNumber)) {
+                                modifiedDecorations.push({ range: i.modifiedRange, options: (i.modifiedRange.isEmpty() && showEmptyDecorations) ? diffAddDecorationEmpty : diffAddDecoration });
+                            }
+                        }
+                    }
+                }
+            }
+            if (movedTextToCompare) {
+                for (const m of movedTextToCompare.changes) {
+                    const fullRangeOriginal = m.original.toInclusiveRange();
+                    if (fullRangeOriginal) {
+                        originalDecorations.push({ range: fullRangeOriginal, options: renderIndicators ? diffLineDeleteDecorationBackgroundWithIndicator : diffLineDeleteDecorationBackground });
+                    }
+                    const fullRangeModified = m.modified.toInclusiveRange();
+                    if (fullRangeModified) {
+                        modifiedDecorations.push({ range: fullRangeModified, options: renderIndicators ? diffLineAddDecorationBackgroundWithIndicator : diffLineAddDecorationBackground });
+                    }
+                    for (const i of m.innerChanges || []) {
+                        originalDecorations.push({ range: i.originalRange, options: diffDeleteDecoration });
+                        modifiedDecorations.push({ range: i.modifiedRange, options: diffAddDecoration });
+                    }
+                }
+            }
+            const activeMovedText = this._diffModel.read(reader).activeMovedText.read(reader);
+            for (const m of diff.movedTexts) {
+                originalDecorations.push({
+                    range: m.lineRangeMapping.original.toInclusiveRange(), options: {
+                        description: 'moved',
+                        blockClassName: 'movedOriginal' + (m === activeMovedText ? ' currentMove' : ''),
+                        blockPadding: [MovedBlocksLinesPart.movedCodeBlockPadding, 0, MovedBlocksLinesPart.movedCodeBlockPadding, MovedBlocksLinesPart.movedCodeBlockPadding],
+                    }
+                });
+                modifiedDecorations.push({
+                    range: m.lineRangeMapping.modified.toInclusiveRange(), options: {
+                        description: 'moved',
+                        blockClassName: 'movedModified' + (m === activeMovedText ? ' currentMove' : ''),
+                        blockPadding: [4, 0, 4, 4],
+                    }
+                });
+            }
+            return { originalDecorations, modifiedDecorations };
+        });
+        this._register(new RevertButtonsFeature(_editors, _diffModel, _options, widget));
+        this._register(applyObservableDecorations(this._editors.original, this._decorations.map(d => (d === null || d === void 0 ? void 0 : d.originalDecorations) || [])));
+        this._register(applyObservableDecorations(this._editors.modified, this._decorations.map(d => (d === null || d === void 0 ? void 0 : d.modifiedDecorations) || [])));
+    }
+}
+class RevertButtonsFeature extends Disposable {
+    constructor(_editors, _diffModel, _options, _widget) {
+        super();
+        this._editors = _editors;
+        this._diffModel = _diffModel;
+        this._options = _options;
+        this._widget = _widget;
+        const emptyArr = [];
+        const selectedDiffs = derived(this, (reader) => {
+            /** @description selectedDiffs */
+            const model = this._diffModel.read(reader);
+            const diff = model === null || model === void 0 ? void 0 : model.diff.read(reader);
+            if (!diff) {
+                return emptyArr;
+            }
+            const selections = this._editors.modifiedSelections.read(reader);
+            if (selections.every(s => s.isEmpty())) {
+                return emptyArr;
+            }
+            const lineRanges = new LineRangeSet(selections.map(s => LineRange.fromRangeInclusive(s)));
+            const mappings = diff.mappings.filter(m => m.lineRangeMapping.innerChanges && lineRanges.intersects(m.lineRangeMapping.modified));
+            const result = mappings.map(mapping => ({
+                mapping,
+                rangeMappings: mapping.lineRangeMapping.innerChanges.filter(c => selections.some(s => Range.areIntersecting(c.modifiedRange, s)))
+            }));
+            if (result.length === 0 || result.every(r => r.rangeMappings.length === 0)) {
+                return emptyArr;
+            }
+            return result;
+        });
+        this._register(autorunWithStore((reader, store) => {
+            const model = this._diffModel.read(reader);
+            const diff = model === null || model === void 0 ? void 0 : model.diff.read(reader);
+            if (!model || !diff) {
+                return;
+            }
+            const movedTextToCompare = this._diffModel.read(reader).movedTextToCompare.read(reader);
+            if (movedTextToCompare) {
+                return;
+            }
+            if (!this._options.shouldRenderRevertArrows.read(reader)) {
+                return;
+            }
+            const glyphWidgetsModified = [];
+            const selectedDiffs_ = selectedDiffs.read(reader);
+            const diffsSet = new Set(selectedDiffs_.map(d => d.mapping));
+            if (selectedDiffs_.length > 0) {
+                const selections = this._editors.modifiedSelections.read(reader);
+                const btn = new RevertButton(selections[selections.length - 1].positionLineNumber, this._widget, selectedDiffs_.flatMap(d => d.rangeMappings), true);
+                this._editors.modified.addGlyphMarginWidget(btn);
+                glyphWidgetsModified.push(btn);
+            }
+            for (const m of diff.mappings) {
+                if (diffsSet.has(m)) {
+                    continue;
+                }
+                if (!m.lineRangeMapping.modified.isEmpty && m.lineRangeMapping.innerChanges) {
+                    const btn = new RevertButton(m.lineRangeMapping.modified.startLineNumber, this._widget, m.lineRangeMapping.innerChanges, false);
+                    this._editors.modified.addGlyphMarginWidget(btn);
+                    glyphWidgetsModified.push(btn);
+                }
+            }
+            store.add(toDisposable(() => {
+                for (const w of glyphWidgetsModified) {
+                    this._editors.modified.removeGlyphMarginWidget(w);
+                }
+            }));
+        }));
+    }
+}
+class RevertButton {
+    getId() { return this._id; }
+    constructor(_lineNumber, _widget, _diffs, _selection) {
+        this._lineNumber = _lineNumber;
+        this._widget = _widget;
+        this._diffs = _diffs;
+        this._selection = _selection;
+        this._id = `revertButton${RevertButton.counter++}`;
+        this._domNode = h('div.revertButton', {
+            title: this._selection
+                ? localize('revertSelectedChanges', 'Revert Selected Changes')
+                : localize('revertChange', 'Revert Change')
+        }, [renderIcon(Codicon.arrowRight)]).root;
+        this._domNode.onmousedown = e => {
+            // don't prevent context menu from showing up
+            if (e.button !== 2) {
+                e.stopPropagation();
+                e.preventDefault();
+            }
+        };
+        this._domNode.onmouseup = e => {
+            e.stopPropagation();
+            e.preventDefault();
+        };
+        this._domNode.onclick = (e) => {
+            this._widget.revertRangeMappings(this._diffs);
+            e.stopPropagation();
+            e.preventDefault();
+        };
+    }
+    /**
+     * Get the dom node of the glyph widget.
+     */
+    getDomNode() {
+        return this._domNode;
+    }
+    /**
+     * Get the placement of the glyph widget.
+     */
+    getPosition() {
+        return {
+            lane: GlyphMarginLane.Right,
+            range: {
+                startColumn: 1,
+                startLineNumber: this._lineNumber,
+                endColumn: 1,
+                endLineNumber: this._lineNumber,
+            },
+            zIndex: 10001,
+        };
+    }
+}
+RevertButton.counter = 0;