diff --git a/src/IsRule.php b/src/IsRule.php
new file mode 100644
index 0000000..4fc3301
--- /dev/null
+++ b/src/IsRule.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Tempest\Markdown;
+
+/**
+ * The default token support of a rule. Implementations declare the context
+ * they are written for, and the tokens that deviate from it.
+ */
+trait IsRule
+{
+    /** @var \Tempest\Markdown\RuleContext[] */
+    private(set) array $contexts = [RuleContext::BLOCK];
+
+    /** @var array<class-string<\Tempest\Markdown\Token>, bool> */
+    private(set) array $tokenSupport = [];
+
+    public function supportsToken(Token $token): bool
+    {
+        return (
+            $this->tokenSupport[$token::class] ?? in_array(
+                RuleContext::INLINE,
+                $this->contexts,
+                strict: true,
+            )
+        );
+    }
+
+    /** @param class-string<\Tempest\Markdown\Token> $token */
+    public function addTokenSupport(string $token): static
+    {
+        $this->tokenSupport[$token] = true;
+
+        return $this;
+    }
+
+    /** @param class-string<\Tempest\Markdown\Token> $token */
+    public function removeTokenSupport(string $token): static
+    {
+        $this->tokenSupport[$token] = false;
+
+        return $this;
+    }
+}
diff --git a/src/Markdown.php b/src/Markdown.php
index f40bf71..342edba 100644
--- a/src/Markdown.php
+++ b/src/Markdown.php
@@ -53,4 +53,15 @@ public function removeRules(string ...$rules): self
 
         return $this;
     }
+
+    /**
+     * The registered instance of $rule, to reconfigure it or to change the
+     * tokens it supports.
+     *
+     * @param class-string<\Tempest\Markdown\Rule> $rule
+     */
+    public function getRule(string $rule): ?Rule
+    {
+        return $this->parser->getRule($rule);
+    }
 }
diff --git a/src/Parser.php b/src/Parser.php
index 26ce0ba..2487580 100644
--- a/src/Parser.php
+++ b/src/Parser.php
@@ -4,11 +4,17 @@
 
 use Tempest\Highlight\Highlighter;
 use Tempest\Markdown\Exceptions\MaximumNestingDepthWasExceeded;
+use Tempest\Markdown\Rules\BoldAndItalicRule;
+use Tempest\Markdown\Rules\BoldRule;
+use Tempest\Markdown\Rules\CodeRule;
 use Tempest\Markdown\Rules\DivRule;
 use Tempest\Markdown\Rules\FrontMatterRule;
 use Tempest\Markdown\Rules\HeadingRule;
 use Tempest\Markdown\Rules\HtmlCommentRule;
 use Tempest\Markdown\Rules\HtmlRule;
+use Tempest\Markdown\Rules\ImageRule;
+use Tempest\Markdown\Rules\ItalicRule;
+use Tempest\Markdown\Rules\LinkRule;
 use Tempest\Markdown\Rules\ListRule;
 use Tempest\Markdown\Rules\NewLineRule;
 use Tempest\Markdown\Rules\OrderedListRule;
@@ -16,7 +22,10 @@
 use Tempest\Markdown\Rules\PreRule;
 use Tempest\Markdown\Rules\QuoteRule;
 use Tempest\Markdown\Rules\RawRule;
+use Tempest\Markdown\Rules\SocialHandleRule;
+use Tempest\Markdown\Rules\StrikethroughRule;
 use Tempest\Markdown\Rules\TableRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Rules\ThickRulerRule;
 use Tempest\Markdown\Rules\ThinRulerRule;
 use Tempest\Markdown\Tokens\FrontMatterToken;
@@ -33,6 +42,7 @@ final class Parser
     private(set) ?string $current;
     private(set) string $content;
     private(set) ?Token $lastToken = null;
+    /** Every registered rule, whether or not it runs here. */
     /** @var \Tempest\Markdown\Rule[] */
     private(set) array $rules = [];
     /** @var \Tempest\Markdown\Rule[] */
@@ -45,6 +55,7 @@ final class Parser
 
     private static int $depth = 0;
 
+    /** @param \Tempest\Markdown\Rule[] $rules */
     public function __construct(
         public ?Highlighter $highlighter = new Highlighter(),
         public ?ResponsiveImageFactory $imageFactory = null,
@@ -65,12 +76,27 @@ public function __construct(
             new HtmlRule(),
             new TableRule(),
             new ParagraphRule(),
+            new BoldAndItalicRule(),
+            new BoldRule(),
+            new ItalicRule(),
+            new StrikethroughRule(),
+            new CodeRule(),
+            new LinkRule(),
+            new SocialHandleRule(),
+            new ImageRule(),
+            new TextRule(),
         ],
     ) {
         $this->setRules($rules);
     }
 
-    public function forToken(Token $token, array $rules): self
+    /**
+     * A parser for the content of $token, running every registered rule that
+     * supports it. Rules are never rebuilt here: they are the configured
+     * instances, so adding, removing or reconfiguring a rule reaches nested
+     * content too.
+     */
+    public function forToken(Token $token): self
     {
         if (isset($this->cache[$token::class])) {
             return $this->cache[$token::class];
@@ -78,13 +104,36 @@ public function forToken(Token $token, array $rules): self
 
         $clone = clone $this;
 
-        $clone->setRules($rules);
+        $clone->activateRules(array_values(array_filter(
+            $this->rules,
+            static fn (Rule $rule) => $rule->supportsToken($token),
+        )));
 
         $this->cache[$token::class] = $clone;
 
         return $clone;
     }
 
+    /**
+     * The registered instance of $rule, to reconfigure it or to change the
+     * tokens it supports. Sub-parsers are derived from the rules, so handing
+     * one out drops the ones already built from it.
+     *
+     * @param class-string<\Tempest\Markdown\Rule> $rule
+     */
+    public function getRule(string $rule): ?Rule
+    {
+        $this->cache = [];
+
+        foreach ($this->rules as $registered) {
+            if ($registered::class === $rule) {
+                return $registered;
+            }
+        }
+
+        return null;
+    }
+
     public function withRules(Rule ...$rules): self
     {
         $clone = clone $this;
@@ -125,24 +174,41 @@ public function removeRules(string ...$rules): self
         return $clone;
     }
 
+    /** @param \Tempest\Markdown\Rule[] $rules */
     private function setRules(array $rules): self
     {
-        /** @var \Tempest\Markdown\NeedsStopChars[] $needsStopChars */
-        $needsStopChars = [];
+        $this->rules = $rules;
+
+        return $this->activateRules($rules);
+    }
+
+    /** @param \Tempest\Markdown\Rule[] $rules */
+    private function activateRules(array $rules): self
+    {
         $providedStopChars = '';
 
         foreach ($rules as $rule) {
-            if ($rule instanceof ProvidesStopChar) {
-                $providedStopChars .= $rule->stopChar;
+            if (! $rule instanceof ProvidesStopChar) {
+                continue;
             }
 
-            if ($rule instanceof NeedsStopChars) {
-                $needsStopChars[] = $rule;
-            }
+            $providedStopChars .= $rule->stopChar;
         }
 
-        foreach ($needsStopChars as $rule) {
-            $rule->stopChars .= $providedStopChars;
+        foreach ($rules as $key => $rule) {
+            if (! $rule instanceof NeedsStopChars) {
+                continue;
+            }
+
+            if ($rule->stopChars === $providedStopChars) {
+                continue;
+            }
+
+            // Stop chars belong to a rule set, not to a rule: the registered
+            // instance is shared between sets, so this set gets its own copy
+            // instead of overwriting the stop chars of the previous one.
+            $rules[$key] = clone $rule;
+            $rules[$key]->stopChars = $providedStopChars;
         }
 
         $perCharRules = [];
@@ -167,12 +233,11 @@ private function setRules(array $rules): self
             }
         }
 
-        /** @var \Tempest\Markdown\Rule[] $rules */
         /** @var \Tempest\Markdown\Rule[] $defaultRules */
         /** @var \Tempest\Markdown\Rule[][] $perCharRules */
-        $this->rules = $rules;
         $this->defaultRules = $defaultRules;
         $this->perCharRules = $perCharRules;
+        $this->cache = [];
 
         return $this;
     }
diff --git a/src/Rule.php b/src/Rule.php
index 420dc88..1de81de 100644
--- a/src/Rule.php
+++ b/src/Rule.php
@@ -7,4 +7,13 @@ interface Rule
     public function shouldParse(Parser $parser): bool;
 
     public function parse(Parser $parser): ?Token;
+
+    /** Whether this rule runs on the content of $token. */
+    public function supportsToken(Token $token): bool;
+
+    /** @param class-string<\Tempest\Markdown\Token> $token */
+    public function addTokenSupport(string $token): static;
+
+    /** @param class-string<\Tempest\Markdown\Token> $token */
+    public function removeTokenSupport(string $token): static;
 }
diff --git a/src/RuleContext.php b/src/RuleContext.php
new file mode 100644
index 0000000..54e64e9
--- /dev/null
+++ b/src/RuleContext.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Tempest\Markdown;
+
+/**
+ * The content a rule is written for. It decides which tokens a rule supports
+ * by default; {@see \Tempest\Markdown\Rule::addTokenSupport()} and
+ * {@see \Tempest\Markdown\Rule::removeTokenSupport()} override that per token.
+ */
+enum RuleContext
+{
+    /** Structure: the rule only runs on the document, and on the containers that opt in. */
+    case BLOCK;
+
+    /** A run of text: the rule runs inside every token that holds inline content. */
+    case INLINE;
+}
diff --git a/src/Rules/BoldAndItalicRule.php b/src/Rules/BoldAndItalicRule.php
index f1733a0..049f622 100644
--- a/src/Rules/BoldAndItalicRule.php
+++ b/src/Rules/BoldAndItalicRule.php
@@ -2,21 +2,36 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\BoldAndItalicToken;
+use Tempest\Markdown\Tokens\BoldToken;
+use Tempest\Markdown\Tokens\ItalicToken;
 
 final class BoldAndItalicRule implements
     Rule,
     ProvidesFirstChar,
     ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '*_';
     private(set) string $stopChar = '_*';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+
