@jupyterlab/notebook

constructor

constructor(model: ISharedNotebook);

• Construct the cell list.

property changed

readonly changed: ISignal<this, IObservableList.IChangedArgs<ICellModel>>;

• A signal emitted when the cell list has changed.

property isDisposed

readonly isDisposed: boolean;

• Test whether the cell list has been disposed.

property length

readonly length: number;

• Get the length of the cell list.

  Returns

  The number of cells in the cell list.

property model

protected model: ISharedNotebook;

method [Symbol.iterator]

[Symbol.iterator]: () => IterableIterator<ICellModel>;

• Create an iterator over the cells in the cell list.

  Returns

  A new iterator starting at the front of the cell list.

method dispose

dispose: () => void;

• Dispose of the resources held by the cell list.

method get

get: (index: number) => ICellModel;

• Get the cell at the specified index.

  Parameter index

  The positive integer index of interest.

  Returns

  The cell at the specified index.

constructor

constructor(widget: Notebook, translator?: ITranslator);

• Construct a new cell type switcher.

property handleChange

handleChange: (event: React.ChangeEvent<HTMLSelectElement>) => void;

• Handle change events for the HTMLSelect component.

property handleKeyDown

handleKeyDown: (event: React.KeyboardEvent) => void;

• Handle keydown events for the HTMLSelect component.

method render

render: () => JSX.Element;

constructor

constructor(translator?: ITranslator);

• Construct a new CommandEdit status item.

property translator

protected translator: ITranslator;

method render

render: () => JSX.Element | null;

• Render the CommandEdit status item.

constructor

constructor(translator?: ITranslator, showProgress?: boolean);

• Construct the kernel status widget.

method render

render: () => JSX.Element | null;

• Render the execution status item.

constructor

constructor(content: KernelMessage.IExecuteReplyMsg);

• Construct the kernel error.

property errorName

readonly errorName: string;

• Exception name

property errorValue

readonly errorValue: string;

• Exception value

property traceback

readonly traceback: string[];

• Traceback

constructor

constructor(options: Notebook.IOptions);

• Construct a notebook widget.

property activeCell

readonly activeCell: any;

• Get the active cell widget.

  #### Notes This is a cell or null if there is no active cell.

property activeCellChanged

readonly activeCellChanged: ISignal<this, any>;

• A signal emitted when the active cell changes.

  #### Notes This can be due to the active index changing or the cell at the active index changing.

property activeCellIndex

activeCellIndex: number;

• The active cell index of the notebook.

  #### Notes The index will be clamped to the bounds of the notebook cells.

property lastClipboardInteraction

lastClipboardInteraction: 'copy' | 'cut' | 'paste';

property mode

mode: NotebookMode;

• The interactivity mode of the notebook.

property selectedCells

readonly selectedCells: Cell[];

• List of selected and active cells

property selectionChanged

readonly selectionChanged: ISignal<this, void>;

• A signal emitted when the selection state of the notebook changes.

property stateChanged

readonly stateChanged: ISignal<this, IChangedArgs<any>>;

• A signal emitted when the state of the notebook changes.

method addFooter

protected addFooter: () => void;

• Adds a footer to the notebook.

method deselect

deselect: (widget: Cell) => void;

• Deselect a cell widget.

  #### Notes It is a no-op if the value does not change. It will emit the selectionChanged signal.

method deselectAll

deselectAll: () => void;

• Deselect all of the cells.

method dispose

dispose: () => void;

• Dispose of the resources held by the widget.

method extendContiguousSelectionTo

extendContiguousSelectionTo: (index: number) => void;

• Move the head of an existing contiguous selection to extend the selection.

  Parameter index

  The new head of the existing selection.

  #### Notes If there is no existing selection, the active cell is considered an existing one-cell selection.

  If the new selection is a single cell, that cell becomes the active cell and all cells are deselected.

  There is no change if there are no cells (i.e., activeCellIndex is -1).

method getContiguousSelection

getContiguousSelection: () =>
    | { head: number; anchor: number }
    | { head: null; anchor: null };

• Get the head and anchor of a contiguous cell selection.

  The head of a contiguous selection is always the active cell.

  If there are no cells selected, {head: null, anchor: null} is returned.

  Throws an error if the currently selected cells do not form a contiguous selection.

method handleEvent

