RegularParser now properly takes into account escaped tokens, updated GitHub actions up to PHP 8.6

thunderer · thunderer · commit 9dc01d8d7e4a · 2026-01-23T21:59:19.000+01:00
diff --git a/.github/workflows/test-old.yaml b/.github/workflows/test-old.yaml
@@ -20,7 +20,7 @@ jobs:
         uses: 'shivammathur/setup-php@v2'
         with:
           php-version: '${{ matrix.php }}'
-          tools: 'composer:v1'
+          tools: 'composer:v2'
           coverage: 'xdebug'
       - name: 'PHP'
         run: 'php -v'
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
@@ -11,12 +11,11 @@ jobs:
     runs-on: '${{ matrix.os }}'
     strategy:
       matrix:
-        php: ['7.4', '8.0', '8.1', '8.2', '8.3']
+        php: ['7.4', '8.0', '8.1', '8.2', '8.3', '8.4', '8.5']
         os: ['ubuntu-latest']
         failure: [false]
         include:
-          - { php: '8.4', os: 'ubuntu-latest', failure: true } # Psalm does not support PHP 8.4 yet
-          - { php: '8.5', os: 'ubuntu-latest', failure: true } # '8.5' means 'nightly'
+          - { php: '8.6', os: 'ubuntu-latest', failure: true } # '8.6' means 'nightly'
     steps:
       - name: 'Checkout'
         uses: 'actions/checkout@v4'
@@ -38,7 +37,7 @@ jobs:
       - name: 'Psalm'
         run: |
           composer remove --dev -W 'phpunit/phpunit'
-          composer require --dev -W 'vimeo/psalm=^5.0' 'nikic/php-parser=^4.0'
+          composer require --dev -W 'vimeo/psalm=>=5.0' 'nikic/php-parser=>=4.0'
           php vendor/bin/psalm --shepherd --php-version=${{ matrix.php }}
         continue-on-error: '${{ matrix.failure }}'
       - name: 'Infection'
diff --git a/Makefile b/Makefile
@@ -1,4 +1,4 @@
-PHP_VERSION ?= 8.0
+PHP_VERSION ?= 8.5
 PHP := docker-compose run --rm php-${PHP_VERSION}
 
 php-version:
diff --git a/docker-compose.yaml b/docker-compose.yaml
@@ -18,3 +18,8 @@ services:
   php-7.3: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 7.3   } } }
   php-7.4: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 7.4   } } }
   php-8.0: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 8.0   } } }
+  php-8.1: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 8.1   } } }
+  php-8.2: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 8.2   } } }
+  php-8.3: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 8.3   } } }
+  php-8.4: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 8.4   } } }
+  php-8.5: { <<: *php, build: { context: docker/php,     args: { PHP_VERSION: 8.5   } } }
diff --git a/docker/php/Dockerfile b/docker/php/Dockerfile
@@ -2,7 +2,7 @@ ARG PHP_VERSION=8.0
 FROM php:$PHP_VERSION
 
 RUN php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');" \
- && php -r "if (hash_file('sha384', 'composer-setup.php') === '906a84df04cea2aa72f40b5f787e49f22d4c2f19492ac310e8cba5b96ac8b64115ac402c8cd292b8a03482574915d1a8') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;" \
+ && php -r "if (hash_file('sha384', 'composer-setup.php') === 'c8b085408188070d5f52bcfe4ecfbee5f727afa458b2573b8eaaf77b3419b0bf2768dc67c86944da1544f06fa544fd47') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;" \
  && php composer-setup.php \
  && php -r "unlink('composer-setup.php');" \
  && mv composer.phar /usr/local/bin/composer
diff --git a/psalm.xml b/psalm.xml
@@ -16,4 +16,9 @@
         </ignoreFiles>
     </projectFiles>
 
+    <issueHandlers>
+        <MissingOverrideAttribute errorLevel="suppress" />
+        <UnusedPsalmSuppress errorLevel="suppress" />
+    </issueHandlers>
+
 </psalm>
