Node

A read-only handle into a Document for navigation and reading.

A Node is a cheap reference — a shared pointer into the owning document plus an identity, never a copy of the subtree. It carries no editing methods; all mutation goes through the owning Document. Accessors return content only for the node kinds that carry it and None otherwise, so the same handle works uniformly across kinds.

You obtain handles from Document.root(), Document.errors(), Document.find_commands(), the create_* staging constructors, and the navigation methods here.

Kind#

kind() -> NodeKind

doc = texform.Parser().parse(r"\frac{x}{y}")["document"]
doc.root().kind()  # 'Root'

Predicates#

is_command(name: str | None = None) -> bool

node.is_command()        # any command
node.is_command("frac")  # specifically \frac

is_char(value: str | None = None) -> bool

node.is_char("+")

is_error() -> bool

is_known() -> bool | None

Navigation#

parent() -> Node | None

children() -> list[Node]

doc = texform.Parser().parse(r"\frac{x}{y} + a")["document"]
[n.kind() for n in doc.root().children()]  # ['Command', 'Char', 'Char']

next_sibling() -> Node | None

prev_sibling() -> Node | None

ancestors() -> list[Node]

descendants() -> list[Node]

path() -> str | None

slot() -> NodeSlot | None

Content accessors#

command_name() -> str | None

env_name() -> str | None

text() -> str | None

char() -> str | None

prime_count() -> int | None

doc = texform.Parser().parse(r"f''")["document"]
prime = next(n for n in doc.root().descendants() if n.kind() == "Prime")
prime.prime_count()  # 2

error_parts() -> ErrorParts | None

doc = texform.Parser().parse(r"\sqrt[")["document"]
err = next(n for n in doc.root().descendants() if n.is_error())
err.error_parts()  # {'message': '...', 'snippet': '\sqrt['}

content_mode() -> RuntimeContentMode | None

Groups#

group_kind() -> GroupKindRef | None

doc = texform.Parser().parse(r"{x}")["document"]
group = next(n for n in doc.root().descendants() if n.kind() == "Group")
group.group_kind()  # {'kind': 'Explicit'}

Command arguments#

arg_count() -> int

arg(index: int) -> ArgRef | None

doc = texform.Parser().parse(r"\frac{x}{y}")["document"]
frac = next(n for n in doc.root().descendants() if n.is_command("frac"))
frac.arg_count()  # 2
frac.arg(0)       # {'kind': 'Math', 'node': <Node>}

arg_slots() -> list[ArgRef | None]

Scripts and infix#

script_base() -> Node | None

subscript() -> Node | None

doc = texform.Parser().parse(r"x_i^2")["document"]
sc = next(n for n in doc.root().descendants() if n.kind() == "Scripted")
sc.subscript().kind(), sc.superscript().kind()  # ('Char', 'Char')

superscript() -> Node | None

infix_left() -> Node | None

infix_right() -> Node | None

env_body() -> Node | None

Spans#

span() -> Span | None

doc = texform.Parser().parse(r"a + b")["document"]
doc.root().children()[0].span()  # {'start': 0, 'end': 1}

Identity#

document() -> Document

__eq__(other: object) -> bool

__hash__() -> int

__repr__() -> str

Node kind as reported by Node.kind(). Python uses PascalCase ("Root", "Command", "ActiveSpace").

Runtime content mode reported by the tree API: "math" or "text".

The decomposed content of an Error placeholder node.

A group written with explicit braces { ... }.

A group with no surrounding braces, inferred from structure.

A group bounded by a delimiter pair, such as \left( ... \right).

A group introduced by inline math shift, such as $ ... $ in text mode.

The kind of a Group node: explicit, implicit, delimited, or inline-math.

A delimiter string: a character, a backslash-prefixed control, or a dot.

A command argument carrying math-mode content.

A command argument carrying text-mode content.

A command argument that is a single delimiter token.

A command argument that is a control-sequence name.

A command argument that is a TeX dimension, such as 2pt.

A command argument that is an integer literal.

A command argument that is a key=value list.

A command argument that is a tabular column specification.

A command argument that is a star flag, modeled as a boolean.

A read command argument: one of the discriminated argument-value dicts.

Immutable content and delimiter pair for an argspec Paired slot.

Pass it as a slot value to select an explicit delimiter pair. value is a detached node or source written between open and close. Instances compare and hash by value.

Slot input: source written inside the slot, a detached content node, a star flag, absence, or an explicit Paired delimiter pair.