@codingame/monaco-vscode-notebook-service-override 8.0.4 → 9.0.2

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.js

@@ -1,7 +1,6 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Disposable, DisposableStore, toDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { SimpleWorkerClient } from 'vscode/vscode/vs/base/common/worker/simpleWorker';
-import { DefaultWorkerFactory } from 'vscode/vscode/vs/base/browser/defaultWorkerFactory';
+import { createWebWorker } from 'vscode/vscode/vs/base/browser/defaultWorkerFactory';
 import { NotebookCellsChangeType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 
@@ -35,7 +34,7 @@ class WorkerManager extends Disposable {
     }
     withWorker() {
         if (!this._editorWorkerClient) {
-            this._editorWorkerClient = ( new NotebookWorkerClient(this._notebookService, 'notebookEditorWorkerService'));
+            this._editorWorkerClient = ( new NotebookWorkerClient(this._notebookService));
         }
         return Promise.resolve(this._editorWorkerClient);
     }
@@ -65,7 +64,7 @@ class NotebookEditorModelManager extends Disposable {
             return;
         }
         const modelUrl = ( resource.toString());
-        this._proxy.acceptNewModel(( model.uri.toString()), {
+        this._proxy.$acceptNewModel(( model.uri.toString()), {
             cells: ( model.cells.map(cell => ({
                 handle: cell.handle,
                 uri: cell.uri,
@@ -114,7 +113,7 @@ class NotebookEditorModelManager extends Disposable {
                         : e);
                 return data;
             }));
-            this._proxy.acceptModelChanged(( modelUrl.toString()), {
+            this._proxy.$acceptModelChanged(( modelUrl.toString()), {
                 rawEvents: dto,
                 versionId: event.versionId
             });
@@ -123,7 +122,7 @@ class NotebookEditorModelManager extends Disposable {
             this._stopModelSync(modelUrl);
         }));
         toDispose.add(toDisposable(() => {
-            this._proxy.acceptRemovedModel(modelUrl);
+            this._proxy.$acceptRemovedModel(modelUrl);
         }));
         this._syncedModels[modelUrl] = toDispose;
     }
@@ -134,34 +133,20 @@ class NotebookEditorModelManager extends Disposable {
         dispose(toDispose);
     }
 }
-class NotebookWorkerHost {
-    constructor(workerClient) {
-        this._workerClient = workerClient;
-    }
-    fhr(method, args) {
-        return this._workerClient.fhr(method, args);
-    }
-}
 class NotebookWorkerClient extends Disposable {
-    constructor(_notebookService, label) {
+    constructor(_notebookService) {
         super();
         this._notebookService = _notebookService;
-        this._workerFactory = ( new DefaultWorkerFactory(label));
         this._worker = null;
         this._modelManager = null;
     }
-    fhr(method, args) {
-        throw ( new Error(`Not implemented!`));
-    }
     computeDiff(original, modified) {
-        return this._withSyncedResources([original, modified]).then(proxy => {
-            return proxy.computeDiff(( original.toString()), ( modified.toString()));
-        });
+        const proxy = this._ensureSyncedResources([original, modified]);
+        return proxy.$computeDiff(( original.toString()), ( modified.toString()));
     }
     canPromptRecommendation(modelUri) {
-        return this._withSyncedResources([modelUri]).then(proxy => {
-            return proxy.canPromptRecommendation(( modelUri.toString()));
-        });
+        const proxy = this._ensureSyncedResources([modelUri]);
+        return proxy.$canPromptRecommendation(( modelUri.toString()));
     }
     _getOrCreateModelManager(proxy) {
         if (!this._modelManager) {
@@ -169,20 +154,15 @@ class NotebookWorkerClient extends Disposable {
         }
         return this._modelManager;
     }
-    _withSyncedResources(resources) {
-        return this._getProxy().then((proxy) => {
-            this._getOrCreateModelManager(proxy).ensureSyncedResources(resources);
-            return proxy;
-        });
+    _ensureSyncedResources(resources) {
+        const proxy = this._getOrCreateWorker().proxy;
+        this._getOrCreateModelManager(proxy).ensureSyncedResources(resources);
+        return proxy;
     }
     _getOrCreateWorker() {
         if (!this._worker) {
             try {
-                this._worker = this._register(( new SimpleWorkerClient(
-                    this._workerFactory,
-                    'vs/workbench/contrib/notebook/common/services/notebookSimpleWorker',
-                    ( new NotebookWorkerHost(this))
-                )));
+                this._worker = this._register(createWebWorker('vs/workbench/contrib/notebook/common/services/notebookSimpleWorker', 'NotebookEditorWorker'));
             }
             catch (err) {
                 throw (err);
@@ -190,11 +170,6 @@ class NotebookWorkerClient extends Disposable {
         }
         return this._worker;
     }
-    _getProxy() {
-        return this._getOrCreateWorker().getProxyObject().then(undefined, (err) => {
-            throw (err);
-        });
-    }
 }
 
 export { NotebookEditorWorkerServiceImpl };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory.js

@@ -11,7 +11,6 @@ import 'vscode/vscode/vs/base/common/htmlContent';
 import 'vscode/vscode/vs/base/common/filters';
 import 'vscode/vscode/vs/base/common/strings';
 import 'vscode/vscode/vs/base/common/lifecycle';
-import 'vscode/external/vscode-marked/lib/marked.esm.js';
 import 'vscode/vscode/vs/base/common/charCode';
 import 'vscode/vscode/vs/base/common/marshallingIds';
 import 'vscode/vscode/vs/base/common/path';

package/vscode/src/vs/workbench/contrib/notebook/common/model/notebookTextModel.js

@@ -16,6 +16,8 @@ import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/langu
 import { TextModel } from 'vscode/vscode/vs/editor/common/model/textModel';
 import { isDefined } from 'vscode/vscode/vs/base/common/types';
 import { ILanguageDetectionService } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService.service';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { SearchParams } from 'vscode/vscode/vs/editor/common/model/textModelSearch';
 
 var NotebookTextModel_1;
 class StackOperation {
@@ -1000,6 +1002,32 @@ let NotebookTextModel = NotebookTextModel_1 = class NotebookTextModel extends Di
     _indexIsInvalid(index) {
         return index < 0 || index >= this._cells.length;
     }
+    findNextMatch(searchString, searchStart, isRegex, matchCase, wordSeparators) {
+        this._assertIndex(searchStart.cellIndex);
+        const searchParams = ( new SearchParams(searchString, isRegex, matchCase, wordSeparators));
+        const searchData = searchParams.parseSearchRequest();
+        if (!searchData) {
+            return null;
+        }
+        let cellIndex = searchStart.cellIndex;
+        let searchStartPosition = searchStart.position;
+        while (cellIndex < this._cells.length) {
+            const cell = this._cells[cellIndex];
+            const searchRange = ( new Range(
+                searchStartPosition.lineNumber,
+                searchStartPosition.column,
+                cell.textBuffer.getLineCount(),
+                cell.textBuffer.getLineMaxColumn(cell.textBuffer.getLineCount())
+            ));
+            const result = cell.textBuffer.findMatchesLineByLine(searchRange, searchData, false, 1);
+            if (result.length > 0) {
+                return { cell, match: result[0] };
+            }
+            cellIndex++;
+            searchStartPosition = { lineNumber: 1, column: 1 };
+        }
+        return null;
+    }
 };
 NotebookTextModel = NotebookTextModel_1 = ( __decorate([
     ( __param(5, IUndoRedoService)),

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js

@@ -5,7 +5,6 @@ import { NotebookWorkingCopyTypeIdentifier, NotebookSetting, CellUri } from 'vsc
 import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
 import { ReferenceCollection, DisposableStore, dispose, combinedDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Emitter, AsyncEmitter } from 'vscode/vscode/vs/base/common/event';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
@@ -17,15 +16,16 @@ import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
 
 let NotebookModelReferenceCollection = class NotebookModelReferenceCollection extends ReferenceCollection {
-    constructor(_instantiationService, _notebookService, _logService, _configurationService, _telemetryService) {
+    constructor(_instantiationService, _notebookService, _configurationService, _telemetryService, _notebookLoggingService) {
         super();
         this._instantiationService = _instantiationService;
         this._notebookService = _notebookService;
-        this._logService = _logService;
         this._configurationService = _configurationService;
         this._telemetryService = _telemetryService;
+        this._notebookLoggingService = _notebookLoggingService;
         this._disposables = ( new DisposableStore());
         this._workingCopyManagers = ( new Map());
         this._modelListener = ( new Map());
@@ -57,7 +57,7 @@ let NotebookModelReferenceCollection = class NotebookModelReferenceCollection ex
                 this._notebookService,
                 this._configurationService,
                 this._telemetryService,
-                this._logService
+                this._notebookLoggingService
             ));
             workingCopyManager = this._instantiationService.createInstance(FileWorkingCopyManager, workingCopyTypeId, factory, factory);
             this._workingCopyManagers.set(workingCopyTypeId, workingCopyManager);
@@ -99,7 +99,7 @@ let NotebookModelReferenceCollection = class NotebookModelReferenceCollection ex
                 model.dispose();
             }
             catch (err) {
-                this._logService.error('FAILED to destory notebook', err);
+                this._notebookLoggingService.error('NotebookModelCollection', 'FAILED to destory notebook - ' + err);
             }
             finally {
                 this.modelsToDispose.delete(key);
@@ -110,9 +110,9 @@ let NotebookModelReferenceCollection = class NotebookModelReferenceCollection ex
 NotebookModelReferenceCollection = ( __decorate([
     ( __param(0, IInstantiationService)),
     ( __param(1, INotebookService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ITelemetryService))
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, INotebookLoggingService))
 ], NotebookModelReferenceCollection));
 let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
     constructor(instantiationService, _notebookService, _extensionService, _uriIdentService) {
@@ -131,45 +131,33 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
     isDirty(resource) {
         return this._data.isDirty(resource);
     }
-    async resolve(arg0, viewType, options) {
-        let resource;
-        let hasAssociatedFilePath = false;
-        if (URI.isUri(arg0)) {
-            resource = arg0;
+    createUntitledUri(notebookType) {
+        const info = this._notebookService.getContributedNotebookType(assertIsDefined(notebookType));
+        if (!info) {
+            throw ( new Error('UNKNOWN notebook type: ' + notebookType));
         }
-        else {
-            if (!arg0.untitledResource) {
-                const info = this._notebookService.getContributedNotebookType(assertIsDefined(viewType));
-                if (!info) {
-                    throw ( new Error('UNKNOWN view type: ' + viewType));
-                }
-                const suffix = NotebookProviderInfo.possibleFileEnding(info.selectors) ?? '';
-                for (let counter = 1;; counter++) {
-                    const candidate = ( URI.from(
-                        { scheme: Schemas.untitled, path: `Untitled-${counter}${suffix}`, query: viewType }
-                    ));
-                    if (!this._notebookService.getNotebookTextModel(candidate)) {
-                        resource = candidate;
-                        break;
-                    }
-                }
-            }
-            else if (arg0.untitledResource.scheme === Schemas.untitled) {
-                resource = arg0.untitledResource;
-            }
-            else {
-                resource = arg0.untitledResource.with({ scheme: Schemas.untitled });
-                hasAssociatedFilePath = true;
+        const suffix = NotebookProviderInfo.possibleFileEnding(info.selectors) ?? '';
+        for (let counter = 1;; counter++) {
+            const candidate = ( URI.from(
+                { scheme: Schemas.untitled, path: `Untitled-${counter}${suffix}`, query: notebookType }
+            ));
+            if (!this._notebookService.getNotebookTextModel(candidate)) {
+                return candidate;
             }
         }
-        if (resource.scheme === CellUri.scheme) {
-            throw ( new Error(`CANNOT open a cell-uri as notebook. Tried with ${( resource.toString())}`));
+    }
+    async validateResourceViewType(uri, viewType) {
+        if (!uri && !viewType) {
+            throw ( new Error('Must provide at least one of resource or viewType'));
+        }
+        if (uri?.scheme === CellUri.scheme) {
+            throw ( new Error(`CANNOT open a cell-uri as notebook. Tried with ${( uri.toString())}`));
         }
-        resource = this._uriIdentService.asCanonicalUri(resource);
-        const existingViewType = this._notebookService.getNotebookTextModel(resource)?.viewType;
+        const resource = this._uriIdentService.asCanonicalUri(uri ?? this.createUntitledUri(viewType));
+        const existingNotebook = this._notebookService.getNotebookTextModel(resource);
         if (!viewType) {
-            if (existingViewType) {
-                viewType = existingViewType;
+            if (existingNotebook) {
+                viewType = existingNotebook.viewType;
             }
             else {
                 await this._extensionService.whenInstalledExtensionsRegistered();
@@ -182,8 +170,8 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
         if (!viewType) {
             throw ( new Error(`Missing viewType for '${resource}'`));
         }
-        if (existingViewType && existingViewType !== viewType) {
-            await this._onWillFailWithConflict.fireAsync({ resource, viewType }, CancellationToken.None);
+        if (existingNotebook && existingNotebook.viewType !== viewType) {
+            await this._onWillFailWithConflict.fireAsync({ resource: resource, viewType }, CancellationToken.None);
             const existingViewType2 = this._notebookService.getNotebookTextModel(resource)?.viewType;
             if (existingViewType2 && existingViewType2 !== viewType) {
                 throw ( new Error(
@@ -191,7 +179,29 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
                 ));
             }
         }
-        const reference = this._data.acquire(( resource.toString()), viewType, hasAssociatedFilePath, options?.limits, options?.scratchpad);
+        return { resource, viewType };
+    }
+    async createUntitledNotebookTextModel(viewType) {
+        const resource = this._uriIdentService.asCanonicalUri(this.createUntitledUri(viewType));
+        return (await this._notebookService.createNotebookTextModel(viewType, resource));
+    }
+    async resolve(arg0, viewType, options) {
+        let resource;
+        let hasAssociatedFilePath;
+        if (URI.isUri(arg0)) {
+            resource = arg0;
+        }
+        else if (arg0.untitledResource) {
+            if (arg0.untitledResource.scheme === Schemas.untitled) {
+                resource = arg0.untitledResource;
+            }
+            else {
+                resource = arg0.untitledResource.with({ scheme: Schemas.untitled });
+                hasAssociatedFilePath = true;
+            }
+        }
+        const validated = await this.validateResourceViewType(resource, viewType);
+        const reference = this._data.acquire(( validated.resource.toString()), validated.viewType, hasAssociatedFilePath, options?.limits, options?.scratchpad);
         try {
             const model = await reference.object;
             return {

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.js

@@ -152,7 +152,7 @@ class NotebookEditorSimpleWorker {
     }
     dispose() {
     }
-    acceptNewModel(uri, data) {
+    $acceptNewModel(uri, data) {
         this._models[uri] = ( new MirrorNotebookDocument(( URI.parse(uri)), ( data.cells.map(dto => ( new MirrorCell(
             dto.handle,
             dto.source,
@@ -162,17 +162,17 @@ class NotebookEditorSimpleWorker {
             dto.metadata
         )))), data.metadata));
     }
-    acceptModelChanged(strURL, event) {
+    $acceptModelChanged(strURL, event) {
         const model = this._models[strURL];
         model?.acceptModelChanged(event);
     }
-    acceptRemovedModel(strURL) {
+    $acceptRemovedModel(strURL) {
         if (!this._models[strURL]) {
             return;
         }
         delete this._models[strURL];
     }
-    computeDiff(originalUrl, modifiedUrl) {
+    $computeDiff(originalUrl, modifiedUrl) {
         const original = this._getModel(originalUrl);
         const modified = this._getModel(modifiedUrl);
         const diff = ( new LcsDiff(( new CellSequence(original)), ( new CellSequence(modified))));
@@ -181,7 +181,7 @@ class NotebookEditorSimpleWorker {
             cellsDiff: diffResult,
         };
     }
-    canPromptRecommendation(modelUrl) {
+    $canPromptRecommendation(modelUrl) {
         const model = this._getModel(modelUrl);
         const cells = model.cells;
         for (let i = 0; i < cells.length; i++) {
@@ -211,7 +211,7 @@ class NotebookEditorSimpleWorker {
         return this._models[uri];
     }
 }
-function create(host) {
+function create(workerServer) {
     return ( new NotebookEditorSimpleWorker());
 }
 

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.js

@@ -47,8 +47,8 @@ import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/prog
 var FileWorkingCopyManager_1;
 let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
     static { FileWorkingCopyManager_1 = this; }
-    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localize(8049, "File Created"))); }
-    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localize(8050, "File Replaced"))); }
+    static { this.FILE_WORKING_COPY_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyCreate.source', ( localize(7841, "File Created"))); }
+    static { this.FILE_WORKING_COPY_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('fileWorkingCopyReplace.source', ( localize(7842, "File Replaced"))); }
     constructor(workingCopyTypeId, storedWorkingCopyModelFactory, untitledWorkingCopyModelFactory, fileService, lifecycleService, labelService, logService, workingCopyFileService, workingCopyBackupService, uriIdentityService, fileDialogService, filesConfigurationService, workingCopyService, notificationService, workingCopyEditorService, editorService, elevatedFileService, pathService, environmentService, dialogService, decorationsService, progressService) {
         super();
         this.workingCopyTypeId = workingCopyTypeId;
@@ -103,7 +103,7 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
             constructor(stored) {
                 super();
                 this.stored = stored;
-                this.label = ( localize(8051, "File Working Copy Decorations"));
+                this.label = ( localize(7843, "File Working Copy Decorations"));
                 this._onDidChange = this._register(( (new Emitter())));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
@@ -130,20 +130,20 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(8052, "Deleted, Read-only")),
+                        tooltip: ( localize(7844, "Deleted, Read-only")),
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(8053, "Read-only")),
+                        tooltip: ( localize(7845, "Read-only")),
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(8054, "Deleted")),
+                        tooltip: ( localize(7846, "Deleted")),
                     };
                 }
                 return undefined;
@@ -275,17 +275,17 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                8055,
+                7847,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                8056,
+                7848,
                 "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
                 basename(resource),
                 basename(dirname(resource))
             )),
-            primaryButton: ( localize(8057, "&&Replace"))
+            primaryButton: ( localize(7849, "&&Replace"))
         });
         return confirmed;
     }
@@ -293,12 +293,12 @@ let FileWorkingCopyManager = class FileWorkingCopyManager extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                8058,
+                7850,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(8059, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(8060, "&&Save Anyway"))
+            detail: ( localize(7851, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(7852, "&&Save Anyway"))
         });
         return confirmed;
     }

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopyManager.js

@@ -77,7 +77,7 @@ let StoredFileWorkingCopyManager = class StoredFileWorkingCopyManager extends Ba
             this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdownWeb(), 'veto.fileWorkingCopyManager')));
         }
         else {
-            this._register(this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), { id: 'join.fileWorkingCopyManager', label: ( localize(10717, "Saving working copies")) })));
+            this._register(this.lifecycleService.onWillShutdown(event => event.join(this.onWillShutdownDesktop(), { id: 'join.fileWorkingCopyManager', label: ( localize(10724, "Saving working copies")) })));
         }
     }
     onBeforeShutdownWeb() {

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffCellEditorOptions.js

@@ -1,47 +0,0 @@
-const fixedEditorPadding = {
-    top: 12,
-    bottom: 12
-};
-const fixedEditorOptions = {
-    padding: fixedEditorPadding,
-    scrollBeyondLastLine: false,
-    scrollbar: {
-        verticalScrollbarSize: 14,
-        horizontal: 'auto',
-        vertical: 'auto',
-        useShadows: true,
-        verticalHasArrows: false,
-        horizontalHasArrows: false,
-        alwaysConsumeMouseWheel: false,
-    },
-    renderLineHighlightOnlyWhenFocus: true,
-    overviewRulerLanes: 0,
-    overviewRulerBorder: false,
-    selectOnLineNumbers: false,
-    wordWrap: 'off',
-    lineNumbers: 'off',
-    lineDecorationsWidth: 0,
-    glyphMargin: false,
-    fixedOverflowWidgets: true,
-    minimap: { enabled: false },
-    renderValidationDecorations: 'on',
-    renderLineHighlight: 'none',
-    readOnly: true
-};
-const fixedDiffEditorOptions = {
-    ...fixedEditorOptions,
-    glyphMargin: true,
-    enableSplitViewResizing: false,
-    renderIndicators: true,
-    renderMarginRevertIcon: false,
-    readOnly: false,
-    isInEmbeddedEditor: true,
-    renderOverviewRuler: false,
-    wordWrap: 'off',
-    diffWordWrap: 'off',
-    diffAlgorithm: 'advanced',
-    renderSideBySide: true,
-    useInlineViewWhenSpaceIsLimited: false
-};
-
-export { fixedDiffEditorOptions, fixedEditorOptions, fixedEditorPadding };