xterm

constructor

constructor(options?: ITerminalOptions & ITerminalInitOnlyOptions);

• Creates a new Terminal object.

  Parameter options

  An object containing a set of options.

property buffer

readonly buffer: IBufferNamespace;

• Access to the terminal's normal and alt buffer.

property cols

readonly cols: number;

• The number of columns in the terminal's viewport. Use ITerminalOptions.cols to set this in the constructor and Terminal.resize for when the terminal exists.

property element

readonly element: HTMLElement;

• The element containing the terminal.

property markers

readonly markers: readonly IMarker[];

• (EXPERIMENTAL) Get all markers registered against the buffer. If the alt buffer is active this will always return [].

property modes

readonly modes: IModes;

• Gets the terminal modes as set by SM/DECSET.

property onBell

onBell: IEvent<void, void>;

• Adds an event listener for when the bell is triggered.

  Returns

  an IDisposable to stop listening.

property onBinary

onBinary: IEvent<string, void>;

• Adds an event listener for when a binary event fires. This is used to enable non UTF-8 conformant binary messages to be sent to the backend. Currently this is only used for a certain type of mouse reports that happen to be not UTF-8 compatible. The event value is a JS string, pass it to the underlying pty as binary data, e.g. pty.write(Buffer.from(data, 'binary')).

  Returns

  an IDisposable to stop listening.

property onCursorMove

onCursorMove: IEvent<void, void>;

• Adds an event listener for the cursor moves.

  Returns

  an IDisposable to stop listening.

property onData

onData: IEvent<string, void>;

• Adds an event listener for when a data event fires. This happens for example when the user types or pastes into the terminal. The event value is whatever string results, in a typical setup, this should be passed on to the backing pty.

  Returns

  an IDisposable to stop listening.

property onKey

onKey: IEvent<{ key: string; domEvent: KeyboardEvent }, void>;

• Adds an event listener for when a key is pressed. The event value contains the string that will be sent in the data event as well as the DOM event that triggered it.

  Returns

  an IDisposable to stop listening.

property onLineFeed

onLineFeed: IEvent<void, void>;

• Adds an event listener for when a line feed is added.

  Returns

  an IDisposable to stop listening.

property onRender

onRender: IEvent<{ start: number; end: number }, void>;

• Adds an event listener for when rows are rendered. The event value contains the start row and end rows of the rendered area (ranges from 0 to Terminal.rows - 1).

  Returns

  an IDisposable to stop listening.

property onResize

onResize: IEvent<{ cols: number; rows: number }, void>;

• Adds an event listener for when the terminal is resized. The event value contains the new size.

  Returns

  an IDisposable to stop listening.

property onScroll

onScroll: IEvent<number, void>;

• Adds an event listener for when a scroll occurs. The event value is the new position of the viewport.

  Returns

  an IDisposable to stop listening.

property onSelectionChange

onSelectionChange: IEvent<void, void>;

• Adds an event listener for when a selection change occurs.

  Returns

  an IDisposable to stop listening.

property onTitleChange

onTitleChange: IEvent<string, void>;

• Adds an event listener for when an OSC 0 or OSC 2 title change occurs. The event value is the new title.

  Returns

  an IDisposable to stop listening.

property onWriteParsed

onWriteParsed: IEvent<void, void>;

• Adds an event listener for when data has been parsed by the terminal, after write is called. This event is useful to listen for any changes in the buffer.

  This fires at most once per frame, after data parsing completes. Note that this can fire when there are still writes pending if there is a lot of data.

property options

options: ITerminalOptions;

• Gets or sets the terminal options. This supports setting multiple options.

  Example 1

  Get a single option

  console.log(terminal.options.fontSize);

  Example 2

  Set a single option:

  terminal.options.fontSize = 12;

  Note that for options that are object, a new object must be used in order to take effect as a reference comparison will be done:

  const newValue = terminal.options.theme;
  newValue.background = '#000000';
  
  // This won't work
  terminal.options.theme = newValue;
  
  // This will work
  terminal.options.theme = { ...newValue };

  Example 3

  Set multiple options

  terminal.options = {
    fontSize: 12,
    fontFamily: 'Courier New'
  };

property parser

readonly parser: IParser;

• Get the parser interface to register custom escape sequence handlers.

property rows

readonly rows: number;

• The number of rows in the terminal's viewport. Use ITerminalOptions.rows to set this in the constructor and Terminal.resize for when the terminal exists.

property strings

static strings: ILocalizableStrings;

• Natural language strings that can be localized.

property textarea

readonly textarea: HTMLTextAreaElement;

• The textarea that accepts input for the terminal.

property unicode

readonly unicode: IUnicodeHandling;

• (EXPERIMENTAL) Get the Unicode handling interface to register and switch Unicode version.

method attachCustomKeyEventHandler

attachCustomKeyEventHandler: (
    customKeyEventHandler: (event: KeyboardEvent) => boolean
) => void;