+        $this->removeTokenSupport(BoldToken::class);
+        $this->removeTokenSupport(ItalicToken::class);
+        $this->removeTokenSupport(BoldAndItalicToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return (
diff --git a/src/Rules/BoldRule.php b/src/Rules/BoldRule.php
index de2a7ad..5b4ac88 100644
--- a/src/Rules/BoldRule.php
+++ b/src/Rules/BoldRule.php
@@ -2,18 +2,31 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
+use Tempest\Markdown\Tokens\BoldAndItalicToken;
 use Tempest\Markdown\Tokens\BoldToken;
 
 final class BoldRule implements Rule, ProvidesFirstChar, ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '*_';
     private(set) string $stopChar = '*_';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+
+        $this->removeTokenSupport(BoldToken::class);
+        $this->removeTokenSupport(BoldAndItalicToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         $stopToken = $parser->lookaheadUntil('*_')[0] ?? null;
diff --git a/src/Rules/CodeRule.php b/src/Rules/CodeRule.php
index 4a1b6cc..9f1966d 100644
--- a/src/Rules/CodeRule.php
+++ b/src/Rules/CodeRule.php
@@ -2,18 +2,27 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\CodeToken;
 
 final class CodeRule implements Rule, ProvidesFirstChar, ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '`';
     private(set) string $stopChar = '`';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return $parser->comesNext('`', 1);
diff --git a/src/Rules/DivRule.php b/src/Rules/DivRule.php
index 556640c..73d86c4 100644
--- a/src/Rules/DivRule.php
+++ b/src/Rules/DivRule.php
@@ -2,18 +2,27 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\DivToken;
+use Tempest\Markdown\Tokens\ParagraphToken;
 
 final class DivRule implements Rule, ProvidesFirstChar, ProvidesStopChar
 {
+    use IsRule;
+
     public string $stopChar = ':';
     public string $firstChar = ':';
 
+    public function __construct()
+    {
+        $this->addTokenSupport(ParagraphToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return $parser->comesNext(':::', 3);
diff --git a/src/Rules/FrontMatterRule.php b/src/Rules/FrontMatterRule.php
index 232835e..af0afb5 100644
--- a/src/Rules/FrontMatterRule.php
+++ b/src/Rules/FrontMatterRule.php
@@ -7,6 +7,7 @@
 use Tempest\Markdown\Exceptions\FrontMatterCouldNotBeParsed;
 use Tempest\Markdown\Exceptions\FrontMatterShouldBeAnArray;
 use Tempest\Markdown\Exceptions\FrontMatterWasNotProperlyClosed;
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -15,6 +16,8 @@
 
 final class FrontMatterRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '-';
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Rules/HeadingRule.php b/src/Rules/HeadingRule.php
index edc05e7..3f8ca01 100644
--- a/src/Rules/HeadingRule.php
+++ b/src/Rules/HeadingRule.php
@@ -2,14 +2,18 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
 use Tempest\Markdown\Token;
+use Tempest\Markdown\Tokens\DivToken;
 use Tempest\Markdown\Tokens\HeadingToken;
 
 final class HeadingRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '#';
 
     public function __construct(
@@ -18,7 +22,9 @@ public function __construct(
          * content. An id written as `## Title ## id` is kept either way.
          */
         public bool $generateIds = true,
-    ) {}
+    ) {
+        $this->addTokenSupport(DivToken::class);
+    }
 
     public function shouldParse(Parser $parser): bool
     {
diff --git a/src/Rules/HtmlCommentRule.php b/src/Rules/HtmlCommentRule.php
index 3513afc..625c022 100644
--- a/src/Rules/HtmlCommentRule.php
+++ b/src/Rules/HtmlCommentRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -10,6 +11,8 @@
 
 final class HtmlCommentRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '<';
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Rules/HtmlRule.php b/src/Rules/HtmlRule.php
index a56e0cc..51e47a3 100644
--- a/src/Rules/HtmlRule.php
+++ b/src/Rules/HtmlRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -10,6 +11,8 @@
 
 final class HtmlRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     /**
      * Elements whose content is raw text rather than Markdown.
      *
diff --git a/src/Rules/ImageRule.php b/src/Rules/ImageRule.php
index 7bd2bdc..bf28b35 100644
--- a/src/Rules/ImageRule.php
+++ b/src/Rules/ImageRule.php
@@ -4,18 +4,27 @@
 
 use Tempest\Markdown\Exceptions\ImageSourceWasMissing;
 use Tempest\Markdown\Exceptions\ImageSourceWasNotClosed;
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\ImageToken;
 
 final class ImageRule implements Rule, ProvidesFirstChar, ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '!';
     private(set) string $stopChar = '!';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return $parser->comesNext('![', 2);
diff --git a/src/Rules/ItalicRule.php b/src/Rules/ItalicRule.php
index 539970b..c7edc36 100644
--- a/src/Rules/ItalicRule.php
+++ b/src/Rules/ItalicRule.php
@@ -2,18 +2,31 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
+use Tempest\Markdown\Tokens\BoldAndItalicToken;
 use Tempest\Markdown\Tokens\ItalicToken;
 
 final class ItalicRule implements Rule, ProvidesFirstChar, ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '*_';
     private(set) string $stopChar = '*_';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+
+        $this->removeTokenSupport(ItalicToken::class);
+        $this->removeTokenSupport(BoldAndItalicToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         $stopToken = $parser->lookaheadUntil('*_')[0] ?? null;
diff --git a/src/Rules/LinkRule.php b/src/Rules/LinkRule.php
index 3c16b96..2c3f6d2 100644
--- a/src/Rules/LinkRule.php
+++ b/src/Rules/LinkRule.php
@@ -2,18 +2,29 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\LinkToken;
 
 final class LinkRule implements Rule, ProvidesFirstChar, ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '[';
     private(set) string $stopChar = '[';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+
+        $this->removeTokenSupport(LinkToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return $parser->comesNext('[', 1);
diff --git a/src/Rules/ListRule.php b/src/Rules/ListRule.php
index 73704c0..65e0e71 100644
--- a/src/Rules/ListRule.php
+++ b/src/Rules/ListRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -11,6 +12,8 @@
 
 final class ListRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '-*+';
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Rules/NewLineRule.php b/src/Rules/NewLineRule.php
index 8bf42f5..a8d582b 100644
--- a/src/Rules/NewLineRule.php
+++ b/src/Rules/NewLineRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -10,6 +11,8 @@
 
 final class NewLineRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = "\n\r";
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Rules/OrderedListRule.php b/src/Rules/OrderedListRule.php
index 588673b..4a1245c 100644
--- a/src/Rules/OrderedListRule.php
+++ b/src/Rules/OrderedListRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -11,6 +12,8 @@
 
 final class OrderedListRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '0123456789';
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Rules/ParagraphRule.php b/src/Rules/ParagraphRule.php
index 707fb3f..239fd29 100644
--- a/src/Rules/ParagraphRule.php
+++ b/src/Rules/ParagraphRule.php
@@ -2,14 +2,17 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rule;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\HeadingToken;
 use Tempest\Markdown\Tokens\ParagraphToken;
 
-final readonly class ParagraphRule implements Rule
+final class ParagraphRule implements Rule
 {
+    use IsRule;
+
     public function shouldParse(Parser $parser): bool
     {
         return true;
diff --git a/src/Rules/PreRule.php b/src/Rules/PreRule.php
index 7c8cc8d..ef6bc11 100644
--- a/src/Rules/PreRule.php
+++ b/src/Rules/PreRule.php
@@ -2,16 +2,27 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
 use Tempest\Markdown\Token;
+use Tempest\Markdown\Tokens\DivToken;
+use Tempest\Markdown\Tokens\ParagraphToken;
 use Tempest\Markdown\Tokens\PreToken;
 
 final class PreRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '`~';
 
+    public function __construct()
+    {
+        $this->addTokenSupport(DivToken::class);
+        $this->addTokenSupport(ParagraphToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return $parser->comesNext('```', 3) || $parser->comesNext('~~~', 3);
diff --git a/src/Rules/QuoteRule.php b/src/Rules/QuoteRule.php
index 90321ba..52f4fb2 100644
--- a/src/Rules/QuoteRule.php
+++ b/src/Rules/QuoteRule.php
@@ -2,18 +2,28 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
 use Tempest\Markdown\Token;
+use Tempest\Markdown\Tokens\DivToken;
 use Tempest\Markdown\Tokens\QuoteToken;
 
 final class QuoteRule implements Rule, ProvidesFirstChar, ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '>';
     private(set) string $stopChar = '>';
 
+    public function __construct()
+    {
+        $this->addTokenSupport(DivToken::class);
+        $this->addTokenSupport(QuoteToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         if (! $parser->comesNext('>', 1)) {
diff --git a/src/Rules/RawRule.php b/src/Rules/RawRule.php
index bc1ed13..f913411 100644
--- a/src/Rules/RawRule.php
+++ b/src/Rules/RawRule.php
@@ -2,13 +2,16 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rule;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\RawToken;
 
-final readonly class RawRule implements Rule
+final class RawRule implements Rule
 {
+    use IsRule;
+
     public function shouldParse(Parser $parser): bool
     {
         return $parser->comesNext('@@', length: 2);
diff --git a/src/Rules/SocialHandleRule.php b/src/Rules/SocialHandleRule.php
index fbcf9a1..29d8245 100644
--- a/src/Rules/SocialHandleRule.php
+++ b/src/Rules/SocialHandleRule.php
@@ -4,10 +4,12 @@
 
 use Tempest\Markdown\Exceptions\SocialHandlePlatformWasUnknown;
 use Tempest\Markdown\Exceptions\SocialHandleWasInvalid;
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\LinkToken;
 
@@ -20,9 +22,18 @@ final class SocialHandleRule implements
     ProvidesFirstChar,
     ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '{';
     private(set) string $stopChar = '{';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+
+        $this->removeTokenSupport(LinkToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return (
diff --git a/src/Rules/StrikethroughRule.php b/src/Rules/StrikethroughRule.php
index 2e9adc3..faf0955 100644
--- a/src/Rules/StrikethroughRule.php
+++ b/src/Rules/StrikethroughRule.php
@@ -2,10 +2,12 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\ProvidesStopChar;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\StrikethroughToken;
 use Tempest\Markdown\Tokens\TextToken;
@@ -15,9 +17,18 @@ final class StrikethroughRule implements
     ProvidesFirstChar,
     ProvidesStopChar
 {
+    use IsRule;
+
     private(set) string $firstChar = '~';
     private(set) string $stopChar = '~';
 
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+
+        $this->removeTokenSupport(StrikethroughToken::class);
+    }
+
     public function shouldParse(Parser $parser): bool
     {
         return $parser->comesNext('~', 1);
diff --git a/src/Rules/TableRule.php b/src/Rules/TableRule.php
index c5e16f9..dd96ec9 100644
--- a/src/Rules/TableRule.php
+++ b/src/Rules/TableRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -11,6 +12,8 @@
 
 final class TableRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '|';
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Rules/TextRule.php b/src/Rules/TextRule.php
index e78f1e7..0c73735 100644
--- a/src/Rules/TextRule.php
+++ b/src/Rules/TextRule.php
@@ -2,17 +2,23 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\NeedsStopChars;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
 use Tempest\Markdown\Token;
 use Tempest\Markdown\Tokens\TextToken;
 
 final class TextRule implements Rule, NeedsStopChars
 {
+    use IsRule;
+
     public function __construct(
         public string $stopChars = '',
-    ) {}
+    ) {
+        $this->contexts = [RuleContext::INLINE];
+    }
 
     public function shouldParse(Parser $parser): bool
     {
diff --git a/src/Rules/ThickRulerRule.php b/src/Rules/ThickRulerRule.php
index 881e8ec..fc4e648 100644
--- a/src/Rules/ThickRulerRule.php
+++ b/src/Rules/ThickRulerRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -11,6 +12,8 @@
 
 final class ThickRulerRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '=';
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Rules/ThinRulerRule.php b/src/Rules/ThinRulerRule.php
index 53f0b86..8e71a6d 100644
--- a/src/Rules/ThinRulerRule.php
+++ b/src/Rules/ThinRulerRule.php
@@ -2,6 +2,7 @@
 
 namespace Tempest\Markdown\Rules;
 
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\ProvidesFirstChar;
 use Tempest\Markdown\Rule;
@@ -11,6 +12,8 @@
 
 final class ThinRulerRule implements Rule, ProvidesFirstChar
 {
+    use IsRule;
+
     public string $firstChar = '-';
 
     public function shouldParse(Parser $parser): bool
diff --git a/src/Tokens/BoldAndItalicToken.php b/src/Tokens/BoldAndItalicToken.php
index 271ee18..7773ace 100644
--- a/src/Tokens/BoldAndItalicToken.php
+++ b/src/Tokens/BoldAndItalicToken.php
@@ -3,12 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class BoldAndItalicToken implements Token
@@ -20,14 +14,7 @@ public function __construct(
     public function parse(Parser $parser): string
     {
         $content = $parser
-            ->forToken($this, [
-                new StrikethroughRule(),
-                new CodeRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->content);
 
         return "<strong><em>{$content}</em></strong>";
diff --git a/src/Tokens/BoldToken.php b/src/Tokens/BoldToken.php
index cd2a8a0..2614c12 100644
--- a/src/Tokens/BoldToken.php
+++ b/src/Tokens/BoldToken.php
@@ -3,13 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class BoldToken implements Token
@@ -21,15 +14,7 @@ public function __construct(
     public function parse(Parser $parser): string
     {
         $content = $parser
-            ->forToken($this, [
-                new ItalicRule(),
-                new StrikethroughRule(),
-                new CodeRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->content);
 
         return "<strong>{$content}</strong>";
diff --git a/src/Tokens/DivToken.php b/src/Tokens/DivToken.php
index 0ea7470..2f19efd 100644
--- a/src/Tokens/DivToken.php
+++ b/src/Tokens/DivToken.php
@@ -3,18 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\HeadingRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\PreRule;
-use Tempest\Markdown\Rules\QuoteRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class DivToken implements Token
@@ -27,20 +15,7 @@ public function __construct(
     public function parse(Parser $parser): string
     {
         $content = $parser
-            ->forToken($this, [
-                new HeadingRule(),
-                new QuoteRule(),
-                new BoldAndItalicRule(),
-                new BoldRule(),
-                new ItalicRule(),
-                new StrikethroughRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new PreRule(),
-                new CodeRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->content);
 
         $class = $this->class
diff --git a/src/Tokens/HeadingToken.php b/src/Tokens/HeadingToken.php
index 385f3b2..96c38e2 100644
--- a/src/Tokens/HeadingToken.php
+++ b/src/Tokens/HeadingToken.php
@@ -3,15 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class HeadingToken implements Token
@@ -33,17 +24,7 @@ public function parse(Parser $parser): string
         }
 
         $content = $parser
-            ->forToken($this, [
-                new BoldAndItalicRule(),
-                new BoldRule(),
-                new ItalicRule(),
-                new StrikethroughRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new CodeRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->content);
 
         return "<{$tag}{$id}>{$content}</{$tag}>";
diff --git a/src/Tokens/HtmlToken.php b/src/Tokens/HtmlToken.php
index 5663e04..a1ecfe3 100644
--- a/src/Tokens/HtmlToken.php
+++ b/src/Tokens/HtmlToken.php
@@ -3,15 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class HtmlToken implements Token
@@ -30,17 +21,7 @@ public function parse(Parser $parser): string
         }
 
         return $parser
-            ->forToken($this, [
-                new BoldAndItalicRule(),
-                new BoldRule(),
-                new ItalicRule(),
-                new StrikethroughRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new CodeRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->html)
             ->html;
     }
diff --git a/src/Tokens/ItalicToken.php b/src/Tokens/ItalicToken.php
index dceeb9e..aabbea1 100644
--- a/src/Tokens/ItalicToken.php
+++ b/src/Tokens/ItalicToken.php
@@ -3,13 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class ItalicToken implements Token
@@ -21,15 +14,7 @@ public function __construct(
     public function parse(Parser $parser): string
     {
         $content = $parser
-            ->forToken($this, [
-                new BoldRule(),
-                new StrikethroughRule(),
-                new CodeRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->content);
 
         return "<em>{$content}</em>";
diff --git a/src/Tokens/LinkToken.php b/src/Tokens/LinkToken.php
index 7e8c856..785aee1 100644
--- a/src/Tokens/LinkToken.php
+++ b/src/Tokens/LinkToken.php
@@ -3,13 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class LinkToken implements Token
@@ -28,15 +21,7 @@ public function parse(Parser $parser): string
 
         if ($this->parseContent) {
             $content = $parser
-                ->forToken($this, [
-                    new CodeRule(),
-                    new BoldAndItalicRule(),
-                    new BoldRule(),
-                    new ItalicRule(),
-                    new StrikethroughRule(),
-                    new ImageRule(),
-                    new TextRule(),
-                ])
+                ->forToken($this)
                 ->parse($this->content);
         }
 
diff --git a/src/Tokens/ListToken.php b/src/Tokens/ListToken.php
index e228ed3..3597f66 100644
--- a/src/Tokens/ListToken.php
+++ b/src/Tokens/ListToken.php
@@ -3,15 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class ListToken implements Token
@@ -23,17 +14,7 @@ public function __construct(
 
     public function parse(Parser $parser): string
     {
-        $parser = $parser->forToken($this, [
-            new BoldAndItalicRule(),
-            new BoldRule(),
-            new ItalicRule(),
-            new StrikethroughRule(),
-            new LinkRule(),
-            new SocialHandleRule(),
-            new ImageRule(),
-            new CodeRule(),
-            new TextRule(),
-        ]);
+        $parser = $parser->forToken($this);
 
         $list = '<ul>';
 
diff --git a/src/Tokens/OrderedListToken.php b/src/Tokens/OrderedListToken.php
index d588b46..f80a7ff 100644
--- a/src/Tokens/OrderedListToken.php
+++ b/src/Tokens/OrderedListToken.php
@@ -3,15 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class OrderedListToken implements Token
@@ -26,17 +17,7 @@ public function __construct(
 
     public function parse(Parser $parser): string
     {
-        $parser = $parser->forToken($this, [
-            new BoldAndItalicRule(),
-            new BoldRule(),
-            new ItalicRule(),
-            new StrikethroughRule(),
-            new LinkRule(),
-            new SocialHandleRule(),
-            new ImageRule(),
-            new CodeRule(),
-            new TextRule(),
-        ]);
+        $parser = $parser->forToken($this);
 
         $list = $this->start === 1
             ? '<ol>'
diff --git a/src/Tokens/ParagraphToken.php b/src/Tokens/ParagraphToken.php
index e7af088..c4cd2c4 100644
--- a/src/Tokens/ParagraphToken.php
+++ b/src/Tokens/ParagraphToken.php
@@ -3,17 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\DivRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\PreRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class ParagraphToken implements Token
@@ -24,20 +13,7 @@ public function __construct(
 
     public function parse(Parser $parser): string
     {
-        $parser = $parser->forToken($this, [
-            new BoldAndItalicRule(),
-            new BoldRule(),
-            new ItalicRule(),
-            new StrikethroughRule(),
-            new LinkRule(),
-            // @todo(aidan-casey): We shouldn't parse social handles by default. We need to make these "sub-parsers" configurable.
-            new SocialHandleRule(),
-            new ImageRule(),
-            new PreRule(),
-            new CodeRule(),
-            new DivRule(),
-            new TextRule(),
-        ]);
+        $parser = $parser->forToken($this);
 
         $content = $parser->parse($this->content);
 
diff --git a/src/Tokens/QuoteToken.php b/src/Tokens/QuoteToken.php
index f6f11d5..134ece3 100644
--- a/src/Tokens/QuoteToken.php
+++ b/src/Tokens/QuoteToken.php
@@ -3,16 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\QuoteRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class QuoteToken implements Token
@@ -24,18 +14,7 @@ public function __construct(
     public function parse(Parser $parser): string
     {
         $content = $parser
-            ->forToken($this, [
-                new BoldAndItalicRule(),
-                new BoldRule(),
-                new ItalicRule(),
-                new StrikethroughRule(),
-                new CodeRule(),
-                new QuoteRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->content);
 
         return "<blockquote>{$content}</blockquote>";
diff --git a/src/Tokens/StrikethroughToken.php b/src/Tokens/StrikethroughToken.php
index 8b68180..d6e75c7 100644
--- a/src/Tokens/StrikethroughToken.php
+++ b/src/Tokens/StrikethroughToken.php
@@ -3,14 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class StrikethroughToken implements Token
@@ -22,16 +14,7 @@ public function __construct(
     public function parse(Parser $parser): string
     {
         $content = $parser
-            ->forToken($this, [
-                new BoldAndItalicRule(),
-                new BoldRule(),
-                new ItalicRule(),
-                new CodeRule(),
-                new LinkRule(),
-                new SocialHandleRule(),
-                new ImageRule(),
-                new TextRule(),
-            ])
+            ->forToken($this)
             ->parse($this->content);
 
         return "<s>{$content}</s>";
diff --git a/src/Tokens/TableToken.php b/src/Tokens/TableToken.php
index ea69f2d..c35af47 100644
--- a/src/Tokens/TableToken.php
+++ b/src/Tokens/TableToken.php
@@ -3,15 +3,6 @@
 namespace Tempest\Markdown\Tokens;
 
 use Tempest\Markdown\Parser;
-use Tempest\Markdown\Rules\BoldAndItalicRule;
-use Tempest\Markdown\Rules\BoldRule;
-use Tempest\Markdown\Rules\CodeRule;
-use Tempest\Markdown\Rules\ImageRule;
-use Tempest\Markdown\Rules\ItalicRule;
-use Tempest\Markdown\Rules\LinkRule;
-use Tempest\Markdown\Rules\SocialHandleRule;
-use Tempest\Markdown\Rules\StrikethroughRule;
-use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Token;
 
 final class TableToken implements Token
@@ -23,17 +14,7 @@ public function __construct(
 
     public function parse(Parser $parser): string
     {
-        $parser = $parser->forToken($this, [
-            new BoldAndItalicRule(),
-            new BoldRule(),
-            new ItalicRule(),
-            new StrikethroughRule(),
-            new LinkRule(),
-            new SocialHandleRule(),
-            new CodeRule(),
-            new ImageRule(),
-            new TextRule(),
-        ]);
+        $parser = $parser->forToken($this);
 
         $headerRows = array_values(array_filter(
             $this->rows,
diff --git a/tests/MarkdownTest.php b/tests/MarkdownTest.php
index fcdc618..2c8554a 100644
--- a/tests/MarkdownTest.php
+++ b/tests/MarkdownTest.php
@@ -4,6 +4,7 @@
 
 use PHPUnit\Framework\Attributes\Before;
 use PHPUnit\Framework\Attributes\Test;
+use Tempest\Markdown\IsRule;
 use Tempest\Markdown\Markdown;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rule;
@@ -32,6 +33,8 @@ public function test_parse(): void
     public function test_prepend_rules_takes_priority_over_default_rules(): void
     {
         $customRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return $parser->comesNext('#');
@@ -63,6 +66,8 @@ public function parse(Parser $parser): string
     public function test_prepend_rules_can_be_chained(): void
     {
         $customRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return $parser->comesNext('#');
@@ -86,6 +91,8 @@ public function parse(Parser $parser): string
         };
 
         $neverMatchRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return false;
@@ -109,6 +116,8 @@ public function parse(Parser $parser): ?Token
     public function test_with_rules_replaces_all_default_rules(): void
     {
         $customRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return $parser->comesNext('#');
@@ -140,6 +149,8 @@ public function parse(Parser $parser): string
     public function test_with_rules_returns_same_instance(): void
     {
         $customRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return false;
@@ -160,6 +171,8 @@ public function parse(Parser $parser): ?Token
     public function test_append_rules_matches_after_with_rules_removes_catch_all(): void
     {
         $headingRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return $parser->comesNext('#');
@@ -194,6 +207,8 @@ public function parse(Parser $parser): string
     public function test_append_rules_loses_to_default_rules_when_both_match(): void
     {
         $customRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return $parser->comesNext('#');
@@ -226,6 +241,8 @@ public function parse(Parser $parser): string
     public function test_prepend_rules_returns_same_instance(): void
     {
         $customRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return false;
@@ -246,6 +263,8 @@ public function parse(Parser $parser): ?Token
     public function test_append_rules_returns_same_instance(): void
     {
         $customRule = new class implements Rule {
+            use IsRule;
+
             public function shouldParse(Parser $parser): bool
             {
                 return false;
diff --git a/tests/RuleRegistryTest.php b/tests/RuleRegistryTest.php
new file mode 100644
index 0000000..a8fcbf1
--- /dev/null
+++ b/tests/RuleRegistryTest.php
@@ -0,0 +1,214 @@
+<?php
+
+namespace Tempest\Markdown\Tests;
+
+use PHPUnit\Framework\Attributes\Test;
+use Tempest\Markdown\IsRule;
+use Tempest\Markdown\Markdown;
+use Tempest\Markdown\Parser;
+use Tempest\Markdown\ProvidesFirstChar;
+use Tempest\Markdown\ProvidesStopChar;
+use Tempest\Markdown\Rule;
+use Tempest\Markdown\RuleContext;
+use Tempest\Markdown\Rules\ImageRule;
+use Tempest\Markdown\Rules\LinkRule;
+use Tempest\Markdown\Rules\StrikethroughRule;
+use Tempest\Markdown\Token;
+use Tempest\Markdown\Tokens\HeadingToken;
+use Tempest\Markdown\Tokens\LinkToken;
+
+/**
+ * The parser is the single place rules are registered. Nested content is
+ * parsed with the rules that are registered there and support the token,
+ * never with a list rebuilt by the token.
+ */
+final class RuleRegistryTest extends ParserTestCase
+{
+    #[Test]
+    public function a_removed_rule_does_not_reach_nested_content(): void
+    {
+        $markdown = new Markdown(highlighter: null)->removeRules(
+            StrikethroughRule::class,
+        );
+
+        $this->assertSame(
+            '<p>~~struck~~</p>',
+            $markdown->parse('~~struck~~')->html,
+        );
+        $this->assertSame(
+            '<ul><li>~~struck~~</li></ul>',
+            $markdown->parse('- ~~struck~~')->html,
+        );
+        $this->assertSame(
+            '<p><strong>~~struck~~</strong></p>',
+            $markdown->parse('**~~struck~~**')->html,
+        );
+    }
+
+    #[Test]
+    public function an_added_inline_rule_reaches_nested_content(): void
+    {
+        $markdown = new Markdown(highlighter: null)->prependRules(
+            new HighlightRule(),
+        );
+
+        $this->assertSame(
+            '<p>look <mark>here</mark> now</p>',
+            $markdown->parse('look ==here== now')->html,
+        );
+        $this->assertSame(
+            '<ul><li><mark>here</mark></li></ul>',
+            $markdown->parse('- ==here==')->html,
+        );
+        $this->assertSame(
+            '<blockquote><mark>here</mark></blockquote>',
+            $markdown->parse('> ==here==')->html,
+        );
+        $this->assertSame(
+            '<p><strong><mark>here</mark></strong></p>',
+            $markdown->parse('**==here==**')->html,
+        );
+    }
+
+    #[Test]
+    public function a_custom_token_gets_the_registered_inline_rules(): void
+    {
+        $markdown = new Markdown(highlighter: null)->prependRules(
+            new AsideRule(),
+        );
+
+        $this->assertSame(
+            '<aside><strong>bold</strong> and <s>struck</s></aside>',
+            $markdown->parse('!! **bold** and ~~struck~~')->html,
+        );
+    }
+
+    #[Test]
+    public function token_support_can_be_added_on_a_registered_rule(): void
+    {
+        $markdown = new Markdown(highlighter: null);
+
+        $this->assertSame(
+            '<p><a href="/b">a [c](/d) e</a></p>',
+            $markdown->parse('[a [c](/d) e](/b)')->html,
+        );
+
+        $markdown->getRule(LinkRule::class)?->addTokenSupport(LinkToken::class);
+
+        $this->assertSame(
+            '<p><a href="/b">a <a href="/d">c</a> e</a></p>',
+            $markdown->parse('[a [c](/d) e](/b)')->html,
+        );
+    }
+
+    #[Test]
+    public function token_support_can_be_removed_on_a_registered_rule(): void
+    {
+        $markdown = new Markdown(highlighter: null);
+
+        $markdown
+            ->getRule(ImageRule::class)
+            ?->removeTokenSupport(
+                HeadingToken::class,
+            );
+
+        $this->assertSame(
+            '<p><img src="i.png" alt="a"></p>',
+            $markdown->parse('![a](i.png)')->html,
+        );
+        $this->assertSame(
+            '<h1 id="a-i-png">!<a href="i.png">a</a></h1>',
+            $markdown->parse('# ![a](i.png)')->html,
+        );
+    }
+
+    #[Test]
+    public function nested_rule_sets_keep_their_own_stop_chars(): void
+    {
+        $markdown = new Markdown(highlighter: null);
+
+        // The second call reuses the sub-parser cached by the first one.
+        $this->assertSame(
+            '<p><strong>bold</strong></p>',
+            $markdown->parse('**bold**')->html,
+        );
+        $this->assertSame(
+            '<p><strong>bold</strong></p>',
+            $markdown->parse('**bold**')->html,
+        );
+    }
+}
+
+final class HighlightRule implements Rule, ProvidesFirstChar, ProvidesStopChar
+{
+    use IsRule;
+
+    private(set) string $firstChar = '=';
+    private(set) string $stopChar = '=';
+
+    public function __construct()
+    {
+        $this->contexts = [RuleContext::INLINE];
+    }
+
+    public function shouldParse(Parser $parser): bool
+    {
+        return $parser->comesNext('==', 2) && $parser->hasNext('==', "\n");
+    }
+
+    public function parse(Parser $parser): Token
+    {
+        $parser->consume(2);
+
+        $content = $parser->consumeUntilString('==');
+
+        $parser->consume(2);
+
+        return new HighlightToken($content);
+    }
+}
+
+final class HighlightToken implements Token
+{
+    public function __construct(
+        public string $content,
+    ) {}
+
+    public function parse(Parser $parser): string
+    {
+        return "<mark>{$this->content}</mark>";
+    }
+}
+
+final class AsideRule implements Rule, ProvidesFirstChar
+{
+    use IsRule;
+
+    private(set) string $firstChar = '!';
+
+    public function shouldParse(Parser $parser): bool
+    {
+        return $parser->comesNext('!! ', 3);
+    }
+
+    public function parse(Parser $parser): Token
+    {
+        $parser->consume(3);
+
+        return new AsideToken($parser->consumeUntil(Parser::NEW_LINE));
+    }
+}
+
+final class AsideToken implements Token
+{
+    public function __construct(
+        public string $content,
+    ) {}
+
+    public function parse(Parser $parser): string
+    {
+        $content = $parser->forToken($this)->parse($this->content);
+
+        return "<aside>{$content}</aside>";
+    }
+}
diff --git a/tests/Rules/BoldAndItalicRuleTest.php b/tests/Rules/BoldAndItalicRuleTest.php
index 1f51f5d..9e20dea 100644
--- a/tests/Rules/BoldAndItalicRuleTest.php
+++ b/tests/Rules/BoldAndItalicRuleTest.php
@@ -7,6 +7,7 @@
 use Tempest\Markdown\Rules\BoldAndItalicRule;
 use Tempest\Markdown\Rules\BoldRule;
 use Tempest\Markdown\Rules\ItalicRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class BoldAndItalicRuleTest extends ParserTestCase
@@ -18,6 +19,7 @@ public function test_triple_asterisk_bold_and_italic(): void
             new BoldAndItalicRule(),
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('***text***');
 
         $this->assertSame('<strong><em>text</em></strong>', $html);
@@ -30,6 +32,7 @@ public function test_triple_underscore_bold_and_italic(): void
             new BoldAndItalicRule(),
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('___text___');
 
         $this->assertSame('<strong><em>text</em></strong>', $html);
@@ -42,6 +45,7 @@ public function test_single_underscore_double_asterisk(): void
             new BoldAndItalicRule(),
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('_**text**_');
 
         $this->assertSame('<em><strong>text</strong></em>', $html);
@@ -54,6 +58,7 @@ public function test_single_asterisk_double_underscore(): void
             new BoldAndItalicRule(),
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('*__text__*');
 
         $this->assertSame('<em><strong>text</strong></em>', $html);
@@ -66,6 +71,7 @@ public function test_double_underscore_single_asterisk(): void
             new BoldAndItalicRule(),
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('__*text*__');
 
         $this->assertSame('<strong><em>text</em></strong>', $html);
@@ -78,6 +84,7 @@ public function test_double_asterisk_single_underscore(): void
             new BoldAndItalicRule(),
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('**_text_**');
 
         $this->assertSame('<strong><em>text</em></strong>', $html);
@@ -86,33 +93,39 @@ public function test_double_asterisk_single_underscore(): void
     #[Test]
     public function test_does_not_lex_double_asterisk(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldAndItalicRule()])->parse(
-                '**text**',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldAndItalicRule(),
+            new TextRule(),
+        ])->parse(
+            '**text**',
+        );
 
-        $this->assertSame('', $html);
+        $this->assertSame('**text**', $html);
     }
 
     #[Test]
     public function test_does_not_lex_single_asterisk(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldAndItalicRule()])->parse(
-                '*text*',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldAndItalicRule(),
+            new TextRule(),
+        ])->parse(
+            '*text*',
+        );
 
-        $this->assertSame('', $html);
+        $this->assertSame('*text*', $html);
     }
 
     #[Test]
     public function test_does_not_lex_double_underscore(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldAndItalicRule()])->parse(
-                '__text__',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldAndItalicRule(),
+            new TextRule(),
+        ])->parse(
+            '__text__',
+        );
 
