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

package/dist/services.js

@@ -48,6 +48,9 @@ export { IDebugService } from './vscode/vs/workbench/contrib/debug/common/debug.
 export { ILogService, ILoggerService, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 export { IViewsService } from './vscode/vs/workbench/common/views.js';
 export { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+export { IPreferencesService } from './vscode/vs/workbench/services/preferences/common/preferences.js';
+export { IPreferencesSearchService } from './vscode/vs/workbench/contrib/preferences/common/preferences.js';
+export { IKeybindingEditingService } from './vscode/vs/workbench/services/keybinding/common/keybindingEditing.js';
 const serviceInitializeParticipants = [];
 function registerServiceInitializeParticipant(participant) {
     serviceInitializeParticipants.push(participant);

package/dist/severity.d.ts

@@ -0,0 +1,16 @@
+declare enum Severity {
+    Ignore = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3
+}
+declare namespace Severity {
+    /**
+     * Parses 'error', 'warning', 'warn', 'info' in call casings
+     * and falls back to ignore.
+     */
+    function fromValue(value: string): Severity;
+    function toString(severity: Severity): string;
+}
+
+export { Severity as S };

package/dist/uri.d.ts

@@ -107,13 +107,14 @@ declare class URI implements UriComponents {
      * @param path A file system path (see `URI#fsPath`)
      */
     static file(path: string): URI;
-    static from(components: {
-        scheme: string;
-        authority?: string;
-        path?: string;
-        query?: string;
-        fragment?: string;
-    }): URI;
+    /**
+     * Creates new URI from uri components.
+     *
+     * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs
+     * validation and should be used for untrusted uri components retrieved from storage,
+     * user input, command arguments etc
+     */
+    static from(components: UriComponents, strict?: boolean): URI;
     /**
      * Join a URI path with path fragments and normalizes the resulting path.
      *
@@ -135,6 +136,16 @@ declare class URI implements UriComponents {
      */
     toString(skipEncoding?: boolean): string;
     toJSON(): UriComponents;
+    /**
+     * A helper function to revive URIs.
+     *
+     * **Note** that this function should only be used when receiving URI#toJSON generated data
+     * and that it doesn't do any validation. Use {@link URI.from} when received "untrusted"
+     * uri components such as command arguments or data from storage.
+     *
+     * @param data The URI components or URI to revive.
+     * @returns The revived URI or undefined or null.
+     */
     static revive(data: UriComponents | URI): URI;
     static revive(data: UriComponents | URI | undefined): URI | undefined;
     static revive(data: UriComponents | URI | null): URI | null;
@@ -142,10 +153,10 @@ declare class URI implements UriComponents {
 }
 interface UriComponents {
     scheme: string;
-    authority: string;
-    path: string;
-    query: string;
-    fragment: string;
+    authority?: string;
+    path?: string;
+    query?: string;
+    fragment?: string;
 }
 
 export { URI as U, UriComponents as a };

package/dist/views.d.ts

@@ -0,0 +1,270 @@
+import { S as ServiceIdentifier, b as SyncDescriptor } from './instantiation.js';
+import { U as URI } from './uri.js';
+import { E as Event } from './event.js';
+import { T as ThemeIcon } from './themables.js';
+import { C as ContextKeyExpression } from './contextkey.js';
+import { I as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
+import { I as IComposite, a as IProgressIndicator } from './composite.js';
+
+interface IKeybindings {
+    primary?: number;
+    secondary?: number[];
+    win?: {
+        primary: number;
+        secondary?: number[];
+    };
+    linux?: {
+        primary: number;
+        secondary?: number[];
+    };
+    mac?: {
+        primary: number;
+        secondary?: number[];
+    };
+}
+
+interface IPaneComposite extends IComposite {
+    /**
+     * Returns the minimal width needed to avoid any content horizontal truncation
+     */
+    getOptimalWidth(): number | undefined;
+    openView<T extends IView>(id: string, focus?: boolean): T | undefined;
+    getViewPaneContainer(): IViewPaneContainer | undefined;
+}
+
+declare const enum ViewContainerLocation {
+    Sidebar = 0,
+    Panel = 1,
+    AuxiliaryBar = 2
+}
+type OpenCommandActionDescriptor = {
+    readonly id: string;
+    readonly title?: ILocalizedString | string;
+    readonly mnemonicTitle?: string;
+    readonly order?: number;
+    readonly keybindings?: IKeybindings & {
+        when?: ContextKeyExpression;
+    };
+};
+/**
+ * View Container Contexts
+ */
+interface IViewContainerDescriptor {
+    /**
+     * The id of the view container
+     */
+    readonly id: string;
+    /**
+     * The title of the view container
+     */
+    readonly title: ILocalizedString | string;
+    /**
+     * Icon representation of the View container
+     */
+    readonly icon?: ThemeIcon | URI;
+    /**
+     * Order of the view container.
+     */
+    readonly order?: number;
+    /**
+     * IViewPaneContainer Ctor to instantiate
+     */
+    readonly ctorDescriptor: SyncDescriptor<IViewPaneContainer>;
+    /**
+     * Descriptor for open view container command
+     * If not provided, view container info (id, title) is used.
+     *
+     * Note: To prevent registering open command, use `doNotRegisterOpenCommand` flag while registering the view container
+     */
+    readonly openCommandActionDescriptor?: OpenCommandActionDescriptor;
+    /**
+     * Storage id to use to store the view container state.
+     * If not provided, it will be derived.
+     */
+    readonly storageId?: string;
+    /**
+     * If enabled, view container is not shown if it has no active views.
+     */
+    readonly hideIfEmpty?: boolean;
+    /**
+     * Id of the extension that contributed the view container
+     */
+    readonly extensionId?: ExtensionIdentifier;
+    readonly alwaysUseContainerInfo?: boolean;
+    readonly viewOrderDelegate?: ViewOrderDelegate;
+    readonly rejectAddedViews?: boolean;
+    requestedIndex?: number;
+}
+interface ViewOrderDelegate {
+    getOrder(group?: string): number | undefined;
+}
+interface ViewContainer extends IViewContainerDescriptor {
+}
+interface IViewDescriptor {
+    readonly type?: string;
+    readonly id: string;
+    readonly name: string;
+    readonly ctorDescriptor: SyncDescriptor<IView>;
+    readonly when?: ContextKeyExpression;
+    readonly order?: number;
+    readonly weight?: number;
+    readonly collapsed?: boolean;
+    readonly canToggleVisibility?: boolean;
+    readonly canMoveView?: boolean;
+    readonly containerIcon?: ThemeIcon | URI;
+    readonly containerTitle?: string;
+    readonly hideByDefault?: boolean;
+    readonly workspace?: boolean;
+    readonly focusCommand?: {
+        id: string;
+        keybindings?: IKeybindings;
+    };
+    readonly group?: string;
+    readonly remoteAuthority?: string | string[];
+    readonly virtualWorkspace?: string;
+    readonly openCommandActionDescriptor?: OpenCommandActionDescriptor;
+}
+interface IViewDescriptorRef {
+    viewDescriptor: IViewDescriptor;
+    index: number;
+}
+interface IAddedViewDescriptorRef extends IViewDescriptorRef {
+    collapsed: boolean;
+    size?: number;
+}
+interface IViewContainerModel {
+    readonly viewContainer: ViewContainer;
+    readonly title: string;
+    readonly icon: ThemeIcon | URI | undefined;
+    readonly keybindingId: string | undefined;
+    readonly onDidChangeContainerInfo: Event<{
+        title?: boolean;
+        icon?: boolean;
+        keybindingId?: boolean;
+        badgeEnablement?: boolean;
+    }>;
+    readonly allViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidChangeAllViewDescriptors: Event<{
+        added: ReadonlyArray<IViewDescriptor>;
+        removed: ReadonlyArray<IViewDescriptor>;
+    }>;
+    readonly activeViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidChangeActiveViewDescriptors: Event<{
+        added: ReadonlyArray<IViewDescriptor>;
+        removed: ReadonlyArray<IViewDescriptor>;
+    }>;
+    readonly visibleViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidAddVisibleViewDescriptors: Event<IAddedViewDescriptorRef[]>;
+    readonly onDidRemoveVisibleViewDescriptors: Event<IViewDescriptorRef[]>;
+    readonly onDidMoveVisibleViewDescriptors: Event<{
+        from: IViewDescriptorRef;
+        to: IViewDescriptorRef;
+    }>;
+    isVisible(id: string): boolean;
+    setVisible(id: string, visible: boolean): void;
+    isCollapsed(id: string): boolean;
+    setCollapsed(id: string, collapsed: boolean): void;
+    getSize(id: string): number | undefined;
+    setSizes(newSizes: readonly {
+        id: string;
+        size: number;
+    }[]): void;
+    move(from: string, to: string): void;
+}
+interface IView {
+    readonly id: string;
+    focus(): void;
+    isVisible(): boolean;
+    isBodyVisible(): boolean;
+    setExpanded(expanded: boolean): boolean;
+    getProgressIndicator(): IProgressIndicator | undefined;
+}
+declare const IViewsService: ServiceIdentifier<IViewsService>;
+interface IViewsService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeViewContainerVisibility: Event<{
+        id: string;
+        visible: boolean;
+        location: ViewContainerLocation;
+    }>;
+    isViewContainerVisible(id: string): boolean;
+    openViewContainer(id: string, focus?: boolean): Promise<IPaneComposite | null>;
+    closeViewContainer(id: string): void;
+    getVisibleViewContainer(location: ViewContainerLocation): ViewContainer | null;
+    getActiveViewPaneContainerWithId(viewContainerId: string): IViewPaneContainer | null;
+    readonly onDidChangeViewVisibility: Event<{
+        id: string;
+        visible: boolean;
+    }>;
+    isViewVisible(id: string): boolean;
+    openView<T extends IView>(id: string, focus?: boolean): Promise<T | null>;
+    closeView(id: string): void;
+    getActiveViewWithId<T extends IView>(id: string): T | null;
+    getViewWithId<T extends IView>(id: string): T | null;
+    getViewProgressIndicator(id: string): IProgressIndicator | undefined;
+}
+declare enum ViewVisibilityState {
+    Default = 0,
+    Expand = 1
+}
+declare const IViewDescriptorService: ServiceIdentifier<IViewDescriptorService>;
+interface IViewDescriptorService {
+    readonly _serviceBrand: undefined;
+    readonly viewContainers: ReadonlyArray<ViewContainer>;
+    readonly onDidChangeViewContainers: Event<{
+        added: ReadonlyArray<{
+            container: ViewContainer;
+            location: ViewContainerLocation;
+        }>;
+        removed: ReadonlyArray<{
+            container: ViewContainer;
+            location: ViewContainerLocation;
+        }>;
+    }>;
+    getDefaultViewContainer(location: ViewContainerLocation): ViewContainer | undefined;
+    getViewContainerById(id: string): ViewContainer | null;
+    isViewContainerRemovedPermanently(id: string): boolean;
+    getDefaultViewContainerLocation(viewContainer: ViewContainer): ViewContainerLocation | null;
+    getViewContainerLocation(viewContainer: ViewContainer): ViewContainerLocation | null;
+    getViewContainersByLocation(location: ViewContainerLocation): ViewContainer[];
+    getViewContainerModel(viewContainer: ViewContainer): IViewContainerModel;
+    readonly onDidChangeContainerLocation: Event<{
+        viewContainer: ViewContainer;
+        from: ViewContainerLocation;
+        to: ViewContainerLocation;
+    }>;
+    moveViewContainerToLocation(viewContainer: ViewContainer, location: ViewContainerLocation, requestedIndex?: number): void;
+    getViewContainerBadgeEnablementState(id: string): boolean;
+    setViewContainerBadgeEnablementState(id: string, badgesEnabled: boolean): void;
+    getViewDescriptorById(id: string): IViewDescriptor | null;
+    getViewContainerByViewId(id: string): ViewContainer | null;
+    getDefaultContainerById(id: string): ViewContainer | null;
+    getViewLocationById(id: string): ViewContainerLocation | null;
+    readonly onDidChangeContainer: Event<{
+        views: IViewDescriptor[];
+        from: ViewContainer;
+        to: ViewContainer;
+    }>;
+    moveViewsToContainer(views: IViewDescriptor[], viewContainer: ViewContainer, visibilityState?: ViewVisibilityState): void;
+    readonly onDidChangeLocation: Event<{
+        views: IViewDescriptor[];
+        from: ViewContainerLocation;
+        to: ViewContainerLocation;
+    }>;
+    moveViewToLocation(view: IViewDescriptor, location: ViewContainerLocation): void;
+    reset(): void;
+}
+interface IViewPaneContainer {
+    onDidAddViews: Event<IView[]>;
+    onDidRemoveViews: Event<IView[]>;
+    onDidChangeViewVisibility: Event<IView>;
+    readonly views: IView[];
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    focus(): void;
+    getActionsContext(): unknown;
+    getView(viewId: string): IView | undefined;
+    toggleViewVisibility(viewId: string): void;
+}
+
+export { IView as I, ViewContainerLocation as V, IViewDescriptorService as a, IViewPaneContainer as b, ViewContainer as c, IViewContainerModel as d, IViewDescriptor as e, IAddedViewDescriptorRef as f, IPaneComposite as g, IViewsService as h };

package/dist/vscode/vs/base/common/processes.js

@@ -0,0 +1,24 @@
+function sanitizeProcessEnvironment(env, ...preserve) {
+    const set = preserve.reduce((set, key) => {
+        set[key] = true;
+        return set;
+    }, {});
+    const keysToRemove = [
+        /^ELECTRON_.+$/,
+        /^VSCODE_(?!(PORTABLE|SHELL_LOGIN|ENV_REPLACE|ENV_APPEND|ENV_PREPEND)).+$/,
+        /^SNAP(|_.*)$/,
+        /^GDK_PIXBUF_.+$/,
+    ];
+    const envKeys = ( Object.keys(env));
+    envKeys
+        .filter(key => !set[key])
+        .forEach(envKey => {
+        for (let i = 0; i < keysToRemove.length; i++) {
+            if (envKey.search(keysToRemove[i]) !== -1) {
+                delete env[envKey];
+                break;
+            }
+        }
+    });
+}
+export { sanitizeProcessEnvironment };

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

@@ -0,0 +1,20 @@
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+const diffFullLineAddDecoration = ModelDecorationOptions.register({
+    className: 'line-insert',
+    description: 'line-insert',
+    isWholeLine: true,
+});
+const diffFullLineDeleteDecoration = ModelDecorationOptions.register({
+    className: 'line-delete',
+    description: 'line-delete',
+    isWholeLine: true,
+});
+const diffAddDecoration = ModelDecorationOptions.register({
+    className: 'char-insert',
+    description: 'char-insert',
+});
+const diffDeleteDecoration = ModelDecorationOptions.register({
+    className: 'char-delete',
+    description: 'char-delete',
+});
+export { diffAddDecoration, diffDeleteDecoration, diffFullLineAddDecoration, diffFullLineDeleteDecoration };

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

@@ -0,0 +1,106 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class DelegatingEditor extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._id = ++DelegatingEditor.idCounter;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+    }
+    getId() { return this.getEditorType() + ':' + this._id; }
+    getVisibleColumnFromPosition(position) {
+        return this._targetEditor.getVisibleColumnFromPosition(position);
+    }
+    getStatusbarColumn(position) {
+        return this._targetEditor.getStatusbarColumn(position);
+    }
+    getPosition() {
+        return this._targetEditor.getPosition();
+    }
+    setPosition(position, source = 'api') {
+        this._targetEditor.setPosition(position, source);
+    }
+    revealLine(lineNumber, scrollType = 0 ) {
+        this._targetEditor.revealLine(lineNumber, scrollType);
+    }
+    revealLineInCenter(lineNumber, scrollType = 0 ) {
+        this._targetEditor.revealLineInCenter(lineNumber, scrollType);
+    }
+    revealLineInCenterIfOutsideViewport(lineNumber, scrollType = 0 ) {
+        this._targetEditor.revealLineInCenterIfOutsideViewport(lineNumber, scrollType);
+    }
+    revealLineNearTop(lineNumber, scrollType = 0 ) {
+        this._targetEditor.revealLineNearTop(lineNumber, scrollType);
+    }
+    revealPosition(position, scrollType = 0 ) {
+        this._targetEditor.revealPosition(position, scrollType);
+    }
+    revealPositionInCenter(position, scrollType = 0 ) {
+        this._targetEditor.revealPositionInCenter(position, scrollType);
+    }
+    revealPositionInCenterIfOutsideViewport(position, scrollType = 0 ) {
+        this._targetEditor.revealPositionInCenterIfOutsideViewport(position, scrollType);
+    }
+    revealPositionNearTop(position, scrollType = 0 ) {
+        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 ) {
+        this._targetEditor.revealLines(startLineNumber, endLineNumber, scrollType);
+    }
+    revealLinesInCenter(startLineNumber, endLineNumber, scrollType = 0 ) {
+        this._targetEditor.revealLinesInCenter(startLineNumber, endLineNumber, scrollType);
+    }
+    revealLinesInCenterIfOutsideViewport(startLineNumber, endLineNumber, scrollType = 0 ) {
+        this._targetEditor.revealLinesInCenterIfOutsideViewport(startLineNumber, endLineNumber, scrollType);
+    }
+    revealLinesNearTop(startLineNumber, endLineNumber, scrollType = 0 ) {
+        this._targetEditor.revealLinesNearTop(startLineNumber, endLineNumber, scrollType);
+    }
+    revealRange(range, scrollType = 0 , revealVerticalInCenter = false, revealHorizontal = true) {
+        this._targetEditor.revealRange(range, scrollType, revealVerticalInCenter, revealHorizontal);
+    }
+    revealRangeInCenter(range, scrollType = 0 ) {
+        this._targetEditor.revealRangeInCenter(range, scrollType);
+    }
+    revealRangeInCenterIfOutsideViewport(range, scrollType = 0 ) {
+        this._targetEditor.revealRangeInCenterIfOutsideViewport(range, scrollType);
+    }
+    revealRangeNearTop(range, scrollType = 0 ) {
+        this._targetEditor.revealRangeNearTop(range, scrollType);
+    }
+    revealRangeNearTopIfOutsideViewport(range, scrollType = 0 ) {
+        this._targetEditor.revealRangeNearTopIfOutsideViewport(range, scrollType);
+    }
+    revealRangeAtTop(range, scrollType = 0 ) {
+        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;
+export { DelegatingEditor };

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

@@ -0,0 +1,59 @@
+import { Sash } from 'monaco-editor/esm/vs/base/browser/ui/sash/sash.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableValue, derived, autorun } from 'monaco-editor/esm/vs/base/common/observable.js';
+class DiffEditorSash extends Disposable {
+    constructor(_enableSplitViewResizing, _defaultSashRatio, _domNode, _dimensions) {
+        super();
+        this._enableSplitViewResizing = _enableSplitViewResizing;
+        this._defaultSashRatio = _defaultSashRatio;
+        this._domNode = _domNode;
+        this._dimensions = _dimensions;
+        this._sashRatio = observableValue('sashRatio', undefined);
+        this.sashLeft = derived('sashLeft', reader => {
+            const ratio = this._sashRatio.read(reader) ?? this._defaultSashRatio.read(reader);
+            return this._computeSashLeft(ratio, reader);
+        });
+        this._sash = this._register(( new Sash(this._domNode, {
+            getVerticalSashTop: (_sash) => 0,
+            getVerticalSashLeft: (_sash) => this.sashLeft.get(),
+            getVerticalSashHeight: (_sash) => this._dimensions.height.get(),
+        }, { orientation: 0  })));
+        this._startSashPosition = undefined;
+        this._register(this._sash.onDidStart(() => {
+            this._startSashPosition = this.sashLeft.get();
+        }));
+        this._register(this._sash.onDidChange((e) => {
+            const contentWidth = this._dimensions.width.get();
+            const sashPosition = this._computeSashLeft((this._startSashPosition + (e.currentX - e.startX)) / contentWidth, undefined);
+            this._sashRatio.set(sashPosition / contentWidth, undefined);
+        }));
+        this._register(this._sash.onDidEnd(() => this._sash.layout()));
+        this._register(this._sash.onDidReset(() => this._sashRatio.set(undefined, undefined)));
+        this._register(autorun('update sash layout', (reader) => {
+            const enabled = this._enableSplitViewResizing.read(reader);
+            this._sash.state = enabled ? 3  : 0 ;
+            this.sashLeft.read(reader);
+            this._sash.layout();
+        }));
+    }
+    setBoundarySashes(sashes) {
+        this._sash.orthogonalEndSash = sashes.bottom;
+    }
+    _computeSashLeft(desiredRatio, reader) {
+        const contentWidth = this._dimensions.width.read(reader);
+        const midPoint = Math.floor(this._defaultSashRatio.read(reader) * contentWidth);
+        const sashLeft = this._enableSplitViewResizing.read(reader) ? Math.floor(desiredRatio * contentWidth) : midPoint;
+        const MINIMUM_EDITOR_WIDTH = 100;
+        if (contentWidth <= MINIMUM_EDITOR_WIDTH * 2) {
+            return midPoint;
+        }
+        if (sashLeft < MINIMUM_EDITOR_WIDTH) {
+            return MINIMUM_EDITOR_WIDTH;
+        }
+        if (sashLeft > contentWidth - MINIMUM_EDITOR_WIDTH) {
+            return contentWidth - MINIMUM_EDITOR_WIDTH;
+        }
+        return sashLeft;
+    }
+}
+export { DiffEditorSash };

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

@@ -0,0 +1,41 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, MenuRegistry, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, ContextKeyEqualsExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+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,
+            precondition: ContextKeyEqualsExpr.create('diffEditorVersion', 2),
+        });
+    }
+    run(accessor, ...args) {
+        const configurationService = accessor.get(IConfigurationService);
+        const newValue = !configurationService.getValue('diffEditor.experimental.collapseUnchangedRegions');
+        configurationService.updateValue('diffEditor.experimental.collapseUnchangedRegions', newValue);
+    }
+}
+registerAction2(ToggleCollapseUnchangedRegions);
+MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+    command: {
+        id: ( new ToggleCollapseUnchangedRegions()).desc.id,
+        title: ( localize('collapseUnchangedRegions', "Collapse Unchanged Regions")),
+        icon: Codicon.map
+    },
+    group: 'navigation',
+    when: ( ContextKeyExpr.and(( ContextKeyExpr.has('config.diffEditor.experimental.collapseUnchangedRegions')), ContextKeyEqualsExpr.create('diffEditorVersion', 2)))
+});
+MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+    command: {
+        id: ( new ToggleCollapseUnchangedRegions()).desc.id,
+        title: ( localize('showUnchangedRegions', "Show Unchanged Regions")),
+        icon: ThemeIcon.modify(Codicon.map, 'disabled'),
+    },
+    group: 'navigation',
+    when: ( ContextKeyExpr.and(( ( ContextKeyExpr.has('config.diffEditor.experimental.collapseUnchangedRegions')).negate()), ContextKeyEqualsExpr.create('diffEditorVersion', 2)))
+});
+export { ToggleCollapseUnchangedRegions };