• Attaches a custom key event handler which is run before keys are processed, giving consumers of xterm.js ultimate control as to what keys should be processed by the terminal and what keys should not.

  Parameter customKeyEventHandler

  The custom KeyboardEvent handler to attach. This is a function that takes a KeyboardEvent, allowing consumers to stop propagation and/or prevent the default action. The function returns whether the event should be processed by xterm.js.

  Example 1

  A custom keymap that overrides the backspace key

  const keymap = [
    { "key": "Backspace", "shiftKey": false, "mapCode": 8 },
    { "key": "Backspace", "shiftKey": true, "mapCode": 127 }
  ];
  term.attachCustomKeyEventHandler(ev => {
    if (ev.type === 'keydown') {
      for (let i in keymap) {
        if (keymap[i].key == ev.key && keymap[i].shiftKey == ev.shiftKey) {
          socket.send(String.fromCharCode(keymap[i].mapCode));
          return false;
        }
      }
    }
  });

method blur

blur: () => void;

• Unfocus the terminal.

method clear

clear: () => void;

• Clear the entire buffer, making the prompt line the new first line.

method clearSelection

clearSelection: () => void;

• Clears the current terminal selection.

method clearTextureAtlas

clearTextureAtlas: () => void;

• Clears the texture atlas of the canvas renderer if it's active. Doing this will force a redraw of all glyphs which can workaround issues causing the texture to become corrupt, for example Chromium/Nvidia has an issue where the texture gets messed up when resuming the OS from sleep.

method deregisterCharacterJoiner

deregisterCharacterJoiner: (joinerId: number) => void;

• (EXPERIMENTAL) Deregisters the character joiner if one was registered. NOTE: character joiners are only used by the canvas renderer.

  Parameter joinerId

  The character joiner's ID (returned after register)

method dispose

dispose: () => void;

method focus

focus: () => void;

• Focus the terminal.

method getSelection

getSelection: () => string;

• Gets the terminal's current selection, this is useful for implementing copy behavior outside of xterm.js.

method getSelectionPosition

getSelectionPosition: () => IBufferRange | undefined;

• Gets the selection position or undefined if there is no selection.

method hasSelection

hasSelection: () => boolean;

• Gets whether the terminal has an active selection.

method loadAddon

loadAddon: (addon: ITerminalAddon) => void;

• Loads an addon into this instance of xterm.js.

  Parameter addon

  The addon to load.

method open

open: (parent: HTMLElement) => void;

• Opens the terminal within an element.

  Parameter parent

  The element to create the terminal within. This element must be visible (have dimensions) when open is called as several DOM- based measurements need to be performed when this function is called.

method paste

paste: (data: string) => void;

• Writes text to the terminal, performing the necessary transformations for pasted text.

  Parameter data

  The text to write to the terminal.

method refresh

refresh: (start: number, end: number) => void;

• Tells the renderer to refresh terminal content between two rows (inclusive) at the next opportunity.

  Parameter start

  The row to start from (between 0 and this.rows - 1).

  Parameter end

  The row to end at (between start and this.rows - 1).

method registerCharacterJoiner

registerCharacterJoiner: (
    handler: (text: string) => [number, number][]
) => number;

• (EXPERIMENTAL) Registers a character joiner, allowing custom sequences of characters to be rendered as a single unit. This is useful in particular for rendering ligatures and graphemes, among other things.

  Each registered character joiner is called with a string of text representing a portion of a line in the terminal that can be rendered as a single unit. The joiner must return a sorted array, where each entry is itself an array of length two, containing the start (inclusive) and end (exclusive) index of a substring of the input that should be rendered as a single unit. When multiple joiners are provided, the results of each are collected. If there are any overlapping substrings between them, they are combined into one larger unit that is drawn together.

  All character joiners that are registered get called every time a line is rendered in the terminal, so it is essential for the handler function to run as quickly as possible to avoid slowdowns when rendering. Similarly, joiners should strive to return the smallest possible substrings to render together, since they aren't drawn as optimally as individual characters.

  NOTE: character joiners are only used by the canvas renderer.

  Parameter handler

  The function that determines character joins. It is called with a string of text that is eligible for joining and returns an array where each entry is an array containing the start (inclusive) and end (exclusive) indexes of ranges that should be rendered as a single unit.

  Returns

  The ID of the new joiner, this can be used to deregister

method registerDecoration

registerDecoration: (
    decorationOptions: IDecorationOptions
) => IDecoration | undefined;

• (EXPERIMENTAL) Adds a decoration to the terminal using

  Parameter decorationOptions

  , which takes a marker and an optional anchor, width, height, and x offset from the anchor. Returns the decoration or undefined if the alt buffer is active or the marker has already been disposed of.

  Throws

  when options include a negative x offset.

method registerLinkProvider

registerLinkProvider: (linkProvider: ILinkProvider) => IDisposable;

• Registers a link provider, allowing a custom parser to be used to match and handle links. Multiple link providers can be used, they will be asked in the order in which they are registered.

  Parameter linkProvider

  The link provider to use to detect links.

method registerMarker

registerMarker: (cursorYOffset?: number) => IMarker;

• Adds a marker to the normal buffer and returns it.

  Parameter cursorYOffset

  The y position offset of the marker from the cursor.

  Returns

  The new marker or undefined.