-        $this->assertSame('', $html);
+        $this->assertSame('__text__', $html);
     }
 }
diff --git a/tests/Rules/BoldRuleTest.php b/tests/Rules/BoldRuleTest.php
index 9e59e9b..5204ed6 100644
--- a/tests/Rules/BoldRuleTest.php
+++ b/tests/Rules/BoldRuleTest.php
@@ -8,6 +8,7 @@
 use Tempest\Markdown\Rules\ItalicRule;
 use Tempest\Markdown\Rules\NewLineRule;
 use Tempest\Markdown\Rules\ParagraphRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class BoldRuleTest extends ParserTestCase
@@ -15,10 +16,12 @@ class BoldRuleTest extends ParserTestCase
     #[Test]
     public function test_lex_double_asterisk(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldRule()])->parse(
-                '**bold**',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldRule(),
+            new TextRule(),
+        ])->parse(
+            '**bold**',
+        );
 
         $this->assertSame('<strong>bold</strong>', $html);
     }
@@ -30,6 +33,7 @@ public function test_double_asterisk_must_be_terminated(): void
             new NewLineRule(),
             new BoldRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("Hello**world\n\nHi");
 
         $this->assertSame("<p>Hello**world</p>\n\n<p>Hi</p>", $html);
@@ -41,6 +45,7 @@ public function test_lex_asterisk_with_underscore(): void
         $html = (string) new Parser(highlighter: null, rules: [
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('**_bold_**');
 
         $this->assertSame('<strong><em>bold</em></strong>', $html);
@@ -49,21 +54,25 @@ public function test_lex_asterisk_with_underscore(): void
     #[Test]
     public function test_does_not_lex_single_asterisk(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldRule()])->parse(
-                '*bold*',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldRule(),
+            new TextRule(),
+        ])->parse(
+            '*bold*',
+        );
 
