Node

A read-only handle into a Document.

Node carries navigation and accessor members but no editing methods — all edits go through the owning document. It is a cheap reference, not a copy of the subtree; reads delegate back into the document. Obtain handles from Document.root, Document.errors, Document.findCommands, the create* staging constructors, and the navigation members below.

Kind#

Predicates#

isCommand(name: string | null | undefined): boolean

node.isCommand();       // any command
node.isCommand('frac'); // specifically \frac

isChar(value: string | null | undefined): boolean

isError(): boolean

isKnown(): boolean | null

Navigation#

parent(): Node | null

nextSibling(): Node | null

prevSibling(): Node | null

ancestors(): Node[]

descendants(): Node[]

path(): string | null

slot(): NodeSlot | null

Content accessors#

primeCount(): number | null

const doc = new Parser().parse(String.raw`f''`).document;
const prime = doc.root().descendants().find((n) => n.kind === 'prime');
prime.primeCount(); // 2

errorParts(): { message: string; snippet: string } | null

const doc = new Parser().parse(String.raw`\sqrt[`).document;
const err = doc.root().descendants().find((n) => n.isError());
err.errorParts(); // { message: 'unclosed bracket argument', snippet: '\\sqrt[' }

contentMode(): RuntimeContentMode | null

Groups#

groupKind(): GroupKindRef | null

const doc = new Parser().parse(String.raw`{x}`).document;
const group = doc.root().descendants().find((n) => n.kind === 'group');
group.groupKind(); // { kind: 'Explicit' }

Command arguments#

argCount(): number

arg(index: number): ArgRef | null

const doc = new Parser().parse(String.raw`\frac{x}{y}`).document;
const frac = doc.root().descendants().find((n) => n.isCommand('frac'));
frac.argCount(); // 2
frac.arg(0);     // { kind: 'Math', node: <Node> }

argKind(index: number): ArgForm | null

argSlots(): Array<ArgRef | null>

Scripts and infix#

scriptBase(): Node | null

subscript(): Node | null

const doc = new Parser().parse(String.raw`x_i^2`).document;
const sc = doc.root().descendants().find((n) => n.kind === 'scripted');
[sc.subscript().kind, sc.superscript().kind]; // ['char', 'char']

superscript(): Node | null

infixLeft(): Node | null

infixRight(): Node | null

envBody(): Node | null

Spans#

span(): Span | null

const doc = new Parser().parse(String.raw`a + b`).document;
doc.root().children[0].span(); // { start: 0, end: 1 }

Identity#

document(): Document

isSameNode(other: Node): boolean

Lifecycle#

free(): void

[Symbol.dispose](): void

The runtime kind of a Node, read from the lowercase Node.kind property.

Note the casing convention: node kinds are lowercase strings ('command', 'scripted'), unlike the capitalized discriminators inside argument and group views (arg.kind === 'Math', groupKind().kind === 'Explicit').

Content mode as it appears in a SyntaxNode snapshot: "Math" or "Text" (capitalized snapshot form).

Content mode as reported by the runtime tree API: "math" or "text" (lowercase form used by Node.contentMode and the mode arguments of lookup methods).

The kind of a group in SyntaxNode snapshot form: an Explicit brace group, an Implicit group, a Delimited group carrying its left/right delimiters, or an InlineMath group.

The kind of a group in runtime view form, with a kind discriminator. Returned by Node.groupKind; the discriminator keeps its capitalized form ('Explicit', 'Delimited', ...). A Delimited group carries left and right delimiter strings.

A delimiter token in SyntaxNode snapshot form: the literal "None", a single character ({ Char }), or a control sequence ({ Control }). Runtime views use delimiter strings instead: ., one character, or a backslash-prefixed control sequence such as \langle.

A present command/environment argument in SyntaxNode snapshot form, pairing its syntactic ArgumentKind with its parsed ArgumentValue.

The syntactic kind of a command argument in SyntaxNode snapshot form (mandatory, optional, starred, group, until, or delimited/paired). Until forms carry close; delimited/paired forms carry open and close.

The parsed value carried by an Argument in snapshot form: math or text content, a delimiter, a control-sequence name, a dimension, an integer, a key=value list, a column spec, or a boolean flag.

An argument slot of a Node's argument list: either a present Argument or an empty slot (null/undefined).

Optional argument slots that were not supplied in the source surface as the empty value rather than being dropped, so a slot's index stays stable.

A command/environment argument in runtime view form, returned by Node.arg and Node.argSlots.

Content kinds (Math, Text, OperatorName) carry a live node Node handle; leaf kinds (Delimiter, CSName, Dimension, Integer, KeyVal, Column, Boolean) carry a value. Delimiter values use source strings. The kind discriminator keeps its capitalized form.

The delimiter form of an argument slot; close is present for until, and both open and close for delimited and paired forms.

The parent slot a Node fills; index is set for indexed slots such as children and arguments.

A slot value accepted by construction and editing methods: a string is the source written inside the slot's boundaries, a detached Node is content, boolean sets a star slot, null omits an optional slot, and { value, open, close } selects an explicit delimiter pair.