method reset

reset: () => void;

• Perform a full reset (RIS, aka '\x1bc').

method resize

resize: (columns: number, rows: number) => void;

• Resizes the terminal. It's best practice to debounce calls to resize, this will help ensure that the pty can respond to the resize event before another one occurs.

  Parameter x

  The number of columns to resize to.

  Parameter y

  The number of rows to resize to.

method scrollLines

scrollLines: (amount: number) => void;

• Scroll the display of the terminal

  Parameter amount

  The number of lines to scroll down (negative scroll up).

method scrollPages

scrollPages: (pageCount: number) => void;

• Scroll the display of the terminal by a number of pages.

  Parameter pageCount

  The number of pages to scroll (negative scrolls up).

method scrollToBottom

scrollToBottom: () => void;

• Scrolls the display of the terminal to the bottom.

method scrollToLine

scrollToLine: (line: number) => void;

• Scrolls to a line within the buffer.

  Parameter line

  The 0-based line index to scroll to.

method scrollToTop

scrollToTop: () => void;

• Scrolls the display of the terminal to the top.

method select

select: (column: number, row: number, length: number) => void;

• Selects text within the terminal.

  Parameter column

  The column the selection starts at.

  Parameter row

  The row the selection starts at.

  Parameter length

  The length of the selection.

method selectAll

selectAll: () => void;

• Selects all text within the terminal.

method selectLines

selectLines: (start: number, end: number) => void;

• Selects text in the buffer between 2 lines.

  Parameter start

  The 0-based line index to select from (inclusive).

  Parameter end

  The 0-based line index to select to (inclusive).

method write

write: (data: string | Uint8Array, callback?: () => void) => void;

• Write data to the terminal.

  Parameter data

  The data to write to the terminal. This can either be raw bytes given as Uint8Array from the pty or a string. Raw bytes will always be treated as UTF-8 encoded, string data as UTF-16.

  Parameter callback

  Optional callback that fires when the data was processed by the parser.

method writeln

writeln: (data: string | Uint8Array, callback?: () => void) => void;

• Writes data to the terminal, followed by a break line character (\n).

  Parameter data

  The data to write to the terminal. This can either be raw bytes given as Uint8Array from the pty or a string. Raw bytes will always be treated as UTF-8 encoded, string data as UTF-16.

  Parameter callback

  Optional callback that fires when the data was processed by the parser.

property baseY

readonly baseY: number;

• The line within the buffer where the top of the bottom page is (when fully scrolled down).

property cursorX

readonly cursorX: number;

• The x position of the cursor. This ranges between 0 (left side) and Terminal.cols (after last cell of the row).

property cursorY

readonly cursorY: number;

• The y position of the cursor. This ranges between 0 (when the cursor is at baseY) and Terminal.rows - 1 (when the cursor is on the last row).

property length

readonly length: number;

• The amount of lines in the buffer.

property type

readonly type: 'normal' | 'alternate';

• The type of the buffer.

property viewportY

readonly viewportY: number;

• The line within the buffer where the top of the viewport is.

method getLine

getLine: (y: number) => IBufferLine | undefined;

• Gets a line from the buffer, or undefined if the line index does not exist.

  Note that the result of this function should be used immediately after calling as when the terminal updates it could lead to unexpected behavior.

  Parameter y

  The line index to get.

method getNullCell

getNullCell: () => IBufferCell;

• Creates an empty cell object suitable as a cell reference in line.getCell(x, cell). Use this to avoid costly recreation of cell objects when dealing with tons of cells.

method getBgColor

getBgColor: () => number;

• Gets a cell's background color number, this differs depending on what the color mode of the cell is:

  - Default: This should be 0, representing the default background color (CSI 49 m). - Palette: This is a number from 0 to 255 of ANSI colors (CSI 4(0-7) m, CSI 10(0-7) m, CSI 48 ; 5 ; 0-255 m). - RGB: A hex value representing a 'true color': 0xRRGGBB (CSI 4 8 ; 2 ; Pi ; Pr ; Pg ; Pb)

method getBgColorMode

getBgColorMode: () => number;

• Gets the number representation of the background color mode, this can be used to perform quick comparisons of 2 cells to see if they're the same. Use isBgRGB, isBgPalette and isBgDefault to check what color mode a cell is.

method getChars

getChars: () => string;

• The character(s) within the cell. Examples of what this can contain:

  - A normal width character - A wide character (eg. CJK) - An emoji

method getCode

getCode: () => number;

• Gets the UTF32 codepoint of single characters, if content is a combined string it returns the codepoint of the last character in the string.

method getFgColor

getFgColor: () => number;

• Gets a cell's foreground color number, this differs depending on what the color mode of the cell is:

  - Default: This should be 0, representing the default foreground color (CSI 39 m). - Palette: This is a number from 0 to 255 of ANSI colors (CSI 3(0-7) m, CSI 9(0-7) m, CSI 38 ; 5 ; 0-255 m). - RGB: A hex value representing a 'true color': 0xRRGGBB. (CSI 3 8 ; 2 ; Pi ; Pr ; Pg ; Pb)