-        $this->assertSame('', $html);
+        $this->assertSame('*bold*', $html);
     }
 
     #[Test]
     public function test_lex_double_underscore(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldRule()])->parse(
-                '__bold__',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldRule(),
+            new TextRule(),
+        ])->parse(
+            '__bold__',
+        );
 
         $this->assertSame('<strong>bold</strong>', $html);
     }
@@ -75,6 +84,7 @@ public function test_double_underscore_must_be_terminated(): void
             new NewLineRule(),
             new BoldRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("Hello__world\n\nHi");
 
         $this->assertSame("<p>Hello__world</p>\n\n<p>Hi</p>", $html);
@@ -83,21 +93,24 @@ public function test_double_underscore_must_be_terminated(): void
     #[Test]
     public function test_does_not_lex_single_underscore(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldRule()])->parse(
-                '_bold_',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldRule(),
+            new TextRule(),
+        ])->parse(
+            '_bold_',
+        );
 
-        $this->assertSame('', $html);
+        $this->assertSame('_bold_', $html);
     }
 
     #[Test]
     public function test_underscore_with_asterisk(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new BoldRule()])->parse(
-                '__*bold*__',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new BoldRule(),
+            new ItalicRule(),
+            new TextRule(),
+        ])->parse('__*bold*__');
 
         $this->assertSame('<strong><em>bold</em></strong>', $html);
     }
