1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
---
layout: default
title: The Environment
description: Configuring the CommonMark environment with custom options and added functionality
---
# The Environment
The `Environment` contains all of the parsers, renderers, configurations, etc. that the library uses during the conversion process. You therefore must register all parsers, renderers, etc. with the `Environment` so that the library is aware of them.
A pre-configured `Environment` can be obtained like this:
```php
use League\CommonMark\Environment;
$environment = Environment::createCommonMarkEnvironment();
```
All of the core renders, parsers, etc. needed to implement the CommonMark spec will be pre-registered and ready to go.
You can customize this default `Environment` (or even a new, empty one) using any of the methods below (from the `ConfigurableEnvironmentInterface` interface).
## mergeConfig()
```php
public function mergeConfig(array $config = []);
```
Merges the given [configuration](/1.6/configuration/) settings into any existing ones.
## addExtension()
```php
public function addExtension(ExtensionInterface $extension);
```
Registers the given [extension](/1.6/customization/extensions/) with the environment. This is typically how you'd integrate third-party extensions with this library.
## addBlockParser()
```php
public function addBlockParser(BlockParserInterface $parser, int $priority = 0);
```
Registers the given `BlockParserInterface` with the environment with the given priority (a higher number will be executed earlier).
See [Block Parsing](/1.6/customization/block-parsing/) for details.
## addBlockRenderer()
```php
public function addBlockRenderer(string $blockClass, BlockRendererInterface $blockRenderer, int $priority = 0);
```
Registers a `BlockRendererInterface` to handle a specific type of block (`$blockClass`) with the given priority (a higher number will be executed earlier).
See [Block Rendering](/1.6/customization/block-rendering/) for details.
## addInlineParser()
```php
public function addInlineParser(InlineParserInterface $parser, int $priority = 0);
```
Registers the given `InlineParserInterface` with the environment with the given priority (a higher number will be executed earlier).
See [Inline Parsing](/1.6/customization/inline-parsing/) for details.
## addInlineRenderer()
```php
public function addInlineRenderer(string $inlineClass, InlineRendererInterface $renderer, int $priority = 0);
```
Registers an `InlineRendererInterface` to handle a specific type of inline (`$inlineClass`) with the given priority (a higher number will be executed earlier).
A single renderer can handle multiple inline classes, but you must register it separately for each type. (The same renderer instance can be re-used if desired.)
See [Inline Rendering](/1.6/customization/inline-rendering/) for details.
## addDelimiterProcessor()
```php
public function addDelimiterProcessor(DelimiterProcessorInterface $processor);
```
Registers the given `DelimiterProcessorInterface` with the environment.
See [Inline Parsing](/1.6/customization/delimiter-processing/) for details.
## addEventListener()
```php
public function addEventListener(string $eventClass, callable $listener, int $priority = 0);
```
Registers the given event listener with the environment.
See [Event Dispatcher](/1.6/customization/event-dispatcher/) for details.
## Priority
Several of these methods allows you to specify a numeric `$priority`. In cases where multiple things are registered, the internal engine will attempt to use the higher-priority ones first, falling back to lower priority ones if the first one(s) were unable to handle things.
## Accessing the Environment and Configuration within parsers/renderers/etc
If your custom parser/renderer/listener/etc. implements either `EnvironmentAwareInterface` or `ConfigurationAwareInterface` we'll automatically inject the environment or configuration into them once the environment has been fully initialized. This will provide your code with access to the finalized information it may need.
|