method getFgColorMode

getFgColorMode: () => number;

• Gets the number representation of the foreground color mode, this can be used to perform quick comparisons of 2 cells to see if they're the same. Use isFgRGB, isFgPalette and isFgDefault to check what color mode a cell is.

method getWidth

getWidth: () => number;

• The width of the character. Some examples:

  - 1 for most cells. - 2 for wide character like CJK glyphs. - 0 for cells immediately following cells with a width of 2.

method isAttributeDefault

isAttributeDefault: () => boolean;

• Whether the cell has the default attribute (no color or style).

method isBgDefault

isBgDefault: () => boolean;

• Whether the cell is using the default background color mode.

method isBgPalette

isBgPalette: () => boolean;

• Whether the cell is using the palette background color mode.

method isBgRGB

isBgRGB: () => boolean;

• Whether the cell is using the RGB background color mode.

method isBlink

isBlink: () => number;

• Whether the cell has the blink attribute (CSI 5 m).

method isBold

isBold: () => number;

• Whether the cell has the bold attribute (CSI 1 m).

method isDim

isDim: () => number;

• Whether the cell has the dim attribute (CSI 2 m).

method isFgDefault

isFgDefault: () => boolean;

• Whether the cell is using the default foreground color mode.

method isFgPalette

isFgPalette: () => boolean;

• Whether the cell is using the palette foreground color mode.

method isFgRGB

isFgRGB: () => boolean;

• Whether the cell is using the RGB foreground color mode.

method isInverse

isInverse: () => number;

• Whether the cell has the inverse attribute (CSI 7 m).

method isInvisible

isInvisible: () => number;

• Whether the cell has the invisible attribute (CSI 8 m).

method isItalic

isItalic: () => number;

• Whether the cell has the italic attribute (CSI 3 m).

method isOverline

isOverline: () => number;

• Whether the cell has the overline attribute (CSI 53 m).

method isStrikethrough

isStrikethrough: () => number;

• Whether the cell has the strikethrough attribute (CSI 9 m).

method isUnderline

isUnderline: () => number;

• Whether the cell has the underline attribute (CSI 4 m).

property x

x: number;

• The x position within the buffer (1-based).

property y

y: number;

• The y position within the buffer (1-based).

method provideBufferElements

provideBufferElements: () => DocumentFragment | HTMLElement;

• Provides a document fragment or HTMLElement containing the buffer elements.

property isWrapped

readonly isWrapped: boolean;

• Whether the line is wrapped from the previous line.

property length

readonly length: number;

• The length of the line, all call to getCell beyond the length will result in undefined. Note that this may exceed columns as the line array may not be trimmed after a resize, compare against Terminal.cols to get the actual maximum length of a line.

method getCell

getCell: (x: number, cell?: IBufferCell) => IBufferCell | undefined;

• Gets a cell from the line, or undefined if the line index does not exist.

  Note that the result of this function should be used immediately after calling as when the terminal updates it could lead to unexpected behavior.

  Parameter x

  The character index to get.

  Parameter cell

  Optional cell object to load data into for performance reasons. This is mainly useful when every cell in the buffer is being looped over to avoid creating new objects for every cell.

method translateToString

translateToString: (
    trimRight?: boolean,
    startColumn?: number,
    endColumn?: number
) => string;

• Gets the line as a string. Note that this is gets only the string for the line, not taking isWrapped into account.

  Parameter trimRight

  Whether to trim any whitespace at the right of the line.

  Parameter startColumn

  The column to start from (inclusive).

  Parameter endColumn

  The column to end at (exclusive).

property active

readonly active: IBuffer;

• The active buffer, this will either be the normal or alternate buffers.

property alternate

readonly alternate: IBuffer;

• The alternate buffer, this becomes the active buffer when an application enters this mode via DECSET (CSI ? 4 7 h)

property normal

readonly normal: IBuffer;

• The normal buffer.

property onBufferChange

onBufferChange: IEvent<IBuffer>;

• Adds an event listener for when the active buffer changes.

  Returns

  an IDisposable to stop listening.

property end

end: IBufferCellPosition;

• The end position of the range.

property start

start: IBufferCellPosition;

• The start position of the range.

property element

element: HTMLElement | undefined;

• The element that the decoration is rendered to. This will be undefined until it is rendered for the first time by IDecoration.onRender. that.

property marker

readonly marker: IMarker;

property onRender

readonly onRender: IEvent<HTMLElement>;

• An event fired when the decoration is rendered, returns the dom element associated with the decoration.

property options

options: Pick<IDecorationOptions, 'overviewRulerOptions'>;

• The options for the overview ruler that can be updated. This will only take effect when IDecorationOptions.overviewRulerOptions were provided initially.

property anchor

readonly anchor?: 'right' | 'left';

property backgroundColor

readonly backgroundColor?: string;

• The background color of the cell(s). When 2 decorations both set the foreground color the last registered decoration will be used. Only the #RRGGBB format is supported.

property foregroundColor

readonly foregroundColor?: string;

