@codingame/monaco-vscode-api 2.2.1 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -96,12 +96,12 @@
   "dependencies": {
     "vscode-marked": "npm:marked@=3.0.2",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-files-service-override": "2.2.1",
-    "@codingame/monaco-vscode-quickaccess-service-override": "2.2.1",
-    "@codingame/monaco-vscode-extensions-service-override": "2.2.1",
-    "@codingame/monaco-vscode-environment-service-override": "2.2.1",
-    "@codingame/monaco-vscode-layout-service-override": "2.2.1",
-    "@codingame/monaco-vscode-host-service-override": "2.2.1",
-    "@codingame/monaco-vscode-base-service-override": "2.2.1"
+    "@codingame/monaco-vscode-extensions-service-override": "2.2.2",
+    "@codingame/monaco-vscode-files-service-override": "2.2.2",
+    "@codingame/monaco-vscode-quickaccess-service-override": "2.2.2",
+    "@codingame/monaco-vscode-environment-service-override": "2.2.2",
+    "@codingame/monaco-vscode-layout-service-override": "2.2.2",
+    "@codingame/monaco-vscode-host-service-override": "2.2.2",
+    "@codingame/monaco-vscode-base-service-override": "2.2.2"
   }
 }

package/service-override/tools/views.d.ts

@@ -4,6 +4,7 @@ import { BrandedService, ServicesAccessor } from '../../vscode/src/vs/platform/i
 import { IDisposable } from '../../vscode/src/vs/base/common/lifecycle.js';
 import { Dimension } from '../../vscode/src/vs/base/browser/dom.js';
 import { Event } from '../../vscode/src/vs/base/common/event.js';
+import { DomScrollableElement } from '../../vscode/src/vs/base/browser/ui/scrollbar/scrollableElement.js';
 import { CancellationToken } from '../../vscode/src/vs/base/common/cancellation.js';
 import { URI } from '../../vscode/src/vs/base/common/uri.js';
 import { IStorageService } from '../../vscode/src/vs/platform/storage/common/storage.js';
