@codingame/monaco-vscode-api 1.85.0 → 1.85.2

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

@@ -0,0 +1,65 @@
+const mapping = ( new Map([
+    ['theme-font-family', 'vscode-font-family'],
+    ['theme-font-weight', 'vscode-font-weight'],
+    ['theme-font-size', 'vscode-font-size'],
+    ['theme-code-font-family', 'vscode-editor-font-family'],
+    ['theme-code-font-weight', 'vscode-editor-font-weight'],
+    ['theme-code-font-size', 'vscode-editor-font-size'],
+    ['theme-scrollbar-background', 'vscode-scrollbarSlider-background'],
+    ['theme-scrollbar-hover-background', 'vscode-scrollbarSlider-hoverBackground'],
+    ['theme-scrollbar-active-background', 'vscode-scrollbarSlider-activeBackground'],
+    ['theme-quote-background', 'vscode-textBlockQuote-background'],
+    ['theme-quote-border', 'vscode-textBlockQuote-border'],
+    ['theme-code-foreground', 'vscode-textPreformat-foreground'],
+    ['theme-background', 'vscode-editor-background'],
+    ['theme-foreground', 'vscode-editor-foreground'],
+    ['theme-ui-foreground', 'vscode-foreground'],
+    ['theme-link', 'vscode-textLink-foreground'],
+    ['theme-link-active', 'vscode-textLink-activeForeground'],
+    ['theme-button-background', 'vscode-button-background'],
+    ['theme-button-hover-background', 'vscode-button-hoverBackground'],
+    ['theme-button-foreground', 'vscode-button-foreground'],
+    ['theme-button-secondary-background', 'vscode-button-secondaryBackground'],
+    ['theme-button-secondary-hover-background', 'vscode-button-secondaryHoverBackground'],
+    ['theme-button-secondary-foreground', 'vscode-button-secondaryForeground'],
+    ['theme-button-hover-foreground', 'vscode-button-foreground'],
+    ['theme-button-focus-foreground', 'vscode-button-foreground'],
+    ['theme-button-secondary-hover-foreground', 'vscode-button-secondaryForeground'],
+    ['theme-button-secondary-focus-foreground', 'vscode-button-secondaryForeground'],
+    ['theme-input-background', 'vscode-input-background'],
+    ['theme-input-foreground', 'vscode-input-foreground'],
+    ['theme-input-placeholder-foreground', 'vscode-input-placeholderForeground'],
+    ['theme-input-focus-border-color', 'vscode-focusBorder'],
+    ['theme-menu-background', 'vscode-menu-background'],
+    ['theme-menu-foreground', 'vscode-menu-foreground'],
+    ['theme-menu-hover-background', 'vscode-menu-selectionBackground'],
+    ['theme-menu-focus-background', 'vscode-menu-selectionBackground'],
+    ['theme-menu-hover-foreground', 'vscode-menu-selectionForeground'],
+    ['theme-menu-focus-foreground', 'vscode-menu-selectionForeground'],
+    ['theme-error-background', 'vscode-inputValidation-errorBackground'],
+    ['theme-error-foreground', 'vscode-foreground'],
+    ['theme-warning-background', 'vscode-inputValidation-warningBackground'],
+    ['theme-warning-foreground', 'vscode-foreground'],
+    ['theme-info-background', 'vscode-inputValidation-infoBackground'],
+    ['theme-info-foreground', 'vscode-foreground'],
+    ['theme-notebook-output-background', 'vscode-notebook-outputContainerBackgroundColor'],
+    ['theme-notebook-output-border', 'vscode-notebook-outputContainerBorderColor'],
+    ['theme-notebook-cell-selected-background', 'vscode-notebook-selectedCellBackground'],
+    ['theme-notebook-symbol-highlight-background', 'vscode-notebook-symbolHighlightBackground'],
+    ['theme-notebook-diff-removed-background', 'vscode-diffEditor-removedTextBackground'],
+    ['theme-notebook-diff-inserted-background', 'vscode-diffEditor-insertedTextBackground'],
+]));
+const constants = {
+    'theme-input-border-width': '1px',
+    'theme-button-primary-hover-shadow': 'none',
+    'theme-button-secondary-hover-shadow': 'none',
+    'theme-input-border-color': 'transparent',
+};
+const transformWebviewThemeVars = (s) => {
+    const result = { ...s, ...constants };
+    for (const [target, src] of mapping) {
+        result[target] = s[src];
+    }
+    return result;
+};
+export { transformWebviewThemeVars };

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