• The foreground color of the cell(s). When 2 decorations both set the foreground color the last registered decoration will be used. Only the #RRGGBB format is supported.

property height

readonly height?: number;

• The height of the decoration in cells, defaults to 1.

property layer

readonly layer?: 'bottom' | 'top';

• What layer to render the decoration at when backgroundColor or foregroundColor are used. 'bottom' will render under the selection, 'top' will render above the selection*.

  ** The selection will render on top regardless of layer on the canvas renderer due to how it renders selection separately.*

property marker

readonly marker: IMarker;

• The line in the terminal where the decoration will be displayed

property overviewRulerOptions

overviewRulerOptions?: IDecorationOverviewRulerOptions;

• When defined, renders the decoration in the overview ruler to the right of the terminal. ITerminalOptions.overviewRulerWidth must be set in order to see the overview ruler.

  Parameter color

  The color of the decoration.

  Parameter position

  The position of the decoration.

property width

readonly width?: number;

• The width of the decoration in cells, defaults to 1.

property x

readonly x?: number;

• The x position offset relative to the anchor

property color

color: string;

property position

position?: 'left' | 'center' | 'right' | 'full';

method dispose

dispose: () => void;

property isDisposed

readonly isDisposed: boolean;

• Whether this is disposed.

property onDispose

onDispose: IEvent<void>;

• Event listener to get notified when this gets disposed.

call signature

(listener: (arg1: T, arg2: U) => any): IDisposable;

property final

final: string;

• Final byte, must be in range \x40 .. \x7e for CSI and DCS, \x30 .. \x7e for ESC.

property intermediates

intermediates?: string;

• Optional intermediate bytes, must be in range \x20 .. \x2f. Usable in CSI, DCS and ESC.

property prefix

prefix?: string;

• Optional prefix byte, must be in range \x3c .. \x3f. Usable in CSI and DCS.

property decorations

decorations?: ILinkDecorations;

• What link decorations to show when hovering the link, this property is tracked and changes made after the link is provided will trigger changes. If not set, all decroations will be enabled.

property range

range: IBufferRange;

• The buffer range of the link.

property text

text: string;

• The text of the link.

method activate

activate: (event: MouseEvent, text: string) => void;

• Calls when the link is activated.

  Parameter event

  The mouse event triggering the callback.

  Parameter text

  The text of the link.

method dispose

dispose: () => void;

• Called when the link is released and no longer used by xterm.js.

method hover

hover: (event: MouseEvent, text: string) => void;

• Called when the mouse hovers the link. To use this to create a DOM-based hover tooltip, create the hover element within Terminal.element and add the xterm-hover class to it, that will cause mouse events to not fall through and activate other links.

  Parameter event

  The mouse event triggering the callback.

  Parameter text

  The text of the link.

method leave

leave: (event: MouseEvent, text: string) => void;

• Called when the mouse leaves the link.

  Parameter event

  The mouse event triggering the callback.

  Parameter text

  The text of the link.

property pointerCursor

pointerCursor: boolean;

• Whether the cursor is set to pointer.

property underline

underline: boolean;

• Whether the underline is visible

property allowNonHttpProtocols

allowNonHttpProtocols?: boolean;

• Whether to receive non-HTTP URLs from LinkProvider. When false, any usage of non-HTTP URLs will be ignored. Enabling this option without proper protection in activate function may cause security issues such as XSS.

method activate

activate: (event: MouseEvent, text: string, range: IBufferRange) => void;

• Calls when the link is activated.

  Parameter event

  The mouse event triggering the callback.

  Parameter text

  The text of the link.

  Parameter range

  The buffer range of the link.

method hover

hover: (event: MouseEvent, text: string, range: IBufferRange) => void;

• Called when the mouse hovers the link. To use this to create a DOM-based hover tooltip, create the hover element within Terminal.element and add the xterm-hover class to it, that will cause mouse events to not fall through and activate other links.

  Parameter event

  The mouse event triggering the callback.

  Parameter text

  The text of the link.

  Parameter range

  The buffer range of the link.

method leave

leave: (event: MouseEvent, text: string, range: IBufferRange) => void;

• Called when the mouse leaves the link.

  Parameter event

  The mouse event triggering the callback.

  Parameter text

  The text of the link.

  Parameter range

  The buffer range of the link.

method provideLinks

provideLinks: (
    bufferLineNumber: number,
    callback: (links: ILink[] | undefined) => void
) => void;

• Provides a link a buffer position

  Parameter bufferLineNumber

  The y position of the buffer to check for links within.

  Parameter callback

  The callback to be fired when ready with the resulting link(s) for the line or undefined.

property promptLabel

promptLabel: string;

• The aria label for the underlying input textarea for the terminal.

property tooMuchOutput

tooMuchOutput: string;

• Announcement for when line reading is suppressed due to too many lines being printed to the terminal when screenReaderMode is enabled.

method debug

debug: (message: string, ...args: any[]) => void;

• Log a debug message, this will only be called if ITerminalOptions.logLevel is set to debug or below.

method error

error: (message: string | Error, ...args: any[]) => void;

