Création d'une extension
************************

.[perex]
Une extension est une classe réutilisable qui permet de définir des balises, des filtres, des fonctions, des fournisseurs, etc. personnalisés.

Nous créons des extensions lorsque nous voulons réutiliser nos personnalisations Latte dans différents projets ou les partager avec d'autres.
Il est également utile de créer une extension pour chaque projet Web qui contiendra toutes les balises et tous les filtres spécifiques que vous souhaitez utiliser dans les modèles de projet.


Classe d'extension .[#toc-extension-class]
==========================================

Extension est une classe héritant de [api:Latte\Extension]. Elle est enregistrée dans Latte à l'aide de `addExtension()` (ou via le [fichier de configuration |application:configuration#Latte]) :

```php
$latte = new Latte\Engine;
$latte->addExtension(new MyLatteExtension);
```

Si vous enregistrez plusieurs extensions et qu'elles définissent des balises, des filtres ou des fonctions de même nom, la dernière extension ajoutée l'emporte. Cela implique également que vos extensions peuvent remplacer les tags/filtres/fonctions natifs.

Chaque fois que vous apportez une modification à une classe et que l'actualisation automatique n'est pas désactivée, Latte recompile automatiquement vos modèles.

Une classe peut mettre en œuvre l'une des méthodes suivantes :

```php
abstract class Extension
{
	/**
	 * Initializes before template is compiler.
	 */
	public function beforeCompile(Engine $engine): void;

	/**
	 * Returns a list of parsers for Latte tags.
	 * @return array<string, callable>
	 */
	public function getTags(): array;

	/**
	 * Returns a list of compiler passes.
	 * @return array<string, callable>
	 */
	public function getPasses(): array;

	/**
	 * Returns a list of |filters.
	 * @return array<string, callable>
	 */
	public function getFilters(): array;

	/**
	 * Returns a list of functions used in templates.
	 * @return array<string, callable>
	 */
	public function getFunctions(): array;

	/**
	 * Returns a list of providers.
	 * @return array<mixed>
	 */
	public function getProviders(): array;

	/**
	 * Returns a value to distinguish multiple versions of the template.
	 */
	public function getCacheKey(Engine $engine): mixed;

	/**
	 * Initializes before template is rendered.
	 */
	public function beforeRender(Template $template): void;
}
```

Pour avoir une idée de ce à quoi ressemble l'extension, jetez un coup d'œil à la "CoreExtension":https://github.com/nette/latte/blob/master/src/Latte/Essential/CoreExtension.php intégrée.


beforeCompile(Latte\Engine $engine): void .[method]
---------------------------------------------------

Appelé avant que le modèle ne soit compilé. Cette méthode peut être utilisée pour les initialisations liées à la compilation, par exemple.


getTags(): array .[method]
--------------------------