handleEvent: (event: Event) => void;

• Handle the DOM events for the widget.

  Parameter event

  The DOM event sent to the widget.

  #### Notes This method implements the DOM EventListener interface and is called in response to events on the notebook panel's node. It should not be called directly by user code.

method isSelected

isSelected: (widget: Cell) => boolean;

• Whether a cell is selected.

method isSelectedOrActive

isSelectedOrActive: (widget: Cell) => boolean;

• Whether a cell is selected or is the active cell.

method moveCell

moveCell: (from: number, to: number, n?: number) => void;

• Move cells preserving widget view state.

  #### Notes This is required because at the model level a move is a deletion followed by an insertion. Hence the view state is not preserved.

  Parameter from

  The index of the cell to move

  Parameter to

  The new index of the cell

  Parameter n

  Number of cells to move

method onActivateRequest

protected onActivateRequest: (msg: Message) => void;

• Handle 'activate-request' messages.

method onAfterAttach

protected onAfterAttach: (msg: Message) => void;

• Handle after-attach messages for the widget.

method onAfterShow

protected onAfterShow: (msg: Message) => void;

• A message handler invoked on an 'after-show' message.

method onBeforeDetach

protected onBeforeDetach: (msg: Message) => void;

• Handle before-detach messages for the widget.

method onBeforeHide

protected onBeforeHide: (msg: Message) => void;

• A message handler invoked on an 'before-hide' message.

method onCellInserted

protected onCellInserted: (index: number, cell: Cell) => void;

• Handle a cell being inserted.

method onCellRemoved

protected onCellRemoved: (index: number, cell: Cell) => void;

• Handle a cell being removed.

method onModelChanged

protected onModelChanged: (
    oldValue: INotebookModel,
    newValue: INotebookModel
) => void;

• Handle a new model.

method onResize

protected onResize: (msg: Widget.ResizeMessage) => void;

• A message handler invoked on a 'resize' message.

method onUpdateRequest

protected onUpdateRequest: (msg: Message) => void;

• Handle update-request messages sent to the widget.

method scrollToCell

scrollToCell: (cell: Cell, align?: WindowedList.ScrollToAlign) => Promise<void>;

• Scroll so that the given cell is in view. Selects and activates cell.

  Parameter cell

  A cell in the notebook widget.

  Parameter align

  Type of alignment.

method select

select: (widget: Cell) => void;

• Select a cell widget.

  #### Notes It is a no-op if the value does not change. It will emit the selectionChanged signal.

method setFragment

setFragment: (fragment: string) => Promise<void>;

• Set URI fragment identifier.

method setMode

protected setMode: (
    newValue: NotebookMode,
    options?: { focus?: boolean }
) => void;

• Set the notebook mode.

  Parameter newValue

  Notebook mode

  Parameter options

  Control mode side-effect

  Parameter

  options.focus Whether to ensure focus (default) or not when setting the mode.

property executed

static readonly executed: ISignal<
    any,
    {
        notebook: Notebook;
        cell: Cell;
        success: boolean;
        error?: KernelError | null;
    }
>;

• A signal that emits whenever a cell completes execution.

property executionScheduled

static readonly executionScheduled: ISignal<
    any,
    { notebook: Notebook; cell: Cell }
>;

• A signal that emits whenever a cell execution is scheduled.

property outputCleared

static readonly outputCleared: ISignal<any, { notebook: Notebook; cell: Cell }>;

• A signal that emits when a cell's output is cleared.

property selectionExecuted

static readonly selectionExecuted: ISignal<
    any,
    { notebook: Notebook; lastCell: Cell }
>;

• A signal that emits when one notebook's cells are all executed.

constructor

constructor(editorWidget: NotebookPanel, options: IAdapterOptions);

property activeEditor

readonly activeEditor: any;

• Get the activated CM editor.

property documentPath

readonly documentPath: string;

• Get current path of the document.

property editor

readonly editor: Notebook;

• The wrapped Notebook widget.

property editors

readonly editors: Document.ICodeBlockOptions[];

• Get the list of CM editor with its type in the document,

property editorWidget

editorWidget: NotebookPanel;

property languageFileExtension

readonly languageFileExtension: string;

• Get the file extension of the document.

property mimeType

readonly mimeType: string;

• Get the mime type of the document.

property options

protected options: IAdapterOptions;

property ready