diff --git a/tests/Rules/CodeRuleTest.php b/tests/Rules/CodeRuleTest.php
index 8138522..36fa855 100644
--- a/tests/Rules/CodeRuleTest.php
+++ b/tests/Rules/CodeRuleTest.php
@@ -5,6 +5,7 @@
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\CodeRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class CodeRuleTest extends ParserTestCase
@@ -12,10 +13,12 @@ class CodeRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new CodeRule()])->parse(
-                '`code`',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new CodeRule(),
+            new TextRule(),
+        ])->parse(
+            '`code`',
+        );
 
         $this->assertSame('<code>code</code>', $html);
     }
@@ -23,10 +26,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_with_language(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new CodeRule()])->parse(
-                '`{php}code`',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new CodeRule(),
+            new TextRule(),
+        ])->parse(
+            '`{php}code`',
+        );
 
         $this->assertSame('<code class="language-php">code</code>', $html);
     }
@@ -34,10 +39,12 @@ public function test_lex_with_language(): void
     #[Test]
     public function test_with_custom_hl_token(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new CodeRule()])->parse(
-                '`{:hl-class:code:}`',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new CodeRule(),
+            new TextRule(),
+        ])->parse(
+            '`{:hl-class:code:}`',
+        );
 
         $this->assertSame('<code>{:hl-class:code:}</code>', $html);
     }
diff --git a/tests/Rules/DivRuleTest.php b/tests/Rules/DivRuleTest.php
index 634aa46..a98dcd9 100644
--- a/tests/Rules/DivRuleTest.php
+++ b/tests/Rules/DivRuleTest.php
@@ -5,6 +5,7 @@
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\DivRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class DivRuleTest extends ParserTestCase
@@ -12,10 +13,12 @@ class DivRuleTest extends ParserTestCase
     #[Test]
     public function test_lex_without_class(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new DivRule()])->parse(
-                ":::\nHello\n:::\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new DivRule(),
+            new TextRule(),
+        ])->parse(
+            ":::\nHello\n:::\n",
+        );
 
         $this->assertSame("<div>Hello\n</div>", $html);
     }
@@ -23,10 +26,12 @@ public function test_lex_without_class(): void
     #[Test]
     public function test_lex_with_class(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new DivRule()])->parse(
-                ":::warning\nHello\n:::\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new DivRule(),
+            new TextRule(),
+        ])->parse(
+            ":::warning\nHello\n:::\n",
+        );
 
         $this->assertSame("<div class=\"warning\">Hello\n</div>", $html);
     }
@@ -34,10 +39,12 @@ public function test_lex_with_class(): void
     #[Test]
     public function test_lex_with_multiple_classes(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new DivRule()])->parse(
-                ":::foo bar\nHello\n:::\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new DivRule(),
+            new TextRule(),
+        ])->parse(
+            ":::foo bar\nHello\n:::\n",
+        );
 
         $this->assertSame("<div class=\"foo bar\">Hello\n</div>", $html);
     }
@@ -45,10 +52,12 @@ public function test_lex_with_multiple_classes(): void
     #[Test]
     public function test_lex_multiline_content(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new DivRule()])->parse(
-                ":::warning\nline one\nline two\n:::\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new DivRule(),
+            new TextRule(),
+        ])->parse(
+            ":::warning\nline one\nline two\n:::\n",
+        );
 
         $this->assertSame(
             "<div class=\"warning\">line one\nline two\n</div>",
diff --git a/tests/Rules/FrontMatterRuleTest.php b/tests/Rules/FrontMatterRuleTest.php
index 4411dbd..a040c93 100644
--- a/tests/Rules/FrontMatterRuleTest.php
+++ b/tests/Rules/FrontMatterRuleTest.php
@@ -11,6 +11,7 @@
 use Tempest\Markdown\Rules\FrontMatterRule;
 use Tempest\Markdown\Rules\NewLineRule;
 use Tempest\Markdown\Rules\ParagraphRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Rules\ThinRulerRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
@@ -23,6 +24,7 @@ public function standalone_delimiter_is_a_thematic_break(): void
             new FrontMatterRule(),
             new ThinRulerRule(),
             new NewLineRule(),
+            new TextRule(),
         ]);
 
         $this->assertSame('<hr/>', $parser->parse('---')->html);
@@ -57,6 +59,7 @@ public function test_lex(): void
             new FrontMatterRule(),
             new NewLineRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse(<<<'MD'
         ---
         title: Hello
@@ -80,6 +83,7 @@ public function test_lex_with_longer_frontmatter_lines(): void
             new FrontMatterRule(),
             new NewLineRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse(<<<'MD'
         -----
         title: Hello
@@ -104,6 +108,7 @@ public function scalar_frontmatter_is_normalized_to_empty_data(): void
                 new FrontMatterRule(),
                 new NewLineRule(),
                 new ParagraphRule(),
+                new TextRule(),
             ])->parse(<<<'MD'
             ---
             just text
@@ -127,6 +132,7 @@ public function test_complex_frontmatter(): void
             new FrontMatterRule(),
             new NewLineRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse(<<<'MD'
         ---
         title: Introduction
@@ -151,7 +157,10 @@ public function test_complex_frontmatter(): void
     public function invalid_frontmatter_throws_exception(): void
     {
         try {
-            new Parser(highlighter: null, rules: [new FrontMatterRule()])->parse(
+            new Parser(highlighter: null, rules: [
+                new FrontMatterRule(),
+                new TextRule(),
+            ])->parse(
                 <<<'MD'
                 ---
                 title: "Introduction
@@ -171,7 +180,10 @@ public function invalid_frontmatter_throws_exception(): void
     public function unclosed_frontmatter_throws_exception(): void
     {
         try {
-            new Parser(highlighter: null, rules: [new FrontMatterRule()])->parse(
+            new Parser(highlighter: null, rules: [
+                new FrontMatterRule(),
+                new TextRule(),
+            ])->parse(
                 <<<'MD'
                 ---
                 title: "Introduction"
diff --git a/tests/Rules/HeadingRuleTest.php b/tests/Rules/HeadingRuleTest.php
index 314d0a0..b89517d 100644
--- a/tests/Rules/HeadingRuleTest.php
+++ b/tests/Rules/HeadingRuleTest.php
@@ -6,6 +6,7 @@
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\HeadingRule;
 use Tempest\Markdown\Rules\ParagraphRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class HeadingRuleTest extends ParserTestCase
@@ -13,10 +14,12 @@ class HeadingRuleTest extends ParserTestCase
     #[Test]
     public function test_lex_h1(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HeadingRule()])->parse(
-                '# Hello',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ])->parse(
+            '# Hello',
+        );
 
         $this->assertSame('<h1 id="hello">Hello</h1>', $html);
     }
@@ -24,10 +27,12 @@ public function test_lex_h1(): void
     #[Test]
     public function test_lex_deep_heading(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HeadingRule()])->parse(
-                '### Hello',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ])->parse(
+            '### Hello',
+        );
 
         $this->assertSame('<h3 id="hello">Hello</h3>', $html);
     }
@@ -35,10 +40,12 @@ public function test_lex_deep_heading(): void
     #[Test]
     public function test_heading_text_shorter_than_level(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HeadingRule()])->parse(
-                '#### Fin',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ])->parse(
+            '#### Fin',
+        );
 
         $this->assertSame('<h4 id="fin">Fin</h4>', $html);
     }
@@ -46,10 +53,12 @@ public function test_heading_text_shorter_than_level(): void
     #[Test]
     public function test_lex_with_heading_id(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HeadingRule()])->parse(
-                '### Hello ### hello-world',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ])->parse(
+            '### Hello ### hello-world',
+        );
 
         $this->assertSame('<h3 id="hello-world">Hello</h3>', $html);
     }
@@ -57,10 +66,12 @@ public function test_lex_with_heading_id(): void
     #[Test]
     public function test_slug_is_constrained_to_a_safe_alphabet(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HeadingRule()])->parse(
-                '# Hello, "World" & Friends!',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ])->parse(
+            '# Hello, "World" & Friends!',
+        );
 
         $this->assertSame(
             '<h1 id="hello-world-friends">Hello, "World" & Friends!</h1>',
@@ -71,10 +82,12 @@ public function test_slug_is_constrained_to_a_safe_alphabet(): void
     #[Test]
     public function test_slug_cannot_break_out_of_the_id_attribute(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HeadingRule()])->parse(
-                '# h " onclick="alert(1)',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ])->parse(
+            '# h " onclick="alert(1)',
+        );
 
         $this->assertSame(
             '<h1 id="h-onclick-alert-1">h " onclick="alert(1)</h1>',
@@ -85,10 +98,12 @@ public function test_slug_cannot_break_out_of_the_id_attribute(): void
     #[Test]
     public function lex_generates_an_id_by_default(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HeadingRule()])->parse(
-                '## A heading',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ])->parse(
+            '## A heading',
+        );
 
         $this->assertSame('<h2 id="a-heading">A heading</h2>', $html);
     }
@@ -98,6 +113,7 @@ public function lex_without_generated_ids(): void
     {
         $html = (string) new Parser(highlighter: null, rules: [
             new HeadingRule(generateIds: false),
+            new TextRule(),
         ])->parse('## A heading');
 
         $this->assertSame('<h2>A heading</h2>', $html);
@@ -108,6 +124,7 @@ public function lex_keeps_an_explicit_id_without_generated_ids(): void
     {
         $html = (string) new Parser(highlighter: null, rules: [
             new HeadingRule(generateIds: false),
+            new TextRule(),
         ])->parse('## A heading ## custom-id');
 
         $this->assertSame('<h2 id="custom-id">A heading</h2>', $html);
@@ -119,6 +136,7 @@ public function lex_without_a_space_after_the_marker_is_not_a_heading(): void
         $parser = new Parser(highlighter: null, rules: [
             new HeadingRule(),
             new ParagraphRule(),
+            new TextRule(),
         ]);
 
         $this->assertSame('<p>#titre</p>', (string) $parser->parse('#titre'));
@@ -135,6 +153,7 @@ public function lex_more_than_six_markers_is_not_a_heading(): void
         $html = (string) new Parser(highlighter: null, rules: [
             new HeadingRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse('####### seven');
 
         $this->assertSame('<p>####### seven</p>', $html);
@@ -143,7 +162,10 @@ public function lex_more_than_six_markers_is_not_a_heading(): void
     #[Test]
     public function lex_marker_alone_is_an_empty_heading(): void
     {
-        $parser = new Parser(highlighter: null, rules: [new HeadingRule()]);
+        $parser = new Parser(highlighter: null, rules: [
+            new HeadingRule(),
+            new TextRule(),
+        ]);
 
         $this->assertSame('<h1></h1>', (string) $parser->parse('#'));
         $this->assertSame('<h2></h2>', (string) $parser->parse('##'));
diff --git a/tests/Rules/HtmlCommentRuleTest.php b/tests/Rules/HtmlCommentRuleTest.php
index 4ee0bd8..dc11999 100644
--- a/tests/Rules/HtmlCommentRuleTest.php
+++ b/tests/Rules/HtmlCommentRuleTest.php
@@ -7,6 +7,7 @@
 use Tempest\Markdown\Rules\HtmlCommentRule;
 use Tempest\Markdown\Rules\NewLineRule;
 use Tempest\Markdown\Rules\ParagraphRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class HtmlCommentRuleTest extends ParserTestCase
@@ -14,10 +15,12 @@ class HtmlCommentRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlCommentRule()])->parse(
-                '<!-- comment -->',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlCommentRule(),
+            new TextRule(),
+        ])->parse(
+            '<!-- comment -->',
+        );
 
         $this->assertSame('<!-- comment -->', $html);
     }
@@ -27,10 +30,12 @@ public function test_lex_multiline(): void
     {
         $comment = "<!--\nmultiline\ncomment\n-->";
 
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlCommentRule()])->parse(
-                $comment,
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlCommentRule(),
+            new TextRule(),
+        ])->parse(
+            $comment,
+        );
 
         $this->assertSame($comment, $html);
     }
