@codingame/monaco-vscode-api 8.0.4 → 9.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/codeCellExecutionIcon.js

@@ -49,26 +49,26 @@ let CollapsedCodeCellExecutionIcon = class CollapsedCodeCellExecutionIcon extend
         if (!state && lastRunSuccess) {
             return {
                 text: `$(${successStateIcon.id})`,
-                tooltip: ( localize(11529, "Success")),
+                tooltip: ( localize(11590, "Success")),
             };
         }
         else if (!state && lastRunSuccess === false) {
             return {
                 text: `$(${errorStateIcon.id})`,
-                tooltip: ( localize(11530, "Failure")),
+                tooltip: ( localize(11591, "Failure")),
             };
         }
         else if (state === NotebookCellExecutionState.Pending || state === NotebookCellExecutionState.Unconfirmed) {
             return {
                 text: `$(${pendingStateIcon.id})`,
-                tooltip: ( localize(11531, "Pending")),
+                tooltip: ( localize(11592, "Pending")),
             };
         }
         else if (state === NotebookCellExecutionState.Executing) {
             const icon = ThemeIcon.modify(executingStateIcon, 'spin');
             return {
                 text: `$(${icon.id})`,
-                tooltip: ( localize(11532, "Executing")),
+                tooltip: ( localize(11593, "Executing")),
             };
         }
         return;

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/codeCellRunToolbar.js