readonly ready: Promise<void>;

• Promise that resolves once the adapter is initialized

property wrapperElement

readonly wrapperElement: HTMLElement;

• Get the inner HTMLElement of the document widget.

method createVirtualDocument

createVirtualDocument: () => VirtualDocument;

• Generate the virtual document associated with the document.

method dispose

dispose: () => void;

• Dispose the widget.

method getEditorIndex

getEditorIndex: (ceEditor: Document.IEditor) => number;

• Get the index of input editor

  Parameter ceEditor

  instance of the code editor

method getEditorIndexAt

getEditorIndexAt: (position: IVirtualPosition) => number;

• Get the index of editor from the cursor position in the virtual document.

  Parameter position

  the position of cursor in the virtual document.

  Deprecated

  This is error-prone and will be removed in JupyterLab 5.0, use getEditorIndex() with virtualDocument.getEditorAtVirtualLine(position) instead.

method getEditorWrapper

getEditorWrapper: (ceEditor: Document.IEditor) => HTMLElement;

• Get the wrapper of input editor.

  Parameter ceEditor

  instance of the code editor

method handleCellChange

handleCellChange: (
    cells: CellList,
    change: IObservableList.IChangedArgs<ICellModel>
) => Promise<void>;

• Update the virtual document on cell changing event.

  Parameter cells

  Observable list of changed cells

  Parameter change

  Changed data

method initOnceReady

protected initOnceReady: () => Promise<void>;

• Initialization function called once the editor and the LSP connection manager is ready. This function will create the virtual document and connect various signals.

method isReady

isReady: () => boolean;

• Method to check if the notebook context is ready.

method language_info

protected language_info: () => nbformat.ILanguageInfoMetadata;

• Get the metadata of notebook.

method onKernelChanged

onKernelChanged: (
    _session: SessionContext,
    change: Session.ISessionConnection.IKernelChangedArgs
) => Promise<void>;

• Callback on kernel changed event, it will disconnect the document with the language server and then reconnect.

  Parameter _session

  Session context of changed kernel

  Parameter change

  Changed data

constructor

constructor(options: NotebookHistory.IOptions);

• Construct a new console history object.

property editor

editor: any;

• The current editor used by the history manager.

property isDisposed

readonly isDisposed: boolean;

• Get whether the notebook history manager is disposed.

property kernelSession

readonly kernelSession: string;

• Kernel session number for filtering

property placeholder

readonly placeholder: string;

• The placeholder text that a history session began with.

method back

back: (activeCell: Cell) => Promise<string | undefined>;

• Get the previous item in the notebook history.

  Parameter activeCell

  The currently selected Cell in the notebook.

  Returns

  A Promise resolving to the historical cell content text.

method checkSession

protected checkSession: (activeCell: Cell) => Promise<void>;

• Set placeholder and editor. Start session if one is not already started.

  Parameter activeCell

  The currently selected Cell in the notebook.

method dispose

dispose: () => void;

• Dispose of the resources held by the notebook history manager.

method forward

forward: (activeCell: Cell) => Promise<string | undefined>;

• Get the next item in the notebook history.

  Parameter activeCell

  The currently selected Cell in the notebook.

  Returns

  A Promise resolving to the historical cell content text.

method onHistory

protected onHistory: (
    value: KernelMessage.IHistoryReplyMsg,
    cell?: Cell
) => void;

• Populate the history collection on history reply from a kernel.

  Parameter value

  The kernel message history reply.

  #### Notes History entries have the shape: [session: number, line: number, input: string] Contiguous duplicates are stripped out of the API response.

method onTextChange

protected onTextChange: () => void;

• Handle a text change signal from the editor.

method reset

reset: () => void;

• Reset the history navigation state, i.e., start a new history session.

method setFilter

protected setFilter: (filterStr?: string) => void;

• Set the filter data.

  Parameter filterStr

  The string to use when filtering the data.

method updateEditor

updateEditor: (activeCell: Cell, content: string | undefined) => void;

• Update the editor of the cell with provided text content.

  Parameter activeCell

  The currently selected Cell in the notebook.

  Parameter content

  the result from back or forward

constructor

constructor(options?: NotebookModel.IOptions);

• Construct a new notebook model.

property cells

readonly cells: CellList;

• Get the observable list of notebook cells.

property collaborative