@@ -42,6 +47,7 @@ public function test_lex_with_surrounding_content(): void
             new NewLineRule(),
             new HtmlCommentRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("Hello\n\n<!-- comment -->\n\nWorld");
 
         $this->assertSame(
diff --git a/tests/Rules/HtmlRuleTest.php b/tests/Rules/HtmlRuleTest.php
index 5f8208d..316c5fc 100644
--- a/tests/Rules/HtmlRuleTest.php
+++ b/tests/Rules/HtmlRuleTest.php
@@ -4,6 +4,7 @@
 
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
+use Tempest\Markdown\Rules\BoldRule;
 use Tempest\Markdown\Rules\HtmlRule;
 use Tempest\Markdown\Rules\NewLineRule;
 use Tempest\Markdown\Rules\ParagraphRule;
@@ -15,10 +16,12 @@ class HtmlRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlRule()])->parse(
-                '<p>Hi</p>',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlRule(),
+            new TextRule(),
+        ])->parse(
+            '<p>Hi</p>',
+        );
 
         $this->assertSame('<p>Hi</p>', $html);
     }
@@ -26,10 +29,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_nested(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlRule()])->parse(
-                '<div><div>Hi</div></div>',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlRule(),
+            new TextRule(),
+        ])->parse(
+            '<div><div>Hi</div></div>',
+        );
 
         $this->assertSame('<div><div>Hi</div></div>', $html);
     }
@@ -51,6 +56,7 @@ public function test_lex_multiline(): void
             new NewLineRule(),
             new HtmlRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse($input);
 
         $this->assertStringContainsString('<p>Hello</p>', $html);
@@ -78,6 +84,7 @@ public function test_void_tags_are_case_insensitive(): void
             new HtmlRule(),
             new NewLineRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("<BR>\nHello");
 
         $this->assertSame("<BR>\n<p>Hello</p>", $html);
@@ -86,10 +93,12 @@ public function test_void_tags_are_case_insensitive(): void
     #[Test]
     public function lex_keeps_script_content_raw(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlRule()])->parse(
-                '<script>const x = "**a**";</script>',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlRule(),
+            new TextRule(),
+        ])->parse(
+            '<script>const x = "**a**";</script>',
+        );
 
         $this->assertSame('<script>const x = "**a**";</script>', $html);
     }
@@ -97,10 +106,12 @@ public function lex_keeps_script_content_raw(): void
     #[Test]
     public function lex_keeps_style_content_raw(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlRule()])->parse(
-                '<style>a::after{content:"*x*"}</style>',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlRule(),
+            new TextRule(),
+        ])->parse(
+            '<style>a::after{content:"*x*"}</style>',
+        );
 
         $this->assertSame('<style>a::after{content:"*x*"}</style>', $html);
     }
@@ -108,7 +119,10 @@ public function lex_keeps_style_content_raw(): void
     #[Test]
     public function lex_keeps_pre_and_textarea_content_raw(): void
     {
-        $parser = new Parser(highlighter: null, rules: [new HtmlRule()]);
+        $parser = new Parser(highlighter: null, rules: [
+            new HtmlRule(),
+            new TextRule(),
+        ]);
 
         $this->assertSame(
             '<pre>**a** _b_</pre>',
@@ -124,10 +138,12 @@ public function lex_keeps_pre_and_textarea_content_raw(): void
     #[Test]
     public function lex_detects_raw_text_tags_case_insensitively(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlRule()])->parse(
-                '<SCRIPT>**a**</SCRIPT>',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlRule(),
+            new TextRule(),
+        ])->parse(
+            '<SCRIPT>**a**</SCRIPT>',
+        );
 
         $this->assertSame('<SCRIPT>**a**</SCRIPT>', $html);
     }
@@ -135,10 +151,11 @@ public function lex_detects_raw_text_tags_case_insensitively(): void
     #[Test]
     public function lex_still_parses_markdown_in_other_elements(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new HtmlRule()])->parse(
-                '<div>**a**</div>',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new HtmlRule(),
+            new BoldRule(),
+            new TextRule(),
+        ])->parse('<div>**a**</div>');
 
         $this->assertSame('<div><strong>a</strong></div>', $html);
     }
diff --git a/tests/Rules/ImageRuleTest.php b/tests/Rules/ImageRuleTest.php
index 36fbc97..1f7ed2e 100644
--- a/tests/Rules/ImageRuleTest.php
+++ b/tests/Rules/ImageRuleTest.php
@@ -7,6 +7,7 @@
 use Tempest\Markdown\Exceptions\ImageSourceWasNotClosed;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\ImageRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class ImageRuleTest extends ParserTestCase
@@ -14,10 +15,12 @@ class ImageRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ImageRule()])->parse(
-                '![alt](src)',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ImageRule(),
+            new TextRule(),
+        ])->parse(
+            '![alt](src)',
+        );
 
         $this->assertSame('<img src="src" alt="alt">', $html);
     }
@@ -25,10 +28,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_without_alt(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ImageRule()])->parse(
-                '![](src)',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ImageRule(),
+            new TextRule(),
+        ])->parse(
+            '![](src)',
+        );
 
         $this->assertSame('<img src="src">', $html);
     }
@@ -37,7 +42,10 @@ public function test_lex_without_alt(): void
     public function test_invalid_image_throws_exception(): void
     {
         try {
-            new Parser(highlighter: null, rules: [new ImageRule()])->parse(
+            new Parser(highlighter: null, rules: [
+                new ImageRule(),
+                new TextRule(),
+            ])->parse(
                 'Hello ![alt] world',
             );
         } catch (ImageSourceWasMissing $e) {
@@ -51,7 +59,10 @@ public function test_invalid_image_throws_exception(): void
     public function test_invalid_image_source_throws_exception(): void
     {
         try {
-            new Parser(highlighter: null, rules: [new ImageRule()])->parse(
+            new Parser(highlighter: null, rules: [
+                new ImageRule(),
+                new TextRule(),
+            ])->parse(
                 'Hello ![alt](foo world',
             );
         } catch (ImageSourceWasNotClosed $e) {
diff --git a/tests/Rules/ItalicRuleTest.php b/tests/Rules/ItalicRuleTest.php
index ce8c693..3672b4c 100644
--- a/tests/Rules/ItalicRuleTest.php
+++ b/tests/Rules/ItalicRuleTest.php
@@ -8,6 +8,7 @@
 use Tempest\Markdown\Rules\ItalicRule;
 use Tempest\Markdown\Rules\NewLineRule;
 use Tempest\Markdown\Rules\ParagraphRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class ItalicRuleTest extends ParserTestCase
@@ -15,10 +16,12 @@ class ItalicRuleTest extends ParserTestCase
     #[Test]
     public function test_lex_with_underscore(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ItalicRule()])->parse(
-                '_italic_',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ItalicRule(),
+            new TextRule(),
+        ])->parse(
+            '_italic_',
+        );
 
         $this->assertSame('<em>italic</em>', $html);
     }
@@ -30,6 +33,7 @@ public function test_underscore_must_be_terminated(): void
             new NewLineRule(),
             new ItalicRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("Hello_world\n\nHi");
 
         $this->assertSame("<p>Hello_world</p>\n\n<p>Hi</p>", $html);
@@ -38,10 +42,12 @@ public function test_underscore_must_be_terminated(): void
     #[Test]
     public function test_lex_with_asterisk(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ItalicRule()])->parse(
-                '*italic*',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ItalicRule(),
+            new TextRule(),
+        ])->parse(
+            '*italic*',
+        );
 
         $this->assertSame('<em>italic</em>', $html);
     }
@@ -53,6 +59,7 @@ public function test_asterisk_must_be_terminated(): void
             new NewLineRule(),
             new ItalicRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("Hello*world\n\nHi");
 
         $this->assertSame("<p>Hello*world</p>\n\n<p>Hi</p>", $html);
@@ -64,6 +71,7 @@ public function test_multiple_in_a_row(): void
         $html = (string) new Parser(highlighter: null, rules: [
             new BoldRule(),
             new ItalicRule(),
+            new TextRule(),
         ])->parse('_a__b_');
 
         $this->assertSame('<em>a</em><em>b</em>', $html);
diff --git a/tests/Rules/LinkRuleTest.php b/tests/Rules/LinkRuleTest.php
index 4e0a285..f8a2369 100644
--- a/tests/Rules/LinkRuleTest.php
+++ b/tests/Rules/LinkRuleTest.php
@@ -4,7 +4,9 @@
 
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
+use Tempest\Markdown\Rules\ImageRule;
 use Tempest\Markdown\Rules\LinkRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class LinkRuleTest extends ParserTestCase
@@ -12,10 +14,12 @@ class LinkRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new LinkRule()])->parse(
-                '[click here](#)',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new LinkRule(),
+            new TextRule(),
+        ])->parse(
+            '[click here](#)',
+        );
 
         $this->assertSame('<a href="#">click here</a>', $html);
     }
@@ -23,10 +27,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_without_href(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new LinkRule()])->parse(
-                '[click here]',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new LinkRule(),
+            new TextRule(),
+        ])->parse(
+            '[click here]',
+        );
 
         $this->assertSame('<a href="">click here</a>', $html);
     }
@@ -34,10 +40,11 @@ public function test_lex_without_href(): void
     #[Test]
     public function test_lex_with_image_content(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new LinkRule()])->parse(
-                '[![alt](/image.jpg)](/link)',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new LinkRule(),
+            new ImageRule(),
+            new TextRule(),
+        ])->parse('[![alt](/image.jpg)](/link)');
 
         $this->assertSame(
             '<a href="/link"><img src="/image.jpg" alt="alt"></a>',
@@ -48,10 +55,12 @@ public function test_lex_with_image_content(): void
     #[Test]
     public function lex_with_parenthesis_content(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new LinkRule()])->parse(
-                '[.NET best practices](https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms229043(v=vs.100)?redirectedfrom=MSDN)',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new LinkRule(),
+            new TextRule(),
+        ])->parse(
+            '[.NET best practices](https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms229043(v=vs.100)?redirectedfrom=MSDN)',
+        );
 
         $this->assertSame(
             '<a href="https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms229043(v=vs.100)?redirectedfrom=MSDN">.NET best practices</a>',
@@ -62,10 +71,12 @@ public function lex_with_parenthesis_content(): void
     #[Test]
     public function lex_with_end_parenthesis_without_start_parenthesis(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new LinkRule()])->parse(
-                '[.NET best practices](https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms229043v=vs.100\)?redirectedfrom=MSDN)',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new LinkRule(),
+            new TextRule(),
+        ])->parse(
+            '[.NET best practices](https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms229043v=vs.100\)?redirectedfrom=MSDN)',
+        );
 
         $this->assertSame(
             '<a href="https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-4.0/ms229043v=vs.100)?redirectedfrom=MSDN">.NET best practices</a>',
diff --git a/tests/Rules/ListRuleTest.php b/tests/Rules/ListRuleTest.php
index 06a3b16..a108a75 100644
--- a/tests/Rules/ListRuleTest.php
+++ b/tests/Rules/ListRuleTest.php
@@ -13,10 +13,12 @@ class ListRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ListRule()])->parse(
-                "- item\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ])->parse(
+            "- item\n",
+        );
 
         $this->assertSame('<ul><li>item</li></ul>', $html);
     }
