Class Tree

constructor

• new Tree(
      type: NodeType,
      children: readonly (Tree | TreeBuffer)[],
      positions: readonly number[],
      length: number,
      props?: readonly [number | NodeProp<any>, any][],
  ): Tree

  Construct a new tree. See also Tree.build.

  Parameters

  • type: NodeType

    The type of the top node.

  • children: readonly (Tree | TreeBuffer)[]

    This node's child nodes.

  • positions: readonly number[]

    The positions (offsets relative to the start of this tree) of the children.

  • length: number

    The total length of this tree

  • Optionalprops: readonly [number | NodeProp<any>, any][]

    Per-node node props to associate with this node.

  Returns Tree

Readonlychildren

Readonlylength

Readonlypositions

Readonlytype

Staticempty

propValues

• get propValues(): readonly [number | NodeProp<any>, any][]

  Returns the node's per-node props in a format that can be passed to the Tree constructor.

  Returns readonly [number | NodeProp<any>, any][]

topNode

• get topNode(): SyntaxNode

  Get a syntax node object for the top of the tree.

  Returns SyntaxNode

balance

• balance(
      config?: {
          makeTree?: (
              children: readonly (Tree | TreeBuffer)[],
              positions: readonly number[],
              length: number,
          ) => Tree;
      },
  ): Tree

  Balance the direct children of this tree, producing a copy of which may have children grouped into subtrees with type NodeType.none.

  Parameters

  • Optionalconfig: {
        makeTree?: (
            children: readonly (Tree | TreeBuffer)[],
            positions: readonly number[],
            length: number,
        ) => Tree;
    }

    • OptionalmakeTree?: (
          children: readonly (Tree | TreeBuffer)[],
          positions: readonly number[],
          length: number,
      ) => Tree

      Function to create the newly balanced subtrees.

  Returns Tree

cursor

• cursor(mode?: IterMode): TreeCursor

  Get a tree cursor positioned at the top of the tree. Mode can be used to control which nodes the cursor visits.

  Parameters

  • Optionalmode: IterMode

  Returns TreeCursor

cursorAt

• cursorAt(pos: number, side?: -1 | 0 | 1, mode?: IterMode): TreeCursor

  Get a tree cursor pointing into this tree at the given position and side (see moveTo.

  Parameters

  • pos: number
  • Optionalside: -1 | 0 | 1
  • Optionalmode: IterMode

  Returns TreeCursor

iterate

• iterate(
      spec: {
          from?: number;
          mode?: IterMode;
          to?: number;
          enter(node: SyntaxNodeRef): boolean | void;
          leave?(node: SyntaxNodeRef): void;
      },
  ): void

  Iterate over the tree and its children, calling enter for any node that touches the from/to region (if given) before running over such a node's children, and leave (if given) when leaving the node. When enter returns false, that node will not have its children iterated over (or leave called).

  Parameters

  • spec: {
        from?: number;
        mode?: IterMode;
        to?: number;
        enter(node: SyntaxNodeRef): boolean | void;
        leave?(node: SyntaxNodeRef): void;
    }

  Returns void

prop

• prop<T>(prop: NodeProp<T>): T

  Get the value of the given node prop for this node. Works with both per-node and per-type props.

  Type Parameters

  • T

  Parameters

  • prop: NodeProp<T>

  Returns T

resolve

• resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode

  Get the syntax node at the given position. If side is -1, this will move into nodes that end at the position. If 1, it'll move into nodes that start at the position. With 0, it'll only enter nodes that cover the position from both sides.

  Note that this will not enter overlays, and you often want resolveInner instead.

  Parameters

  • pos: number
  • Optionalside: -1 | 0 | 1

  Returns SyntaxNode

resolveInner

• resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode

  Like resolve, but will enter overlaid nodes, producing a syntax node pointing into the innermost overlaid tree at the given position (with parent links going through all parent structure, including the host trees).

  Parameters

  • pos: number
  • Optionalside: -1 | 0 | 1

  Returns SyntaxNode

resolveStack

• resolveStack(pos: number, side?: -1 | 0 | 1): NodeIterator

  In some situations, it can be useful to iterate through all nodes around a position, including those in overlays that don't directly cover the position. This method gives you an iterator that will produce all nodes, from small to big, around the given position.

  Parameters

  • pos: number
  • Optionalside: -1 | 0 | 1

  Returns NodeIterator

Staticbuild

• build(data: BuildData): Tree

  Build a tree from a postfix-ordered buffer of node information, or a cursor over such a buffer.

  Parameters

  • data: BuildData

  Returns Tree