create-prisma-php-app 3.6.3 → 3.6.5

package/dist/src/Lib/PHPX/TemplateCompiler.php

@@ -16,53 +16,74 @@ use Bootstrap;
 use LibXMLError;
 use ReflectionClass;
 use ReflectionProperty;
-use ReflectionType;
 use ReflectionNamedType;
 use Lib\PHPX\TypeCoercer;
 use Lib\PHPX\Exceptions\ComponentValidationException;
 
 class TemplateCompiler
 {
-    protected const BINDING_REGEX = '/\{\{\s*((?:(?!\{\{|\}\})[\s\S])*?)\s*\}\}/uS';
+    private const BINDING_REGEX = '/\{\{\s*((?:(?!\{\{|\}\})[\s\S])*?)\s*\}\}/uS';
+    private const ATTRIBUTE_REGEX = '/(\s[\w:-]+=)([\'"])(.*?)\2/s';
+    private const MUSTACHE_REGEX = '/\{\{[\s\S]*?\}\}/u';
+    private const NAMED_ENTITY_REGEX = '/&([a-zA-Z][a-zA-Z0-9]+);/';
+    private const COMPONENT_TAG_REGEX = '/<\/*[A-Z][\w-]*/u';
+    private const SELF_CLOSING_REGEX = '/<([a-z0-9-]+)([^>]*)\/>/i';
+    private const SCRIPT_REGEX = '#<script\b([^>]*?)>(.*?)</script>#is';
+    private const HEAD_PATTERNS = [
+        'open' => '/(<head\b[^>]*>)/i',
+        'close' => '/(<\/head\s*>)/i',
+    ];
+    private const BODY_PATTERNS = [
+        'open' => '/<body([^>]*)>/i',
+        'close' => '/(<\/body\s*>)/i',
+    ];
+
     private const LITERAL_TEXT_TAGS = [
         'code' => true,
-        'pre'  => true,
+        'pre' => true,
         'samp' => true,
-        'kbd'  => true,
-        'var'  => true,
+        'kbd' => true,
+        'var' => true,
     ];
+
     private const SYSTEM_PROPS = [
         'children' => true,
         'key' => true,
         'ref' => true,
     ];
 
-    protected static array $classMappings = [];
-    protected static array $selfClosingTags = [
-        'area',
-        'base',
-        'br',
-        'col',
-        'command',
-        'embed',
-        'hr',
-        'img',
-        'input',
-        'keygen',
-        'link',
-        'meta',
-        'param',
-        'source',
-        'track',
-        'wbr'
+    private const SELF_CLOSING_TAGS = [
+        'area' => true,
+        'base' => true,
+        'br' => true,
+        'col' => true,
+        'command' => true,
+        'embed' => true,
+        'hr' => true,
+        'img' => true,
+        'input' => true,
+        'keygen' => true,
+        'link' => true,
+        'meta' => true,
+        'param' => true,
+        'source' => true,
+        'track' => true,
+        'wbr' => true,
     ];
+
+    private const SCRIPT_TYPES = [
+        '' => true,
+        'text/javascript' => true,
+        'application/javascript' => true,
+        'module' => true,
+        'text/php' => true,
+    ];
+
+    private static array $classMappings = [];
+    private static array $reflectionCache = [];
     private static array $sectionStack = [];
     private static int $compileDepth = 0;
     private static array $componentInstanceCounts = [];
-    private static array $reflections       = [];
-    private static array $constructors      = [];
-    private static array $publicProperties  = [];
-    private static array $allowedProps = [];
 
     public static function compile(string $templateContent): string
     {
@@ -71,154 +92,191 @@ class TemplateCompiler
         }
         self::$compileDepth++;
 
-        if (empty(self::$classMappings)) {
-            self::initializeClassMappings();
+        try {
+            if (empty(self::$classMappings)) {
+                self::initializeClassMappings();
+            }
+
+            $dom = self::convertToXml($templateContent);
+            $output = self::processChildNodes($dom->documentElement->childNodes);
+
+            return implode('', $output);
+        } finally {
+            self::$compileDepth--;
         }
+    }
 
-        $dom = self::convertToXml($templateContent);
-        $root = $dom->documentElement;
+    public static function injectDynamicContent(string $htmlContent): string
+    {
+        $replacements = [
+            self::HEAD_PATTERNS['open'] => '$1' . MainLayout::outputMetadata(),
+            self::HEAD_PATTERNS['close'] => MainLayout::outputHeadScripts() . '$1',
+            self::BODY_PATTERNS['close'] => MainLayout::outputFooterScripts() . '$1',
+        ];
 
-        $output = [];
-        foreach ($root->childNodes as $child) {
-            $output[] = self::processNode($child);
+        foreach ($replacements as $pattern => $replacement) {
+            $htmlContent = preg_replace($pattern, $replacement, $htmlContent, 1);
         }
 
-        self::$compileDepth--;
-        return implode('', $output);
+        if (
+            !isset($_SERVER['HTTP_X_PPHP_NAVIGATION']) &&
+            !PrismaPHPSettings::$option->backendOnly
+        ) {
+            $htmlContent = preg_replace(
+                self::BODY_PATTERNS['open'],
+                '<body$1 hidden>',
+                $htmlContent,
+                1
+            );
+        }
+
+        return $htmlContent;
     }
 
-    public static function injectDynamicContent(string $htmlContent): string
+    public static function convertToXml(string $templateContent): DOMDocument
     {
-        $headOpenPattern = '/(<head\b[^>]*>)/i';
+        $content = self::processContentForXml($templateContent);
+        $xml = "<root>{$content}</root>";
 
-        $htmlContent = preg_replace(
-            $headOpenPattern,
-            '$1' . MainLayout::outputMetadata(),
-            $htmlContent,
-            1
-        );
+        return self::createDomFromXml($xml);
+    }
 
-        $headClosePattern = '/(<\/head\s*>)/i';
-        $headScripts      = MainLayout::outputHeadScripts();
-        $htmlContent = preg_replace(
-            $headClosePattern,
-            $headScripts . '$1',
-            $htmlContent,
-            1
+    private static function processContentForXml(string $content): string
+    {
+        return self::escapeMustacheAngles(
+            self::escapeAttributeAngles(
+                self::escapeLiteralTextContent(
+                    self::escapeAmpersands(
+                        self::normalizeNamedEntities(
+                            self::protectInlineScripts($content)
+                        )
+                    )
+                )
+            )
         );
+    }
 
-        if (!isset($_SERVER['HTTP_X_PPHP_NAVIGATION'])) {
-            if (!PrismaPHPSettings::$option->backendOnly) {
-                $htmlContent = preg_replace(
-                    '/<body([^>]*)>/i',
-                    '<body$1 hidden>',
-                    $htmlContent,
-                    1
-                );
-            }
-        }
+    private static function createDomFromXml(string $xml): DOMDocument
+    {
+        $dom = new DOMDocument('1.0', 'UTF-8');
+        libxml_use_internal_errors(true);
 
-        $bodyClosePattern = '/(<\/body\s*>)/i';
+        if (!$dom->loadXML($xml, LIBXML_NOERROR | LIBXML_NOWARNING | LIBXML_NONET)) {
+            $errors = self::getXmlErrors();
+            libxml_use_internal_errors(false);
+            throw new RuntimeException('XML Parsing Failed: ' . implode('; ', $errors));
+        }
 
-        $htmlContent = preg_replace(
-            $bodyClosePattern,
-            MainLayout::outputFooterScripts() . '$1',
-            $htmlContent,
-            1
-        );
+        libxml_clear_errors();
+        libxml_use_internal_errors(false);
 
-        return $htmlContent;
+        return $dom;
     }
 
-    private static function escapeAmpersands(string $content): string
+    private static function processChildNodes($childNodes): array
     {
-        $parts = preg_split('/(<!\[CDATA\[[\s\S]*?\]\]>)/', $content, -1, PREG_SPLIT_DELIM_CAPTURE);
-        if ($parts === false) {
-            return $content;
+        $output = [];
+        foreach ($childNodes as $child) {
+            $output[] = self::processNode($child);
         }
+        return $output;
+    }
 
-        foreach ($parts as $i => $part) {
-            if (str_starts_with($part, '<![CDATA[')) {
-                continue;
-            }
-
-            $parts[$i] = preg_replace(
+    private static function escapeAmpersands(string $content): string
+    {
+        return self::processCDataAwareParts(
+            $content,
+            fn($part) => preg_replace(
                 '/&(?![a-zA-Z][A-Za-z0-9]*;|#[0-9]+;|#x[0-9A-Fa-f]+;)/',
                 '&amp;',
                 $part
-            );
-        }
-        return implode('', $parts);
+            )
+        );
     }
 
     private static function escapeAttributeAngles(string $html): string
     {
         return preg_replace_callback(
-            '/(\s[\w:-]+=)([\'"])(.*?)\2/s',
-            fn($m) => $m[1] . $m[2] . str_replace(['<', '>'], ['&lt;', '&gt;'], $m[3]) . $m[2],
+            self::ATTRIBUTE_REGEX,
+            static fn($m) => $m[1] . $m[2] .
+                str_replace(['<', '>'], ['&lt;', '&gt;'], $m[3]) . $m[2],
             $html
         );
     }
 
-    private static function escapeMustacheAngles(string $content): string
+    private static function escapeLiteralTextContent(string $content): string
     {
+        $literalTags = implode('|', array_keys(self::LITERAL_TEXT_TAGS));
+        $pattern = '/(<(?:' . $literalTags . ')\b[^>]*>)(.*?)(<\/(?:' . $literalTags . ')>)/is';
+
         return preg_replace_callback(
-            '/\{\{[\s\S]*?\}\}/u',
-            fn($m) => str_replace(['<', '>'], ['&lt;', '&gt;'], $m[0]),
+            $pattern,
+            static function ($matches) {
+                $openTag = $matches[1];
+                $textContent = $matches[2];
+                $closeTag = $matches[3];
+
+                $escapedContent = preg_replace_callback(
+                    '/(\s|^|,)([<>]=?)(\s|$|,)/',
+                    function ($match) {
+                        $operator = $match[2];
+                        $escapedOp = str_replace(['<', '>'], ['&lt;', '&gt;'], $operator);
+                        return $match[1] . $escapedOp . $match[3];
+                    },
+                    $textContent
+                );
+
+                return $openTag . $escapedContent . $closeTag;
+            },
             $content
         );
     }
 
-    public static function convertToXml(string $templateContent): DOMDocument
+    private static function escapeMustacheAngles(string $content): string
     {
-        $content = self::protectInlineScripts($templateContent);
-        $content = self::normalizeNamedEntities($content);
-
-        $content = self::escapeAmpersands($content);
-        $content = self::escapeAttributeAngles($content);
-        $content = self::escapeMustacheAngles($content);
-
-        $xml = "<root>{$content}</root>";
-
-        $dom = new DOMDocument('1.0', 'UTF-8');
-        libxml_use_internal_errors(true);
-        if (!$dom->loadXML($xml, LIBXML_NOERROR | LIBXML_NOWARNING | LIBXML_NONET)) {
-            throw new RuntimeException(
-                'XML Parsing Failed: ' . implode('; ', self::getXmlErrors())
-            );
-        }
-        libxml_clear_errors();
-        libxml_use_internal_errors(false);
-        return $dom;
+        return preg_replace_callback(
+            self::MUSTACHE_REGEX,
+            static fn($m) => str_replace(['<', '>'], ['&lt;', '&gt;'], $m[0]),
+            $content
+        );
     }
 
     private static function normalizeNamedEntities(string $html): string
     {
-        $parts = preg_split('/(<!\[CDATA\[[\s\S]*?\]\]>)/', $html, -1, PREG_SPLIT_DELIM_CAPTURE);
+        return self::processCDataAwareParts(
+            $html,
+            static function (string $part): string {
+                return preg_replace_callback(
+                    self::NAMED_ENTITY_REGEX,
+                    static function (array $m): string {
+                        $decoded = html_entity_decode($m[0], ENT_HTML5, 'UTF-8');
+                        if ($decoded === $m[0]) {
+                            return $m[0];
+                        }
+
+                        $code = function_exists('mb_ord')
+                            ? mb_ord($decoded, 'UTF-8')
+                            : unpack('N', mb_convert_encoding($decoded, 'UCS-4BE', 'UTF-8'))[1];
+
+                        return '&#' . $code . ';';
+                    },
+                    $part
+                );
+            }
+        );
+    }
+
+    private static function processCDataAwareParts(string $content, callable $processor): string
+    {
+        $parts = preg_split('/(<!\[CDATA\[[\s\S]*?\]\]>)/', $content, -1, PREG_SPLIT_DELIM_CAPTURE);
         if ($parts === false) {
-            return $html;
+            return $content;
         }
 
         foreach ($parts as $i => $part) {
-            if (str_starts_with($part, '<![CDATA[')) {
-                continue;
+            if (!str_starts_with($part, '<![CDATA[')) {
+                $parts[$i] = $processor($part);
             }
-
-            $parts[$i] = preg_replace_callback(
-                '/&([a-zA-Z][a-zA-Z0-9]+);/',
-                static function (array $m): string {
-                    $decoded = html_entity_decode($m[0], ENT_HTML5, 'UTF-8');
-                    if ($decoded === $m[0]) {
-                        return $m[0];
-                    }
-                    if (function_exists('mb_ord')) {
-                        return '&#' . mb_ord($decoded, 'UTF-8') . ';';
-                    }
-                    $code = unpack('N', mb_convert_encoding($decoded, 'UCS-4BE', 'UTF-8'))[1];
-                    return '&#' . $code . ';';
-                },
-                $part
-            );
         }
 
         return implode('', $parts);
@@ -226,169 +284,100 @@ class TemplateCompiler
 
     private static function protectInlineScripts(string $html): string
     {
-        if (stripos($html, '<script') === false) {
+        if (!str_contains($html, '<script')) {
             return $html;
         }
 
-        $processScripts = static function (string $content): string {
-            $callback = static function (array $m): string {
-                if (preg_match('/\bsrc\s*=/i', $m[1])) {
-                    return $m[0];
-                }
-
-                if (str_contains($m[2], '<![CDATA[')) {
-                    return $m[0];
-                }
-
-                $type = '';
-                if (preg_match('/\btype\s*=\s*([\'"]?)([^\'"\s>]+)/i', $m[1], $t)) {
-                    $type = strtolower($t[2]);
-                }
-
-                $codeTypes = [
-                    '',
-                    'text/javascript',
-                    'application/javascript',
-                    'module',
-                    'text/php',
-                ];
-
-                if (!in_array($type, $codeTypes, true)) {
-                    return $m[0];
-                }
-
-                $code = str_replace(']]>', ']]]]><![CDATA[>', $m[2]);
-
-                return "<script{$m[1]}><![CDATA[\n{$code}\n]]></script>";
-            };
-
-            $result = preg_replace_callback(
-                '#<script\b([^>]*?)>(.*?)</script>#is',
-                $callback,
-                $content
-            );
+        $callback = static function (array $m): string {
+            if (preg_match('/\bsrc\s*=/i', $m[1])) {
+                return $m[0];
+            }
 
-            if ($result === null) {
-                $result = preg_replace_callback(
-                    '#<script\b([^>]*?)>(.*?)</script>#is',
-                    $callback,
-                    $content
-                );
+            if (str_contains($m[2], '<![CDATA[')) {
+                return $m[0];
+            }
 
-                return $result ?? $content;
+            $type = self::extractScriptType($m[1]);
+            if (!isset(self::SCRIPT_TYPES[$type])) {
+                return $m[0];
             }
 
-            return $result;
+            $code = str_replace(']]>', ']]]]><![CDATA[>', $m[2]);
+            return "<script{$m[1]}><![CDATA[\n{$code}\n]]></script>";
         };
 
         if (preg_match('/^(.*?<body\b[^>]*>)(.*?)(<\/body>.*)$/is', $html, $parts)) {
-            [$all, $beforeBody, $body, $afterBody] = $parts;
-            return $beforeBody . $processScripts($body) . $afterBody;
+            [, $beforeBody, $body, $afterBody] = $parts;
+            return $beforeBody . self::processScriptsInContent($body, $callback) . $afterBody;
         }
 
-        return $processScripts($html);
+        return self::processScriptsInContent($html, $callback);
     }
 
-    public static function innerXml(DOMNode $node): string
+    private static function extractScriptType(string $attributes): string
     {
-        if ($node instanceof DOMDocument) {
-            $node = $node->documentElement;
-        }
-
-        /** @var DOMDocument $doc */
-        $doc  = $node->ownerDocument;
-
-        $html = '';
-        foreach ($node->childNodes as $child) {
-            $html .= $doc->saveXML($child);
+        if (preg_match('/\btype\s*=\s*([\'"]?)([^\'"\s>]+)/i', $attributes, $matches)) {
+            return strtolower($matches[2]);
         }
-        return $html;
+        return '';
     }
 
-    protected static function getXmlErrors(): array
+    private static function processScriptsInContent(string $content, callable $callback): string
     {
-        $errors = libxml_get_errors();
-        libxml_clear_errors();
-        return array_map(fn($e) => self::formatLibxmlError($e), $errors);
+        return preg_replace_callback(self::SCRIPT_REGEX, $callback, $content) ?? $content;
     }
 
-    protected static function formatLibxmlError(LibXMLError $error): string
+    protected static function processNode(DOMNode $node): string
     {
-        $type = match ($error->level) {
-            LIBXML_ERR_WARNING => 'Warning',
-            LIBXML_ERR_ERROR   => 'Error',
-            LIBXML_ERR_FATAL   => 'Fatal',
-            default            => 'Unknown',
+        return match (true) {
+            $node instanceof DOMText => self::processTextNode($node),
+            $node instanceof DOMElement => self::processElementNode($node),
+            $node instanceof DOMComment => "<!--{$node->textContent}-->",
+            default => $node->textContent,
         };
-        return sprintf(
-            "[%s] Line %d, Col %d: %s",
-            $type,
-            $error->line,
-            $error->column,
-            trim($error->message)
-        );
     }
 
-    protected static function processNode(DOMNode $node): string
+    private static function processElementNode(DOMElement $node): string
     {
-        if ($node instanceof DOMText) {
-            return self::processTextNode($node);
-        }
+        $tag = strtolower($node->nodeName);
+        $pushed = false;
 
-        if ($node instanceof DOMElement) {
-            $pushed = false;
-            $tag    = strtolower($node->nodeName);
-
-            if (
-                $tag === 'script' &&
-                !$node->hasAttribute('src') &&
-                !$node->hasAttribute('type')
-            ) {
-                $node->setAttribute('type', 'text/php');
-            }
+        if ($tag === 'script' && !$node->hasAttribute('src') && !$node->hasAttribute('type')) {
+            $node->setAttribute('type', 'text/php');
+        }
 
-            if ($node->hasAttribute('pp-component')) {
-                self::$sectionStack[] = $node->getAttribute('pp-component');
-                $pushed = true;
-            }
+        // Handle component sections
+        if ($node->hasAttribute('pp-component')) {
+            self::$sectionStack[] = $node->getAttribute('pp-component');
+            $pushed = true;
+        }
 
+        try {
             self::processAttributes($node);
 
             if (isset(self::$classMappings[$node->nodeName])) {
-                $html = self::renderComponent(
+                return self::renderComponent(
                     $node,
                     $node->nodeName,
                     self::getNodeAttributes($node)
                 );
-                if ($pushed) {
-                    array_pop(self::$sectionStack);
-                }
-                return $html;
             }
 
-            $children = '';
-            foreach ($node->childNodes as $c) {
-                $children .= self::processNode($c);
-            }
+            $children = implode('', self::processChildNodes($node->childNodes));
             $attrs = self::getNodeAttributes($node) + ['children' => $children];
-            $out   = self::renderAsHtml($node->nodeName, $attrs);
 
+            return self::renderAsHtml($node->nodeName, $attrs);
+        } finally {
             if ($pushed) {
                 array_pop(self::$sectionStack);
             }
-            return $out;
         }
-
-        if ($node instanceof DOMComment) {
-            return "<!--{$node->textContent}-->";
-        }
-
-        return $node->textContent;
     }
 
     private static function processTextNode(DOMText $node): string
     {
         $parent = strtolower($node->parentNode?->nodeName ?? '');
+
         if (isset(self::LITERAL_TEXT_TAGS[$parent])) {
             return htmlspecialchars(
                 $node->textContent,
@@ -399,32 +388,17 @@ class TemplateCompiler
 
         return preg_replace_callback(
             self::BINDING_REGEX,
-            fn($m) => self::processBindingExpression(trim($m[1])),
+            static fn($m) => self::processBindingExpression(trim($m[1])),
             $node->textContent
         );
     }
 
-    private static function processAttributes(DOMElement $node): void
-    {
-        foreach ($node->attributes as $a) {
-            if (!preg_match(self::BINDING_REGEX, $a->value, $m)) {
-                continue;
-            }
-
-            $rawExpr = trim($m[1]);
-            $node->setAttribute("pp-bind-{$a->name}", $rawExpr);
-        }
-    }
-
     private static function processBindingExpression(string $expr): string
     {
         $escaped = htmlspecialchars($expr, ENT_QUOTES, 'UTF-8');
+        $attribute = preg_match('/^[\w.]+$/u', $expr) ? 'pp-bind' : 'pp-bind-expr';
 
-        if (preg_match('/^[\w.]+$/u', $expr)) {
-            return "<span pp-bind=\"{$escaped}\"></span>";
-        }
-
-        return "<span pp-bind-expr=\"{$escaped}\"></span>";
+        return "<span {$attribute}=\"{$escaped}\"></span>";
     }
 
     protected static function renderComponent(
@@ -432,232 +406,284 @@ class TemplateCompiler
         string $componentName,
         array $incomingProps
     ): string {
-        $mapping  = self::selectComponentMapping($componentName);
-
-        $baseId = 's' . base_convert(sprintf('%u', crc32($mapping['className'])), 10, 36);
-        $idx = self::$componentInstanceCounts[$baseId] ?? 0;
-        self::$componentInstanceCounts[$baseId] = $idx + 1;
-        $sectionId = $idx === 0 ? $baseId : "{$baseId}{$idx}";
+        $mapping = self::selectComponentMapping($componentName);
+        $sectionId = self::generateSectionId($mapping['className']);
 
         $originalStack = self::$sectionStack;
         self::$sectionStack[] = $sectionId;
 
-        PHPX::setRenderingContext($originalStack, $sectionId);
+        try {
+            PHPX::setRenderingContext($originalStack, $sectionId);
 
-        $instance = self::initializeComponentInstance($mapping, $incomingProps);
+            $instance = self::initializeComponentInstance($mapping, $incomingProps);
+            $instance->children = self::getChildrenHtml($node);
 
-        $childHtml = '';
-        foreach ($node->childNodes as $c) {
-            $childHtml .= self::processNode($c);
+            PHPX::setRenderingContext($originalStack, $sectionId);
+
+            return self::compileComponentHtml($instance->render(), $sectionId);
+        } finally {
+            self::$sectionStack = $originalStack;
         }
+    }
 
-        self::$sectionStack = $originalStack;
+    private static function generateSectionId(string $className): string
+    {
+        $baseId = 's' . base_convert(sprintf('%u', crc32($className)), 10, 36);
+        $idx = self::$componentInstanceCounts[$baseId] ?? 0;
+        self::$componentInstanceCounts[$baseId] = $idx + 1;
 
-        $instance->children = trim($childHtml);
+        return $idx === 0 ? $baseId : "{$baseId}{$idx}";
+    }
 
-        PHPX::setRenderingContext($originalStack, $sectionId);
+    private static function getChildrenHtml(DOMElement $node): string
+    {
+        $output = [];
+        foreach ($node->childNodes as $child) {
+            $output[] = self::processNode($child);
+        }
+        return trim(implode('', $output));
+    }
 
-        $html = $instance->render();
+    private static function compileComponentHtml(string $html, string $sectionId): string
+    {
         $html = self::preprocessFragmentSyntax($html);
-
         $fragDom = self::convertToXml($html);
-        $root = $fragDom->documentElement;
-        foreach ($root->childNodes as $c) {
-            if ($c instanceof DOMElement) {
-                $c->setAttribute('pp-component', $sectionId);
+
+        foreach ($fragDom->documentElement->childNodes as $child) {
+            if ($child instanceof DOMElement) {
+                $child->setAttribute('pp-component', $sectionId);
                 break;
             }
         }
 
         $htmlOut = self::innerXml($fragDom);
-        $htmlOut = preg_replace_callback(
-            '/<([a-z0-9-]+)([^>]*)\/>/i',
-            fn($m) => in_array(strtolower($m[1]), self::$selfClosingTags, true)
-                ? $m[0]
-                : "<{$m[1]}{$m[2]}></{$m[1]}>",
-            $htmlOut
-        );
+        $htmlOut = self::normalizeSelfClosingTags($htmlOut);
 
-        if (
-            str_contains($htmlOut, '{{') ||
-            self::hasComponentTag($htmlOut) ||
-            stripos($htmlOut, '<script') !== false
-        ) {
+        if (self::needsRecompilation($htmlOut)) {
             $htmlOut = self::compile($htmlOut);
         }
 
         return $htmlOut;
     }
 
-    private static function preprocessFragmentSyntax(string $content): string
+    private static function needsRecompilation(string $html): bool
     {
-        $content = preg_replace('/<>/', '<Fragment>', $content);
-        $content = preg_replace('/<\/>/', '</Fragment>', $content);
-
-        return $content;
+        return str_contains($html, '{{') ||
+            preg_match(self::COMPONENT_TAG_REGEX, $html) === 1 ||
+            stripos($html, '<script') !== false;
     }
 
-    private static function selectComponentMapping(string $componentName): array
+    private static function normalizeSelfClosingTags(string $html): string
     {
-        if (!isset(self::$classMappings[$componentName])) {
-            throw new RuntimeException("Component {$componentName} not registered");
-        }
-        $mappings = self::$classMappings[$componentName];
-
-        $srcNorm = str_replace('\\', '/', SRC_PATH) . '/';
-        $relImp  = str_replace($srcNorm, '', str_replace('\\', '/', Bootstrap::$contentToInclude));
-
-        if (isset($mappings[0]) && is_array($mappings[0])) {
-            foreach ($mappings as $entry) {
-                $imp = isset($entry['importer'])
-                    ? str_replace('\\', '/', $entry['importer'])
-                    : '';
-                if (str_replace($srcNorm, '', $imp) === $relImp) {
-                    return $entry;
-                }
-            }
-            return $mappings[0];
-        }
-        return $mappings;
+        return preg_replace_callback(
+            self::SELF_CLOSING_REGEX,
+            static fn($m) => isset(self::SELF_CLOSING_TAGS[strtolower($m[1])])
+                ? $m[0]
+                : "<{$m[1]}{$m[2]}></{$m[1]}>",
+            $html
+        );
     }
 
-    protected static function initializeComponentInstance(array $mapping, array $attributes)
+    private static function initializeComponentInstance(array $mapping, array $attributes)
     {
-        if (!isset($mapping['className'], $mapping['filePath'])) {
-            throw new RuntimeException("Invalid mapping");
-        }
+        ['className' => $className, 'filePath' => $filePath] = $mapping;
 
-        $className = $mapping['className'];
-        $filePath  = $mapping['filePath'];
+        self::ensureClassLoaded($className, $filePath);
+        $reflection = self::getClassReflection($className);
 
-        require_once str_replace('\\', '/', SRC_PATH . '/' . $filePath);
-        if (!class_exists($className)) {
-            throw new RuntimeException("Class {$className} not found");
-        }
-
-        self::cacheClassReflection($className);
+        self::validateComponentProps($className, $attributes);
 
-        if (!isset(self::$reflections[$className])) {
-            $rc = new ReflectionClass($className);
-            self::$reflections[$className]      = $rc;
-            self::$constructors[$className]     = $rc->getConstructor();
-            self::$publicProperties[$className] = array_filter(
-                $rc->getProperties(ReflectionProperty::IS_PUBLIC),
-                fn(ReflectionProperty $p) => !$p->isStatic()
-            );
-        }
+        $instance = $reflection['class']->newInstanceWithoutConstructor();
+        self::setInstanceProperties($instance, $attributes, $reflection['properties']);
 
-        self::validateComponentProps($className, $attributes);
+        $reflection['constructor']?->invoke($instance, $attributes);
 
-        $ref  = self::$reflections[$className];
-        $ctor = self::$constructors[$className];
-        $inst = $ref->newInstanceWithoutConstructor();
+        return $instance;
+    }
 
-        foreach (self::$publicProperties[$className] as $prop) {
-            $name = $prop->getName();
+    private static function ensureClassLoaded(string $className, string $filePath): void
+    {
+        if (!class_exists($className)) {
+            require_once str_replace('\\', '/', SRC_PATH . '/' . $filePath);
 
-            if (!array_key_exists($name, $attributes)) {
-                continue;
+            if (!class_exists($className)) {
+                throw new RuntimeException("Class {$className} not found");
             }
-            $value = self::coerce($attributes[$name], $prop->getType());
-            $prop->setValue($inst, $value);
-        }
-
-        if ($ctor) {
-            $ctor->invoke($inst, $attributes);
         }
-
-        return $inst;
     }
 
-    private static function cacheClassReflection(string $className): void
+    private static function getClassReflection(string $className): array
     {
-        if (isset(self::$reflections[$className])) {
-            return;
-        }
+        if (!isset(self::$reflectionCache[$className])) {
+            $rc = new ReflectionClass($className);
+            $publicProps = array_filter(
+                $rc->getProperties(ReflectionProperty::IS_PUBLIC),
+                static fn(ReflectionProperty $p) => !$p->isStatic()
+            );
 
-        $rc = new ReflectionClass($className);
-        self::$reflections[$className] = $rc;
-        self::$constructors[$className] = $rc->getConstructor();
+            self::$reflectionCache[$className] = [
+                'class' => $rc,
+                'constructor' => $rc->getConstructor(),
+                'properties' => $publicProps,
+                'allowedProps' => self::SYSTEM_PROPS + array_flip(
+                    array_map(static fn($p) => $p->getName(), $publicProps)
+                ),
+            ];
+        }
 
-        $publicProps = array_filter(
-            $rc->getProperties(ReflectionProperty::IS_PUBLIC),
-            fn(ReflectionProperty $p) => !$p->isStatic()
-        );
-        self::$publicProperties[$className] = $publicProps;
+        return self::$reflectionCache[$className];
+    }
 
-        $allowed = self::SYSTEM_PROPS;
-        foreach ($publicProps as $prop) {
-            $allowed[$prop->getName()] = true;
+    private static function setInstanceProperties(
+        object $instance,
+        array $attributes,
+        array $properties
+    ): void {
+        foreach ($properties as $prop) {
+            $name = $prop->getName();
+            if (array_key_exists($name, $attributes)) {
+                $value = TypeCoercer::coerce($attributes[$name], $prop->getType());
+                $prop->setValue($instance, $value);
+            }
         }
-        self::$allowedProps[$className] = $allowed;
     }
 
     private static function validateComponentProps(string $className, array $attributes): void
     {
-        foreach (self::$publicProperties[$className] as $prop) {
+        $reflection = self::getClassReflection($className);
+
+        foreach ($reflection['properties'] as $prop) {
             $name = $prop->getName();
             $type = $prop->getType();
 
             if (
-                $type instanceof ReflectionNamedType && $type->isBuiltin()
-                && ! $type->allowsNull()
-                && ! array_key_exists($name, $attributes)
+                $type instanceof ReflectionNamedType &&
+                $type->isBuiltin() &&
+                !$type->allowsNull() &&
+                !array_key_exists($name, $attributes)
             ) {
                 throw new ComponentValidationException(
                     $name,
                     $className,
-                    array_map(fn($p) => $p->getName(), self::$publicProperties[$className])
+                    array_map(static fn($p) => $p->getName(), $reflection['properties'])
                 );
             }
         }
-
-        return;
     }
 
-    private static function coerce(mixed $value, ?ReflectionType $type): mixed
+    private static function selectComponentMapping(string $componentName): array
     {
-        return TypeCoercer::coerce($value, $type);
+        if (!isset(self::$classMappings[$componentName])) {
+            throw new RuntimeException("Component {$componentName} not registered");
+        }
+
+        $mappings = self::$classMappings[$componentName];
+
+        if (!isset($mappings[0]) || !is_array($mappings[0])) {
+            return $mappings;
+        }
+
+        $srcNorm = str_replace('\\', '/', SRC_PATH) . '/';
+        $relImp = str_replace($srcNorm, '', str_replace('\\', '/', Bootstrap::$contentToInclude));
+
+        foreach ($mappings as $entry) {
+            if (isset($entry['importer'])) {
+                $imp = str_replace([$srcNorm, '\\'], ['', '/'], $entry['importer']);
+                if ($imp === $relImp) {
+                    return $entry;
+                }
+            }
+        }
+
+        return $mappings[0];
     }
 
-    protected static function initializeClassMappings(): void
+    public static function innerXml(DOMNode $node): string
     {
-        foreach (PrismaPHPSettings::$classLogFiles as $tag => $cls) {
-            self::$classMappings[$tag] = $cls;
+        if ($node instanceof DOMDocument) {
+            $node = $node->documentElement;
+        }
+
+        $html = '';
+        foreach ($node->childNodes as $child) {
+            $html .= $node->ownerDocument->saveXML($child);
         }
+
+        return $html;
     }
 
-    protected static function hasComponentTag(string $html): bool
+    private static function preprocessFragmentSyntax(string $content): string
+    {
+        return str_replace(['<>', '</>'], ['<Fragment>', '</Fragment>'], $content);
+    }
+
+    private static function processAttributes(DOMElement $node): void
     {
-        return preg_match('/<\/*[A-Z][\w-]*/u', $html) === 1;
+        foreach ($node->attributes as $attr) {
+            if (preg_match(self::BINDING_REGEX, $attr->value, $matches)) {
+                $node->setAttribute("pp-bind-{$attr->name}", trim($matches[1]));
+            }
+        }
     }
 
     private static function getNodeAttributes(DOMElement $node): array
     {
-        $out = [];
-        foreach ($node->attributes as $a) {
-            $out[$a->name] = $a->value;
+        $attrs = [];
+        foreach ($node->attributes as $attr) {
+            $attrs[$attr->name] = $attr->value;
         }
-        return $out;
+        return $attrs;
     }
 
     private static function renderAsHtml(string $tag, array $attrs): string
     {
-        $pairs = [];
-        foreach ($attrs as $k => $v) {
-            if ($k === 'children') {
-                continue;
+        $children = $attrs['children'] ?? '';
+        unset($attrs['children']);
+
+        if (empty($attrs)) {
+            $attrStr = '';
+        } else {
+            $pairs = [];
+            foreach ($attrs as $name => $value) {
+                $pairs[] = sprintf(
+                    '%s="%s"',
+                    $name,
+                    htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8')
+                );
             }
-            $pairs[] = sprintf(
-                '%s="%s"',
-                $k,
-                htmlspecialchars($v, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8')
-            );
+            $attrStr = ' ' . implode(' ', $pairs);
         }
-        $attrStr = $pairs ? ' ' . implode(' ', $pairs) : '';
 
-        return in_array(strtolower($tag), self::$selfClosingTags, true)
+        return isset(self::SELF_CLOSING_TAGS[strtolower($tag)])
             ? "<{$tag}{$attrStr} />"
-            : "<{$tag}{$attrStr}>{$attrs['children']}</{$tag}>";
+            : "<{$tag}{$attrStr}>{$children}</{$tag}>";
+    }
+
+    protected static function initializeClassMappings(): void
+    {
+        self::$classMappings = PrismaPHPSettings::$classLogFiles;
+    }
+
+    protected static function getXmlErrors(): array
+    {
+        $errors = libxml_get_errors();
+        libxml_clear_errors();
+
+        return array_map(static function (LibXMLError $error): string {
+            $type = match ($error->level) {
+                LIBXML_ERR_WARNING => 'Warning',
+                LIBXML_ERR_ERROR => 'Error',
+                LIBXML_ERR_FATAL => 'Fatal',
+                default => 'Unknown',
+            };
+
+            return sprintf(
+                "[%s] Line %d, Col %d: %s",
+                $type,
+                $error->line,
+                $error->column,
+                trim($error->message)
+            );
+        }, $errors);
     }
 }