readonly collaborative: boolean;

• Whether the model is collaborative or not.

property contentChanged

readonly contentChanged: ISignal<this, void>;

• A signal emitted when the document content changes.

property defaultKernelLanguage

readonly defaultKernelLanguage: string;

• The default kernel language of the document.

property defaultKernelName

readonly defaultKernelName: string;

• The default kernel name of the document.

property deletedCells

readonly deletedCells: string[];

• A list of deleted cells for the notebook..

property dirty

dirty: boolean;

• The dirty state of the document.

property isDisposed

readonly isDisposed: boolean;

• Whether the model is disposed.

property metadata

readonly metadata: nbformat.INotebookMetadata;

• The metadata associated with the notebook.

  ### Notes This is a copy of the metadata. Changing a part of it won't affect the model. As this returns a copy of all metadata, it is advised to use getMetadata to speed up the process of getting a single key.

property metadataChanged

readonly metadataChanged: ISignal<INotebookModel, IMapChange<any>>;

• Signal emitted when notebook metadata changes.

property nbformat

readonly nbformat: number;

• The major version number of the nbformat.

property nbformatMinor

readonly nbformatMinor: number;

• The minor version number of the nbformat.

property readOnly

readOnly: boolean;

• The read only state of the document.

property sharedModel

readonly sharedModel: ISharedNotebook;

• The shared notebook model.

property standaloneModel

protected standaloneModel: boolean;

• Whether the model should disposed the shared model on disposal or not.

property stateChanged

readonly stateChanged: ISignal<this, IChangedArgs<any>>;

• A signal emitted when the document state changes.

method deleteMetadata

deleteMetadata: (key: string) => void;

• Delete a metadata

  Parameter key

  Metadata key

method dispose

dispose: () => void;

• Dispose of the resources held by the model.

method fromJSON

fromJSON: (value: nbformat.INotebookContent) => void;

• Deserialize the model from JSON.

  #### Notes Should emit a [contentChanged] signal.

method fromString

fromString: (value: string) => void;

• Deserialize the model from a string.

  #### Notes Should emit a [contentChanged] signal.

method getMetadata

getMetadata: (key: string) => any;

• Get a metadata

  ### Notes This returns a copy of the key value.

  Parameter key

  Metadata key

method setMetadata

setMetadata: (key: string, value: any) => void;

• Set a metadata

  Parameter key

  Metadata key

  Parameter value

  Metadata value

method toJSON

toJSON: () => nbformat.INotebookContent;

• Serialize the model to JSON.

method toString

toString: () => string;

• Serialize the model to a string.

method triggerContentChange

protected triggerContentChange: () => void;

• Trigger a content changed signal.

method triggerStateChange

protected triggerStateChange: (args: IChangedArgs<any>) => void;

• Trigger a state change signal.

constructor

constructor(options?: NotebookModelFactory.IOptions);

• Construct a new notebook model factory.

property collaborative

readonly collaborative: boolean;

• Whether the model is collaborative or not.

property contentType

readonly contentType: Contents.ContentType;

• The content type of the file.

property disableDocumentWideUndoRedo

disableDocumentWideUndoRedo: boolean;

• Define the disableDocumentWideUndoRedo property.

  Modifiers

  • @experimental
  • @alpha

property fileFormat

readonly fileFormat: Contents.FileFormat;

• The format of the file.

property isDisposed

readonly isDisposed: boolean;

• Get whether the model factory has been disposed.

property name

readonly name: string;

• The name of the model.

method createNew

createNew: (
    options?: DocumentRegistry.IModelOptions<ISharedNotebook>
) => INotebookModel;

• Create a new model for a given path.

  Parameter options

  Model options.

  Returns

  A new document model.

method dispose

dispose: () => void;

• Dispose of the model factory.

method preferredLanguage

preferredLanguage: (path: string) => string;

• Get the preferred kernel language given a path.

constructor

constructor(options: DocumentWidget.IOptions<Notebook, INotebookModel>);

• Construct a new notebook panel.

property model

readonly model: INotebookModel;

• The model for the widget.

property sessionContext

readonly sessionContext: ISessionContext;

• The session context used by the panel.

property translator

translator: ITranslator;

method [Printing.symbol]

[Printing.symbol]: () => () => Promise<void>;

• Prints the notebook by converting to HTML with nbconvert.