• Log a debug message, this will only be called if ITerminalOptions.logLevel is set to error or below.

method info

info: (message: string, ...args: any[]) => void;

• Log a debug message, this will only be called if ITerminalOptions.logLevel is set to info or below.

method trace

trace: (message: string, ...args: any[]) => void;

• Log a trace message, this will only be called if ITerminalOptions.logLevel is set to trace.

method warn

warn: (message: string, ...args: any[]) => void;

• Log a debug message, this will only be called if ITerminalOptions.logLevel is set to warn or below.

property id

readonly id: number;

• A unique identifier for this marker.

property line

readonly line: number;

• The actual line index in the buffer at this point in time. This is set to -1 if the marker has been disposed.

property applicationCursorKeysMode

readonly applicationCursorKeysMode: boolean;

• Application Cursor Keys (DECCKM): CSI ? 1 h

property applicationKeypadMode

readonly applicationKeypadMode: boolean;

• Application Keypad Mode (DECNKM): CSI ? 6 6 h

property bracketedPasteMode

readonly bracketedPasteMode: boolean;

• Bracketed Paste Mode: CSI ? 2 0 0 4 h

property insertMode

readonly insertMode: boolean;

• Insert Mode (IRM): CSI 4 h

property mouseTrackingMode

readonly mouseTrackingMode: 'none' | 'x10' | 'vt200' | 'drag' | 'any';

• Mouse Tracking, this can be one of the following: - none: This is the default value and can be reset with DECRST - x10: Send Mouse X & Y on button press CSI ? 9 h - vt200: Send Mouse X & Y on button press and release CSI ? 1 0 0 0 h - drag: Use Cell Motion Mouse Tracking CSI ? 1 0 0 2 h - any: Use All Motion Mouse Tracking CSI ? 1 0 0 3 h

property originMode

readonly originMode: boolean;

• Origin Mode (DECOM): CSI ? 6 h

property reverseWraparoundMode

readonly reverseWraparoundMode: boolean;

• Reverse-wraparound Mode: CSI ? 4 5 h

property sendFocusMode

readonly sendFocusMode: boolean;

• Send FocusIn/FocusOut events: CSI ? 1 0 0 4 h

property wraparoundMode

readonly wraparoundMode: boolean;

• Auto-Wrap Mode (DECAWM): CSI ? 7 h

method registerCsiHandler

registerCsiHandler: (
    id: IFunctionIdentifier,
    callback: (params: (number | number[])[]) => boolean | Promise<boolean>
) => IDisposable;

• Adds a handler for CSI escape sequences.

  Parameter id

  Specifies the function identifier under which the callback gets registered, e.g. {final: 'm'} for SGR.

  Parameter callback

  The function to handle the sequence. The callback is called with the numerical params. If the sequence has subparams the array will contain subarrays with their numercial values. Return true if the sequence was handled, false if the parser should try a previous handler. The most recently added handler is tried first.

  Returns

  An IDisposable you can call to remove this handler.

method registerDcsHandler

registerDcsHandler: (
    id: IFunctionIdentifier,
    callback: (
        data: string,
        param: (number | number[])[]
    ) => boolean | Promise<boolean>
) => IDisposable;

• Adds a handler for DCS escape sequences.

  Parameter id

  Specifies the function identifier under which the callback gets registered, e.g. {intermediates: '$' final: 'q'} for DECRQSS.

  Parameter callback

  The function to handle the sequence. Note that the function will only be called once if the sequence finished sucessfully. There is currently no way to intercept smaller data chunks, data chunks will be stored up until the sequence is finished. Since DCS sequences are not limited by the amount of data this might impose a problem for big payloads. Currently xterm.js limits DCS payload to 10 MB which should give enough room for most use cases. The function gets the payload and numerical parameters as arguments. Return true if the sequence was handled, false if the parser should try a previous handler. The most recently added handler is tried first.

  Returns

  An IDisposable you can call to remove this handler.

method registerEscHandler

registerEscHandler: (
    id: IFunctionIdentifier,
    handler: () => boolean | Promise<boolean>
) => IDisposable;

• Adds a handler for ESC escape sequences.

  Parameter id

  Specifies the function identifier under which the callback gets registered, e.g. {intermediates: '%' final: 'G'} for default charset selection.

  Parameter callback

  The function to handle the sequence. Return true if the sequence was handled, false if the parser should try a previous handler. The most recently added handler is tried first.

  Returns

  An IDisposable you can call to remove this handler.

method registerOscHandler

registerOscHandler: (
    ident: number,
    callback: (data: string) => boolean | Promise<boolean>
) => IDisposable;

• Adds a handler for OSC escape sequences.

  Parameter ident

  The number (first parameter) of the sequence.

  Parameter callback

  The function to handle the sequence. Note that the function will only be called once if the sequence finished sucessfully. There is currently no way to intercept smaller data chunks, data chunks will be stored up until the sequence is finished. Since OSC sequences are not limited by the amount of data this might impose a problem for big payloads. Currently xterm.js limits OSC payload to 10 MB which should give enough room for most use cases. The callback is called with OSC data string. Return true if the sequence was handled, false if the parser should try a previous handler. The most recently added handler is tried first.

  Returns

  An IDisposable you can call to remove this handler.