diff --git a/src/Event/FilterShortcodesEvent.php b/src/Event/FilterShortcodesEvent.php
@@ -10,6 +10,7 @@
  * is used directly in processor.
  *
  * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ * @psalm-suppress ClassMustBeFinal
  */
 class FilterShortcodesEvent
 {
diff --git a/src/Event/ReplaceShortcodesEvent.php b/src/Event/ReplaceShortcodesEvent.php
@@ -10,6 +10,7 @@
  * results in the source text.
  *
  * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ * @psalm-suppress ClassMustBeFinal
  */
 class ReplaceShortcodesEvent
 {
diff --git a/src/Parser/RegexParser.php b/src/Parser/RegexParser.php
@@ -46,6 +46,7 @@ public function parse($text)
         // loop instead of array_map to pass the arguments explicitly
         $shortcodes = array();
         foreach($matches[0] as $match) {
+            /** @psalm-suppress PossiblyFalseArgument */
             $offset = mb_strlen(substr($text, 0, $match[1]), 'utf-8');
             $shortcodes[] = $this->parseSingle($match[0], $offset);
         }
@@ -108,11 +109,13 @@ private function parseValue($value)
      * @param string $value
      *
      * @return string
+     * @psalm-suppress InvalidFalsableReturnType
      */
     private function extractValue($value)
     {
         $length = strlen($this->syntax->getParameterValueDelimiter());
 
+        /** @psalm-suppress FalsableReturnStatement */
         return $this->isDelimitedValue($value) ? substr($value, $length, -1 * $length) : $value;
     }
 
diff --git a/src/Parser/RegularParser.php b/src/Parser/RegularParser.php
@@ -9,6 +9,8 @@
 
 /**
  * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ * @psalm-suppress PossiblyUndefinedArrayOffset
+ * @psalm-suppress PossiblyUndefinedVariable
  */
 final class RegularParser implements ParserInterface
 {
@@ -79,6 +81,7 @@ public function parse($text)
                 }
             }
         }
+        /** @psalm-suppress PossiblyFalseArgument */
         ini_set('xdebug.max_nesting_level', $nestingLevel);
 
         return $shortcodes;
@@ -269,7 +272,9 @@ private function getBacktrack()
     {
         $position = array_pop($this->backtracks);
         $backtrack = '';
+        /** @psalm-suppress PossiblyNullOperand */
         for($i = $position; $i < $this->position; $i++) {
+            /** @psalm-suppress PossiblyNullArrayOffset */
             $backtrack .= $this->tokens[$i][1];
         }
 
@@ -285,13 +290,17 @@ private function backtrack($modifyPosition = true)
     {
         $position = array_pop($this->backtracks);
         if($modifyPosition) {
+            /** @psalm-suppress PossiblyNullPropertyAssignmentValue */
             $this->position = $position;
         }
 
         $backtrack = '';
+        /** @psalm-suppress PossiblyNullOperand */
         for($i = $position; $i < $this->lastBacktrack; $i++) {
+            /** @psalm-suppress PossiblyNullArrayOffset */
             $backtrack .= $this->tokens[$i][1];
         }
+        /** @psalm-suppress PossiblyNullPropertyAssignmentValue */
         $this->lastBacktrack = $position;
 
         return $backtrack;
@@ -339,6 +348,7 @@ private function match($type, $ws)
      * @param string $text
      *
      * @psalm-return list<array{0:int,1:string,2:int}>
+     * @psalm-suppress MixedReturnTypeCoercion
      */
     private function tokenize($text)
     {
@@ -362,21 +372,23 @@ private function tokenize($text)
                 default: { throw new \RuntimeException('Invalid token.'); }
             }
             $tokens[] = array($type, $token, $position);
+            /** @psalm-suppress MixedArgument */
             $position += mb_strlen($token, 'utf-8');
         }
 
+        /** @psalm-suppress MixedReturnTypeCoercion */
         return $tokens;
     }
 
     /** @return non-empty-string */
     private function prepareLexer(SyntaxInterface $syntax)
     {
         // FIXME: for some reason Psalm does not understand the `@psalm-var callable() $var` annotation
-        /** @psalm-suppress MissingClosureParamType, MissingClosureReturnType */
+        /** @psalm-suppress MissingClosureParamType,MissingClosureReturnType,PossiblyNullOperand */
         $group = function($text, $group) {
             return '(?<'.(string)$group.'>'.preg_replace('/(.)/us', '\\\\$0', (string)$text).')';
         };
-        /** @psalm-suppress MissingClosureParamType, MissingClosureReturnType */
+        /** @psalm-suppress MissingClosureParamType,MissingClosureReturnType */
         $quote = function($text) {
             return preg_replace('/(.)/us', '\\\\$0', (string)$text);
         };
@@ -388,6 +400,7 @@ private function prepareLexer(SyntaxInterface $syntax)
                 $quote($syntax->getClosingTagMarker()),
                 $quote($syntax->getParameterValueSeparator()),
                 $quote($syntax->getParameterValueDelimiter()),
+                '\\\\',
                 '\s+',
             )).').)+)',
             '(?<ws>\s+)',