@@ -60,7 +60,7 @@ let RunToolbar = class RunToolbar extends CellContentPart {
     }
     createRunCellToolbar(container, cellContainer, contextKeyService) {
         const actionViewItemDisposables = this._register(( (new DisposableStore())));
-        const dropdownAction = this._register(( (new Action('notebook.moreRunActions', ( localize(11388, "More...")), 'codicon-chevron-down', true))));
+        const dropdownAction = this._register(( (new Action('notebook.moreRunActions', ( localize(11465, "More...")), 'codicon-chevron-down', true))));
         const keybindingProvider = (action) => this.keybindingService.lookupKeybinding(action.id, executionContextKeyService);
         const executionContextKeyService = this._register(getCodeCellExecutionContextKeyService(contextKeyService));
         this.toolbar = this._register(( (new ToolBar(container, this.contextMenuService, {

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/collapsedCellOutput.js

@@ -12,13 +12,13 @@ let CollapsedCellOutput = class CollapsedCellOutput extends CellContentPart {
         super();
         this.notebookEditor = notebookEditor;
         const placeholder = append(cellOutputCollapseContainer, $('span.expandOutputPlaceholder'));
-        placeholder.textContent = ( localize(11389, "Outputs are collapsed"));
+        placeholder.textContent = ( localize(11466, "Outputs are collapsed"));
         const expandIcon = append(cellOutputCollapseContainer, $('span.expandOutputIcon'));
         expandIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.more));
         const keybinding = keybindingService.lookupKeybinding(EXPAND_CELL_OUTPUT_COMMAND_ID);
         if (keybinding) {
-            placeholder.title = ( localize(11390, "Double-click to expand cell output ({0})", keybinding.getLabel()));
-            cellOutputCollapseContainer.title = ( localize(11391, "Expand Cell Output (${0})", keybinding.getLabel()));
+            placeholder.title = ( localize(11467, "Double-click to expand cell output ({0})", keybinding.getLabel()));
+            cellOutputCollapseContainer.title = ( localize(11468, "Expand Cell Output (${0})", keybinding.getLabel()));
         }
         hide(cellOutputCollapseContainer);
         this._register(addDisposableListener(expandIcon, EventType.CLICK, () => this.expand()));

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/foldedCellHint.js

@@ -55,8 +55,8 @@ let FoldedCellHint = class FoldedCellHint extends CellContentPart {
     }
     getHiddenCellsLabel(num) {
         const label = num === 1 ?
-            ( localize(11392, "1 cell hidden")) :
-            ( localize(11393, "{0} cells hidden", num));
+            ( localize(11469, "1 cell hidden")) :
+            ( localize(11470, "{0} cells hidden", num));
         return $('span.notebook-folded-hint-label', undefined, label);
     }
     getHiddenCellHintButton(element) {

package/vscode/src/vs/workbench/contrib/notebook/browser/view/cellParts/markupCell.js

@@ -231,8 +231,8 @@ let MarkupCell = class MarkupCell extends Disposable {
         expandIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.more));
         const keybinding = this.keybindingService.lookupKeybinding(EXPAND_CELL_INPUT_COMMAND_ID);
         if (keybinding) {
-            element.title = ( localize(11394, "Double-click to expand cell input ({0})", keybinding.getLabel()));
-            expandIcon.title = ( localize(11395, "Expand Cell Input ({0})", keybinding.getLabel()));
+            element.title = ( localize(11471, "Double-click to expand cell input ({0})", keybinding.getLabel()));
+            expandIcon.title = ( localize(11472, "Expand Cell Input ({0})", keybinding.getLabel()));
         }
         this.markdownAccessibilityContainer.ariaHidden = 'true';
         this.templateData.container.classList.toggle('input-collapsed', true);

package/vscode/src/vs/workbench/contrib/notebook/browser/view/notebookCellEditorPool.js

@@ -0,0 +1,114 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { $, prepend } from '../../../../../base/browser/dom.js';
+import { createCancelablePromise } from '../../../../../base/common/async.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { CodeEditorWidget } from '../../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { EditorContextKeys } from '../../../../../editor/common/editorContextKeys.js';
+import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../../platform/instantiation/common/serviceCollection.js';
+import { CellFocusMode } from '../notebookBrowser.js';
+import { CellEditorOptions } from './cellParts/cellEditorOptions.js';
+let NotebookCellEditorPool = class NotebookCellEditorPool extends Disposable {
+    constructor(notebookEditor, contextKeyServiceProvider, textModelService, _configurationService, _instantiationService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.contextKeyServiceProvider = contextKeyServiceProvider;
+        this.textModelService = textModelService;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._editorDisposable = this._register(( new MutableDisposable()));
+        this._isInitialized = false;
+        this._isDisposed = false;
+        this._focusedEditorDOM = this.notebookEditor.getDomNode().appendChild($('.cell-editor-part-cache'));
+        this._focusedEditorDOM.style.position = 'absolute';
+        this._focusedEditorDOM.style.top = '-50000px';
+        this._focusedEditorDOM.style.width = '1px';
+        this._focusedEditorDOM.style.height = '1px';
+    }
+    _initializeEditor(cell) {
+        this._editorContextKeyService = this._register(this.contextKeyServiceProvider(this._focusedEditorDOM));
+        const editorContainer = prepend(this._focusedEditorDOM, $('.cell-editor-container'));
+        const editorInstaService = this._register(this._instantiationService.createChild(( new ServiceCollection([IContextKeyService, this._editorContextKeyService]))));
+        EditorContextKeys.inCompositeEditor.bindTo(this._editorContextKeyService).set(true);
+        const editorOptions = ( new CellEditorOptions(
+            this.notebookEditor.getBaseCellEditorOptions(cell.language),
+            this.notebookEditor.notebookOptions,
+            this._configurationService
+        ));
+        this._editor = this._register(editorInstaService.createInstance(CodeEditorWidget, editorContainer, {
+            ...editorOptions.getDefaultValue(),
+            dimension: {
+                width: 0,
+                height: 0
+            },
+            scrollbar: {
+                vertical: 'hidden',
+                horizontal: 'auto',
+                handleMouseWheel: false,
+                useShadows: false,
+            },
+        }, {
+            contributions: this.notebookEditor.creationOptions.cellEditorContributions
+        }));
+        this._isInitialized = true;
+    }
+    preserveFocusedEditor(cell) {
+        if (!this._isInitialized) {
+            this._initializeEditor(cell);
+        }
+        this._editorDisposable.clear();
+        this._focusEditorCancellablePromise?.cancel();
+        this._focusEditorCancellablePromise = createCancelablePromise(async (token) => {
+            const ref = await this.textModelService.createModelReference(cell.uri);
+            if (this._isDisposed || token.isCancellationRequested) {
+                ref.dispose();
+                return;
+            }
+            const editorDisposable = ( new DisposableStore());
+            editorDisposable.add(ref);
+            this._editor.setModel(ref.object.textEditorModel);
+            this._editor.setSelections(cell.getSelections());
+            this._editor.focus();
+            const _update = () => {
+                const editorSelections = this._editor.getSelections();
+                if (editorSelections) {
+                    cell.setSelections(editorSelections);
+                }
+                this.notebookEditor.revealInView(cell);
+                this._editor.setModel(null);
+                ref.dispose();
+            };
+            editorDisposable.add(this._editor.onDidChangeModelContent((e) => {
+                _update();
+            }));
+            editorDisposable.add(this._editor.onDidChangeCursorSelection(e => {
+                if (e.source === 'keyboard' || e.source === 'mouse') {
+                    _update();
+                }
+            }));
+            editorDisposable.add(this.notebookEditor.onDidChangeActiveEditor(() => {
+                const latestActiveCell = this.notebookEditor.getActiveCell();
+                if (latestActiveCell !== cell || latestActiveCell.focusMode !== CellFocusMode.Editor) {
+                    this._editorDisposable.clear();
+                    this._editor.setModel(null);
+                    ref.dispose();
+                }
+            }));
+            this._editorDisposable.value = editorDisposable;
+        });
+    }
+    dispose() {
+        this._isDisposed = true;
+        this._focusEditorCancellablePromise?.cancel();
+        super.dispose();
+    }
+};
+NotebookCellEditorPool = ( __decorate([
+    ( __param(2, ITextModelService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService))
+], NotebookCellEditorPool));
+export { NotebookCellEditorPool };

package/vscode/src/vs/workbench/contrib/notebook/browser/view/notebookCellList.js

@@ -896,7 +896,6 @@ let NotebookCellList = class NotebookCellList extends WorkbenchList {
         else if (alignHint === 'top') {
             this.view.setScrollTop(positionTop - 30);
         }
-        element.revealRangeInCenter(range);
     }
     revealCellOffsetInCenter(cell, offset) {
         const viewIndex = this._getViewIndexUpperBound(cell);

package/vscode/src/vs/workbench/contrib/notebook/browser/view/notebookCellListView.js

@@ -147,7 +147,7 @@ class NotebookCellsLayout {
         if (offset >= (this._size - this._paddingTop - whitespaceBeforeFirstItem)) {
             return this.count;
         }
-        return this._prefixSumComputer.getIndexOf(offset).index;
+        return this._prefixSumComputer.getIndexOf(Math.trunc(offset)).index;
     }
     indexAfter(position) {
         const index = this.indexAt(position);

package/vscode/src/vs/workbench/contrib/notebook/browser/view/renderers/backLayerWebView.js

@@ -183,9 +183,9 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
             'notebook-cell-output-line-height': `${this.options.outputLineHeight}px`,
             'notebook-cell-output-max-height': `${this.options.outputLineHeight * this.options.outputLineLimit + 2}px`,
             'notebook-cell-output-font-family': this.options.outputFontFamily || this.options.fontFamily,
-            'notebook-cell-markup-empty-content': ( localize(10692, "Empty markdown cell, double-click or press enter to edit.")),
-            'notebook-cell-renderer-not-found-error': ( localize(10693, "No renderer found for '$0'")),
-            'notebook-cell-renderer-fallbacks-exhausted': ( localize(10694, "Could not render content for '$0'")),
+            'notebook-cell-markup-empty-content': ( localize(10730, "Empty markdown cell, double-click or press enter to edit.")),
+            'notebook-cell-renderer-not-found-error': ( localize(10731, "No renderer found for '$0'")),
+            'notebook-cell-renderer-fallbacks-exhausted': ( localize(10732, "Could not render content for '$0'")),
         };
     }
     generateContent(baseUrl) {
@@ -985,7 +985,7 @@ let BackLayerWebView = class BackLayerWebView extends Themable {
         this.localResourceRootsCache = this._getResourceRootsCache();
         const webview = webviewService.createWebviewElement({
             origin: BackLayerWebView_1.getOriginStore(this.storageService).getOrigin(this.notebookViewType, undefined),
-            title: ( localize(10695, "Notebook webview content")),
+            title: ( localize(10733, "Notebook webview content")),
             options: {
                 purpose: WebviewContentPurpose.NotebookRenderer,
                 enableFindWidget: false,

package/vscode/src/vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer.js

@@ -204,9 +204,10 @@ MarkupCellRenderer = MarkupCellRenderer_1 = ( (__decorate([
 let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
     static { CodeCellRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'code_cell'; }
-    constructor(notebookEditor, renderedEditors, dndController, contextKeyServiceProvider, configurationService, contextMenuService, menuService, instantiationService, keybindingService, notificationService) {
+    constructor(notebookEditor, renderedEditors, editorPool, dndController, contextKeyServiceProvider, configurationService, contextMenuService, menuService, instantiationService, keybindingService, notificationService) {
         super(instantiationService, notebookEditor, contextMenuService, menuService, configurationService, keybindingService, notificationService, contextKeyServiceProvider, PLAINTEXT_LANGUAGE_ID, dndController);
         this.renderedEditors = renderedEditors;
+        this.editorPool = editorPool;
     }
     get templateId() {
         return CodeCellRenderer_1.TEMPLATE_ID;
@@ -228,7 +229,7 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
         const cellInputCollapsedContainer = append(cellContainer, $('.input-collapse-container'));
         cellInputCollapsedContainer.style.display = 'none';
         const executionOrderLabel = append(focusIndicatorLeft.domNode, $('div.execution-count-label'));
-        executionOrderLabel.title = ( localize(10696, 'Execution Order'));
+        executionOrderLabel.title = ( localize(10734, 'Execution Order'));
         const editorPart = append(cellContainer, $('.cell-editor-part'));
         const editorContainer = append(editorPart, $('.cell-editor-container'));
         const cellCommentPartContainer = append(container, $('.cell-comment-container'));
@@ -241,6 +242,12 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
                 width: 0,
                 height: 0
             },
+            scrollbar: {
+                vertical: 'hidden',
+                horizontal: 'auto',
+                handleMouseWheel: false,
+                useShadows: false,
+            },
         }, {
             contributions: this.notebookEditor.creationOptions.cellEditorContributions
         });
@@ -318,7 +325,7 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
         }
         templateData.outputContainer.domNode.innerText = '';
         templateData.outputContainer.domNode.appendChild(templateData.cellOutputCollapsedContainer);
-        templateData.elementDisposables.add(templateData.instantiationService.createInstance(CodeCell, this.notebookEditor, element, templateData));
+        templateData.elementDisposables.add(templateData.instantiationService.createInstance(CodeCell, this.notebookEditor, element, templateData, this.editorPool));
         this.renderedEditors.set(element, templateData.editor);
     }
     disposeTemplate(templateData) {
@@ -330,11 +337,11 @@ let CodeCellRenderer = class CodeCellRenderer extends AbstractCellRenderer {
     }
 };
 CodeCellRenderer = CodeCellRenderer_1 = ( (__decorate([
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, IContextMenuService))),
-    ( (__param(6, IMenuService))),
-    ( (__param(7, IInstantiationService))),
-    ( (__param(8, IKeybindingService))),
-    ( (__param(9, INotificationService)))
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IContextMenuService))),
+    ( (__param(7, IMenuService))),
+    ( (__param(8, IInstantiationService))),
+    ( (__param(9, IKeybindingService))),
+    ( (__param(10, INotificationService)))
 ], CodeCellRenderer)));
 export { CodeCellRenderer, MarkupCellRenderer, NotebookCellListDelegate };

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

@@ -48,6 +48,12 @@ class BaseCellViewModel extends Disposable {
         this._lineNumbers = lineNumbers;
         this._onDidChangeState.fire({ cellLineNumberChanged: true });
     }
+    get commentOptions() {
+        return this._commentOptions;
+    }
+    set commentOptions(newOptions) {
+        this._commentOptions = newOptions;
+    }
     get focusMode() {
         return this._focusMode;
     }
@@ -150,6 +156,12 @@ class BaseCellViewModel extends Disposable {
         if (this.model.collapseState?.outputCollapsed) {
             this._outputCollapsed = true;
         }
+        this._commentOptions = this._configurationService.getValue('editor.comments', { overrideIdentifier: this.language });
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('editor.comments')) {
+                this._commentOptions = this._configurationService.getValue('editor.comments', { overrideIdentifier: this.language });
+            }
+        }));
     }
     assertTextModelAttached() {
         if (this.textModel && this._textEditor && this._textEditor.getModel() === this.textModel) {
@@ -379,11 +391,29 @@ class BaseCellViewModel extends Disposable {
     }
     setSelections(selections) {
         if (selections.length) {
-            this._textEditor?.setSelections(selections);
+            if (this._textEditor) {
+                this._textEditor?.setSelections(selections);
+            }
+            else if (this._editorViewStates) {
+                this._editorViewStates.cursorState = ( selections.map(selection => {
+                    return {
+                        inSelectionMode: !selection.isEmpty(),
+                        selectionStart: selection.getStartPosition(),
+                        position: selection.getEndPosition(),
+                    };
+                }));
+            }
         }
     }
     getSelections() {
-        return this._textEditor?.getSelections() || [];
+        return this._textEditor?.getSelections()
+            ?? this._editorViewStates?.cursorState.map(state => ( new Selection(
+            state.selectionStart.lineNumber,
+            state.selectionStart.column,
+            state.position.lineNumber,
+            state.position.column
+        )))
+            ?? [];
     }
     getSelectionsStartPosition() {
         if (this._textEditor) {

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

@@ -1,7 +1,7 @@
 import { renderMarkdownAsPlaintext } from '../../../../../base/browser/markdownRenderer.js';
 import { Emitter } from '../../../../../base/common/event.js';
 import { DisposableStore } from '../../../../../base/common/lifecycle.js';
-import marked_1 from '../../../../../../../../external/vscode-marked/lib/marked.esm.js';
+import { marked } from 'marked';
 import { TrackedRangeStickiness } from '../../../../../editor/common/model.js';
 import { FoldingRegions } from '../../../../../editor/contrib/folding/browser/foldingRanges.js';
 import { sanitizeRanges } from '../../../../../editor/contrib/folding/browser/syntaxRangeProvider.js';
@@ -246,7 +246,7 @@ class FoldingModel {
     }
 }
 function* getMarkdownHeadersInCell(cellContent) {
-    for (const token of marked_1.lexer(cellContent, { gfm: true })) {
+    for (const token of marked.lexer(cellContent, { gfm: true })) {
         if (token.type === 'heading') {
             yield {
                 depth: token.depth,

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookEditorStickyScroll.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { addDisposableListener, EventType, getWindow, clearNode } from '../../../../../base/browser/dom.js';
+import { addDisposableListener, EventType, getWindow, clearNode, scheduleAtNextAnimationFrame } from '../../../../../base/browser/dom.js';
 import '../../../../../base/browser/touch.js';
 import { StandardMouseEvent } from '../../../../../base/browser/mouseEvent.js';
 import { Emitter } from '../../../../../base/common/event.js';
@@ -98,17 +98,19 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
         }
         return true;
     }
-    constructor(domNode, notebookEditor, notebookCellList, _contextMenuService, instantiationService) {
+    constructor(domNode, notebookEditor, notebookCellList, layoutFn, _contextMenuService, instantiationService) {
         super();
         this.domNode = domNode;
         this.notebookEditor = notebookEditor;
         this.notebookCellList = notebookCellList;
+        this.layoutFn = layoutFn;
         this._contextMenuService = _contextMenuService;
         this.instantiationService = instantiationService;
         this._disposables = ( new DisposableStore());
         this.currentStickyLines = ( new Map());
         this._onDidChangeNotebookStickyScroll = this._register(( new Emitter()));
         this.onDidChangeNotebookStickyScroll = this._onDidChangeNotebookStickyScroll.event;
+        this._layoutDisposableStore = this._register(( new DisposableStore()));
         if (this.notebookEditor.notebookOptions.getDisplayOptions().stickyScrollEnabled) {
             this.init();
         }
@@ -214,8 +216,15 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
         const sizeDelta = this.getCurrentStickyHeight() - oldStickyHeight;
         if (sizeDelta !== 0) {
             this._onDidChangeNotebookStickyScroll.fire(sizeDelta);
+            const d = this._layoutDisposableStore.add(scheduleAtNextAnimationFrame(getWindow(this.getDomNode()), () => {
+                this.layoutFn(sizeDelta);
+                this.updateDisplay();
+                this._layoutDisposableStore.delete(d);
+            }));
+        }
+        else {
+            this.updateDisplay();
         }
-        this.updateDisplay();
     }
     updateDisplay() {
         const hasSticky = this.getCurrentStickyHeight() > 0;
@@ -301,8 +310,8 @@ let NotebookStickyScroll = NotebookStickyScroll_1 = class NotebookStickyScroll e
     }
 };
 NotebookStickyScroll = NotebookStickyScroll_1 = ( __decorate([
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IInstantiationService))
+    ( __param(4, IContextMenuService)),
+    ( __param(5, IInstantiationService))
 ], NotebookStickyScroll));
 function computeContent(notebookEditor, notebookCellList, notebookOutlineEntries, renderedStickyHeight) {
     const editorScrollTop = notebookEditor.scrollTop - renderedStickyHeight;

package/vscode/src/vs/workbench/contrib/notebook/browser/viewParts/notebookHorizontalTracker.js

@@ -0,0 +1,47 @@
+import { addDisposableListener, getWindow, EventType } from '../../../../../base/browser/dom.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { isChrome } from '../../../../../base/common/platform.js';
+class NotebookHorizontalTracker extends Disposable {
+    constructor(_notebookEditor, _listViewScrollablement) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._listViewScrollablement = _listViewScrollablement;
+        this._register(addDisposableListener(this._listViewScrollablement, EventType.MOUSE_WHEEL, (event) => {
+            if (event.deltaX === 0) {
+                return;
+            }
+            const hoveringOnEditor = this._notebookEditor.codeEditors.find(editor => {
+                const editorLayout = editor[1].getLayoutInfo();
+                if (editorLayout.contentWidth === editorLayout.width) {
+                    return false;
+                }
+                const editorDOM = editor[1].getDomNode();
+                if (editorDOM && editorDOM.contains(event.target)) {
+                    return true;
+                }
+                return false;
+            });
+            if (!hoveringOnEditor) {
+                return;
+            }
+            const targetWindow = getWindow(event);
+            const evt = {
+                deltaMode: event.deltaMode,
+                deltaX: event.deltaX,
+                deltaY: 0,
+                deltaZ: 0,
+                wheelDelta: event.wheelDelta && isChrome ? (event.wheelDelta / targetWindow.devicePixelRatio) : event.wheelDelta,
+                wheelDeltaX: event.wheelDeltaX && isChrome ? (event.wheelDeltaX / targetWindow.devicePixelRatio) : event.wheelDeltaX,
+                wheelDeltaY: 0,
+                detail: event.detail,
+                shiftKey: event.shiftKey,
+                type: event.type,
+                defaultPrevented: false,
+                preventDefault: () => { },
+                stopPropagation: () => { }
+            };
+            hoveringOnEditor[1].delegateScrollFromMouseWheelEvent(evt);
+        }));
+    }
+}
+export { NotebookHorizontalTracker };