@@ -24,10 +26,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_multiple_items(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ListRule()])->parse(
-                "- one\n- two\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ])->parse(
+            "- one\n- two\n",
+        );
 
         $this->assertSame('<ul><li>one</li><li>two</li></ul>', $html);
     }
@@ -35,7 +39,10 @@ public function test_lex_multiple_items(): void
     #[Test]
     public function test_asterisk_and_plus_markers(): void
     {
-        $parser = new Parser(highlighter: null, rules: [new ListRule()]);
+        $parser = new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ]);
 
         $this->assertSame(
             '<ul><li>one</li><li>two</li></ul>',
@@ -50,7 +57,10 @@ public function test_asterisk_and_plus_markers(): void
     #[Test]
     public function test_lazy_continuation(): void
     {
-        $parser = new Parser(highlighter: null, rules: [new ListRule()]);
+        $parser = new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ]);
 
         $this->assertSame(
             '<ul><li>one continued</li><li>two</li></ul>',
@@ -95,10 +105,12 @@ public function test_nested_list_after_lazy_continuation(): void
     #[Test]
     public function test_lex_multiline_items(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ListRule()])->parse(
-                "- one\n   continued\n   further\n- two\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ])->parse(
+            "- one\n   continued\n   further\n- two\n",
+        );
 
         $this->assertSame(
             '<ul><li>one continued further</li><li>two</li></ul>',
@@ -120,10 +132,12 @@ public function test_hyphen_without_whitespace_is_not_a_list(): void
     #[Test]
     public function test_lex_nested(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ListRule()])->parse(
-                "- parent\n  - child\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ])->parse(
+            "- parent\n  - child\n",
+        );
 
         $this->assertSame(
             '<ul><li>parent<ul><li>child</li></ul></li></ul>',
@@ -134,10 +148,12 @@ public function test_lex_nested(): void
     #[Test]
     public function test_lex_nested_multiple_children(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ListRule()])->parse(
-                "- parent\n  - child one\n  - child two\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ])->parse(
+            "- parent\n  - child one\n  - child two\n",
+        );
 
         $this->assertSame(
             '<ul><li>parent<ul><li>child one</li><li>child two</li></ul></li></ul>',
@@ -148,10 +164,12 @@ public function test_lex_nested_multiple_children(): void
     #[Test]
     public function test_lex_nested_sibling_after_sublist(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ListRule()])->parse(
-                "- one\n  - child\n- two\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ListRule(),
+            new TextRule(),
+        ])->parse(
+            "- one\n  - child\n- two\n",
+        );
 
         $this->assertSame(
             '<ul><li>one<ul><li>child</li></ul></li><li>two</li></ul>',
diff --git a/tests/Rules/NewLineRuleTest.php b/tests/Rules/NewLineRuleTest.php
index 1158298..b5bd237 100644
--- a/tests/Rules/NewLineRuleTest.php
+++ b/tests/Rules/NewLineRuleTest.php
@@ -5,6 +5,7 @@
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\NewLineRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class NewLineRuleTest extends ParserTestCase
@@ -12,10 +13,12 @@ class NewLineRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new NewLineRule()])->parse(
-                "\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new NewLineRule(),
+            new TextRule(),
+        ])->parse(
+            "\n",
+        );
 
         $this->assertSame("\n", $html);
     }
@@ -23,10 +26,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_multiple_newlines(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new NewLineRule()])->parse(
-                "\n\n\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new NewLineRule(),
+            new TextRule(),
+        ])->parse(
+            "\n\n\n",
+        );
 
         $this->assertSame("\n\n\n", $html);
     }
diff --git a/tests/Rules/OrderedListRuleTest.php b/tests/Rules/OrderedListRuleTest.php
index fd24d31..b748bac 100644
--- a/tests/Rules/OrderedListRuleTest.php
+++ b/tests/Rules/OrderedListRuleTest.php
@@ -13,10 +13,12 @@ class OrderedListRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "1. item\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "1. item\n",
+        );
 
         $this->assertSame('<ol><li>item</li></ol>', $html);
     }
@@ -24,10 +26,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_multiple_items(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "1. one\n2. two\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "1. one\n2. two\n",
+        );
 
         $this->assertSame('<ol><li>one</li><li>two</li></ol>', $html);
     }
@@ -35,10 +39,12 @@ public function test_lex_multiple_items(): void
     #[Test]
     public function test_lex_multi_digit_numbers(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "10. ten\n11. eleven\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "10. ten\n11. eleven\n",
+        );
 
         $this->assertSame(
             '<ol start="10"><li>ten</li><li>eleven</li></ol>',
@@ -71,10 +77,12 @@ public function test_ordered_list_marker_requires_whitespace_after_period(): voi
     #[Test]
     public function test_lex_nested(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "1. parent\n  1. child\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "1. parent\n  1. child\n",
+        );
 
         $this->assertSame(
             '<ol><li>parent<ol><li>child</li></ol></li></ol>',
@@ -85,10 +93,12 @@ public function test_lex_nested(): void
     #[Test]
     public function test_lex_nested_multiple_children(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "1. parent\n  1. child one\n  2. child two\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "1. parent\n  1. child one\n  2. child two\n",
+        );
 
         $this->assertSame(
             '<ol><li>parent<ol><li>child one</li><li>child two</li></ol></li></ol>',
@@ -99,10 +109,12 @@ public function test_lex_nested_multiple_children(): void
     #[Test]
     public function test_lex_nested_sibling_after_sublist(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "1. one\n  1. child\n2. two\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "1. one\n  1. child\n2. two\n",
+        );
 
         $this->assertSame(
             '<ol><li>one<ol><li>child</li></ol></li><li>two</li></ol>',
@@ -113,21 +125,25 @@ public function test_lex_nested_sibling_after_sublist(): void
     #[Test]
     public function test_only_numbers_are_allowed(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                '1a. one',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            '1a. one',
+        );
 
-        $this->assertSame('', $html);
+        $this->assertSame('1a. one', $html);
     }
 
     #[Test]
     public function lex_keeps_the_start_number(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "2. two\n3. three\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "2. two\n3. three\n",
+        );
 
         $this->assertSame(
             '<ol start="2"><li>two</li><li>three</li></ol>',
@@ -138,10 +154,12 @@ public function lex_keeps_the_start_number(): void
     #[Test]
     public function lex_omits_the_start_attribute_when_the_list_starts_at_one(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new OrderedListRule()])->parse(
-                "1. one\n5. five\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new OrderedListRule(),
+            new TextRule(),
+        ])->parse(
+            "1. one\n5. five\n",
+        );
 
         $this->assertSame('<ol><li>one</li><li>five</li></ol>', $html);
     }
diff --git a/tests/Rules/ParagraphRuleTest.php b/tests/Rules/ParagraphRuleTest.php
index aa481f3..49b92bb 100644
--- a/tests/Rules/ParagraphRuleTest.php
+++ b/tests/Rules/ParagraphRuleTest.php
@@ -6,6 +6,7 @@
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\NewLineRule;
 use Tempest\Markdown\Rules\ParagraphRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class ParagraphRuleTest extends ParserTestCase
@@ -13,10 +14,12 @@ class ParagraphRuleTest extends ParserTestCase
     #[Test]
     public function test_single_line(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ParagraphRule()])->parse(
-                "Hello, world!\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ParagraphRule(),
+            new TextRule(),
+        ])->parse(
+            "Hello, world!\n",
+        );
 
         $this->assertSame("<p>Hello, world!\n</p>", $html);
     }
@@ -24,10 +27,12 @@ public function test_single_line(): void
     #[Test]
     public function test_multi_line_paragraph(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ParagraphRule()])->parse(
-                "First line\nSecond line\n",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ParagraphRule(),
+            new TextRule(),
+        ])->parse(
+            "First line\nSecond line\n",
+        );
 
         $this->assertSame("<p>First line\nSecond line\n</p>", $html);
     }
@@ -38,6 +43,7 @@ public function test_stops_at_blank_line(): void
         $html = (string) new Parser(highlighter: null, rules: [
             new NewLineRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("First\nSecond\n\nThird");
 
         $this->assertSame("<p>First\nSecond</p>\n\n<p>Third</p>", $html);
@@ -46,10 +52,12 @@ public function test_stops_at_blank_line(): void
     #[Test]
     public function test_paragraph_without_trailing_newline(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ParagraphRule()])->parse(
-                'Hello, world!',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ParagraphRule(),
+            new TextRule(),
+        ])->parse(
+            'Hello, world!',
+        );
 
         $this->assertSame('<p>Hello, world!</p>', $html);
     }
@@ -57,7 +65,10 @@ public function test_paragraph_without_trailing_newline(): void
     #[Test]
     public function test_setext_headings(): void
     {
-        $parser = new Parser(highlighter: null, rules: [new ParagraphRule()]);
+        $parser = new Parser(highlighter: null, rules: [
+            new ParagraphRule(),
+            new TextRule(),
+        ]);
 
         $this->assertSame(
             '<h1 id="first-heading">First heading</h1>',
@@ -72,7 +83,10 @@ public function test_setext_headings(): void
     #[Test]
     public function test_setext_heading_can_span_multiple_lines(): void
     {
-        $parser = new Parser(highlighter: null, rules: [new ParagraphRule()]);
+        $parser = new Parser(highlighter: null, rules: [
+            new ParagraphRule(),
+            new TextRule(),
+        ]);
 
         $this->assertSame(
             "<h2 id=\"first-second\">First\nSecond</h2>",
diff --git a/tests/Rules/PreRuleTest.php b/tests/Rules/PreRuleTest.php
index 0e613cf..1b0f93e 100644
--- a/tests/Rules/PreRuleTest.php
+++ b/tests/Rules/PreRuleTest.php
@@ -14,14 +14,16 @@ class PreRuleTest extends ParserTestCase
     #[Test]
     public function test_lex_with_language(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new PreRule()])->parse(
-                <<<'MD'
-                ```php
-                echo "hi";
-                ```
-                MD,
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new PreRule(),
+            new TextRule(),
+        ])->parse(
+            <<<'MD'
+            ```php
+            echo "hi";
+            ```
+            MD,
+        );
 
         $this->assertSame(
             '<pre class="language-php">echo &quot;hi&quot;;</pre>',
@@ -32,14 +34,16 @@ public function test_lex_with_language(): void
     #[Test]
     public function test_lex_with_language_and_title(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new PreRule()])->parse(
-                <<<'MD'
-                ```php file.php
-                echo "hi";
-                ```
-                MD,
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new PreRule(),
+            new TextRule(),
+        ])->parse(
+            <<<'MD'
+            ```php file.php
+            echo "hi";
+            ```
+            MD,
+        );
 
         $this->assertSame(
             '<div class="code-title">file.php</div><pre class="language-php">echo &quot;hi&quot;;</pre>',
@@ -50,14 +54,16 @@ public function test_lex_with_language_and_title(): void
     #[Test]
     public function test_lex_without_language(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new PreRule()])->parse(
-                <<<'MD'
-                ```
-                echo "hi";
-                ```
-                MD,
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new PreRule(),
+            new TextRule(),
+        ])->parse(
+            <<<'MD'
+            ```
+            echo "hi";
+            ```
+            MD,
+        );
 
         $this->assertSame('<pre>echo &quot;hi&quot;;</pre>', $html);
     }
@@ -65,10 +71,12 @@ public function test_lex_without_language(): void
     #[Test]
     public function test_lex_preserves_significant_whitespace(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new PreRule()])->parse(
-                "```\n  keep  \n```",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new PreRule(),
+            new TextRule(),
+        ])->parse(
+            "```\n  keep  \n```",
+        );
 
         $this->assertSame('<pre>  keep  </pre>', $html);
     }
