@codingame/monaco-vscode-api 1.85.0 → 1.85.2

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

@@ -0,0 +1,346 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { hash, StringSHA1 } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { Disposable, DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as UUID from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { PieceTreeTextBuffer } from 'monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBuffer.js';
+import { PieceTreeTextBufferBuilder } from 'monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { NotebookCellOutputTextModel } from './notebookCellOutputTextModel.js';
+class NotebookCellTextModel extends Disposable {
+    get outputs() {
+        return this._outputs;
+    }
+    get metadata() {
+        return this._metadata;
+    }
+    set metadata(newMetadata) {
+        this._metadata = newMetadata;
+        this._hash = null;
+        this._onDidChangeMetadata.fire();
+    }
+    get internalMetadata() {
+        return this._internalMetadata;
+    }
+    set internalMetadata(newInternalMetadata) {
+        const lastRunSuccessChanged = this._internalMetadata.lastRunSuccess !== newInternalMetadata.lastRunSuccess;
+        newInternalMetadata = {
+            ...newInternalMetadata,
+            ...{ runStartTimeAdjustment: computeRunStartTimeAdjustment(this._internalMetadata, newInternalMetadata) }
+        };
+        this._internalMetadata = newInternalMetadata;
+        this._hash = null;
+        this._onDidChangeInternalMetadata.fire({ lastRunSuccessChanged });
+    }
+    get language() {
+        return this._language;
+    }
+    set language(newLanguage) {
+        if (this._textModel
+            && this._textModel.getLanguageId() === this._languageService.getLanguageIdByLanguageName(newLanguage)
+            && this._textModel.getLanguageId() === this._languageService.getLanguageIdByLanguageName(this.language)) {
+            return;
+        }
+        const newLanguageId = this._languageService.getLanguageIdByLanguageName(newLanguage);
+        if (newLanguageId === null) {
+            return;
+        }
+        if (this._textModel) {
+            const languageId = this._languageService.createById(newLanguageId);
+            this._textModel.setLanguage(languageId.languageId);
+        }
+        if (this._language === newLanguage) {
+            return;
+        }
+        this._language = newLanguage;
+        this._hash = null;
+        this._onDidChangeLanguage.fire(newLanguage);
+        this._onDidChangeContent.fire('language');
+    }
+    get mime() {
+        return this._mime;
+    }
+    set mime(newMime) {
+        if (this._mime === newMime) {
+            return;
+        }
+        this._mime = newMime;
+        this._hash = null;
+        this._onDidChangeContent.fire('mime');
+    }
+    get textBuffer() {
+        if (this._textBuffer) {
+            return this._textBuffer;
+        }
+        const builder = ( new PieceTreeTextBufferBuilder());
+        builder.acceptChunk(this._source);
+        const bufferFactory = builder.finish(true);
+        const { textBuffer, disposable } = bufferFactory.create(1 );
+        this._textBuffer = textBuffer;
+        this._register(disposable);
+        this._register(this._textBuffer.onDidChangeContent(() => {
+            this._hash = null;
+            if (!this._textModel) {
+                this._onDidChangeContent.fire('content');
+            }
+        }));
+        return this._textBuffer;
+    }
+    get alternativeId() {
+        return this._alternativeId;
+    }
+    get textModel() {
+        return this._textModel;
+    }
+    set textModel(m) {
+        if (this._textModel === m) {
+            return;
+        }
+        this._textModelDisposables.clear();
+        this._textModel = m;
+        if (this._textModel) {
+            this.setRegisteredLanguage(this._languageService, this._textModel.getLanguageId(), this.language);
+            this._textModelDisposables.add(this._textModel.onDidChangeLanguage((e) => this.setRegisteredLanguage(this._languageService, e.newLanguage, this.language)));
+            this._textModelDisposables.add(this._textModel.onWillDispose(() => this.textModel = undefined));
+            this._textModelDisposables.add(this._textModel.onDidChangeContent(() => {
+                if (this._textModel) {
+                    this._versionId = this._textModel.getVersionId();
+                    this._alternativeId = this._textModel.getAlternativeVersionId();
+                }
+                this._onDidChangeContent.fire('content');
+            }));
+            this._textModel._overwriteVersionId(this._versionId);
+            this._textModel._overwriteAlternativeVersionId(this._versionId);
+        }
+    }
+    setRegisteredLanguage(languageService, newLanguage, currentLanguage) {
+        const isFallBackLanguage = (newLanguage === PLAINTEXT_LANGUAGE_ID || newLanguage === 'jupyter');
+        if (!languageService.isRegisteredLanguageId(currentLanguage) && isFallBackLanguage) {
+            this._onDidChangeLanguage.fire(currentLanguage);
+        }
+        else {
+            this.language = newLanguage;
+        }
+    }
+    constructor(uri, handle, _source, _language, _mime, cellKind, outputs, metadata, internalMetadata, collapseState, transientOptions, _languageService) {
+        super();
+        this.uri = uri;
+        this.handle = handle;
+        this._source = _source;
+        this._language = _language;
+        this._mime = _mime;
+        this.cellKind = cellKind;
+        this.collapseState = collapseState;
+        this.transientOptions = transientOptions;
+        this._languageService = _languageService;
+        this._onDidChangeOutputs = this._register(( new Emitter()));
+        this.onDidChangeOutputs = this._onDidChangeOutputs.event;
+        this._onDidChangeOutputItems = this._register(( new Emitter()));
+        this.onDidChangeOutputItems = this._onDidChangeOutputItems.event;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._onDidChangeMetadata = this._register(( new Emitter()));
+        this.onDidChangeMetadata = this._onDidChangeMetadata.event;
+        this._onDidChangeInternalMetadata = this._register(( new Emitter()));
+        this.onDidChangeInternalMetadata = this._onDidChangeInternalMetadata.event;
+        this._onDidChangeLanguage = this._register(( new Emitter()));
+        this.onDidChangeLanguage = this._onDidChangeLanguage.event;
+        this._textBufferHash = null;
+        this._hash = null;
+        this._versionId = 1;
+        this._alternativeId = 1;
+        this._textModelDisposables = this._register(( new DisposableStore()));
+        this._textModel = undefined;
+        this._outputs = ( outputs.map(op => ( new NotebookCellOutputTextModel(op))));
+        this._metadata = metadata ?? {};
+        this._internalMetadata = internalMetadata ?? {};
+    }
+    resetTextBuffer(textBuffer) {
+        this._textBuffer = textBuffer;
+    }
+    getValue() {
+        const fullRange = this.getFullModelRange();
+        const eol = this.textBuffer.getEOL();
+        if (eol === '\n') {
+            return this.textBuffer.getValueInRange(fullRange, 1 );
+        }
+        else {
+            return this.textBuffer.getValueInRange(fullRange, 2 );
+        }
+    }
+    getTextBufferHash() {
+        if (this._textBufferHash !== null) {
+            return this._textBufferHash;
+        }
+        const shaComputer = ( new StringSHA1());
+        const snapshot = this.textBuffer.createSnapshot(false);
+        let text;
+        while ((text = snapshot.read())) {
+            shaComputer.update(text);
+        }
+        this._textBufferHash = shaComputer.digest();
+        return this._textBufferHash;
+    }
+    getHashValue() {
+        if (this._hash !== null) {
+            return this._hash;
+        }
+        this._hash = hash([hash(this.language), this.getTextBufferHash(), this._getPersisentMetadata(), this.transientOptions.transientOutputs ? [] : ( this._outputs.map(op => ({
+                outputs: ( op.outputs.map(output => ({
+                    mime: output.mime,
+                    data: Array.from(output.data.buffer)
+                }))),
+                metadata: op.metadata
+            })))]);
+        return this._hash;
+    }
+    _getPersisentMetadata() {
+        const filteredMetadata = {};
+        const transientCellMetadata = this.transientOptions.transientCellMetadata;
+        const keys = ( new Set([...( Object.keys(this.metadata))]));
+        for (const key of keys) {
+            if (!(transientCellMetadata[key])) {
+                filteredMetadata[key] = this.metadata[key];
+            }
+        }
+        return filteredMetadata;
+    }
+    getTextLength() {
+        return this.textBuffer.getLength();
+    }
+    getFullModelRange() {
+        const lineCount = this.textBuffer.getLineCount();
+        return ( new Range(1, 1, lineCount, this.textBuffer.getLineLength(lineCount) + 1));
+    }
+    spliceNotebookCellOutputs(splice) {
+        if (splice.deleteCount > 0 && splice.newOutputs.length > 0) {
+            const commonLen = Math.min(splice.deleteCount, splice.newOutputs.length);
+            for (let i = 0; i < commonLen; i++) {
+                const currentOutput = this.outputs[splice.start + i];
+                const newOutput = splice.newOutputs[i];
+                this.replaceOutput(currentOutput.outputId, newOutput);
+            }
+            this.outputs.splice(splice.start + commonLen, splice.deleteCount - commonLen, ...splice.newOutputs.slice(commonLen));
+            this._onDidChangeOutputs.fire({ start: splice.start + commonLen, deleteCount: splice.deleteCount - commonLen, newOutputs: splice.newOutputs.slice(commonLen) });
+        }
+        else {
+            this.outputs.splice(splice.start, splice.deleteCount, ...splice.newOutputs);
+            this._onDidChangeOutputs.fire(splice);
+        }
+    }
+    replaceOutput(outputId, newOutputItem) {
+        const outputIndex = this.outputs.findIndex(output => output.outputId === outputId);
+        if (outputIndex < 0) {
+            return false;
+        }
+        const output = this.outputs[outputIndex];
+        output.replaceData(newOutputItem);
+        this._onDidChangeOutputItems.fire();
+        return true;
+    }
+    changeOutputItems(outputId, append, items) {
+        const outputIndex = this.outputs.findIndex(output => output.outputId === outputId);
+        if (outputIndex < 0) {
+            return false;
+        }
+        const output = this.outputs[outputIndex];
+        if (append) {
+            output.appendData(items);
+        }
+        else {
+            output.replaceData({ outputId: outputId, outputs: items, metadata: output.metadata });
+        }
+        this._onDidChangeOutputItems.fire();
+        return true;
+    }
+    _outputNotEqualFastCheck(left, right) {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let i = 0; i < this.outputs.length; i++) {
+            const l = left[i];
+            const r = right[i];
+            if (l.outputs.length !== r.outputs.length) {
+                return false;
+            }
+            for (let k = 0; k < l.outputs.length; k++) {
+                if (l.outputs[k].mime !== r.outputs[k].mime) {
+                    return false;
+                }
+                if (l.outputs[k].data.byteLength !== r.outputs[k].data.byteLength) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    equal(b) {
+        if (this.language !== b.language) {
+            return false;
+        }
+        if (this.getTextLength() !== b.getTextLength()) {
+            return false;
+        }
+        if (!this.transientOptions.transientOutputs) {
+            if (!this._outputNotEqualFastCheck(this.outputs, b.outputs)) {
+                return false;
+            }
+        }
+        return this.getHashValue() === b.getHashValue();
+    }
+    fastEqual(b) {
+        if (this.language !== b.language) {
+            return false;
+        }
+        if (this.mime !== b.mime) {
+            return false;
+        }
+        if (this.cellKind !== b.cellKind) {
+            return false;
+        }
+        if (this.internalMetadata?.executionOrder !== b.internalMetadata?.executionOrder
+            || this.internalMetadata?.lastRunSuccess !== b.internalMetadata?.lastRunSuccess
+            || this.internalMetadata?.runStartTime !== b.internalMetadata?.runStartTime
+            || this.internalMetadata?.runStartTimeAdjustment !== b.internalMetadata?.runStartTimeAdjustment
+            || this.internalMetadata?.runEndTime !== b.internalMetadata?.runEndTime) {
+            return false;
+        }
+        if (this._textBuffer && this.getValue() !== b.source) {
+            return false;
+        }
+        else if (this._source !== b.source) {
+            return false;
+        }
+        return true;
+    }
+    dispose() {
+        dispose(this._outputs);
+        const emptyDisposedTextBuffer = ( new PieceTreeTextBuffer([], '', '\n', false, false, true, true));
+        emptyDisposedTextBuffer.dispose();
+        this._textBuffer = emptyDisposedTextBuffer;
+        super.dispose();
+    }
+}
+function cloneNotebookCellTextModel(cell) {
+    return {
+        source: cell.getValue(),
+        language: cell.language,
+        mime: cell.mime,
+        cellKind: cell.cellKind,
+        outputs: ( cell.outputs.map(output => ({
+            outputs: output.outputs,
+             outputId: UUID.generateUuid()
+        }))),
+        metadata: {}
+    };
+}
+function computeRunStartTimeAdjustment(oldMetadata, newMetadata) {
+    if (oldMetadata.runStartTime !== newMetadata.runStartTime && typeof newMetadata.runStartTime === 'number') {
+        const offset = Date.now() - newMetadata.runStartTime;
+        return offset < 0 ? Math.abs(offset) : 0;
+    }
+    else {
+        return newMetadata.runStartTimeAdjustment;
+    }
+}
+export { NotebookCellTextModel, cloneNotebookCellTextModel };

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

@@ -1,17 +1,56 @@
 import { encodeBase64, VSBuffer, decodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 const NOTEBOOK_EDITOR_ID = 'workbench.editor.notebook';
+const NOTEBOOK_DIFF_EDITOR_ID = 'workbench.editor.notebookTextDiffEditor';
+const INTERACTIVE_WINDOW_EDITOR_ID = 'workbench.editor.interactive';
 var CellKind;
 ( (function(CellKind) {
     CellKind[CellKind["Markup"] = 1] = "Markup";
     CellKind[CellKind["Code"] = 2] = "Code";
 })(CellKind || (CellKind = {})));
+const NOTEBOOK_DISPLAY_ORDER = [
+    'application/json',
+    'application/javascript',
+    'text/html',
+    'image/svg+xml',
+    Mimes.latex,
+    Mimes.markdown,
+    'image/png',
+    'image/jpeg',
+    Mimes.text
+];
+const ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER = [
+    Mimes.latex,
+    Mimes.markdown,
+    'application/json',
+    'text/html',
+    'image/svg+xml',
+    'image/png',
+    'image/jpeg',
+    Mimes.text,
+];
+const RENDERER_EQUIVALENT_EXTENSIONS = ( new Map([
+    ['ms-toolsai.jupyter', ( new Set(['jupyter-notebook', 'interactive']))],
+    ['ms-toolsai.jupyter-renderers', ( new Set(['jupyter-notebook', 'interactive']))],
+]));
+const RENDERER_NOT_AVAILABLE = '_notAvailable';
 var NotebookCellExecutionState;
 ( (function(NotebookCellExecutionState) {
     NotebookCellExecutionState[NotebookCellExecutionState["Unconfirmed"] = 1] = "Unconfirmed";
     NotebookCellExecutionState[NotebookCellExecutionState["Pending"] = 2] = "Pending";
     NotebookCellExecutionState[NotebookCellExecutionState["Executing"] = 3] = "Executing";
 })(NotebookCellExecutionState || (NotebookCellExecutionState = {})));
+var NotebookExecutionState;
+( (function(NotebookExecutionState) {
+    NotebookExecutionState[NotebookExecutionState["Unconfirmed"] = 1] = "Unconfirmed";
+    NotebookExecutionState[NotebookExecutionState["Pending"] = 2] = "Pending";
+    NotebookExecutionState[NotebookExecutionState["Executing"] = 3] = "Executing";
+})(NotebookExecutionState || (NotebookExecutionState = {})));
 var NotebookCellsChangeType;
 ( (function(NotebookCellsChangeType) {
     NotebookCellsChangeType[NotebookCellsChangeType["ModelChange"] = 1] = "ModelChange";
@@ -102,6 +141,118 @@ var CellUri;
     }
     CellUri.parseCellPropertyUri = parseCellPropertyUri;
 })(CellUri || (CellUri = {})));
+const normalizeSlashes = (str) => isWindows ? str.replace(/\//g, '\\') : str;
+class MimeTypeDisplayOrder {
+    constructor(initialValue = [], defaultOrder = NOTEBOOK_DISPLAY_ORDER) {
+        this.defaultOrder = defaultOrder;
+        this.order = ( [...( new Set(initialValue))].map(pattern => ({
+            pattern,
+            matches: glob.parse(normalizeSlashes(pattern))
+        })));
+    }
+    sort(mimetypes) {
+        const remaining = ( new Map(( Iterable.map(mimetypes, m => [m, normalizeSlashes(m)]))));
+        let sorted = [];
+        for (const { matches } of this.order) {
+            for (const [original, normalized] of remaining) {
+                if (matches(normalized)) {
+                    sorted.push(original);
+                    remaining.delete(original);
+                    break;
+                }
+            }
+        }
+        if (remaining.size) {
+            sorted = sorted.concat([...( remaining.keys())].sort((a, b) => this.defaultOrder.indexOf(a) - this.defaultOrder.indexOf(b)));
+        }
+        return sorted;
+    }
+    prioritize(chosenMimetype, otherMimetypes) {
+        const chosenIndex = this.findIndex(chosenMimetype);
+        if (chosenIndex === -1) {
+            this.order.unshift({ pattern: chosenMimetype, matches: glob.parse(normalizeSlashes(chosenMimetype)) });
+            return;
+        }
+        const uniqueIndicies = ( new Set(( otherMimetypes.map(m => this.findIndex(m, chosenIndex)))));
+        uniqueIndicies.delete(-1);
+        const otherIndices = Array.from(uniqueIndicies).sort();
+        this.order.splice(chosenIndex + 1, 0, ...( otherIndices.map(i => this.order[i])));
+        for (let oi = otherIndices.length - 1; oi >= 0; oi--) {
+            this.order.splice(otherIndices[oi], 1);
+        }
+    }
+    toArray() {
+        return ( this.order.map(o => o.pattern));
+    }
+    findIndex(mimeType, maxIndex = this.order.length) {
+        const normalized = normalizeSlashes(mimeType);
+        for (let i = 0; i < maxIndex; i++) {
+            if (this.order[i].matches(normalized)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+function diff(before, after, contains, equal = (a, b) => a === b) {
+    const result = [];
+    function pushSplice(start, deleteCount, toInsert) {
+        if (deleteCount === 0 && toInsert.length === 0) {
+            return;
+        }
+        const latest = result[result.length - 1];
+        if (latest && latest.start + latest.deleteCount === start) {
+            latest.deleteCount += deleteCount;
+            latest.toInsert.push(...toInsert);
+        }
+        else {
+            result.push({ start, deleteCount, toInsert });
+        }
+    }
+    let beforeIdx = 0;
+    let afterIdx = 0;
+    while (true) {
+        if (beforeIdx === before.length) {
+            pushSplice(beforeIdx, 0, after.slice(afterIdx));
+            break;
+        }
+        if (afterIdx === after.length) {
+            pushSplice(beforeIdx, before.length - beforeIdx, []);
+            break;
+        }
+        const beforeElement = before[beforeIdx];
+        const afterElement = after[afterIdx];
+        if (equal(beforeElement, afterElement)) {
+            beforeIdx += 1;
+            afterIdx += 1;
+            continue;
+        }
+        if (contains(afterElement)) {
+            pushSplice(beforeIdx, 1, []);
+            beforeIdx += 1;
+        }
+        else {
+            pushSplice(beforeIdx, 0, [afterElement]);
+            afterIdx += 1;
+        }
+    }
+    return result;
+}
+const NOTEBOOK_EDITOR_CURSOR_BOUNDARY = ( new RawContextKey('notebookEditorCursorAtBoundary', 'none'));
+const NOTEBOOK_EDITOR_CURSOR_LINE_BOUNDARY = ( new RawContextKey('notebookEditorCursorAtLineBoundary', 'none'));
+var NotebookEditorPriority;
+( (function(NotebookEditorPriority) {
+    NotebookEditorPriority["default"] = "default";
+    NotebookEditorPriority["option"] = "option";
+})(NotebookEditorPriority || (NotebookEditorPriority = {})));
+function isDocumentExcludePattern(filenamePattern) {
+    const arg = filenamePattern;
+    if ((typeof arg.include === 'string' || glob.isRelativePattern(arg.include))
+        && (typeof arg.exclude === 'string' || glob.isRelativePattern(arg.exclude))) {
+        return true;
+    }
+    return false;
+}
 const NotebookSetting = {
     displayOrder: 'notebook.displayOrder',
     cellToolbarLocation: 'notebook.cellToolbarLocation',
@@ -228,4 +379,4 @@ function formatStreamText(buffer) {
     }
     return VSBuffer.fromString(fixCarriageReturn(fixBackspace(textDecoder.decode(buffer.buffer))));
 }
-export { CellKind, CellUri, MOVE_CURSOR_1_LINE_COMMAND, NOTEBOOK_EDITOR_ID, NotebookCellExecutionState, NotebookCellsChangeType, NotebookSetting, NotebookWorkingCopyTypeIdentifier, SelectionStateType, compressOutputItemStreams, isTextStreamMime };
+export { ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, CellKind, CellUri, INTERACTIVE_WINDOW_EDITOR_ID, MOVE_CURSOR_1_LINE_COMMAND, MimeTypeDisplayOrder, NOTEBOOK_DIFF_EDITOR_ID, NOTEBOOK_DISPLAY_ORDER, NOTEBOOK_EDITOR_CURSOR_BOUNDARY, NOTEBOOK_EDITOR_CURSOR_LINE_BOUNDARY, NOTEBOOK_EDITOR_ID, NotebookCellExecutionState, NotebookCellsChangeType, NotebookEditorPriority, NotebookExecutionState, NotebookSetting, NotebookWorkingCopyTypeIdentifier, RENDERER_EQUIVALENT_EXTENSIONS, RENDERER_NOT_AVAILABLE, SelectionStateType, compressOutputItemStreams, diff, isDocumentExcludePattern, isTextStreamMime };

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

@@ -0,0 +1,39 @@
+import { RawContextKey, ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { NOTEBOOK_EDITOR_ID, INTERACTIVE_WINDOW_EDITOR_ID } from './notebookCommon.js';
+const HAS_OPENED_NOTEBOOK = ( new RawContextKey('userHasOpenedNotebook', false));
+const KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED = ( new RawContextKey('notebookFindWidgetFocused', false));
+const InteractiveWindowOpen = ( new RawContextKey('interactiveWindowOpen', false));
+const NOTEBOOK_IS_ACTIVE_EDITOR = ( ContextKeyExpr.equals('activeEditor', NOTEBOOK_EDITOR_ID));
+const INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR = ( ContextKeyExpr.equals('activeEditor', INTERACTIVE_WINDOW_EDITOR_ID));
+const NOTEBOOK_EDITOR_FOCUSED = ( new RawContextKey('notebookEditorFocused', false));
+const NOTEBOOK_CELL_LIST_FOCUSED = ( new RawContextKey('notebookCellListFocused', false));
+const NOTEBOOK_OUTPUT_FOCUSED = ( new RawContextKey('notebookOutputFocused', false));
+const NOTEBOOK_OUPTUT_INPUT_FOCUSED = ( new RawContextKey('notebookOutputInputFocused', false));
+const NOTEBOOK_EDITOR_EDITABLE = ( new RawContextKey('notebookEditable', true));
+const NOTEBOOK_HAS_RUNNING_CELL = ( new RawContextKey('notebookHasRunningCell', false));
+const NOTEBOOK_HAS_SOMETHING_RUNNING = ( new RawContextKey('notebookHasSomethingRunning', false));
+const NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON = ( new RawContextKey('notebookUseConsolidatedOutputButton', false));
+const NOTEBOOK_CELL_TOOLBAR_LOCATION = ( new RawContextKey('notebookCellToolbarLocation', 'left'));
+const NOTEBOOK_CURSOR_NAVIGATION_MODE = ( new RawContextKey('notebookCursorNavigationMode', false));
+const NOTEBOOK_LAST_CELL_FAILED = ( new RawContextKey('notebookLastCellFailed', false));
+const NOTEBOOK_VIEW_TYPE = ( new RawContextKey('notebookType', undefined));
+const NOTEBOOK_CELL_TYPE = ( new RawContextKey('notebookCellType', undefined));
+const NOTEBOOK_CELL_EDITABLE = ( new RawContextKey('notebookCellEditable', false));
+const NOTEBOOK_CELL_FOCUSED = ( new RawContextKey('notebookCellFocused', false));
+const NOTEBOOK_CELL_EDITOR_FOCUSED = ( new RawContextKey('notebookCellEditorFocused', false));
+const NOTEBOOK_CELL_MARKDOWN_EDIT_MODE = ( new RawContextKey('notebookCellMarkdownEditMode', false));
+const NOTEBOOK_CELL_LINE_NUMBERS = ( new RawContextKey('notebookCellLineNumbers', 'inherit'));
+const NOTEBOOK_CELL_EXECUTION_STATE = ( new RawContextKey('notebookCellExecutionState', undefined));
+const NOTEBOOK_CELL_EXECUTING = ( new RawContextKey('notebookCellExecuting', false));
+const NOTEBOOK_CELL_HAS_OUTPUTS = ( new RawContextKey('notebookCellHasOutputs', false));
+const NOTEBOOK_CELL_INPUT_COLLAPSED = ( new RawContextKey('notebookCellInputIsCollapsed', false));
+const NOTEBOOK_CELL_OUTPUT_COLLAPSED = ( new RawContextKey('notebookCellOutputIsCollapsed', false));
+const NOTEBOOK_CELL_RESOURCE = ( new RawContextKey('notebookCellResource', ''));
+const NOTEBOOK_KERNEL = ( new RawContextKey('notebookKernel', undefined));
+const NOTEBOOK_KERNEL_COUNT = ( new RawContextKey('notebookKernelCount', 0));
+const NOTEBOOK_KERNEL_SOURCE_COUNT = ( new RawContextKey('notebookKernelSourceCount', 0));
+const NOTEBOOK_KERNEL_SELECTED = ( new RawContextKey('notebookKernelSelected', false));
+const NOTEBOOK_INTERRUPTIBLE_KERNEL = ( new RawContextKey('notebookInterruptibleKernel', false));
+const NOTEBOOK_MISSING_KERNEL_EXTENSION = ( new RawContextKey('notebookMissingKernelExtension', false));
+const NOTEBOOK_HAS_OUTPUTS = ( new RawContextKey('notebookHasOutputs', false));
+export { HAS_OPENED_NOTEBOOK, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR, InteractiveWindowOpen, KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED, NOTEBOOK_CELL_EDITABLE, NOTEBOOK_CELL_EDITOR_FOCUSED, NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_EXECUTION_STATE, NOTEBOOK_CELL_FOCUSED, NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_CELL_INPUT_COLLAPSED, NOTEBOOK_CELL_LINE_NUMBERS, NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_OUTPUT_COLLAPSED, NOTEBOOK_CELL_RESOURCE, NOTEBOOK_CELL_TOOLBAR_LOCATION, NOTEBOOK_CELL_TYPE, NOTEBOOK_CURSOR_NAVIGATION_MODE, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_HAS_OUTPUTS, NOTEBOOK_HAS_RUNNING_CELL, NOTEBOOK_HAS_SOMETHING_RUNNING, NOTEBOOK_INTERRUPTIBLE_KERNEL, NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_KERNEL, NOTEBOOK_KERNEL_COUNT, NOTEBOOK_KERNEL_SELECTED, NOTEBOOK_KERNEL_SOURCE_COUNT, NOTEBOOK_LAST_CELL_FAILED, NOTEBOOK_MISSING_KERNEL_EXTENSION, NOTEBOOK_OUPTUT_INPUT_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED, NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON, NOTEBOOK_VIEW_TYPE };