method activate

activate: (terminal: Terminal) => void;

• This is called when the addon is activated.

property cols

cols?: number;

• The number of columns in the terminal.

property rows

rows?: number;

• The number of rows in the terminal.

property allowProposedApi

allowProposedApi?: boolean;

• Whether to allow the use of proposed API. When false, any usage of APIs marked as experimental/proposed will throw an error. The default is false.

property allowTransparency

allowTransparency?: boolean;

• Whether background should support non-opaque color. It must be set before executing the Terminal.open() method and can't be changed later without executing it again. Note that enabling this can negatively impact performance.

property altClickMovesCursor

altClickMovesCursor?: boolean;

• If enabled, alt + click will move the prompt cursor to position underneath the mouse. The default is true.

property convertEol

convertEol?: boolean;

• When enabled the cursor will be set to the beginning of the next line with every new line. This is equivalent to sending '\r\n' for each '\n'. Normally the termios settings of the underlying PTY deals with the translation of '\n' to '\r\n' and this setting should not be used. If you deal with data from a non-PTY related source, this settings might be useful.

property cursorBlink

cursorBlink?: boolean;

• Whether the cursor blinks.

property cursorInactiveStyle

cursorInactiveStyle?: 'outline' | 'block' | 'bar' | 'underline' | 'none';

• The style of the cursor when the terminal is not focused.

property cursorStyle

cursorStyle?: 'block' | 'underline' | 'bar';

• The style of the cursor when the terminal is focused.

property cursorWidth

cursorWidth?: number;

• The width of the cursor in CSS pixels when cursorStyle is set to 'bar'.

property customGlyphs

customGlyphs?: boolean;

• Whether to draw custom glyphs for block element and box drawing characters instead of using the font. This should typically result in better rendering with continuous lines, even when line height and letter spacing is used. Note that this doesn't work with the DOM renderer which renders all characters using the font. The default is true.

property disableStdin

disableStdin?: boolean;

• Whether input should be disabled.

property drawBoldTextInBrightColors

drawBoldTextInBrightColors?: boolean;

• Whether to draw bold text in bright colors. The default is true.

property fastScrollModifier

fastScrollModifier?: 'none' | 'alt' | 'ctrl' | 'shift';

• The modifier key hold to multiply scroll speed.

property fastScrollSensitivity

fastScrollSensitivity?: number;

• The scroll speed multiplier used for fast scrolling.

property fontFamily

fontFamily?: string;

• The font family used to render text.

property fontSize

fontSize?: number;

• The font size used to render text.

property fontWeight

fontWeight?: FontWeight;

• The font weight used to render non-bold text.

property fontWeightBold

fontWeightBold?: FontWeight;

• The font weight used to render bold text.

property ignoreBracketedPasteMode

ignoreBracketedPasteMode?: boolean;