diff --git a/src/Parser/WordpressParser.php b/src/Parser/WordpressParser.php
@@ -22,6 +22,8 @@
  * @see https://core.trac.wordpress.org/browser/tags/4.3.1/src/wp-includes/shortcodes.php#L239
  * @see https://core.trac.wordpress.org/browser/tags/4.3.1/src/wp-includes/shortcodes.php#L448
  * @psalm-suppress RiskyTruthyFalsyComparison
+ * @psalm-suppress PossiblyNullArgument
+ * @psalm-suppress PossiblyFalseArgument
  *
  * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
  */
diff --git a/src/Serializer/JsonSerializer.php b/src/Serializer/JsonSerializer.php
@@ -6,6 +6,8 @@
 
 /**
  * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ * @psalm-suppress FalsableReturnStatement
+ * @psalm-suppress InvalidFalsableReturnType
  */
 final class JsonSerializer implements SerializerInterface
 {
diff --git a/src/Serializer/YamlSerializer.php b/src/Serializer/YamlSerializer.php
@@ -7,6 +7,9 @@
 
 /**
  * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ * @psalm-suppress ReservedWord
+ * @psalm-suppress InvalidReturnStatement
+ * @psalm-suppress InvalidReturnType
  */
 final class YamlSerializer implements SerializerInterface
 {
diff --git a/src/ShortcodeFacade.php b/src/ShortcodeFacade.php
@@ -20,6 +20,7 @@
 
 /**
  * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ * @psalm-suppress ClassMustBeFinal
  */
 class ShortcodeFacade
 {
diff --git a/tests/ParserTest.php b/tests/ParserTest.php
@@ -1,6 +1,7 @@
 <?php
 namespace Thunder\Shortcode\Tests;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use Thunder\Shortcode\HandlerContainer\HandlerContainer;
 use Thunder\Shortcode\Parser\RegularParser;
 use Thunder\Shortcode\Parser\ParserInterface;
@@ -23,6 +24,7 @@ final class ParserTest extends AbstractTestCase
      *
      * @dataProvider provideShortcodes
      */
+    #[DataProvider('provideShortcodes')]
     public function testParser(ParserInterface $parser, $code, array $expected)
     {
         $this->assertShortcodes($parser->parse($code), $expected);
@@ -276,6 +278,26 @@ public function testIssue77()
         ));
     }
 
+    public function testIssue119()
+    {
+        $cases = array(
+            '[a k="\"y"]inner[/a]' => new ParsedShortcode(new Shortcode('a', array('k' => '\"y'), 'inner', null), '[a k="\"y"]inner[/a]', 0),
+            '[a k=" \"y"]inner[/a]' => new ParsedShortcode(new Shortcode('a', array('k' => ' \"y'), 'inner', null), '[a k=" \"y"]inner[/a]', 0),
+            '[a k=" x\"y"]inner[/a]' => new ParsedShortcode(new Shortcode('a', array('k' => ' x\"y'), 'inner', null), '[a k=" x\"y"]inner[/a]', 0),
+            '[a k="x\"y"]inner[/a]' => new ParsedShortcode(new Shortcode('a', array('k' => 'x\"y'), 'inner', null), '[a k="x\"y"]inner[/a]', 0),
+            '[mention id=1 name="foo\"ff\""][/mention]' => new ParsedShortcode(new Shortcode('mention', array('id' => '1', 'name' => 'foo\"ff\"'), '', null), '[mention id=1 name="foo\"ff\""][/mention]', 0),
+        );
+        $parser = new RegularParser();
+        foreach($cases as $input => $expected) {
+            $this->assertShortcodes($parser->parse($input), array($expected));
+        }
+
+        $this->assertShortcodes($parser->parse('[a k="x\"y"]inner[/a] [mention id=1 name="foo\"ff\""][/mention]'), array(
+            new ParsedShortcode(new Shortcode('a', array('k' => 'x\"y'), 'inner', null), '[a k="x\"y"]inner[/a]', 0),
+            new ParsedShortcode(new Shortcode('mention', array('id' => '1', 'name' => 'foo\"ff\"'), '', null), '[mention id=1 name="foo\"ff\""][/mention]', 22),
+        ));
+    }
+
     public function testWordPress()
     {
         $parser = new WordpressParser();
diff --git a/tests/ProcessorTest.php b/tests/ProcessorTest.php
@@ -1,6 +1,7 @@
 <?php
 namespace Thunder\Shortcode\Tests;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use Thunder\Shortcode\Handler\ContentHandler;
 use Thunder\Shortcode\Handler\DeclareHandler;
 use Thunder\Shortcode\Handler\EmailHandler;
@@ -62,6 +63,7 @@ public function testReplaceWithoutContentOffset()
      *
      * @dataProvider provideTexts
      */
+    #[DataProvider('provideTexts')]
     public function testProcessorProcess($text, $result)
     {
         $processor = new Processor(new RegexParser(), $this->getHandlers());
@@ -164,6 +166,7 @@ public function testProcessorShortcodePositions()
     /**
      * @dataProvider provideBuiltInTests
      */
+    #[DataProvider('provideBuiltInTests')]
     public function testBuiltInHandlers($text, $result)
     {
         $handlers = new HandlerContainer();
diff --git a/tests/SerializerTest.php b/tests/SerializerTest.php
@@ -1,6 +1,7 @@
 <?php
 namespace Thunder\Shortcode\Tests;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use Thunder\Shortcode\Serializer\JsonSerializer;
 use Thunder\Shortcode\Serializer\SerializerInterface;
 use Thunder\Shortcode\Serializer\TextSerializer;
@@ -18,6 +19,7 @@ final class SerializerTest extends AbstractTestCase
     /**
      * @dataProvider provideShortcodes
      */
+    #[DataProvider('provideShortcodes')]
     public function testSerializer(SerializerInterface $serializer, ShortcodeInterface $test)
     {
         $result = $serializer->serialize($test);
@@ -61,6 +63,7 @@ public static function provideShortcodes()
     /**
      * @dataProvider provideUnserialized
      */
+    #[DataProvider('provideUnserialized')]
     public function testUnserialize(SerializerInterface $serializer, ShortcodeInterface $test, $text)
     {
         $tested = $serializer->unserialize($text);
@@ -89,6 +92,7 @@ public static function provideUnserialized()
     /**
      * @dataProvider provideExceptions
      */
+    #[DataProvider('provideExceptions')]
     public function testSerializerExceptions(SerializerInterface $serializer, $value, $exceptionClass)
     {
         $this->willThrowException($exceptionClass);
diff --git a/tests/ShortcodeTest.php b/tests/ShortcodeTest.php
@@ -1,6 +1,7 @@
 <?php
 namespace Thunder\Shortcode\Tests;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use Thunder\Shortcode\HandlerContainer\HandlerContainer;
 use Thunder\Shortcode\Parser\RegexParser;
 use Thunder\Shortcode\Processor\Processor;
@@ -18,6 +19,7 @@ final class ShortcodeTest extends AbstractTestCase
     /**
      * @dataProvider provideShortcodes
      */
+    #[DataProvider('provideShortcodes')]
     public function testShortcode($expected, $name, array $args, $content)
     {
         $s = new Shortcode($name, $args, $content);
diff --git a/tests/SyntaxTest.php b/tests/SyntaxTest.php
@@ -1,6 +1,7 @@
 <?php
 namespace Thunder\Shortcode\Tests;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use Thunder\Shortcode\Syntax\Syntax;
 use Thunder\Shortcode\Syntax\CommonSyntax;
 use Thunder\Shortcode\Syntax\SyntaxBuilder;
@@ -14,6 +15,7 @@ final class SyntaxTest extends AbstractTestCase
     /**
      * @dataProvider provideSyntaxes
      */
+    #[DataProvider('provideSyntaxes')]
     public function testSyntax(SyntaxInterface $syntax, $open, $close, $slash, $parameter, $value)
     {
         static::assertSame($open, $syntax->getOpeningTag());

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-PHP_VERSION ?= 8.0`
	`1`	`+PHP_VERSION ?= 8.5`
`2`	`2`	`PHP := docker-compose run --rm php-${PHP_VERSION}`
`3`	`3`
`4`	`4`	`php-version:`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`* is used directly in processor.`
`11`	`11`	`*`
`12`	`12`	`* @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>`
	`13`	`+ * @psalm-suppress ClassMustBeFinal`
`13`	`14`	`*/`
`14`	`15`	`class FilterShortcodesEvent`
`15`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@ public function parse($text)`
`46`	`46`	`// loop instead of array_map to pass the arguments explicitly`
`47`	`47`	`$shortcodes = array();`
`48`	`48`	`foreach($matches[0] as $match) {`
	`49`	`+ /** @psalm-suppress PossiblyFalseArgument */`
`49`	`50`	`$offset = mb_strlen(substr($text, 0, $match[1]), 'utf-8');`
`50`	`51`	`$shortcodes[] = $this->parseSingle($match[0], $offset);`
`51`	`52`	`}`
`@@ -108,11 +109,13 @@ private function parseValue($value)`
`108`	`109`	`* @param string $value`
`109`	`110`	`*`
`110`	`111`	`* @return string`
	`112`	`+ * @psalm-suppress InvalidFalsableReturnType`
`111`	`113`	`*/`
`112`	`114`	`private function extractValue($value)`
`113`	`115`	`{`
`114`	`116`	`$length = strlen($this->syntax->getParameterValueDelimiter());`
`115`	`117`
	`118`	`+ /** @psalm-suppress FalsableReturnStatement */`
`116`	`119`	`return $this->isDelimitedValue($value) ? substr($value, $length, -1 * $length) : $value;`
`117`	`120`	`}`
`118`	`121`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`
`10`	`10`	`/**`
`11`	`11`	`* @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>`
	`12`	`+ * @psalm-suppress PossiblyUndefinedArrayOffset`
	`13`	`+ * @psalm-suppress PossiblyUndefinedVariable`
`12`	`14`	`*/`
`13`	`15`	`final class RegularParser implements ParserInterface`
`14`	`16`	`{`
`@@ -79,6 +81,7 @@ public function parse($text)`
`79`	`81`	`}`
`80`	`82`	`}`
`81`	`83`	`}`
	`84`	`+ /** @psalm-suppress PossiblyFalseArgument */`
`82`	`85`	`ini_set('xdebug.max_nesting_level', $nestingLevel);`
`83`	`86`
`84`	`87`	`return $shortcodes;`
`@@ -269,7 +272,9 @@ private function getBacktrack()`
`269`	`272`	`{`
`270`	`273`	`$position = array_pop($this->backtracks);`
`271`	`274`	`$backtrack = '';`
	`275`	`+ /** @psalm-suppress PossiblyNullOperand */`
`272`	`276`	`for($i = $position; $i < $this->position; $i++) {`
	`277`	`+ /** @psalm-suppress PossiblyNullArrayOffset */`
`273`	`278`	`$backtrack .= $this->tokens[$i][1];`
`274`	`279`	`}`
`275`	`280`
`@@ -285,13 +290,17 @@ private function backtrack($modifyPosition = true)`
`285`	`290`	`{`
`286`	`291`	`$position = array_pop($this->backtracks);`
`287`	`292`	`if($modifyPosition) {`
	`293`	`+ /** @psalm-suppress PossiblyNullPropertyAssignmentValue */`
`288`	`294`	`$this->position = $position;`
`289`	`295`	`}`
`290`	`296`
`291`	`297`	`$backtrack = '';`
	`298`	`+ /** @psalm-suppress PossiblyNullOperand */`
`292`	`299`	`for($i = $position; $i < $this->lastBacktrack; $i++) {`
	`300`	`+ /** @psalm-suppress PossiblyNullArrayOffset */`
`293`	`301`	`$backtrack .= $this->tokens[$i][1];`
`294`	`302`	`}`
	`303`	`+ /** @psalm-suppress PossiblyNullPropertyAssignmentValue */`
`295`	`304`	`$this->lastBacktrack = $position;`
`296`	`305`
`297`	`306`	`return $backtrack;`
`@@ -339,6 +348,7 @@ private function match($type, $ws)`
`339`	`348`	`* @param string $text`
`340`	`349`	`*`
`341`	`350`	`* @psalm-return list<array{0:int,1:string,2:int}>`
	`351`	`+ * @psalm-suppress MixedReturnTypeCoercion`
`342`	`352`	`*/`
`343`	`353`	`private function tokenize($text)`
`344`	`354`	`{`
`@@ -362,21 +372,23 @@ private function tokenize($text)`
`362`	`372`	`default: { throw new \RuntimeException('Invalid token.'); }`
`363`	`373`	`}`
`364`	`374`	`$tokens[] = array($type, $token, $position);`
	`375`	`+ /** @psalm-suppress MixedArgument */`
`365`	`376`	`$position += mb_strlen($token, 'utf-8');`
`366`	`377`	`}`
`367`	`378`
	`379`	`+ /** @psalm-suppress MixedReturnTypeCoercion */`
`368`	`380`	`return $tokens;`
`369`	`381`	`}`
`370`	`382`
`371`	`383`	`/** @return non-empty-string */`
`372`	`384`	`private function prepareLexer(SyntaxInterface $syntax)`
`373`	`385`	`{`
`374`	`386`	// FIXME: for some reason Psalm does not understand the `@psalm-var callable() $var` annotation
`375`		`- /** @psalm-suppress MissingClosureParamType, MissingClosureReturnType */`
	`387`	`+ /** @psalm-suppress MissingClosureParamType,MissingClosureReturnType,PossiblyNullOperand */`
`376`	`388`	`$group = function($text, $group) {`
`377`	`389`	`return '(?<'.(string)$group.'>'.preg_replace('/(.)/us', '\\\\$0', (string)$text).')';`
`378`	`390`	`};`
`379`		`- /** @psalm-suppress MissingClosureParamType, MissingClosureReturnType */`
	`391`	`+ /** @psalm-suppress MissingClosureParamType,MissingClosureReturnType */`
`380`	`392`	`$quote = function($text) {`
`381`	`393`	`return preg_replace('/(.)/us', '\\\\$0', (string)$text);`
`382`	`394`	`};`
`@@ -388,6 +400,7 @@ private function prepareLexer(SyntaxInterface $syntax)`
`388`	`400`	`$quote($syntax->getClosingTagMarker()),`
`389`	`401`	`$quote($syntax->getParameterValueSeparator()),`
`390`	`402`	`$quote($syntax->getParameterValueDelimiter()),`
	`403`	`+ '\\\\',`
`391`	`404`	`'\s+',`
`392`	`405`	`)).').)+)',`
`393`	`406`	`'(?<ws>\s+)',`