Appelé lorsque le modèle est compilé. Retourne un tableau associatif *nom de la balise => appelable*, qui sont des [fonctions d'analyse de la balise |#Tag Parsing Function].

```php
public function getTags(): array
{
	return [
		'foo' => [FooNode::class, 'create'],
		'bar' => [BarNode::class, 'create'],
		'n:baz' => [NBazNode::class, 'create'],
		// ...
	];
}
```

La balise `n:baz` représente un pur n:attribut, c'est-à-dire une balise qui ne peut être écrite que comme un attribut.

Dans le cas des balises `foo` et `bar`, Latte reconnaîtra automatiquement s'il s'agit de paires, et si c'est le cas, elles peuvent être écrites automatiquement en utilisant des n:attributs, y compris les variantes avec les préfixes `n:inner-foo` et `n:tag-foo`.

L'ordre d'exécution de ces n:attributes est déterminé par leur ordre dans le tableau renvoyé par `getTags()`. Ainsi, `n:foo` est toujours exécuté avant `n:bar`, même si les attributs sont listés dans l'ordre inverse dans la balise HTML comme `<div n:bar="..." n:foo="...">`.

Si vous devez déterminer l'ordre des n:attributs sur plusieurs extensions, utilisez la méthode d'aide `order()`, où le paramètre `before` xor `after` détermine quelles balises sont ordonnées avant ou après la balise .

```php
public function getTags(): array
{
	return [
		'foo' => self::order([FooNode::class, 'create'], before: 'bar')]
		'bar' => self::order([BarNode::class, 'create'], after: ['block', 'snippet'])]
	];
}
```


getPasses(): array .[method]
----------------------------

Elle est appelée lorsque le modèle est compilé. Elle renvoie un tableau associatif *name pass => callable*, qui sont des fonctions représentant ce qu'on appelle des [passes de compilation |#compiler passes] qui traversent et modifient l'AST.

Là encore, la méthode d'aide `order()` peut être utilisée. La valeur des paramètres `before` ou `after` peut être `*` avec la signification avant/après tout.

```php
public function getPasses(): array
{
	return [
		'optimize' => [Passes::class, 'optimizePass'],
		'sandbox' => self::order([$this, 'sandboxPass'], before: '*'),
		// ...
	];
}
```


beforeRender(Latte\Engine $engine): void .[method]
--------------------------------------------------

Elle est appelée avant chaque rendu de modèle. La méthode peut être utilisée, par exemple, pour initialiser les variables utilisées pendant le rendu.


getFilters(): array .[method]
-----------------------------

Il est appelé avant que le modèle soit rendu. Retourne les [filtres |extending-latte#filters] sous la forme d'un tableau associatif *nom du filtre => appelable*.

```php
public function getFilters(): array
{
	return [
		'batch' => [$this, 'batchFilter'],
		'trim' => [$this, 'trimFilter'],
		// ...
	];
}
```


getFunctions(): array .[method]
-------------------------------

Il est appelé avant que le modèle ne soit rendu. Retourne les [fonctions |extending-latte#functions] sous la forme d'un tableau associatif *nom de la fonction => appelable*.

```php
public function getFunctions(): array
{
	return [
		'clamp' => [$this, 'clampFunction'],
		'divisibleBy' => [$this, 'divisibleByFunction'],
		// ...
	];
}
```


getProviders(): array .[method]
-------------------------------

Elle est appelée avant le rendu du modèle. Renvoie un tableau de fournisseurs, qui sont généralement des objets qui utilisent des balises au moment de l'exécution. Ils sont accessibles via `$this->global->...`.

```php
public function getProviders(): array
{
	return [
		'myFoo' => $this->foo,
		'myBar' => $this->bar,
		// ...
	];
}
```


getCacheKey(Latte\Engine $engine): mixed .[method]
--------------------------------------------------

Elle est appelée avant le rendu du modèle. La valeur de retour fait partie de la clé dont le hachage est contenu dans le nom du fichier de modèle compilé. Ainsi, pour différentes valeurs de retour, Latte générera différents fichiers de cache.


Comment fonctionne Latte ? .[#toc-how-does-latte-work]
======================================================

Pour comprendre comment définir des balises personnalisées ou des passages de compilateur, il est essentiel de comprendre comment Latte fonctionne sous le capot.

La compilation de modèles dans Latte fonctionne de manière simpliste comme suit :

- Tout d'abord, le **lexer** segmente le code source du modèle en petits morceaux (tokens) pour faciliter le traitement.
- Ensuite, le **parser** convertit le flux de tokens en un arbre de nœuds significatif (l'arbre de syntaxe abstraite, AST).
- Enfin, le compilateur **génère** une classe PHP à partir de l'AST qui rend le modèle et le met en cache.

En fait, la compilation est un peu plus compliquée. Latte **a deux** lexers et parsers : un pour le modèle HTML et un pour le code PHP à l'intérieur des balises. De plus, l'analyse syntaxique ne s'exécute pas après la tokénisation, mais le lexer et l'analyse syntaxique s'exécutent en parallèle dans deux "threads" et se coordonnent. C'est de la science-fiction :-)

En outre, toutes les balises ont leurs propres routines d'analyse. Lorsque l'analyseur rencontre une balise, il appelle sa fonction d'analyse (il renvoie [Extension::getTags() |#getTags]).
Son travail consiste à analyser les arguments de la balise et, dans le cas de balises appariées, le contenu interne. Elle renvoie un *node* qui devient une partie de l'AST. Voir [Fonction d'analyse syntaxique des balises |#Tag parsing function] pour plus de détails.

Lorsque l'analyseur syntaxique termine son travail, nous avons un AST complet représentant le modèle. Le nœud racine est `Latte\Compiler\Nodes\TemplateNode`. Les nœuds individuels à l'intérieur de l'arbre représentent non seulement les balises, mais aussi les éléments HTML, leurs attributs, les expressions utilisées à l'intérieur des balises, etc.

Ensuite, les [passes du compilateur |#Compiler passes] entrent en jeu. Il s'agit de fonctions (renvoyées par [Extension::getPasses() |#getPasses]) qui modifient l'AST.

L'ensemble du processus, depuis le chargement du contenu du modèle, en passant par l'analyse syntaxique, jusqu'à la génération du fichier résultant, peut être séquencé à l'aide de ce code, avec lequel vous pouvez expérimenter et vidanger les résultats intermédiaires :

```php
$latte = new Latte\Engine;
$source = $latte->getLoader()->getContent($file);
$ast = $latte->parse($source);
$latte->applyPasses($ast);
$code = $latte->generate($ast, $file);
```


Exemple d'AST .[#toc-example-of-ast]
------------------------------------

Pour avoir une meilleure idée de l'AST, nous ajoutons un exemple. Il s'agit du modèle source :

```latte
{foreach $category->getItems() as $item}
	<li>{$item->name|upper}</li>
	{else}
	no items found
{/foreach}
```

Et voici sa représentation sous forme d'AST :

/--pre
Latte\Compiler\Nodes\<b>TemplateNode</b>(
   Latte\Compiler\Nodes\<b>FragmentNode</b>(
      - Latte\Essential\Nodes\<b>ForeachNode</b>(
           expression: Latte\Compiler\Nodes\Php\Expression\<b>MethodCallNode</b>(
              object: Latte\Compiler\Nodes\Php\Expression\<b>VariableNode</b>('$category')
              name: Latte\Compiler\Nodes\Php\<b>IdentifierNode</b>('getItems')
           )
           value: Latte\Compiler\Nodes\Php\Expression\<b>VariableNode</b>('$item')
           content: Latte\Compiler\Nodes\<b>FragmentNode</b>(
              - Latte\Compiler\Nodes\<b>TextNode</b>('  ')
              - Latte\Compiler\Nodes\<b>Html\ElementNode</b>('li')(
                   content: Latte\Essential\Nodes\<b>PrintNode</b>(
                      expression: Latte\Compiler\Nodes\Php\Expression\<b>PropertyFetchNode</b>(
                         object: Latte\Compiler\Nodes\Php\Expression\<b>VariableNode</b>('$item')
                         name: Latte\Compiler\Nodes\Php\<b>IdentifierNode</b>('name')
                      )
                      modifier: Latte\Compiler\Nodes\Php\<b>ModifierNode</b>(
                         filters:
                            - Latte\Compiler\Nodes\Php\<b>FilterNode</b>('upper')
                      )
                   )
                )
            )
            else: Latte\Compiler\Nodes\<b>FragmentNode</b>(
               - Latte\Compiler\Nodes\<b>TextNode</b>('no items found')
            )
        )
   )
)
\--


Balises personnalisées .[#toc-custom-tags]
==========================================

Trois étapes sont nécessaires pour définir une nouvelle balise :

- définition de la [fonction d'analyse de la balise |#tag parsing function] (responsable de l'analyse de la balise en un nœud)
- création d'une classe de nœud (responsable de la [génération du code PHP |#generating PHP code] et de la [traversée de l'AST |#AST traversing])
- enregistrement de la balise à l'aide de [Extension::getTags() |#getTags]


Fonction d'analyse syntaxique des balises .[#toc-tag-parsing-function]
----------------------------------------------------------------------

L'analyse des balises est gérée par leur fonction d'analyse (celle renvoyée par [Extension::getTags() |#getTags]). Son travail consiste à analyser et à vérifier les arguments contenus dans la balise (elle utilise TagParser pour ce faire).
De plus, si la balise est une paire, elle demandera à TemplateParser d'analyser et de retourner le contenu interne.
La fonction crée et renvoie un nœud, qui est généralement un enfant de `Latte\Compiler\Nodes\StatementNode`, et qui devient une partie de l'AST.

Nous créons une classe pour chaque nœud, ce que nous allons faire maintenant, et nous y plaçons élégamment la fonction d'analyse en tant que fabrique statique. À titre d'exemple, essayons de créer la balise familière `{foreach}`:

```php
use Latte\Compiler\Nodes\StatementNode;

class ForeachNode extends StatementNode
{
	// une fonction d'analyse syntaxique qui crée simplement un nœud pour l'instant
	public static function create(Latte\Compiler\Tag $tag): self
	{
		$node = $tag->node = new self;
		return $node;
	}

	public function print(Latte\Compiler\PrintContext $context): string
	{
		// le code sera ajouté plus tard
	}

	public function &getIterator(): \Generator
	{
		// le code sera ajouté plus tard
	}
}
```

La fonction d'analyse syntaxique `create()` reçoit un objet [api:Latte\Compiler\Tag], qui contient des informations de base sur la balise (s'il s'agit d'une balise classique ou d'un n:attribut, sur quelle ligne elle se trouve, etc.) et accède principalement à [api:Latte\Compiler\TagParser] dans `$tag->parser`.

Si la balise doit avoir des arguments, vérifiez leur existence en appelant `$tag->expectArguments()`. Les méthodes de l'objet `$tag->parser` sont disponibles pour les analyser :

- `parseExpression(): ExpressionNode` pour une expression de type PHP (par exemple `10 + 3`)
- `parseUnquotedStringOrExpression(): ExpressionNode` pour une expression ou une chaîne de caractères non citée
- `parseArguments(): ArrayNode` pour le contenu d'un tableau (par exemple, `10, true, foo => bar`)
- `parseModifier(): ModifierNode` pour un modificateur (par ex. `|upper|truncate:10`)
- `parseType(): expressionNode` pour un indice de type (par exemple, `int|string` ou `Foo\Bar[]`)

et un bas niveau [api:Latte\Compiler\TokenStream] opérant directement avec les jetons :

- `$tag->parser->stream->consume(...): Token`
- `$tag->parser->stream->tryConsume(...): ?Token`

Latte étend la syntaxe de PHP par petites touches, par exemple en ajoutant des modificateurs, des opérateurs ternaires raccourcis, ou en permettant d'écrire des chaînes alphanumériques simples sans guillemets. C'est pourquoi nous utilisons le terme *PHP-like* au lieu de PHP. Ainsi, la méthode `parseExpression()` analyse `foo` comme `'foo'`, par exemple.
En outre, *unquoted-string* est un cas particulier de chaîne de caractères qui n'a pas besoin d'être citée, mais qui n'a pas besoin d'être alphanumérique. Par exemple, il s'agit du chemin d'accès à un fichier dans la balise `{include ../file.latte}`. La méthode `parseUnquotedStringOrExpression()` est utilisée pour l'analyser.

.[note]
L'étude des classes de nœuds qui font partie de Latte est la meilleure façon d'apprendre tous les détails minutieux du processus d'analyse.

Revenons à la balise `{foreach}`. Dans cette balise, nous attendons des arguments de la forme `expression + 'as' + second expression`, que nous analysons comme suit :

```php
use Latte\Compiler\Nodes\StatementNode;
use Latte\Compiler\Nodes\Php\ExpressionNode;
use Latte\Compiler\Nodes\AreaNode;

class ForeachNode extends StatementNode
{
	public ExpressionNode $expression;
	public ExpressionNode $value;

	public static function create(Latte\Compiler\Tag $tag): self
	{
		$tag->expectArguments();
		$node = $tag->node = new self;
		$node->expression = $tag->parser->parseExpression();
		$tag->parser->stream->consume('as');
		$node->value = $parser->parseExpression();
		return $node;
	}
}
```

Les expressions que nous avons écrites dans les variables `$expression` et `$value` représentent des sous-nœuds.

.[tip]
Définissez les variables avec les sous-nœuds comme **publics** afin qu'ils puissent être modifiés dans les [étapes de traitement ultérieures |#Compiler Passes] si nécessaire. Il est également nécessaire de les rendre **disponibles** pour la [navigation |#AST Traversing].

Pour les balises appariées, comme la nôtre, la méthode doit également laisser TemplateParser analyser le contenu interne de la balise. Ceci est géré par `yield`, qui renvoie une paire ''[contenu interne, balise finale]''. Nous stockons le contenu interne dans la variable `$node->content`.

```php
public AreaNode $content;

public static function create(Latte\Compiler\Tag $tag): \Generator
{
	// ...
	[$node->content, $endTag] = yield;
	return $node;
}
```

Le mot-clé `yield` entraîne la fin de la méthode `create()`, qui redonne le contrôle au TemplateParser, qui continue à analyser le contenu jusqu'à ce qu'il atteigne la balise de fin. Il transmet ensuite le contrôle à `create()`, qui reprend là où il s'est arrêté. L'utilisation de la méthode `yield`, renvoie automatiquement `Generator`.

Vous pouvez également transmettre à `yield` un tableau de noms de balises pour lesquelles vous souhaitez arrêter l'analyse s'ils apparaissent avant la balise de fin. Cela nous aide à mettre en œuvre la construction `{foreach}...{else}...{/foreach}` construction. Si `{else}` apparaît, nous analysons le contenu qui le suit dans `$node->elseContent`:

```php
public AreaNode $content;
public ?AreaNode $elseContent = null;

public static function create(Latte\Compiler\Tag $tag): \Generator
{
	// ...
	[$node->content, $nextTag] = yield ['else'];
	if ($nextTag?->name === 'else') {
		[$node->elseContent] = yield;
	}

	return $node;
}
```

Le nœud de retour termine l'analyse des balises.


Génération du code PHP .[#toc-generating-php-code]
--------------------------------------------------

Chaque nœud doit implémenter la méthode `print()`. Renvoie le code PHP qui rend la partie donnée du modèle (code d'exécution). On lui passe un objet [api:Latte\Compiler\PrintContext] en paramètre, qui possède une méthode utile `format()` qui simplifie l'assemblage du code résultant.

La méthode `format(string $mask, ...$args)` accepte les caractères de remplacement suivants dans le masque :
- `%node` imprime Node
- `%dump` exporte la valeur vers PHP
- `%raw` insère le texte directement sans aucune transformation
- `%args` imprime ArrayNode comme arguments à l'appel de fonction
- `%line` imprime un commentaire avec un numéro de ligne
- `%escape(...)` échappe le contenu
- `%modify(...)` applique un modificateur
- `%modifyContent(...)` applique un modificateur aux blocs


Notre fonction `print()` pourrait ressembler à ceci (nous négligeons la branche `else` pour simplifier) :

```php
public function print(Latte\Compiler\PrintContext $context): string
{
	return $context->format(
		<<<'XX'
			foreach (%node as %node) %line {
				%node
			}

			XX,
		$this->expression,
		$this->value,
		$this->position,
		$this->content,
	);
}
```

La variable `$this->position` est déjà définie par la classe [api:Latte\Compiler\Node] et est définie par l'analyseur syntaxique. Elle contient un objet [api:Latte\Compiler\Position] avec la position de la balise dans le code source sous la forme d'un numéro de ligne et de colonne.

Le code d'exécution peut utiliser des variables auxiliaires. Pour éviter toute collision avec les variables utilisées par le modèle lui-même, il est de convention de les préfixer avec les caractères `$ʟ__`.

Il peut également utiliser des valeurs arbitraires au moment de l'exécution, qui sont transmises au modèle sous la forme de fournisseurs à l'aide de la méthode [Extension::getProviders() |#getProviders]. Il y accède en utilisant `$this->global->...`.


Traversée de l'AST .[#toc-ast-traversing]
-----------------------------------------

Afin de traverser l'arbre AST en profondeur, il est nécessaire d'implémenter la méthode `getIterator()`. Cela permettra d'accéder aux sous-nœuds :

```php
public function &getIterator(): \Generator
{
	yield $this->expression;
	yield $this->value;
	yield $this->content;
	if ($this->elseContent) {
		yield $this->elseContent;
	}
}
```

Notez que `getIterator()` renvoie une référence. C'est ce qui permet aux visiteurs des nœuds de remplacer les nœuds individuels par d'autres nœuds.

.[warning]
Si un nœud a des sous-nœuds, il est nécessaire d'implémenter cette méthode et de rendre tous les sous-nœuds disponibles. Sinon, une faille de sécurité pourrait être créée. Par exemple, le mode sandbox ne serait pas en mesure de contrôler les sous-nœuds et de garantir que les constructions non autorisées ne sont pas appelées dans ces derniers.

Étant donné que le mot-clé `yield` doit être présent dans le corps de la méthode, même si celle-ci n'a pas de nœuds enfants, écrivez-la comme suit :

```php
public function &getIterator(): \Generator
{
	if (false) {
		yield;
	}
}
```


AuxiliaryNode (nœud auxiliaire) .[#toc-auxiliarynode]
-----------------------------------------------------

Si vous créez une nouvelle balise pour Latte, il est conseillé de créer une classe de nœuds dédiée, qui la représentera dans l'arbre AST (voir la classe `ForeachNode` dans l'exemple ci-dessus). Dans certains cas, la classe de nœuds auxiliaire triviale [AuxiliaryNode |api:Latte\Compiler\Nodes\Php\Expression\AuxiliaryNode] peut s'avérer utile, car elle permet de passer le corps de la méthode `print()` et la liste des nœuds rendus accessibles par la méthode `getIterator()` en tant que paramètres du constructeur :

```php
// Latte\Compiler\Nodes\Php\Expression\AuxiliaryNode
// or Latte\Compiler\Nodes\AuxiliaryNode

$node = new AuxiliaryNode(
	// body of the print() method:
	fn(PrintContext $context, $argNode) => $context->format('myFunc(%node)', $argNode),
	// nodes accessed via getIterator() and also passed into the print() method:
	[$argNode],
);
```


Le compilateur passe .[#toc-compiler-passes]
============================================

Les Compiler Passes sont des fonctions qui modifient les AST ou collectent des informations dans ces derniers. Elles sont renvoyées par la méthode [Extension::getPasses() |#getPasses].


Traverseur de nœuds .[#toc-node-traverser]
------------------------------------------

La façon la plus courante de travailler avec l'AST est d'utiliser un [api:Latte\Compiler\NodeTraverser]:

```php
use Latte\Compiler\Node;
use Latte\Compiler\NodeTraverser;

$ast = (new NodeTraverser)->traverse(
	$ast,
	enter: fn(Node $node) => ...,
	leave: fn(Node $node) => ...,
);
```

La fonction *enter* (c'est-à-dire le visiteur) est appelée lorsqu'un nœud est rencontré pour la première fois, avant que ses sous-nœuds ne soient traités. La fonction *leave* est appelée après que tous les sous-nœuds aient été visités.
Un modèle commun est que la fonction *enter* est utilisée pour collecter certaines informations, puis la fonction *leave* effectue des modifications sur cette base. Au moment où *leave* est appelée, tout le code à l'intérieur du nœud aura déjà été visité et les informations nécessaires auront été collectées.

Comment modifier l'AST ? La manière la plus simple est de changer simplement les propriétés des nœuds. La deuxième façon est de remplacer entièrement le nœud en retournant un nouveau nœud. Exemple : le code suivant changera tous les entiers de l'AST en chaînes de caractères (par exemple, 42 sera changé en `'42'`).

```php
use Latte\Compiler\Nodes\Php;

$ast = (new NodeTraverser)->traverse(
	$ast,
	leave: function (Node $node) {
		if ($node instanceof Php\Scalar\IntegerNode) {
            return new Php\Scalar\StringNode((string) $node->value);
        }
	},
);
```

Un AST peut facilement contenir des milliers de nœuds, et les parcourir tous peut être lent. Dans certains cas, il est possible d'éviter une traversée complète.

Si vous cherchez tous les `Html\ElementNode` dans un arbre, vous savez qu'une fois que vous avez vu `Php\ExpressionNode`, il est inutile de vérifier également tous ses nœuds enfants, car le HTML ne peut pas être à l'intérieur des expressions. Dans ce cas, vous pouvez demander au traverseur de ne pas faire de récursion dans le nœud de classe :

```php
$ast = (new NodeTraverser)->traverse(
	$ast,
	enter: function (Node $node) {
		if ($node instanceof Php\ExpressionNode) {
			return NodeTraverser::DontTraverseChildren;
        }
        // ...
	},
);
```

Si vous ne recherchez qu'un seul nœud spécifique, il est également possible d'interrompre entièrement la traversée après l'avoir trouvé.

```php
$ast = (new NodeTraverser)->traverse(
	$ast,
	enter: function (Node $node) {
		if ($node instanceof Nodes\ParametersNode) {
			return NodeTraverser::StopTraversal;
        }
        // ...
	},
);
```


Aides pour les nœuds .[#toc-node-helpers]
-----------------------------------------

La classe [api:Latte\Compiler\NodeHelpers] fournit quelques méthodes qui peuvent trouver des noeuds AST qui satisfont un certain callback etc. Quelques exemples sont montrés :

```php
use Latte\Compiler\NodeHelpers;

// trouve tous les nœuds d'éléments HTML
$elements = NodeHelpers::find($ast, fn(Node $node) => $node instanceof Nodes\Html\ElementNode);

// trouve le premier noeud de texte
$text = NodeHelpers::findFirst($ast, fn(Node $node) => $node instanceof Nodes\TextNode);

// convertit le noeud de valeur PHP en valeur réelle
$value = NodeHelpers::toValue($node);

// convertit un noeud textuel statique en chaîne de caractères
$text = NodeHelpers::toText($node);
```