@@ -27,7 +28,7 @@ type Label = string | {
 declare abstract class SimpleEditorPane extends EditorPane {
     protected container: HTMLElement;
     protected wrapper: HTMLElement;
-    private scrollbar;
+    protected scrollbar: DomScrollableElement | undefined;
     private inputDisposable;
     constructor(id: string, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService);
     protected createEditor(parent: HTMLElement): void;
@@ -70,7 +71,7 @@ interface CustomViewOption {
     readonly id: string;
     name: string;
     order?: number;
-    renderBody(container: HTMLElement): IDisposable;
+    renderBody(container: HTMLElement, scrollbar: DomScrollableElement): IDisposable;
     location: ViewContainerLocation;
     icon?: string;
     canMoveView?: boolean;

package/service-override/tools/views.js

@@ -178,13 +178,13 @@ function registerCustomView(options) {
             ctorDescriptor: new SyncDescriptor(class extends ViewPane {
                 renderBody(container) {
                     super.renderBody(container);
+                    this.wrapper = document.createElement('div');
+                    this.scrollbar = this._register(new DomScrollableElement(this.wrapper, { horizontal: 1 , vertical: 1  }));
                     this.container = $('.view-pane-content');
                     this.container.style.display = 'flex';
                     this.container.style.alignItems = 'stretch';
-                    this._register(options.renderBody(this.container));
-                    this.wrapper = document.createElement('div');
+                    this._register(options.renderBody(this.container, this.scrollbar));
                     this.wrapper.append(this.container);
-                    this.scrollbar = this._register(new DomScrollableElement(this.wrapper, { horizontal: 1 , vertical: 1  }));
                     container.appendChild(this.scrollbar.getDomNode());
                     const observer = new ResizeObserver(() => {
                         assertIsDefined(this.scrollbar).scanDomNode();

package/services.d.ts

@@ -22,6 +22,7 @@ export { IAction } from './vscode/src/vs/base/common/actions.js';
 export { IAudioCueService } from './vscode/src/vs/platform/audioCues/browser/audioCueService.js';
 export { ILanguageFeaturesService } from './vscode/src/vs/editor/common/services/languageFeatures.js';
 export { ILogService, ILoggerService, LogLevel } from './vscode/src/vs/platform/log/common/log.js';
+export { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/keybinding.js';
 export { IWorkspaceContextService } from './vscode/src/vs/platform/workspace/common/workspace.js';
 export { IClipboardService } from './vscode/src/vs/platform/clipboard/common/clipboardService.js';
 export { IEditorWorkerService } from './vscode/src/vs/editor/common/services/editorWorker.js';

package/services.js

@@ -139,6 +139,7 @@ export { IStatusbarService } from './vscode/src/vs/workbench/services/statusbar/
 export { ITitleService } from './vscode/src/vs/workbench/services/title/browser/titleService.js';
 export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
 export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
+export { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/keybinding.js';
 export { IDialogService, IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
 async function initialize(overrides, container = document.body, configuration = {}, productConfiguration = {}) {
     checkServicesNotInitialized();

package/vscode/src/vs/base/browser/mouseEvent.d.ts

@@ -35,5 +35,14 @@ declare class StandardMouseEvent implements IMouseEvent {
     preventDefault(): void;
     stopPropagation(): void;
 }
+interface IMouseWheelEvent extends MouseEvent {
+    readonly wheelDelta: number;
+    readonly wheelDeltaX: number;
+    readonly wheelDeltaY: number;
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly deltaZ: number;
+    readonly deltaMode: number;
+}
 
-export { type IMouseEvent, StandardMouseEvent };
+export { type IMouseEvent, type IMouseWheelEvent, StandardMouseEvent };

package/vscode/src/vs/base/browser/ui/scrollbar/scrollableElement.d.ts

@@ -0,0 +1,81 @@
+import { IMouseWheelEvent } from '../../mouseEvent.js';
+import { ScrollableElementCreationOptions, ScrollableElementResolvedOptions, ScrollableElementChangeOptions } from './scrollableElementOptions.js';
+import { Widget } from '../widget.js';
+import { Event } from '../../../common/event.js';
+import { INewScrollPosition, IScrollPosition, Scrollable, ScrollEvent, IScrollDimensions, INewScrollDimensions } from '../../../common/scrollable.js';
+
+interface IOverviewRulerLayoutInfo {
+    parent: HTMLElement;
+    insertBefore: HTMLElement;
+}
+declare abstract class AbstractScrollableElement extends Widget {
+    private readonly _options;
+    protected readonly _scrollable: Scrollable;
+    private readonly _verticalScrollbar;
+    private readonly _horizontalScrollbar;
+    private readonly _domNode;
+    private readonly _leftShadowDomNode;
+    private readonly _topShadowDomNode;
+    private readonly _topLeftShadowDomNode;
+    private readonly _listenOnDomNode;
+    private _mouseWheelToDispose;
+    private _isDragging;
+    private _mouseIsOver;
+    private readonly _hideTimeout;
+    private _shouldRender;
+    private _revealOnScroll;
+    private readonly _onScroll;
+    readonly onScroll: Event<ScrollEvent>;
+    private readonly _onWillScroll;
+    readonly onWillScroll: Event<ScrollEvent>;
+    get options(): Readonly<ScrollableElementResolvedOptions>;
+    protected constructor(element: HTMLElement, options: ScrollableElementCreationOptions, scrollable: Scrollable);
+    dispose(): void;
+    /**
+     * Get the generated 'scrollable' dom node
+     */
+    getDomNode(): HTMLElement;
+    getOverviewRulerLayoutInfo(): IOverviewRulerLayoutInfo;
+    /**
+     * Delegate a pointer down event to the vertical scrollbar.
+     * This is to help with clicking somewhere else and having the scrollbar react.
+     */
+    delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void;
+    getScrollDimensions(): IScrollDimensions;
+    setScrollDimensions(dimensions: INewScrollDimensions): void;
+    /**
+     * Update the class name of the scrollable element.
+     */
+    updateClassName(newClassName: string): void;
+    /**
+     * Update configuration options for the scrollbar.
+     */
+    updateOptions(newOptions: ScrollableElementChangeOptions): void;
+    setRevealOnScroll(value: boolean): void;
+    delegateScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
+    private _setListeningToMouseWheel;
+    private _onMouseWheel;
+    private _onDidScroll;
+    /**
+     * Render / mutate the DOM now.
+     * Should be used together with the ctor option `lazyRender`.
+     */
+    renderNow(): void;
+    private _render;
+    private _onDragStart;
+    private _onDragEnd;
+    private _onMouseLeave;
+    private _onMouseOver;
+    private _reveal;
+    private _hide;
+    private _scheduleHide;
+}
+declare class DomScrollableElement extends AbstractScrollableElement {
+    private _element;
+    constructor(element: HTMLElement, options: ScrollableElementCreationOptions);
+    setScrollPosition(update: INewScrollPosition): void;
+    getScrollPosition(): IScrollPosition;
+    scanDomNode(): void;
+}
+
+export { AbstractScrollableElement, DomScrollableElement, type IOverviewRulerLayoutInfo };

package/vscode/src/vs/base/browser/ui/scrollbar/scrollableElementOptions.d.ts

@@ -0,0 +1,160 @@
+import { ScrollbarVisibility } from '../../../common/scrollable.js';
+
+interface ScrollableElementCreationOptions {
+    /**
+     * The scrollable element should not do any DOM mutations until renderNow() is called.
+     * Defaults to false.
+     */
+    lazyRender?: boolean;
+    /**
+     * CSS Class name for the scrollable element.
+     */
+    className?: string;
+    /**
+     * Drop subtle horizontal and vertical shadows.
+     * Defaults to false.
+     */
+    useShadows?: boolean;
+    /**
+     * Handle mouse wheel (listen to mouse wheel scrolling).
+     * Defaults to true
+     */
+    handleMouseWheel?: boolean;
+    /**
+     * If mouse wheel is handled, make mouse wheel scrolling smooth.
+     * Defaults to true.
+     */
+    mouseWheelSmoothScroll?: boolean;
+    /**
+     * Flip axes. Treat vertical scrolling like horizontal and vice-versa.
+     * Defaults to false.
+     */
+    flipAxes?: boolean;
+    /**
+     * If enabled, will scroll horizontally when scrolling vertical.
+     * Defaults to false.
+     */
+    scrollYToX?: boolean;
+    /**
+     * Consume all mouse wheel events if a scrollbar is needed (i.e. scrollSize > size).
+     * Defaults to false.
+     */
+    consumeMouseWheelIfScrollbarIsNeeded?: boolean;
+    /**
+     * Always consume mouse wheel events, even when scrolling is no longer possible.
+     * Defaults to false.
+     */
+    alwaysConsumeMouseWheel?: boolean;
+    /**
+     * A multiplier to be used on the `deltaX` and `deltaY` of mouse wheel scroll events.
+     * Defaults to 1.
+     */
+    mouseWheelScrollSensitivity?: number;
+    /**
+     * FastScrolling mulitplier speed when pressing `Alt`
+     * Defaults to 5.
+     */
+    fastScrollSensitivity?: number;
+    /**
+     * Whether the scrollable will only scroll along the predominant axis when scrolling both
+     * vertically and horizontally at the same time.
+     * Prevents horizontal drift when scrolling vertically on a trackpad.
+     * Defaults to true.
+     */
+    scrollPredominantAxis?: boolean;
+    /**
+     * Height for vertical arrows (top/bottom) and width for horizontal arrows (left/right).
+     * Defaults to 11.
+     */
+    arrowSize?: number;
+    /**
+     * The dom node events should be bound to.
+     * If no listenOnDomNode is provided, the dom node passed to the constructor will be used for event listening.
+     */
+    listenOnDomNode?: HTMLElement;
+    /**
+     * Control the visibility of the horizontal scrollbar.
+     * Accepted values: 'auto' (on mouse over), 'visible' (always visible), 'hidden' (never visible)
+     * Defaults to 'auto'.
+     */
+    horizontal?: ScrollbarVisibility;
+    /**
+     * Height (in px) of the horizontal scrollbar.
+     * Defaults to 10.
+     */
+    horizontalScrollbarSize?: number;
+    /**
+     * Height (in px) of the horizontal scrollbar slider.
+     * Defaults to `horizontalScrollbarSize`
+     */
+    horizontalSliderSize?: number;
+    /**
+     * Render arrows (left/right) for the horizontal scrollbar.
+     * Defaults to false.
+     */
+    horizontalHasArrows?: boolean;
+    /**
+     * Control the visibility of the vertical scrollbar.
+     * Accepted values: 'auto' (on mouse over), 'visible' (always visible), 'hidden' (never visible)
+     * Defaults to 'auto'.
+     */
+    vertical?: ScrollbarVisibility;
+    /**
+     * Width (in px) of the vertical scrollbar.
+     * Defaults to 10.
+     */
+    verticalScrollbarSize?: number;
+    /**
+     * Width (in px) of the vertical scrollbar slider.
+     * Defaults to `verticalScrollbarSize`
+     */
+    verticalSliderSize?: number;
+    /**
+     * Render arrows (top/bottom) for the vertical scrollbar.
+     * Defaults to false.
+     */
+    verticalHasArrows?: boolean;
+    /**
+     * Scroll gutter clicks move by page vs. jump to position.
+     * Defaults to false.
+     */
+    scrollByPage?: boolean;
+}
+interface ScrollableElementChangeOptions {
+    handleMouseWheel?: boolean;
+    mouseWheelScrollSensitivity?: number;
+    fastScrollSensitivity?: number;
+    scrollPredominantAxis?: boolean;
+    horizontal?: ScrollbarVisibility;
+    horizontalScrollbarSize?: number;
+    vertical?: ScrollbarVisibility;
+    verticalScrollbarSize?: number;
+    scrollByPage?: boolean;
+}
+interface ScrollableElementResolvedOptions {
+    lazyRender: boolean;
+    className: string;
+    useShadows: boolean;
+    handleMouseWheel: boolean;
+    flipAxes: boolean;
+    scrollYToX: boolean;
+    consumeMouseWheelIfScrollbarIsNeeded: boolean;
+    alwaysConsumeMouseWheel: boolean;
+    mouseWheelScrollSensitivity: number;
+    fastScrollSensitivity: number;
+    scrollPredominantAxis: boolean;
+    mouseWheelSmoothScroll: boolean;
+    arrowSize: number;
+    listenOnDomNode: HTMLElement | null;
+    horizontal: ScrollbarVisibility;
+    horizontalScrollbarSize: number;
+    horizontalSliderSize: number;
+    horizontalHasArrows: boolean;
+    vertical: ScrollbarVisibility;
+    verticalScrollbarSize: number;
+    verticalSliderSize: number;
+    verticalHasArrows: boolean;
+    scrollByPage: boolean;
+}
+
+export type { ScrollableElementChangeOptions, ScrollableElementCreationOptions, ScrollableElementResolvedOptions };

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

@@ -1,3 +1,6 @@
+import { Event } from './event.js';
+import { Disposable, IDisposable } from './lifecycle.js';
+
 declare const enum ScrollbarVisibility {
     Auto = 1,
     Hidden = 2,
@@ -24,5 +27,69 @@ interface ScrollEvent {
     scrollHeightChanged: boolean;
     scrollTopChanged: boolean;
 }
+interface IScrollDimensions {
+    readonly width: number;
+    readonly scrollWidth: number;
+    readonly height: number;
+    readonly scrollHeight: number;
+}
+interface INewScrollDimensions {
+    width?: number;
+    scrollWidth?: number;
+    height?: number;
+    scrollHeight?: number;
+}
+interface IScrollPosition {
+    readonly scrollLeft: number;
+    readonly scrollTop: number;
+}
+interface INewScrollPosition {
+    scrollLeft?: number;
+    scrollTop?: number;
+}
+interface IScrollableOptions {
+    /**
+     * Define if the scroll values should always be integers.
+     */
+    forceIntegerValues: boolean;
+    /**
+     * Set the duration (ms) used for smooth scroll animations.
+     */
+    smoothScrollDuration: number;
+    /**
+     * A function to schedule an update at the next frame (used for smooth scroll animations).
+     */
+    scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable;
+}
+declare class Scrollable extends Disposable {
+    _scrollableBrand: void;
+    private _smoothScrollDuration;
+    private readonly _scheduleAtNextAnimationFrame;
+    private _state;
+    private _smoothScrolling;
+    private _onScroll;
+    readonly onScroll: Event<ScrollEvent>;
+    constructor(options: IScrollableOptions);
+    dispose(): void;
+    setSmoothScrollDuration(smoothScrollDuration: number): void;
+    validateScrollPosition(scrollPosition: INewScrollPosition): IScrollPosition;
+    getScrollDimensions(): IScrollDimensions;
+    setScrollDimensions(dimensions: INewScrollDimensions, useRawScrollPositions: boolean): void;
+    /**
+     * Returns the final scroll position that the instance will have once the smooth scroll animation concludes.
+     * If no scroll animation is occurring, it will return the current scroll position instead.
+     */
+    getFutureScrollPosition(): IScrollPosition;
+    /**
+     * Returns the current scroll position.
+     * Note: This result might be an intermediate scroll position, as there might be an ongoing smooth scroll animation.
+     */
+    getCurrentScrollPosition(): IScrollPosition;
+    setScrollPositionNow(update: INewScrollPosition): void;
+    setScrollPositionSmooth(update: INewScrollPosition, reuseAnimation?: boolean): void;
+    hasPendingScrollAnimation(): boolean;
+    private _performSmoothScrolling;
+    private _setState;
+}
 
-export { type ScrollEvent, ScrollbarVisibility };
+export { type INewScrollDimensions, type INewScrollPosition, type IScrollDimensions, type IScrollPosition, type IScrollableOptions, type ScrollEvent, Scrollable, ScrollbarVisibility };

package/vscode/src/vs/editor/browser/config/editorConfiguration.js

@@ -14,7 +14,7 @@ import { EditorZoom } from '../../common/config/editorZoom.js';
 import { BareFontInfo } from '../../common/config/fontInfo.js';
 import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.js';
 let EditorConfiguration = class EditorConfiguration extends Disposable {
-    constructor(isSimpleWidget, options, container, _accessibilityService) {
+    constructor(isSimpleWidget, isStandaloneEditor, options, container, _accessibilityService) {
         super();
         this._accessibilityService = _accessibilityService;
         this._onDidChange = this._register(( new Emitter()));
@@ -28,6 +28,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
         this._glyphMarginDecorationLaneCount = 1;
         this._computeOptionsMemory = ( new ComputeOptionsMemory());
         this.isSimpleWidget = isSimpleWidget;
+        this.isStandaloneEditor = isStandaloneEditor;
         this._containerObserver = this._register(( new ElementSizeObserver(container, options.dimension)));
         this._rawOptions = deepCloneAndMigrateOptions(options);
         this._validatedOptions = EditorOptionsUtil.validateOptions(this._rawOptions);
@@ -75,7 +76,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
     }
     _readEnvConfiguration() {
         return {
-            extraEditorClassName: getExtraEditorClassName(),
+            extraEditorClassName: getExtraEditorClassName(this.isStandaloneEditor),
             outerWidth: this._containerObserver.getWidth(),
             outerHeight: this._containerObserver.getHeight(),
             emptySelectionClipboard: isWebKit || isFirefox,
@@ -141,7 +142,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
     }
 };
 EditorConfiguration = ( __decorate([
-    ( __param(3, IAccessibilityService))
+    ( __param(4, IAccessibilityService))
 ], EditorConfiguration));
 function digitCount(n) {
     let r = 0;
@@ -151,7 +152,7 @@ function digitCount(n) {
     }
     return r ? r : 1;
 }
-function getExtraEditorClassName() {
+function getExtraEditorClassName(isStandaloneEditor) {
     let extra = '';
     if (!isSafari && !isWebkitWebView) {
         extra += 'no-user-select ';
@@ -163,6 +164,9 @@ function getExtraEditorClassName() {
     if (isMacintosh) {
         extra += 'mac ';
     }
+    if (isStandaloneEditor) {
+        extra += 'standalone ';
+    }
     return extra;
 }
 class ValidatedEditorOptions {

package/vscode/src/vs/editor/browser/widget/codeEditorWidget.js

@@ -163,7 +163,7 @@ let CodeEditorWidget = class CodeEditorWidget extends Disposable {
         this._decorationTypeKeysToIds = {};
         this._decorationTypeSubtypes = {};
         this._telemetryData = codeEditorWidgetOptions.telemetryData;
-        this._configuration = this._register(this._createConfiguration(codeEditorWidgetOptions.isSimpleWidget || false, options, accessibilityService));
+        this._configuration = this._register(this._createConfiguration(codeEditorWidgetOptions.isSimpleWidget || false, codeEditorWidgetOptions.isStandaloneEditor || false, options, accessibilityService));
         this._register(this._configuration.onDidChange((e) => {
             this._onDidChangeConfiguration.fire(e);
             const options = this._configuration.options;
@@ -255,8 +255,14 @@ let CodeEditorWidget = class CodeEditorWidget extends Disposable {
     writeScreenReaderContent(reason) {
         this._modelData?.view.writeScreenReaderContent(reason);
     }
-    _createConfiguration(isSimpleWidget, options, accessibilityService) {
-        return ( new EditorConfiguration(isSimpleWidget, options, this._domElement, accessibilityService));
+    _createConfiguration(isSimpleWidget, isStandaloneEditor, options, accessibilityService) {
+        return ( new EditorConfiguration(
+            isSimpleWidget,
+            isStandaloneEditor,
+            options,
+            this._domElement,
+            accessibilityService
+        ));
     }
     getId() {
         return this.getEditorType() + ':' + this._id;

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorWidget.js

@@ -86,6 +86,7 @@ let DiffEditorWidget = class DiffEditorWidget extends DelegatingEditor {
         this.onDidUpdateDiff = Event.fromObservableLight(this._diffValue);
         codeEditorService.willCreateDiffEditor();
         this._contextKeyService.createKey('isInDiffEditor', true);
+        this.elements.root.classList.toggle('standalone', codeEditorWidgetOptions.isStandaloneEditor || false);
         this._domElement.appendChild(this.elements.root);
         this._register(toDisposable(() => this._domElement.removeChild(this.elements.root)));
         this._rootSizeObserver = this._register(( new ObservableElementSizeObserver(this.elements.root, options.dimension)));

package/vscode/src/vs/editor/standalone/browser/standaloneCodeEditor.js

@@ -44,7 +44,7 @@ let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
         const options = { ..._options };
         options.ariaLabel = options.ariaLabel || StandaloneCodeEditorNLS.editorViewAccessibleLabel;
         options.ariaLabel = options.ariaLabel + ';' + (StandaloneCodeEditorNLS.accessibilityHelpMessage);
-        super(domElement, options, {}, instantiationService, codeEditorService, commandService, contextKeyService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
+        super(domElement, options, { isStandaloneEditor: true }, instantiationService, codeEditorService, commandService, contextKeyService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
         if (keybindingService instanceof StandaloneKeybindingService) {
             this._standaloneKeybindingService = keybindingService;
         }
@@ -148,10 +148,7 @@ StandaloneCodeEditor = ( __decorate([
 ], StandaloneCodeEditor));
 let StandaloneEditor = class StandaloneEditor extends StandaloneCodeEditor {
     constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, keybindingService, themeService, notificationService, configurationService, accessibilityService, modelService, languageService, languageConfigurationService, languageFeaturesService) {
-        const options = {
-            extraEditorClassName: 'standalone-monaco-editor',
-            ..._options
-        };
+        const options = { ..._options };
         updateConfigurationService(configurationService, options, false);
         const themeDomRegistration = themeService.registerEditorContainer(domElement);
         if (typeof options.theme === 'string') {
@@ -232,7 +229,7 @@ let StandaloneDiffEditor2 = class StandaloneDiffEditor2 extends DiffEditorWidget
         if (typeof options.autoDetectHighContrast !== 'undefined') {
             themeService.setAutoDetectHighContrast(Boolean(options.autoDetectHighContrast));
         }
-        super(domElement, options, {}, contextKeyService, instantiationService, codeEditorService, audioCueService, editorProgressService);
+        super(domElement, options, { isStandaloneEditor: true }, contextKeyService, instantiationService, codeEditorService, audioCueService, editorProgressService);
         this._configurationService = configurationService;
         this._standaloneThemeService = themeService;
         this._register(themeDomRegistration);