method dispose

dispose: () => void;

• Dispose of the resources used by the widget.

method onBeforeHide

protected onBeforeHide: (msg: Message) => void;

• A message handler invoked on a 'before-hide' message.

method onBeforeShow

protected onBeforeShow: (msg: Message) => void;

• A message handler invoked on a 'before-show' message.

method setConfig

setConfig: (config: NotebookPanel.IConfig) => void;

• Update the options for the current notebook panel.

  Parameter config

  new options to set

method setFragment

setFragment: (fragment: string) => void;

• Set URI fragment identifier.

constructor

constructor(widget: NotebookPanel, translator?: ITranslator);

• Constructor

  Parameter widget

  The widget to search in

  Parameter translator

  Application translator

property currentMatchIndex

readonly currentMatchIndex: number;

• The current index of the selected match.

property delayedActiveCellChangeHandlerReady

protected delayedActiveCellChangeHandlerReady: Promise<void>;

property isReadOnly

readonly isReadOnly: boolean;

• Set to true if the widget under search is read-only, false if it is editable. Will be used to determine whether to show the replace option.

property matchesCount

readonly matchesCount: number;

• The number of matches.

property replaceOptionsSupport

readonly replaceOptionsSupport: IReplaceOptionsSupport;

• Support for options adjusting replacement behavior.

property translator

protected translator: ITranslator;

method clearHighlight

clearHighlight: () => Promise<void>;

• Clear currently highlighted match.

method createNew

static createNew: (
    widget: NotebookPanel,
    translator?: ITranslator
) => ISearchProvider;

• Instantiate a search provider for the notebook panel.

  #### Notes The widget provided is always checked using isApplicable before calling this factory.

  Parameter widget

  The widget to search on

  Parameter translator

  [optional] The translator object

  Returns

  The search provider on the notebook panel

method dispose

dispose: () => void;

• Dispose of the resources held by the search provider.

  #### Notes If the object's dispose method is called more than once, all calls made after the first will be a no-op.

  #### Undefined Behavior It is undefined behavior to use any functionality of the object after it has been disposed unless otherwise explicitly noted.

method endQuery

endQuery: () => Promise<void>;

• Stop the search and clear all internal state.

method getFilters

getFilters: () => { [key: string]: IFilter };

• Get the filters for the given provider.

  Returns

  The filters.

method getInitialQuery

getInitialQuery: () => string;

• Get an initial query value if applicable so that it can be entered into the search box as an initial query

  Returns

  Initial value used to populate the search box.

method getSelectionState

getSelectionState: () => SelectionState;

method highlightNext

highlightNext: (
    loop?: boolean,
    options?: IHighlightAdjacentMatchOptions
) => Promise<ISearchMatch | undefined>;

• Highlight the next match.

  Parameter loop

  Whether to loop within the matches list.

  Returns

  The next match if available.

method highlightPrevious

highlightPrevious: (
    loop?: boolean,
    options?: IHighlightAdjacentMatchOptions
) => Promise<ISearchMatch | undefined>;

• Highlight the previous match.

  Parameter loop

  Whether to loop within the matches list.

  Returns

  The previous match if available.

method isApplicable

static isApplicable: (domain: Widget) => domain is NotebookPanel;

• Report whether or not this provider has the ability to search on the given object

  Parameter domain

  Widget to test

  Returns

  Search ability

method replaceAllMatches

replaceAllMatches: (
    newText: string,
    options?: IReplaceOptions
) => Promise<boolean>;

• Replace all matches in the notebook with the provided text

  Parameter newText

  The replacement text.

  Returns

  A promise that resolves with a boolean indicating whether a replace occurred.

method replaceCurrentMatch

replaceCurrentMatch: (
    newText: string,
    loop?: boolean,
    options?: IReplaceOptions
) => Promise<boolean>;

• Replace the currently selected match with the provided text

  Parameter newText

  The replacement text.

  Parameter loop

  Whether to loop within the matches list.

  Returns

  A promise that resolves with a boolean indicating whether a replace occurred.

method startQuery

startQuery: (query: RegExp, filters: IFilters | undefined) => Promise<void>;

• Search for a regular expression with optional filters.

  Parameter query

  A regular expression to test for

  Parameter filters

  Filter parameters to pass to provider

method validateFilter

