@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.0-next.0

package/vscode/src/vs/base/common/prefixTree.js

@@ -2,25 +2,41 @@ const unset = Symbol('unset');
 class WellDefinedPrefixTree {
     constructor() {
         this.root = ( new Node());
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
     }
     insert(key, value) {
-        let node = this.root;
+        this.opNode(key, n => n.value = value);
+    }
+    mutate(key, mutate) {
+        this.opNode(key, n => n.value = mutate(n.value === unset ? undefined : n.value));
+    }
+    delete(key) {
+        const path = [{ part: '', node: this.root }];
+        let i = 0;
         for (const part of key) {
-            if (!node.children) {
-                const next = ( new Node());
-                node.children = ( new Map([[part, next]]));
-                node = next;
-            }
-            else if (!( node.children.has(part))) {
-                const next = ( new Node());
-                node.children.set(part, next);
-                node = next;
+            const node = path[i].node.children?.get(part);
+            if (!node) {
+                return undefined;
             }
-            else {
-                node = node.children.get(part);
+            path.push({ part, node });
+            i++;
+        }
+        const value = path[i].node.value;
+        if (value === unset) {
+            return;
+        }
+        this._size--;
+        for (; i > 0; i--) {
+            const parent = path[i - 1];
+            parent.node.children.delete(path[i].part);
+            if (parent.node.children.size > 0 || parent.node.value !== unset) {
+                break;
             }
         }
-        node.value = value;
+        return value;
     }
     find(key) {
         let node = this.root;
@@ -58,6 +74,53 @@ class WellDefinedPrefixTree {
         }
         return true;
     }
+    hasKey(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            node = next;
+        }
+        return node.value !== unset;
+    }
+    opNode(key, fn) {
+        let node = this.root;
+        for (const part of key) {
+            if (!node.children) {
+                const next = ( new Node());
+                node.children = ( new Map([[part, next]]));
+                node = next;
+            }
+            else if (!( node.children.has(part))) {
+                const next = ( new Node());
+                node.children.set(part, next);
+                node = next;
+            }
+            else {
+                node = node.children.get(part);
+            }
+        }
+        if (node.value === unset) {
+            this._size++;
+        }
+        fn(node);
+    }
+    *values() {
+        const stack = [this.root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.value !== unset) {
+                yield node.value;
+            }
+            if (node.children) {
+                for (const child of ( node.children.values())) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
 }
 class Node {
     constructor() {

package/vscode/src/vs/base/common/processes.d.ts

@@ -8,4 +8,4 @@ interface ProcessItem {
     children?: ProcessItem[];
 }
 
-export { ProcessItem };
+export type { ProcessItem };

package/vscode/src/vs/base/common/product.d.ts

@@ -123,10 +123,6 @@ interface IProductConfiguration {
     readonly aiConfig?: {
         readonly ariaKey: string;
     };
-    readonly sendASmile?: {
-        readonly reportIssueUrl: string;
-        readonly requestFeatureUrl: string;
-    };
     readonly documentationUrl?: string;
     readonly serverDocumentationUrl?: string;
     readonly releaseNotesUrl?: string;
@@ -136,7 +132,7 @@ interface IProductConfiguration {
     readonly introductoryVideosUrl?: string;
     readonly tipsAndTricksUrl?: string;
     readonly newsletterSignupUrl?: string;
-    readonly twitterUrl?: string;
+    readonly youTubeUrl?: string;
     readonly requestFeatureUrl?: string;
     readonly reportIssueUrl?: string;
     readonly reportMarketplaceIssueUrl?: string;
@@ -185,6 +181,7 @@ interface IProductConfiguration {
     readonly darwinUniversalAssetId?: string;
     readonly profileTemplatesUrl?: string;
     readonly commonlyUsedSettings?: string[];
+    readonly aiGeneratedWorkspaceTrust?: IAiGeneratedWorkspaceTrust;
 }
 interface ITunnelApplicationConfig {
     authenticationProviders: IStringDictionary<{
@@ -273,5 +270,12 @@ interface ISurveyData {
     editCount: number;
     userProbability: number;
 }
+interface IAiGeneratedWorkspaceTrust {
+    readonly title: string;
+    readonly checkboxText: string;
+    readonly trustOption: string;
+    readonly dontTrustOption: string;
+    readonly startupTrustRequestLearnMore: string;
+}
 
-export { ConfigurationSyncStore, ExtensionUntrustedWorkspaceSupport, ExtensionVirtualWorkspaceSupport, IAppCenterConfiguration, IBuiltInExtension, IConfigBasedExtensionTip, IExeBasedExtensionTip, IExtensionRecommendationCondition, IExtensionRecommendations, IFeaturedExtension, IFileContentCondition, IFileLanguageCondition, IFileOpenCondition, IFilePathCondition, IProductConfiguration, IProductWalkthrough, IProductWalkthroughStep, IRemoteExtensionTip, ISettingsEditorOpenCondition, ISurveyData, ITunnelApplicationConfig, IVirtualWorkspaceExtensionTip };
+export type { ConfigurationSyncStore, ExtensionUntrustedWorkspaceSupport, ExtensionVirtualWorkspaceSupport, IAiGeneratedWorkspaceTrust, IAppCenterConfiguration, IBuiltInExtension, IConfigBasedExtensionTip, IExeBasedExtensionTip, IExtensionRecommendationCondition, IExtensionRecommendations, IFeaturedExtension, IFileContentCondition, IFileLanguageCondition, IFileOpenCondition, IFilePathCondition, IProductConfiguration, IProductWalkthrough, IProductWalkthroughStep, IRemoteExtensionTip, ISettingsEditorOpenCondition, ISurveyData, ITunnelApplicationConfig, IVirtualWorkspaceExtensionTip };

package/vscode/src/vs/base/common/resources.d.ts

@@ -104,4 +104,4 @@ interface IExtUri {
     addTrailingPathSeparator(resource: URI, sep?: string): URI;
 }
 
-export { IExtUri };
+export type { IExtUri };

package/vscode/src/vs/base/common/stream.d.ts

@@ -56,4 +56,4 @@ interface Readable<T> {
     read(): T | null;
 }
 
-export { Readable, ReadableStream, ReadableStreamEvents };
+export type { Readable, ReadableStream, ReadableStreamEvents };

package/vscode/src/vs/base/common/ternarySearchTree.d.ts

@@ -43,4 +43,4 @@ declare class TernarySearchTree<K, V> {
     _isBalanced(): boolean;
 }
 
-export { IKeyIterator, TernarySearchTree };
+export { type IKeyIterator, TernarySearchTree };

package/vscode/src/vs/base/common/themables.d.ts

@@ -25,4 +25,4 @@ declare namespace ThemeIcon {
     function isEqual(ti1: ThemeIcon, ti2: ThemeIcon): boolean;
 }
 
-export { IconIdentifier, ThemeColor, ThemeIcon };
+export { type IconIdentifier, ThemeColor, ThemeIcon };

package/vscode/src/vs/base/common/types.d.ts

@@ -13,4 +13,4 @@ type OmitOptional<T> = {
     [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
 };
 
-export { AtLeastOne, OmitOptional, TypeConstraint };
+export type { AtLeastOne, OmitOptional, TypeConstraint };

package/vscode/src/vs/base/common/uri.d.ts

@@ -165,4 +165,4 @@ type UriDto<T> = {
     [K in keyof T]: T[K] extends URI ? UriComponents : UriDto<T[K]>;
 };
 
-export { URI, UriComponents, UriDto };
+export { URI, type UriComponents, type UriDto };

package/vscode/src/vs/base/common/uriIpc.d.ts

@@ -7,4 +7,4 @@ interface IURITransformer {
     transformOutgoingScheme(scheme: string): string;
 }
 
-export { IURITransformer };
+export type { IURITransformer };

package/vscode/src/vs/base/parts/ipc/common/ipc.d.ts

@@ -30,4 +30,4 @@ interface IMessagePassingProtocol {
     drain?(): Promise<void>;
 }
 
-export { IChannel, IMessagePassingProtocol, IServerChannel };
+export type { IChannel, IMessagePassingProtocol, IServerChannel };

package/vscode/src/vs/base/parts/ipc/common/ipc.net.d.ts

@@ -87,4 +87,4 @@ interface ISocket extends IDisposable {
     traceSocketEvent(type: SocketDiagnosticsEventType, data?: VSBuffer | Uint8Array | ArrayBuffer | ArrayBufferView | any): void;
 }
 
-export { ISocket, NodeSocketCloseEvent, SocketCloseEvent, SocketCloseEventType, SocketDiagnosticsEventType, WebSocketCloseEvent };
+export { type ISocket, type NodeSocketCloseEvent, type SocketCloseEvent, SocketCloseEventType, SocketDiagnosticsEventType, type WebSocketCloseEvent };

package/vscode/src/vs/base/parts/storage/common/storage.d.ts

@@ -41,4 +41,4 @@ interface IStorage extends IDisposable {
     close(): Promise<void>;
 }
 
-export { IStorage, IStorageChangeEvent, IStorageItemsChangeEvent, StorageValue };
+export type { IStorage, IStorageChangeEvent, IStorageItemsChangeEvent, StorageValue };

package/vscode/src/vs/editor/browser/editorBrowser.d.ts

@@ -2,7 +2,7 @@ import * as monaco from 'monaco-editor';
 import { IBoundarySashes } from '../../base/browser/ui/sash/sash.js';
 import { Event } from '../../base/common/event.js';
 import { IDiffEditorOptions } from '../common/config/editorOptions.js';
-import { ILineChange, IDiffComputationResult } from '../common/diff/smartLinesDiffComputer.js';
+import { ILineChange, IDiffComputationResult } from '../common/diff/legacyLinesDiffComputer.js';
 import { IEditor, IDiffEditorViewState, IDiffEditorModel, IDiffEditorViewModel } from '../common/editorCommon.js';
 
 /**
@@ -101,4 +101,4 @@ interface IDiffEditor extends IEditor {
     accessibleDiffViewerPrev(): void;
 }
 
-export { ICodeEditor, IDiffEditor };
+export type { ICodeEditor, IDiffEditor };

package/vscode/src/vs/editor/browser/services/bulkEditService.d.ts

@@ -47,4 +47,4 @@ interface IBulkEditService {
     apply(edit: ResourceEdit[] | WorkspaceEdit, options?: IBulkEditOptions): Promise<IBulkEditResult>;
 }
 
-export { IBulkEditOptions, IBulkEditPreviewHandler, IBulkEditResult, IBulkEditService, ResourceEdit, ResourceFileEdit };
+export { type IBulkEditOptions, type IBulkEditPreviewHandler, type IBulkEditResult, IBulkEditService, ResourceEdit, ResourceFileEdit };

package/vscode/src/vs/editor/browser/services/codeEditorService.d.ts

@@ -48,4 +48,4 @@ interface ICodeEditorOpenHandler {
     (input: ITextResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise<ICodeEditor | null>;
 }
 
-export { ICodeEditorOpenHandler, ICodeEditorService };
+export { type ICodeEditorOpenHandler, ICodeEditorService };

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

@@ -1,8 +1,8 @@
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
 import { findFocusedDiffEditor } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditor.contribution.js';
 import { DiffEditorWidget2 } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditorWidget2/diffEditorWidget2.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.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';
@@ -14,35 +14,22 @@ class ToggleCollapseUnchangedRegions extends Action2 {
             title: { value: ( localize('toggleCollapseUnchangedRegions', "Toggle Collapse Unchanged Regions")), original: 'Toggle Collapse Unchanged Regions' },
             icon: Codicon.map,
             precondition: ContextKeyEqualsExpr.create('diffEditorVersion', 2),
+            toggled: ( ContextKeyExpr.has('config.diffEditor.hideUnchangedRegions.enabled')),
+            menu: {
+                id: MenuId.EditorTitle,
+                order: 22,
+                group: 'navigation',
+                when: 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);
+        const newValue = !configurationService.getValue('diffEditor.hideUnchangedRegions.enabled');
+        configurationService.updateValue('diffEditor.hideUnchangedRegions.enabled', newValue);
     }
 }
 registerAction2(ToggleCollapseUnchangedRegions);
-MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
-    command: {
-        id: ( new ToggleCollapseUnchangedRegions()).desc.id,
-        title: ( localize('collapseUnchangedRegions', "Show Unchanged Regions")),
-        icon: Codicon.map
-    },
-    order: 22,
-    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', "Collapse Unchanged Regions")),
-        icon: ThemeIcon.modify(Codicon.map, 'disabled'),
-    },
-    order: 22,
-    group: 'navigation',
-    when: ( ContextKeyExpr.and(( ( ContextKeyExpr.has('config.diffEditor.experimental.collapseUnchangedRegions')).negate()), ContextKeyEqualsExpr.create('diffEditorVersion', 2)))
-});
 class ToggleShowMovedCodeBlocks extends Action2 {
     constructor() {
         super({
@@ -58,6 +45,48 @@ class ToggleShowMovedCodeBlocks extends Action2 {
     }
 }
 registerAction2(ToggleShowMovedCodeBlocks);
+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: ContextKeyEqualsExpr.create('diffEditorVersion', 2),
+        });
+    }
+    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')),
+    },
+    order: 11,
+    group: '1_diff',
+    when: ( ContextKeyExpr.and(
+        EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached,
+        ContextKeyEqualsExpr.create('diffEditorVersion', 2)
+    ))
+});
+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),
+    },
+    order: 10,
+    group: '1_diff',
+    when: ContextKeyEqualsExpr.create('diffEditorVersion', 2)
+});
 const diffEditorCategory = {
     value: ( localize('diffEditor', 'Diff Editor')),
     original: 'Diff Editor',
@@ -73,12 +102,79 @@ class SwitchSide extends EditorAction2 {
             category: diffEditorCategory,
         });
     }
-    runEditorCommand(accessor, editor, ...args) {
+    runEditorCommand(accessor, editor, arg) {
         const diffEditor = findFocusedDiffEditor(accessor);
         if (diffEditor instanceof DiffEditorWidget2) {
-            diffEditor.switchSide();
+            if (arg && arg.dryRun) {
+                return { destinationSelection: diffEditor.mapToOtherSide().destinationSelection };
+            }
+            else {
+                diffEditor.switchSide();
+            }
         }
+        return undefined;
     }
 }
 registerAction2(SwitchSide);
-export { SwitchSide, ToggleCollapseUnchangedRegions, ToggleShowMovedCodeBlocks };
+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 ,
+            }
+        });
+    }
+    runEditorCommand(accessor, editor, ...args) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget2) {
+            diffEditor.exitCompareMove();
+        }
+    }
+}
+registerAction2(ExitCompareMove);
+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.and(ContextKeyEqualsExpr.create('diffEditorVersion', 2), ( ContextKeyExpr.has('isInDiffEditor')))),
+            f1: true,
+            category: diffEditorCategory,
+        });
+    }
+    runEditorCommand(accessor, editor, ...args) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget2) {
+            diffEditor.collapseAllUnchangedRegions();
+        }
+    }
+}
+registerAction2(CollapseAllUnchangedRegions);
+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.and(ContextKeyEqualsExpr.create('diffEditorVersion', 2), ( ContextKeyExpr.has('isInDiffEditor')))),
+            f1: true,
+            category: diffEditorCategory,
+        });
+    }
+    runEditorCommand(accessor, editor, ...args) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget2) {
+            diffEditor.showAllUnchangedRegions();
+        }
+    }
+}
+registerAction2(ShowAllUnchangedRegions);
+export { CollapseAllUnchangedRegions, ExitCompareMove, ShowAllUnchangedRegions, SwitchSide, ToggleCollapseUnchangedRegions, ToggleShowMovedCodeBlocks, ToggleUseInlineViewWhenSpaceIsLimited };

package/vscode/src/vs/editor/common/config/editorOptions.d.ts

@@ -701,6 +701,10 @@ interface IEditorOptions {
      * Controls whether the editor receives tabs or defers them to the workbench for navigation.
      */
     tabFocusMode?: boolean;
+    /**
+     * Controls whether the accessibility hint should be provided to screen reader users when an inline completion is shown.
+     */
+    inlineCompletionsAccessibilityVerbose?: boolean;
 }
 interface IDiffEditorBaseOptions {
     /**
@@ -719,6 +723,16 @@ interface IDiffEditorBaseOptions {
      * Defaults to true.
      */
     renderSideBySide?: boolean;
+    /**
+     * When `renderSideBySide` is enabled, `useInlineViewWhenSpaceIsLimited` is set,
+     * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
+     */
+    renderSideBySideInlineBreakpoint?: number | undefined;
+    /**
+     * When `renderSideBySide` is enabled, `useInlineViewWhenSpaceIsLimited` is set,
+     * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
+     */
+    useInlineViewWhenSpaceIsLimited?: boolean;
     /**
      * Timeout in milliseconds after which diff computation is cancelled.
      * Defaults to 5000.
@@ -772,10 +786,6 @@ interface IDiffEditorBaseOptions {
      */
     accessibilityVerbose?: boolean;
     experimental?: {
-        /**
-         * Defaults to false.
-         */
-        collapseUnchangedRegions?: boolean;
         /**
          * Defaults to false.
          */
@@ -791,6 +801,12 @@ interface IDiffEditorBaseOptions {
      * If the diff editor should only show the difference review mode.
      */
     onlyShowAccessibleDiffViewer?: boolean;
+    hideUnchangedRegions?: {
+        enabled?: boolean;
+        revealLineCount?: number;
+        minimumLineCount?: number;
+        contextLineCount?: number;
+    };
 }
 /**
  * Configuration options for the diff editor.
@@ -904,6 +920,10 @@ interface IEditorStickyScrollOptions {
      * Model to choose for sticky scroll by default
      */
     defaultModel?: 'outlineModel' | 'foldingProviderModel' | 'indentationModel';
+    /**
+     * Define whether to scroll sticky scroll with editor horizontal scrollbae
+     */
+    scrollWithEditor?: boolean;
 }
 /**
  * Configuration options for editor inlayHints
@@ -1383,4 +1403,4 @@ interface IPasteAsOptions {
     showPasteSelector?: 'afterPaste' | 'never';
 }
 
-export { EditorAutoClosingEditStrategy, EditorAutoClosingStrategy, EditorAutoIndentStrategy, EditorAutoSurroundStrategy, GoToLocationValues, IBracketPairColorizationOptions, IDiffEditorBaseOptions, IDiffEditorOptions, IDropIntoEditorOptions, IEditorCommentsOptions, IEditorFindOptions, IEditorHoverOptions, IEditorInlayHintsOptions, IEditorLightbulbOptions, IEditorMinimapOptions, IEditorOptions, IEditorPaddingOptions, IEditorParameterHintOptions, IEditorScrollbarOptions, IEditorStickyScrollOptions, IGotoLocationOptions, IGuidesOptions, IInlineSuggestOptions, IPasteAsOptions, IQuickSuggestionsOptions, IRulerOption, ISmartSelectOptions, ISuggestOptions, IUnicodeHighlightOptions, InUntrustedWorkspace, LineNumbersType, QuickSuggestionsValue };
+export { type EditorAutoClosingEditStrategy, type EditorAutoClosingStrategy, EditorAutoIndentStrategy, type EditorAutoSurroundStrategy, type GoToLocationValues, type IBracketPairColorizationOptions, type IDiffEditorBaseOptions, type IDiffEditorOptions, type IDropIntoEditorOptions, type IEditorCommentsOptions, type IEditorFindOptions, type IEditorHoverOptions, type IEditorInlayHintsOptions, type IEditorLightbulbOptions, type IEditorMinimapOptions, type IEditorOptions, type IEditorPaddingOptions, type IEditorParameterHintOptions, type IEditorScrollbarOptions, type IEditorStickyScrollOptions, type IGotoLocationOptions, type IGuidesOptions, type IInlineSuggestOptions, type IPasteAsOptions, type IQuickSuggestionsOptions, type IRulerOption, type ISmartSelectOptions, type ISuggestOptions, type IUnicodeHighlightOptions, type InUntrustedWorkspace, type LineNumbersType, type QuickSuggestionsValue };

package/vscode/src/vs/editor/common/core/dimension.d.ts

@@ -3,4 +3,4 @@ interface IDimension {
     height: number;
 }
 
-export { IDimension };
+export type { IDimension };

package/vscode/src/vs/editor/common/core/editOperation.d.ts

@@ -20,4 +20,4 @@ interface ISingleEditOperation {
     forceMoveMarkers?: boolean;
 }
 
-export { ISingleEditOperation };
+export type { ISingleEditOperation };

package/vscode/src/vs/editor/common/core/lineRange.d.ts

@@ -1,3 +1,4 @@
+import { OffsetRange } from './offsetRange.js';
 import { Range } from './range.js';
 
 /**
@@ -41,6 +42,7 @@ declare class LineRange {
      * Moves this line range by the given offset of line numbers.
      */
     delta(offset: number): LineRange;
+    deltaLength(offset: number): LineRange;
     /**
      * The number of lines this line range spans.
      */
@@ -67,7 +69,12 @@ declare class LineRange {
      */
     serialize(): ISerializedLineRange;
     includes(lineNumber: number): boolean;
+    /**
+     * Converts this 1-based line range to a 0-based offset range (subtracts 1!).
+     * @internal
+     */
+    toOffsetRange(): OffsetRange;
 }
 type ISerializedLineRange = [startLineNumber: number, endLineNumberExclusive: number];
 
-export { ISerializedLineRange, LineRange };
+export { type ISerializedLineRange, LineRange };

package/vscode/src/vs/editor/common/core/offsetRange.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A range of offsets (0-based).
+*/
+declare class OffsetRange {
+    readonly start: number;
+    readonly endExclusive: number;
+    static addRange(range: OffsetRange, sortedRanges: OffsetRange[]): void;
+    static tryCreate(start: number, endExclusive: number): OffsetRange | undefined;
+    static ofLength(length: number): OffsetRange;
+    constructor(start: number, endExclusive: number);
+    get isEmpty(): boolean;
+    delta(offset: number): OffsetRange;
+    deltaStart(offset: number): OffsetRange;
+    deltaEnd(offset: number): OffsetRange;
+    get length(): number;
+    toString(): string;
+    equals(other: OffsetRange): boolean;
+    containsRange(other: OffsetRange): boolean;
+    contains(offset: number): boolean;
+    /**
+     * for all numbers n: range1.contains(n) or range2.contains(n) => range1.join(range2).contains(n)
+     * The joined range is the smallest range that contains both ranges.
+     */
+    join(other: OffsetRange): OffsetRange;
+    /**
+     * for all numbers n: range1.contains(n) and range2.contains(n) <=> range1.intersect(range2).contains(n)
+     *
+     * The resulting range is empty if the ranges do not intersect, but touch.
+     * If the ranges don't even touch, the result is undefined.
+     */
+    intersect(other: OffsetRange): OffsetRange | undefined;
+    slice<T>(arr: T[]): T[];
+    /**
+     * Returns the given value if it is contained in this instance, otherwise the closest value that is contained.
+     * The range must not be empty.
+     */
+    clip(value: number): number;
+    /**
+     * Returns `r := value + k * length` such that `r` is contained in this range.
+     * The range must not be empty.
+     *
+     * E.g. `[5, 10).clipCyclic(10) === 5`, `[5, 10).clipCyclic(11) === 6` and `[5, 10).clipCyclic(4) === 9`.
+     */
+    clipCyclic(value: number): number;
+}
+
+export { OffsetRange };

package/vscode/src/vs/editor/common/core/position.d.ts

@@ -88,4 +88,4 @@ declare class Position {
     static isIPosition(obj: any): obj is IPosition;
 }
 
-export { IPosition, Position };
+export { type IPosition, Position };

package/vscode/src/vs/editor/common/core/range.d.ts

@@ -189,4 +189,4 @@ declare class Range {
     toJSON(): IRange;
 }
 
-export { IRange, Range };
+export { type IRange, Range };

package/vscode/src/vs/editor/common/core/selection.d.ts

@@ -116,4 +116,4 @@ declare class Selection extends Range {
     static createWithDirection(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, direction: SelectionDirection): Selection;
 }
 
-export { ISelection, Selection, SelectionDirection };
+export { type ISelection, Selection, SelectionDirection };

package/vscode/src/vs/editor/common/diff/documentDiffProvider.d.ts

@@ -1,3 +1,4 @@
+import { CancellationToken } from '../../../base/common/cancellation.js';
 import { Event } from '../../../base/common/event.js';
 import { LineRangeMapping, MovedText } from './linesDiffComputer.js';
 import { ITextModel } from '../model.js';
@@ -9,7 +10,7 @@ interface IDocumentDiffProvider {
     /**
      * Computes the diff between the text models `original` and `modified`.
      */
-    computeDiff(original: ITextModel, modified: ITextModel, options: IDocumentDiffProviderOptions): Promise<IDocumentDiff>;
+    computeDiff(original: ITextModel, modified: ITextModel, options: IDocumentDiffProviderOptions, cancellationToken: CancellationToken): Promise<IDocumentDiff>;
     /**
      * Is fired when settings of the diff algorithm change that could alter the result of the diffing computation.
      * Any user of this provider should recompute the diff when this event is fired.
@@ -56,4 +57,4 @@ interface IDocumentDiff {
     readonly moves: readonly MovedText[];
 }
 
-export { IDocumentDiff, IDocumentDiffProvider, IDocumentDiffProviderOptions };
+export type { IDocumentDiff, IDocumentDiffProvider, IDocumentDiffProviderOptions };

package/vscode/src/vs/editor/common/diff/{smartLinesDiffComputer.d.ts → legacyLinesDiffComputer.d.ts}

@@ -38,4 +38,4 @@ interface ILineChange extends IChange {
     readonly charChanges: ICharChange[] | undefined;
 }
 
-export { IChange, ICharChange, IDiffComputationResult, ILineChange };
+export type { IChange, ICharChange, IDiffComputationResult, ILineChange };