@@ -0,0 +1,95 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { executingStateIcon } from '../notebookIcons.js';
+import { CellKind } from '../../common/notebookCommon.js';
+import { SymbolKinds } from 'monaco-editor/esm/vs/editor/common/languages.js';
+class OutlineEntry {
+    get icon() {
+        if (this.symbolKind) {
+            return SymbolKinds.toIcon(this.symbolKind);
+        }
+        return this.isExecuting && this.isPaused ? executingStateIcon :
+            this.isExecuting ? ThemeIcon.modify(executingStateIcon, 'spin') :
+                this.cell.cellKind === CellKind.Markup ? Codicon.markdown : Codicon.code;
+    }
+    constructor(index, level, cell, label, isExecuting, isPaused, range, symbolKind) {
+        this.index = index;
+        this.level = level;
+        this.cell = cell;
+        this.label = label;
+        this.isExecuting = isExecuting;
+        this.isPaused = isPaused;
+        this.range = range;
+        this.symbolKind = symbolKind;
+        this._children = [];
+    }
+    addChild(entry) {
+        this._children.push(entry);
+        entry._parent = this;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get children() {
+        return this._children;
+    }
+    get markerInfo() {
+        return this._markerInfo;
+    }
+    get position() {
+        if (this.range) {
+            return { startLineNumber: this.range.startLineNumber, startColumn: this.range.startColumn };
+        }
+        return undefined;
+    }
+    updateMarkers(markerService) {
+        if (this.cell.cellKind === CellKind.Code) {
+            const marker = markerService.read({ resource: this.cell.uri, severities: MarkerSeverity.Error | MarkerSeverity.Warning });
+            if (marker.length === 0) {
+                this._markerInfo = undefined;
+            }
+            else {
+                const topSev = marker.find(a => a.severity === MarkerSeverity.Error)?.severity ?? MarkerSeverity.Warning;
+                this._markerInfo = { topSev, count: marker.length };
+            }
+        }
+        else {
+            let topChild;
+            for (const child of this.children) {
+                child.updateMarkers(markerService);
+                if (child.markerInfo) {
+                    topChild = !topChild ? child.markerInfo.topSev : Math.max(child.markerInfo.topSev, topChild);
+                }
+            }
+            this._markerInfo = topChild && { topSev: topChild, count: 0 };
+        }
+    }
+    clearMarkers() {
+        this._markerInfo = undefined;
+        for (const child of this.children) {
+            child.clearMarkers();
+        }
+    }
+    find(cell, parents) {
+        if (cell.id === this.cell.id) {
+            return this;
+        }
+        parents.push(this);
+        for (const child of this.children) {
+            const result = child.find(cell, parents);
+            if (result) {
+                return result;
+            }
+        }
+        parents.pop();
+        return undefined;
+    }
+    asFlatList(bucket) {
+        bucket.push(this);
+        for (const child of this.children) {
+            child.asFlatList(bucket);
+        }
+    }
+}
+export { OutlineEntry };

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

@@ -0,0 +1,507 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { SearchParams } from 'monaco-editor/esm/vs/editor/common/model/textModelSearch.js';
+import { writeTransientState, readTransientState } from '../../../codeEditor/browser/toggleWordWrap.js';
+import { CellEditState, CellFocusMode, CursorAtLineBoundary, CursorAtBoundary } from '../notebookBrowser.js';
+import { getEditorTopPadding } from '../notebookOptions.js';
+class BaseCellViewModel extends Disposable {
+    get handle() {
+        return this.model.handle;
+    }
+    get uri() {
+        return this.model.uri;
+    }
+    get lineCount() {
+        return this.model.textBuffer.getLineCount();
+    }
+    get metadata() {
+        return this.model.metadata;
+    }
+    get internalMetadata() {
+        return this.model.internalMetadata;
+    }
+    get language() {
+        return this.model.language;
+    }
+    get mime() {
+        if (typeof this.model.mime === 'string') {
+            return this.model.mime;
+        }
+        switch (this.language) {
+            case 'markdown':
+                return Mimes.markdown;
+            default:
+                return Mimes.text;
+        }
+    }
+    get lineNumbers() {
+        return this._lineNumbers;
+    }
+    set lineNumbers(lineNumbers) {
+        if (lineNumbers === this._lineNumbers) {
+            return;
+        }
+        this._lineNumbers = lineNumbers;
+        this._onDidChangeState.fire({ cellLineNumberChanged: true });
+    }
+    get focusMode() {
+        return this._focusMode;
+    }
+    set focusMode(newMode) {
+        if (this._focusMode !== newMode) {
+            this._focusMode = newMode;
+            this._onDidChangeState.fire({ focusModeChanged: true });
+        }
+    }
+    get editorAttached() {
+        return !!this._textEditor;
+    }
+    get textModel() {
+        return this.model.textModel;
+    }
+    hasModel() {
+        return !!this.textModel;
+    }
+    get dragging() {
+        return this._dragging;
+    }
+    set dragging(v) {
+        this._dragging = v;
+        this._onDidChangeState.fire({ dragStateChanged: true });
+    }
+    get isInputCollapsed() {
+        return this._inputCollapsed;
+    }
+    set isInputCollapsed(v) {
+        this._inputCollapsed = v;
+        this._onDidChangeState.fire({ inputCollapsedChanged: true });
+    }
+    get isOutputCollapsed() {
+        return this._outputCollapsed;
+    }
+    set isOutputCollapsed(v) {
+        this._outputCollapsed = v;
+        this._onDidChangeState.fire({ outputCollapsedChanged: true });
+    }
+    constructor(viewType, model, id, _viewContext, _configurationService, _modelService, _undoRedoService, _codeEditorService) {
+        super();
+        this.viewType = viewType;
+        this.model = model;
+        this.id = id;
+        this._viewContext = _viewContext;
+        this._configurationService = _configurationService;
+        this._modelService = _modelService;
+        this._undoRedoService = _undoRedoService;
+        this._codeEditorService = _codeEditorService;
+        this._onDidChangeEditorAttachState = this._register(( new Emitter()));
+        this.onDidChangeEditorAttachState = this._onDidChangeEditorAttachState.event;
+        this._onDidChangeState = this._register(( new Emitter()));
+        this.onDidChangeState = this._onDidChangeState.event;
+        this._editState = CellEditState.Preview;
+        this._lineNumbers = 'inherit';
+        this._focusMode = CellFocusMode.Container;
+        this._editorListeners = [];
+        this._editorViewStates = null;
+        this._editorTransientState = null;
+        this._resolvedCellDecorations = ( new Map());
+        this._cellDecorationsChanged = this._register(( new Emitter()));
+        this.onCellDecorationsChanged = this._cellDecorationsChanged.event;
+        this._resolvedDecorations = ( new Map());
+        this._lastDecorationId = 0;
+        this._cellStatusBarItems = ( new Map());
+        this._onDidChangeCellStatusBarItems = this._register(( new Emitter()));
+        this.onDidChangeCellStatusBarItems = this._onDidChangeCellStatusBarItems.event;
+        this._lastStatusBarId = 0;
+        this._dragging = false;
+        this._inputCollapsed = false;
+        this._outputCollapsed = false;
+        this._isDisposed = false;
+        this._editStateSource = '';
+        this._register(model.onDidChangeMetadata(() => {
+            this._onDidChangeState.fire({ metadataChanged: true });
+        }));
+        this._register(model.onDidChangeInternalMetadata(e => {
+            this._onDidChangeState.fire({ internalMetadataChanged: true });
+            if (e.lastRunSuccessChanged) {
+                this.layoutChange({});
+            }
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('notebook.lineNumbers')) {
+                this.lineNumbers = 'inherit';
+            }
+        }));
+        if (this.model.collapseState?.inputCollapsed) {
+            this._inputCollapsed = true;
+        }
+        if (this.model.collapseState?.outputCollapsed) {
+            this._outputCollapsed = true;
+        }
+    }
+    assertTextModelAttached() {
+        if (this.textModel && this._textEditor && this._textEditor.getModel() === this.textModel) {
+            return true;
+        }
+        return false;
+    }
+    attachTextEditor(editor, estimatedHasHorizontalScrolling) {
+        if (!editor.hasModel()) {
+            throw new Error('Invalid editor: model is missing');
+        }
+        if (this._textEditor === editor) {
+            if (this._editorListeners.length === 0) {
+                this._editorListeners.push(this._textEditor.onDidChangeCursorSelection(() => { this._onDidChangeState.fire({ selectionChanged: true }); }));
+                this._onDidChangeState.fire({ selectionChanged: true });
+            }
+            return;
+        }
+        this._textEditor = editor;
+        if (this._editorViewStates) {
+            this._restoreViewState(this._editorViewStates);
+        }
+        else {
+            if (estimatedHasHorizontalScrolling) {
+                this._restoreViewState({
+                    contributionsState: {},
+                    cursorState: [],
+                    viewState: {
+                        scrollLeft: 0,
+                        firstPosition: { lineNumber: 1, column: 1 },
+                        firstPositionDeltaTop: getEditorTopPadding()
+                    }
+                });
+            }
+        }
+        if (this._editorTransientState) {
+            writeTransientState(editor.getModel(), this._editorTransientState, this._codeEditorService);
+        }
+        this._textEditor?.changeDecorations((accessor) => {
+            this._resolvedDecorations.forEach((value, key) => {
+                if (key.startsWith('_lazy_')) {
+                    const ret = accessor.addDecoration(value.options.range, value.options.options);
+                    this._resolvedDecorations.get(key).id = ret;
+                }
+                else {
+                    const ret = accessor.addDecoration(value.options.range, value.options.options);
+                    this._resolvedDecorations.get(key).id = ret;
+                }
+            });
+        });
+        this._editorListeners.push(this._textEditor.onDidChangeCursorSelection(() => { this._onDidChangeState.fire({ selectionChanged: true }); }));
+        this._onDidChangeState.fire({ selectionChanged: true });
+        this._onDidChangeEditorAttachState.fire();
+    }
+    detachTextEditor() {
+        this.saveViewState();
+        this.saveTransientState();
+        this._textEditor?.changeDecorations((accessor) => {
+            this._resolvedDecorations.forEach(value => {
+                const resolvedid = value.id;
+                if (resolvedid) {
+                    accessor.removeDecoration(resolvedid);
+                }
+            });
+        });
+        this._textEditor = undefined;
+        dispose(this._editorListeners);
+        this._editorListeners = [];
+        this._onDidChangeEditorAttachState.fire();
+        if (this._textModelRef) {
+            this._textModelRef.dispose();
+            this._textModelRef = undefined;
+        }
+    }
+    getText() {
+        return this.model.getValue();
+    }
+    getTextLength() {
+        return this.model.getTextLength();
+    }
+    saveViewState() {
+        if (!this._textEditor) {
+            return;
+        }
+        this._editorViewStates = this._textEditor.saveViewState();
+    }
+    saveTransientState() {
+        if (!this._textEditor || !this._textEditor.hasModel()) {
+            return;
+        }
+        this._editorTransientState = readTransientState(this._textEditor.getModel(), this._codeEditorService);
+    }
+    saveEditorViewState() {
+        if (this._textEditor) {
+            this._editorViewStates = this._textEditor.saveViewState();
+        }
+        return this._editorViewStates;
+    }
+    restoreEditorViewState(editorViewStates, totalHeight) {
+        this._editorViewStates = editorViewStates;
+    }
+    _restoreViewState(state) {
+        if (state) {
+            this._textEditor?.restoreViewState(state);
+        }
+    }
+    addModelDecoration(decoration) {
+        if (!this._textEditor) {
+            const id = ++this._lastDecorationId;
+            const decorationId = `_lazy_${this.id};${id}`;
+            this._resolvedDecorations.set(decorationId, { options: decoration });
+            return decorationId;
+        }
+        let id;
+        this._textEditor.changeDecorations((accessor) => {
+            id = accessor.addDecoration(decoration.range, decoration.options);
+            this._resolvedDecorations.set(id, { id, options: decoration });
+        });
+        return id;
+    }
+    removeModelDecoration(decorationId) {
+        const realDecorationId = this._resolvedDecorations.get(decorationId);
+        if (this._textEditor && realDecorationId && realDecorationId.id !== undefined) {
+            this._textEditor.changeDecorations((accessor) => {
+                accessor.removeDecoration(realDecorationId.id);
+            });
+        }
+        this._resolvedDecorations.delete(decorationId);
+    }
+    deltaModelDecorations(oldDecorations, newDecorations) {
+        oldDecorations.forEach(id => {
+            this.removeModelDecoration(id);
+        });
+        const ret = ( newDecorations.map(option => {
+            return this.addModelDecoration(option);
+        }));
+        return ret;
+    }
+    _removeCellDecoration(decorationId) {
+        const options = this._resolvedCellDecorations.get(decorationId);
+        this._resolvedCellDecorations.delete(decorationId);
+        if (options) {
+            for (const existingOptions of ( this._resolvedCellDecorations.values())) {
+                if (options.className === existingOptions.className) {
+                    options.className = undefined;
+                }
+                if (options.outputClassName === existingOptions.outputClassName) {
+                    options.outputClassName = undefined;
+                }
+                if (options.gutterClassName === existingOptions.gutterClassName) {
+                    options.gutterClassName = undefined;
+                }
+                if (options.topClassName === existingOptions.topClassName) {
+                    options.topClassName = undefined;
+                }
+            }
+            this._cellDecorationsChanged.fire({ added: [], removed: [options] });
+        }
+    }
+    _addCellDecoration(options) {
+        const id = ++this._lastDecorationId;
+        const decorationId = `_cell_${this.id};${id}`;
+        this._resolvedCellDecorations.set(decorationId, options);
+        this._cellDecorationsChanged.fire({ added: [options], removed: [] });
+        return decorationId;
+    }
+    getCellDecorations() {
+        return [...( this._resolvedCellDecorations.values())];
+    }
+    getCellDecorationRange(decorationId) {
+        if (this._textEditor) {
+            return this._textEditor.getModel()?.getDecorationRange(decorationId) ?? null;
+        }
+        return null;
+    }
+    deltaCellDecorations(oldDecorations, newDecorations) {
+        oldDecorations.forEach(id => {
+            this._removeCellDecoration(id);
+        });
+        const ret = ( newDecorations.map(option => {
+            return this._addCellDecoration(option);
+        }));
+        return ret;
+    }
+    deltaCellStatusBarItems(oldItems, newItems) {
+        oldItems.forEach(id => {
+            const item = this._cellStatusBarItems.get(id);
+            if (item) {
+                this._cellStatusBarItems.delete(id);
+            }
+        });
+        const newIds = ( newItems.map(item => {
+            const id = ++this._lastStatusBarId;
+            const itemId = `_cell_${this.id};${id}`;
+            this._cellStatusBarItems.set(itemId, item);
+            return itemId;
+        }));
+        this._onDidChangeCellStatusBarItems.fire();
+        return newIds;
+    }
+    getCellStatusBarItems() {
+        return Array.from(( this._cellStatusBarItems.values()));
+    }
+    revealRangeInCenter(range) {
+        this._textEditor?.revealRangeInCenter(range, 1 );
+    }
+    setSelection(range) {
+        this._textEditor?.setSelection(range);
+    }
+    setSelections(selections) {
+        if (selections.length) {
+            this._textEditor?.setSelections(selections);
+        }
+    }
+    getSelections() {
+        return this._textEditor?.getSelections() || [];
+    }
+    getSelectionsStartPosition() {
+        if (this._textEditor) {
+            const selections = this._textEditor.getSelections();
+            return selections?.map(s => s.getStartPosition());
+        }
+        else {
+            const selections = this._editorViewStates?.cursorState;
+            return selections?.map(s => s.selectionStart);
+        }
+    }
+    getLineScrollTopOffset(line) {
+        if (!this._textEditor) {
+            return 0;
+        }
+        const editorPadding = this._viewContext.notebookOptions.computeEditorPadding(this.internalMetadata, this.uri);
+        return this._textEditor.getTopForLineNumber(line) + editorPadding.top;
+    }
+    getPositionScrollTopOffset(range) {
+        if (!this._textEditor) {
+            return 0;
+        }
+        const position = range instanceof Selection ? range.getPosition() : range.getStartPosition();
+        const editorPadding = this._viewContext.notebookOptions.computeEditorPadding(this.internalMetadata, this.uri);
+        return this._textEditor.getTopForPosition(position.lineNumber, position.column) + editorPadding.top;
+    }
+    cursorAtLineBoundary() {
+        if (!this._textEditor || !this.textModel || !this._textEditor.hasTextFocus()) {
+            return CursorAtLineBoundary.None;
+        }
+        const selection = this._textEditor.getSelection();
+        if (!selection || !selection.isEmpty()) {
+            return CursorAtLineBoundary.None;
+        }
+        const currentLineLength = this.textModel.getLineLength(selection.startLineNumber);
+        if (currentLineLength === 0) {
+            return CursorAtLineBoundary.Both;
+        }
+        switch (selection.startColumn) {
+            case 1:
+                return CursorAtLineBoundary.Start;
+            case currentLineLength + 1:
+                return CursorAtLineBoundary.End;
+            default:
+                return CursorAtLineBoundary.None;
+        }
+    }
+    cursorAtBoundary() {
+        if (!this._textEditor) {
+            return CursorAtBoundary.None;
+        }
+        if (!this.textModel) {
+            return CursorAtBoundary.None;
+        }
+        const selection = this._textEditor.getSelection();
+        if (!selection || !selection.isEmpty()) {
+            return CursorAtBoundary.None;
+        }
+        const firstViewLineTop = this._textEditor.getTopForPosition(1, 1);
+        const lastViewLineTop = this._textEditor.getTopForPosition(this.textModel.getLineCount(), this.textModel.getLineLength(this.textModel.getLineCount()));
+        const selectionTop = this._textEditor.getTopForPosition(selection.startLineNumber, selection.startColumn);
+        if (selectionTop === lastViewLineTop) {
+            if (selectionTop === firstViewLineTop) {
+                return CursorAtBoundary.Both;
+            }
+            else {
+                return CursorAtBoundary.Bottom;
+            }
+        }
+        else {
+            if (selectionTop === firstViewLineTop) {
+                return CursorAtBoundary.Top;
+            }
+            else {
+                return CursorAtBoundary.None;
+            }
+        }
+    }
+    get editStateSource() {
+        return this._editStateSource;
+    }
+    updateEditState(newState, source) {
+        this._editStateSource = source;
+        if (newState === this._editState) {
+            return;
+        }
+        this._editState = newState;
+        this._onDidChangeState.fire({ editStateChanged: true });
+        if (this._editState === CellEditState.Preview) {
+            this.focusMode = CellFocusMode.Container;
+        }
+    }
+    getEditState() {
+        return this._editState;
+    }
+    get textBuffer() {
+        return this.model.textBuffer;
+    }
+    async resolveTextModel() {
+        if (!this._textModelRef || !this.textModel) {
+            this._textModelRef = await this._modelService.createModelReference(this.uri);
+            if (this._isDisposed) {
+                return this.textModel;
+            }
+            if (!this._textModelRef) {
+                throw new Error(`Cannot resolve text model for ${this.uri}`);
+            }
+            this._register(this.textModel.onDidChangeContent(() => this.onDidChangeTextModelContent()));
+        }
+        return this.textModel;
+    }
+    cellStartFind(value, options) {
+        let cellMatches = [];
+        if (this.assertTextModelAttached()) {
+            cellMatches = this.textModel.findMatches(value, false, options.regex || false, options.caseSensitive || false, options.wholeWord ? options.wordSeparators || null : null, options.regex || false);
+        }
+        else {
+            const lineCount = this.textBuffer.getLineCount();
+            const fullRange = ( new Range(1, 1, lineCount, this.textBuffer.getLineLength(lineCount) + 1));
+            const searchParams = ( new SearchParams(
+                value,
+                options.regex || false,
+                options.caseSensitive || false,
+                options.wholeWord ? options.wordSeparators || null : null
+            ));
+            const searchData = searchParams.parseSearchRequest();
+            if (!searchData) {
+                return null;
+            }
+            cellMatches = this.textBuffer.findMatchesLineByLine(fullRange, searchData, options.regex || false, 1000);
+        }
+        return cellMatches;
+    }
+    dispose() {
+        this._isDisposed = true;
+        super.dispose();
+        dispose(this._editorListeners);
+        if (this._undoRedoService.getUriComparisonKey(this.uri) === ( this.uri.toString())) {
+            this._undoRedoService.removeElements(this.uri);
+        }
+        this._textModelRef?.dispose();
+    }
+    toJSON() {
+        return {
+            handle: this.handle
+        };
+    }
+}
+export { BaseCellViewModel };