@@ -76,14 +84,16 @@ public function test_lex_preserves_significant_whitespace(): void
     #[Test]
     public function test_lex_with_backtick_in_content(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new PreRule()])->parse(
-                <<<'MD'
-                ```php
-                echo `uname`;
-                ```
-                MD,
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new PreRule(),
+            new TextRule(),
+        ])->parse(
+            <<<'MD'
+            ```php
+            echo `uname`;
+            ```
+            MD,
+        );
 
         $this->assertSame(
             '<pre class="language-php">echo `uname`;</pre>',
diff --git a/tests/Rules/QuoteRuleTest.php b/tests/Rules/QuoteRuleTest.php
index 1bb6bd0..a8a20d9 100644
--- a/tests/Rules/QuoteRuleTest.php
+++ b/tests/Rules/QuoteRuleTest.php
@@ -5,6 +5,7 @@
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\QuoteRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class QuoteRuleTest extends ParserTestCase
@@ -12,10 +13,12 @@ class QuoteRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new QuoteRule()])->parse(
-                '> quote',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new QuoteRule(),
+            new TextRule(),
+        ])->parse(
+            '> quote',
+        );
 
         $this->assertSame('<blockquote>quote</blockquote>', $html);
     }
@@ -23,14 +26,16 @@ public function test_lex(): void
     #[Test]
     public function test_lex_multiline(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new QuoteRule()])->parse(
-                <<<'MD'
-                > line 1
-                > > line 2
-                > line 3
-                MD,
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new QuoteRule(),
+            new TextRule(),
+        ])->parse(
+            <<<'MD'
+            > line 1
+            > > line 2
+            > line 3
+            MD,
+        );
 
         $this->assertSame(
             "<blockquote>line 1\n<blockquote>line 2</blockquote>line 3</blockquote>",
@@ -41,11 +46,13 @@ public function test_lex_multiline(): void
     #[Test]
     public function test_lex_only_at_start_of_line(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new QuoteRule()])->parse(
-                'two > one',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new QuoteRule(),
+            new TextRule(),
+        ])->parse(
+            'two > one',
+        );
 
-        $this->assertSame('', $html);
+        $this->assertSame('two > one', $html);
     }
 }
diff --git a/tests/Rules/RawRuleTest.php b/tests/Rules/RawRuleTest.php
index ed003eb..a2d0ba4 100644
--- a/tests/Rules/RawRuleTest.php
+++ b/tests/Rules/RawRuleTest.php
@@ -13,10 +13,12 @@ class RawRuleTest extends ParserTestCase
     #[Test]
     public function test_raw_content_is_passed_through(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new RawRule()])->parse(
-                '@@<b>raw</b>@@',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new RawRule(),
+            new TextRule(),
+        ])->parse(
+            '@@<b>raw</b>@@',
+        );
 
         $this->assertSame('<b>raw</b>', $html);
     }
@@ -24,10 +26,12 @@ public function test_raw_content_is_passed_through(): void
     #[Test]
     public function test_raw_html_is_not_escaped(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new RawRule()])->parse(
-                '@@<script>alert("xss")</script>@@',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new RawRule(),
+            new TextRule(),
+        ])->parse(
+            '@@<script>alert("xss")</script>@@',
+        );
 
         $this->assertSame('<script>alert("xss")</script>', $html);
     }
@@ -59,10 +63,12 @@ public function test_raw_multiline_content(): void
     {
         $input = "@@line1\nline2@@";
 
-        $html =
-            (string) new Parser(highlighter: null, rules: [new RawRule()])->parse(
-                $input,
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new RawRule(),
+            new TextRule(),
+        ])->parse(
+            $input,
+        );
 
         $this->assertSame("line1\nline2", $html);
     }
diff --git a/tests/Rules/SocialHandleRuleTest.php b/tests/Rules/SocialHandleRuleTest.php
index b7a8c76..91c5b30 100644
--- a/tests/Rules/SocialHandleRuleTest.php
+++ b/tests/Rules/SocialHandleRuleTest.php
@@ -73,8 +73,10 @@ public function unclosed_social_handle_preserves_remaining_text(): void
     #[Test]
     public function social_handle_preserves_underscores_in_default_label(): void
     {
-        $parser =
-            new Parser(highlighter: null, rules: [new SocialHandleRule()]);
+        $parser = new Parser(highlighter: null, rules: [
+            new SocialHandleRule(),
+            new TextRule(),
+        ]);
 
         $html = $parser->parse('{x:my_test_account}')->html;
 
diff --git a/tests/Rules/StrikethroughRuleTest.php b/tests/Rules/StrikethroughRuleTest.php
index 88f55ff..cc27837 100644
--- a/tests/Rules/StrikethroughRuleTest.php
+++ b/tests/Rules/StrikethroughRuleTest.php
@@ -15,10 +15,12 @@ class StrikethroughRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new StrikethroughRule()])->parse(
-                '~~strikethrough~~',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new StrikethroughRule(),
+            new TextRule(),
+        ])->parse(
+            '~~strikethrough~~',
+        );
 
         $this->assertSame('<s>strikethrough</s>', $html);
     }
@@ -26,10 +28,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_single_tilde(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new StrikethroughRule()])->parse(
-                '~strikethrough~',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new StrikethroughRule(),
+            new TextRule(),
+        ])->parse(
+            '~strikethrough~',
+        );
 
         $this->assertSame('<s>strikethrough</s>', $html);
     }
diff --git a/tests/Rules/TableRuleTest.php b/tests/Rules/TableRuleTest.php
index a33ba5e..f44d095 100644
--- a/tests/Rules/TableRuleTest.php
+++ b/tests/Rules/TableRuleTest.php
@@ -6,6 +6,7 @@
 use Tempest\Markdown\Parser;
 use Tempest\Markdown\Rules\ParagraphRule;
 use Tempest\Markdown\Rules\TableRule;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
 class TableRuleTest extends ParserTestCase
@@ -13,10 +14,12 @@ class TableRuleTest extends ParserTestCase
     #[Test]
     public function test_lex_header_only(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new TableRule()])->parse(
-                "| A | B |\n| --- | --- |",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new TableRule(),
+            new TextRule(),
+        ])->parse(
+            "| A | B |\n| --- | --- |",
+        );
 
         $this->assertSame(
             '<table><thead><tr><th>A</th><th>B</th></tr></thead></table>',
@@ -27,10 +30,12 @@ public function test_lex_header_only(): void
     #[Test]
     public function test_lex_full_table(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new TableRule()])->parse(
-                "| A | B |\n| --- | --- |\n| 1 | 2 |",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new TableRule(),
+            new TextRule(),
+        ])->parse(
+            "| A | B |\n| --- | --- |\n| 1 | 2 |",
+        );
 
         $this->assertSame(
             '<table><thead><tr><th>A</th><th>B</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr></tbody></table>',
@@ -41,10 +46,12 @@ public function test_lex_full_table(): void
     #[Test]
     public function test_lex_multiple_data_rows(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new TableRule()])->parse(
-                "| A | B |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new TableRule(),
+            new TextRule(),
+        ])->parse(
+            "| A | B |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |",
+        );
 
         $this->assertSame(
             '<table><thead><tr><th>A</th><th>B</th></tr></thead><tbody><tr><td>1</td><td>2</td></tr><tr><td>3</td><td>4</td></tr></tbody></table>',
@@ -55,10 +62,12 @@ public function test_lex_multiple_data_rows(): void
     #[Test]
     public function test_lex_separator_with_alignment(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new TableRule()])->parse(
-                "| A | B | C |\n| :--- | :---: | ---: |\n| 1 | 2 | 3 |",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new TableRule(),
+            new TextRule(),
+        ])->parse(
+            "| A | B | C |\n| :--- | :---: | ---: |\n| 1 | 2 | 3 |",
+        );
 
         $this->assertSame(
             '<table><thead><tr><th>A</th><th>B</th><th>C</th></tr></thead><tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody></table>',
@@ -69,10 +78,12 @@ public function test_lex_separator_with_alignment(): void
     #[Test]
     public function test_table_with_empty_cells(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new TableRule()])->parse(
-                "| A | B | C |\n| :--- | :---: | ---: |\n| | | 3 |",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new TableRule(),
+            new TextRule(),
+        ])->parse(
+            "| A | B | C |\n| :--- | :---: | ---: |\n| | | 3 |",
+        );
 
         $this->assertSame(
             '<table><thead><tr><th>A</th><th>B</th><th>C</th></tr></thead><tbody><tr><td></td><td></td><td>3</td></tr></tbody></table>',
@@ -83,10 +94,12 @@ public function test_table_with_empty_cells(): void
     #[Test]
     public function test_table_with_all_empty_cells(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new TableRule()])->parse(
-                "| A | B |\n| --- | --- |\n| | |",
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new TableRule(),
+            new TextRule(),
+        ])->parse(
+            "| A | B |\n| --- | --- |\n| | |",
+        );
 
         $this->assertSame(
             '<table><thead><tr><th>A</th><th>B</th></tr></thead><tbody><tr><td></td><td></td></tr></tbody></table>',
@@ -100,6 +113,7 @@ public function test_paragraphs_with_pipe_are_not_treated_as_tables(): void
         $html = (string) new Parser(highlighter: null, rules: [
             new TableRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("| Hello |\nHello");
 
         $this->assertStringNotContainsString('<table>', $html);
@@ -112,6 +126,7 @@ public function test_separator_cells_must_contain_hyphens(): void
         $html = (string) new Parser(highlighter: null, rules: [
             new TableRule(),
             new ParagraphRule(),
+            new TextRule(),
         ])->parse("| not | table |\n| : | : |");
 
         $this->assertStringNotContainsString('<table>', $html);
diff --git a/tests/Rules/ThickRulerRuleTest.php b/tests/Rules/ThickRulerRuleTest.php
index f302e4b..db83fe0 100644
--- a/tests/Rules/ThickRulerRuleTest.php
+++ b/tests/Rules/ThickRulerRuleTest.php
@@ -4,6 +4,7 @@
 
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Rules\ThickRulerRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
@@ -12,10 +13,12 @@ class ThickRulerRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ThickRulerRule()])->parse(
-                '===',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ThickRulerRule(),
+            new TextRule(),
+        ])->parse(
+            '===',
+        );
 
         $this->assertSame('<hr/>', $html);
     }
@@ -23,10 +26,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_long(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ThickRulerRule()])->parse(
-                '=====',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ThickRulerRule(),
+            new TextRule(),
+        ])->parse(
+            '=====',
+        );
 
         $this->assertSame('<hr/>', $html);
     }
diff --git a/tests/Rules/ThinRulerRuleTest.php b/tests/Rules/ThinRulerRuleTest.php
index df9dfc2..07985d6 100644
--- a/tests/Rules/ThinRulerRuleTest.php
+++ b/tests/Rules/ThinRulerRuleTest.php
@@ -4,6 +4,7 @@
 
 use PHPUnit\Framework\Attributes\Test;
 use Tempest\Markdown\Parser;
+use Tempest\Markdown\Rules\TextRule;
 use Tempest\Markdown\Rules\ThinRulerRule;
 use Tempest\Markdown\Tests\ParserTestCase;
 
@@ -12,10 +13,12 @@ class ThinRulerRuleTest extends ParserTestCase
     #[Test]
     public function test_lex(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ThinRulerRule()])->parse(
-                '---',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ThinRulerRule(),
+            new TextRule(),
+        ])->parse(
+            '---',
+        );
 
         $this->assertSame('<hr/>', $html);
     }
@@ -23,10 +26,12 @@ public function test_lex(): void
     #[Test]
     public function test_lex_long(): void
     {
-        $html =
-            (string) new Parser(highlighter: null, rules: [new ThinRulerRule()])->parse(
-                '-----',
-            );
+        $html = (string) new Parser(highlighter: null, rules: [
+            new ThinRulerRule(),
+            new TextRule(),
+        ])->parse(
+            '-----',
+        );
 
         $this->assertSame('<hr/>', $html);
     }