validateFilter: (name: string, value: boolean) => Promise<boolean>;

constructor

constructor(
    tracker: INotebookTracker,
    parser: any,
    sanitizer: IRenderMime.ISanitizer
);

• Constructor

  Parameter tracker

  Widget tracker

  Parameter parser

  Markdown parser

  Parameter sanitizer

  Sanitizer

property parser

protected parser: any;

property sanitizer

protected sanitizer: IRenderMime.ISanitizer;

property scrollToTop

scrollToTop: boolean;

• Whether to scroll the active heading to the top of the document or not.

constructor

constructor(
    widget: NotebookPanel,
    parser: any,
    sanitizer: IRenderMime.ISanitizer,
    configuration?: TableOfContents.IConfig
);

• Constructor

  Parameter widget

  The widget to search in

  Parameter parser

  Markdown parser

  Parameter sanitizer

  Sanitizer

  Parameter configuration

  Default model configuration

property configMetadataMap

protected configMetadataMap: {
    [k: string]: string[];
    [k: number]: string[];
    [k: symbol]: string[];
};

• Mapping between configuration options and notebook metadata.

  If it starts with !, the boolean value of the configuration option is opposite to the one stored in metadata. If it contains /, the metadata data is nested.

property documentType

readonly documentType: string;

• Type of document supported by the model.

  #### Notes A data-document-type attribute with this value will be set on the tree view .jp-TableOfContents-content[data-document-type="..."]

property isAlwaysActive

readonly isAlwaysActive: boolean;

• Whether the model gets updated even if the table of contents panel is hidden or not.

property parser

protected parser: any;

property sanitizer

protected sanitizer: IRenderMime.ISanitizer;

property supportedOptions

readonly supportedOptions: (string | number | symbol)[];

• List of configuration options supported by the model.

method dispose

dispose: () => void;

• Dispose the object

method getCellHeadings

getCellHeadings: (cell: Cell) => INotebookHeading[];

• Get the headings of a given cell.

  Parameter cell

  Cell

  Returns

  The associated headings

method getHeadings

protected getHeadings: () => Promise<INotebookHeading[] | null>;

• Produce the headings for a document.

  Returns

  The list of new headings or null if nothing needs to be updated.

method isHeadingEqual

protected isHeadingEqual: (
    heading1: INotebookHeading,
    heading2: INotebookHeading
) => boolean;

• Test if two headings are equal or not.

  Parameter heading1

  First heading

  Parameter heading2

  Second heading

  Returns

  Whether the headings are equal.

method loadConfigurationFromMetadata

protected loadConfigurationFromMetadata: () => TableOfContents.IConfig;

• Read table of content configuration from notebook metadata.

  Returns

  ToC configuration from metadata

method onActiveCellChanged

protected onActiveCellChanged: (
    notebook: Notebook,
    cell: Cell<ICellModel>
) => void;

method onExecuted

protected onExecuted: (
    _: unknown,
    args: {
        notebook: Notebook;
        cell: Cell;
        success: boolean;
        error: KernelError | null;
    }
) => void;

method onExecutionScheduled

protected onExecutionScheduled: (
    _: unknown,
    args: { notebook: Notebook; cell: Cell }
) => void;

method onHeadingsChanged

protected onHeadingsChanged: () => void;

method onMetadataChanged

protected onMetadataChanged: () => void;

method onOutputCleared

protected onOutputCleared: (
    _: unknown,
    args: { notebook: Notebook; cell: Cell }
) => void;

method setConfiguration

setConfiguration: (c: TableOfContents.IConfig) => void;

• Model configuration setter.

  Parameter c

  New configuration

method toggleCollapse

toggleCollapse: (options: {
    heading?: INotebookHeading;
    collapsed?: boolean;
}) => void;

• Callback on heading collapse.

  Parameter

  options.heading The heading to change state (all headings if not provided)

  Parameter

  options.collapsed The new collapsed status (toggle existing status if not provided)

method updateRunningStatus

protected updateRunningStatus: (headings: INotebookHeading[]) => void;

constructor

constructor(options: NotebookTools.IOptions);

• Construct a new NotebookTools object.

property activeCell

readonly activeCell: any;

• The active cell widget.

property activeNotebookPanel

readonly activeNotebookPanel: NotebookPanel;

• The current notebook.

property selectedCells

readonly selectedCells: Cell[];