• Whether to ignore the bracketed paste mode. When true, this will always paste without the \x1b[200~ and \x1b[201~ sequences, even when the shell enables bracketed mode.

property letterSpacing

letterSpacing?: number;

• The spacing in whole pixels between characters.

property lineHeight

lineHeight?: number;

• The line height used to render text.

property linkHandler

linkHandler?: ILinkHandler | null;

• The handler for OSC 8 hyperlinks. Links will use the confirm browser API with a strongly worded warning if no link handler is set.

  When setting this, consider the security of users opening these links, at a minimum there should be a tooltip or a prompt when hovering or activating the link respectively. An example of what might be possible is a terminal app writing link in the form javascript:... that runs some javascript, a safe approach to prevent that is to validate the link starts with http(s)://.

property logger

logger?: ILogger | null;

• A logger to use instead of console.

property logLevel

logLevel?: LogLevel;

• What log level to use, this will log for all levels below and including what is set:

  1. trace 2. debug 3. info (default) 4. warn 5. error 6. off

property macOptionClickForcesSelection

macOptionClickForcesSelection?: boolean;

• Whether holding a modifier key will force normal selection behavior, regardless of whether the terminal is in mouse events mode. This will also prevent mouse events from being emitted by the terminal. For example, this allows you to use xterm.js' regular selection inside tmux with mouse mode enabled.

property macOptionIsMeta

macOptionIsMeta?: boolean;

• Whether to treat option as the meta key.

property minimumContrastRatio

minimumContrastRatio?: number;

• The minimum contrast ratio for text in the terminal, setting this will change the foreground color dynamically depending on whether the contrast ratio is met. Example values:

  - 1: The default, do nothing. - 4.5: Minimum for WCAG AA compliance. - 7: Minimum for WCAG AAA compliance. - 21: White on black or black on white.

property overviewRulerWidth

overviewRulerWidth?: number;

• The width, in pixels, of the canvas for the overview ruler. The overview ruler will be hidden when not set.

property rightClickSelectsWord

rightClickSelectsWord?: boolean;

• Whether to select the word under the cursor on right click, this is standard behavior in a lot of macOS applications.

property screenReaderMode

screenReaderMode?: boolean;

• Whether screen reader support is enabled. When on this will expose supporting elements in the DOM to support NVDA on Windows and VoiceOver on macOS.

property scrollback

scrollback?: number;

• The amount of scrollback in the terminal. Scrollback is the amount of rows that are retained when lines are scrolled beyond the initial viewport.

property scrollOnUserInput

scrollOnUserInput?: boolean;

• Whether to scroll to the bottom whenever there is some user input. The default is true.

property scrollSensitivity

scrollSensitivity?: number;

• The scrolling speed multiplier used for adjusting normal scrolling speed.

property smoothScrollDuration

smoothScrollDuration?: number;

• The duration to smoothly scroll between the origin and the target in milliseconds. Set to 0 to disable smooth scrolling and scroll instantly.

property tabStopWidth

tabStopWidth?: number;

• The size of tab stops in the terminal.

property theme

theme?: ITheme;

• The color theme of the terminal.

property windowOptions

windowOptions?: IWindowOptions;

• Enable various window manipulation and report features. All features are disabled by default for security reasons.

property windowsMode

windowsMode?: boolean;

• Whether "Windows mode" is enabled. Because Windows backends winpty and conpty operate by doing line wrapping on their side, xterm.js does not have access to wrapped lines. When Windows mode is enabled the following changes will be in effect:

  - Reflow is disabled. - Lines are assumed to be wrapped if the last character of the line is not whitespace.

  When using conpty on Windows 11 version >= 21376, it is recommended to disable this because native text wrapping sequences are output correctly thanks to https://github.com/microsoft/terminal/issues/405

  Deprecated

  Use windowsPty. This value will be ignored if windowsPty is set.

property windowsPty

windowsPty?: IWindowsPty;

• Compatibility information when the pty is known to be hosted on Windows. Setting this will turn on certain heuristics/workarounds depending on the values:

  - if (backend !== undefined || buildNumber !== undefined) - When increasing the rows in the terminal, the amount increased into the scrollback. This is done because ConPTY does not behave like expect scrollback to come back into the viewport, instead it makes empty rows at of the viewport. Not having this behavior can result in missing data as the rows get replaced. - if !(backend === 'conpty' && buildNumber >= 21376) - Reflow is disabled - Lines are assumed to be wrapped if the last character of the line is not whitespace.

property wordSeparator

wordSeparator?: string;

• A string containing all characters that are considered word separated by the double click to select work logic.

property background

background?: string;

• The default background color

property black

black?: string;

• ANSI black (eg. \x1b[30m)

property blue

blue?: string;

• ANSI blue (eg. \x1b[34m)

property brightBlack

brightBlack?: string;

• ANSI bright black (eg. \x1b[1;30m)

property brightBlue

brightBlue?: string;

• ANSI bright blue (eg. \x1b[1;34m)

property brightCyan

brightCyan?: string;

• ANSI bright cyan (eg. \x1b[1;36m)

property brightGreen

brightGreen?: string;

• ANSI bright green (eg. \x1b[1;32m)

property brightMagenta

brightMagenta?: string;

• ANSI bright magenta (eg. \x1b[1;35m)

property brightRed

brightRed?: string;

• ANSI bright red (eg. \x1b[1;31m)

property brightWhite

brightWhite?: string;

• ANSI bright white (eg. \x1b[1;37m)

property brightYellow

brightYellow?: string;

• ANSI bright yellow (eg. \x1b[1;33m)

property cursor

cursor?: string;

• The cursor color

property cursorAccent

cursorAccent?: string;

• The accent color of the cursor (fg color for a block cursor)

property cyan

cyan?: string;

• ANSI cyan (eg. \x1b[36m)

property extendedAnsi

extendedAnsi?: string[];

• ANSI extended colors (16-255)

property foreground

foreground?: string;

• The default foreground color

property green

green?: string;

• ANSI green (eg. \x1b[32m)

property magenta

magenta?: string;

• ANSI magenta (eg. \x1b[35m)

property red

red?: string;

• ANSI red (eg. \x1b[31m)

property selectionBackground

selectionBackground?: string;

• The selection background color (can be transparent)

property selectionForeground

selectionForeground?: string;

• The selection foreground color

property selectionInactiveBackground

selectionInactiveBackground?: string;

• The selection background color when the terminal does not have focus (can be transparent)

property white

white?: string;

• ANSI white (eg. \x1b[37m)

property yellow

yellow?: string;

• ANSI yellow (eg. \x1b[33m)

property activeVersion

activeVersion: string;

• Getter/setter for active Unicode version.

property versions

readonly versions: ReadonlyArray<string>;

• Registered Unicode versions.

method register

register: (provider: IUnicodeVersionProvider) => void;

• Register a custom Unicode version provider.

property version

readonly version: string;

• String indicating the Unicode version provided.

method wcwidth

wcwidth: (codepoint: number) => 0 | 1 | 2;

• Unicode version dependent wcwidth implementation.

property end

end: IViewportRangePosition;

• The end of the range.

property start

start: IViewportRangePosition;