From 1bc3e17bd29afb7dafa6607c13ae4636c87f88f9 Mon Sep 17 00:00:00 2001
From: uzziahlukeka <uzziahlukeka@gmail.com>
Date: Sat, 22 Mar 2025 11:11:03 +0100
Subject: [PATCH 1/6] issue with sanitize

---
 composer.lock                  |  12 +--
 src/BlockFactory.php           |   2 +-
 src/Blocks/Block.php           |  28 +++---
 src/Blocks/Listing.php         |   1 +
 src/Blocks/Paragraph.php       |  34 +++++++
 tests/Blocks/ParagraphTest.php | 159 +++++++++++++++++++++++++++++++++
 6 files changed, 215 insertions(+), 21 deletions(-)
 create mode 100644 tests/Blocks/ParagraphTest.php

diff --git a/composer.lock b/composer.lock
index 970e660..6eeb20b 100755
--- a/composer.lock
+++ b/composer.lock
@@ -499,16 +499,16 @@
         },
         {
             "name": "symfony/html-sanitizer",
-            "version": "v7.2.2",
+            "version": "v7.2.3",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/html-sanitizer.git",
-                "reference": "f6bc679b024e30f27e33815930a5b8b304c79813"
+                "reference": "91443febe34cfa5e8e00425f892e6316db95bc23"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/html-sanitizer/zipball/f6bc679b024e30f27e33815930a5b8b304c79813",
-                "reference": "f6bc679b024e30f27e33815930a5b8b304c79813",
+                "url": "https://api.github.com/repos/symfony/html-sanitizer/zipball/91443febe34cfa5e8e00425f892e6316db95bc23",
+                "reference": "91443febe34cfa5e8e00425f892e6316db95bc23",
                 "shasum": ""
             },
             "require": {
@@ -548,7 +548,7 @@
                 "sanitizer"
             ],
             "support": {
-                "source": "https://github.com/symfony/html-sanitizer/tree/v7.2.2"
+                "source": "https://github.com/symfony/html-sanitizer/tree/v7.2.3"
             },
             "funding": [
                 {
@@ -564,7 +564,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2024-12-30T18:35:15+00:00"
+            "time": "2025-01-27T11:08:17+00:00"
         },
         {
             "name": "symfony/polyfill-mbstring",
diff --git a/src/BlockFactory.php b/src/BlockFactory.php
index b4103a8..0c192fb 100755
--- a/src/BlockFactory.php
+++ b/src/BlockFactory.php
@@ -102,7 +102,7 @@ private static function getAllowedTags(mixed $block, array $allowedTags): array
 
     private static function getSchema(string $schema): array
     {
-        $filename = sprintf("%s/schemas/%s.schema.json", dirname(__DIR__), $schema);
+        $filename = sprintf('%s/schemas/%s.schema.json', dirname(__DIR__), $schema);
         $content = file_get_contents($filename);
         Assert::string($content, sprintf('Schema for block type %s not found', $schema));
 
diff --git a/src/Blocks/Block.php b/src/Blocks/Block.php
index 3995f36..3b9ccd9 100755
--- a/src/Blocks/Block.php
+++ b/src/Blocks/Block.php
@@ -44,18 +44,18 @@ public static function create(array $data, array $allowedTags = []): static
         );
     }
 
-//    private function sanitize(array $data, array|string $allowedTags = []): array
-//    {
-//        $sanitizer = Sanitizer::create($allowedTags);
-//
-//        foreach ($data as $key => $value) {
-//            if (is_array($value)) {
-//                $data[$key] = $this->sanitize($value, $allowedTags);
-//            } else {
-//                $data[$key] = $sanitizer->sanitize($value);
-//            }
-//        }
-//
-//        return $data;
-//    }
+    //    private function sanitize(array $data, array|string $allowedTags = []): array
+    //    {
+    //        $sanitizer = Sanitizer::create($allowedTags);
+    //
+    //        foreach ($data as $key => $value) {
+    //            if (is_array($value)) {
+    //                $data[$key] = $this->sanitize($value, $allowedTags);
+    //            } else {
+    //                $data[$key] = $sanitizer->sanitize($value);
+    //            }
+    //        }
+    //
+    //        return $data;
+    //    }
 }
diff --git a/src/Blocks/Listing.php b/src/Blocks/Listing.php
index fb114f8..ebd2cb2 100755
--- a/src/Blocks/Listing.php
+++ b/src/Blocks/Listing.php
@@ -14,6 +14,7 @@
 namespace Devscast\EditorJs\Blocks;
 
 use Devscast\EditorJs\Assert;
+use Devscast\EditorJs\Sanitizer;
 
 /**
  * Class Listing.
diff --git a/src/Blocks/Paragraph.php b/src/Blocks/Paragraph.php
index 9a3ffd6..17dd08d 100755
--- a/src/Blocks/Paragraph.php
+++ b/src/Blocks/Paragraph.php
@@ -14,6 +14,7 @@
 namespace Devscast\EditorJs\Blocks;
 
 use Devscast\EditorJs\Assert;
+use Devscast\EditorJs\Sanitizer;
 
 /**
  * Class Paragraph.
@@ -40,4 +41,37 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
 
         parent::__construct($id, $type, $data, $tunes, $rules);
     }
+
+    public function toHtml(): string
+    {
+        $allowedTags = [
+            'a' => ['href', 'title', 'rel'],
+            'strong' => [],
+            'em' => [],
+            'u' => [],
+            'br' => [],
+            'p' => ['id'],
+        ];
+        $rawHtml = $this->toRawHtml($this->data);
+        $sanitizedHtml = $this->sanitizeHtml($rawHtml, $allowedTags);
+        dump('Sanitized HTML:', $sanitizedHtml);
+        return $sanitizedHtml;
+    }
+
+    //convertion vers du html brut
+    private function toRawHtml(array $data)
+    {
+        return "<p id=\"{$this->id}\">{$data['text']}</p>";
+    }
+
+    //nettoyage du html
+
+    private function sanitizeHtml(string $html, array|string $allowedTags = [])
+    {
+        $sanitizer = Sanitizer::create($allowedTags);
+        dump('Input HTML:', $html);
+        dump('Sanitized HTML:', $sanitizer->sanitize($html));
+
+        return $sanitizer->sanitize($html);
+    }
 }
diff --git a/tests/Blocks/ParagraphTest.php b/tests/Blocks/ParagraphTest.php
new file mode 100644
index 0000000..7f73311
--- /dev/null
+++ b/tests/Blocks/ParagraphTest.php
@@ -0,0 +1,159 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\Blocks\Paragraph;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class ParagraphTest extends TestCase
+{
+    public function testValidParagraphConstruction(): void
+    {
+        $id = '1';
+        $type = 'paragraph';
+        $data = [
+            'text' => 'This is a test paragraph',
+        ];
+        $tunes = null;
+        $rules = [];
+
+        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
+
+        $this->assertInstanceOf(Paragraph::class, $paragraph);
+    }
+
+    public function testValidParagraphWithFootnotesConstruction(): void
+    {
+        $id = '1';
+        $type = 'paragraph';
+        $data = [
+            'text' => 'This is a test paragraph',
+        ];
+        $tunes = [
+            'footnotes' => [],
+        ];
+        $rules = [];
+
+        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
+
+        $this->assertInstanceOf(Paragraph::class, $paragraph);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $id = '1';
+        $type = 'invalid-type';
+        $data = [
+            'text' => 'This is a test paragraph',
+        ];
+        $tunes = null;
+        $rules = [];
+
+        new Paragraph($id, $type, $data, $tunes, $rules);
+    }
+
+    public function testMissingTextConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $id = '1';
+        $type = 'paragraph';
+        $data = [];
+        $tunes = null;
+        $rules = [];
+
+        new Paragraph($id, $type, $data, $tunes, $rules);
+    }
+
+    public function testMissingFootnotesInTunesConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $id = '1';
+        $type = 'paragraph';
+        $data = [
+            'text' => 'This is a test paragraph',
+        ];
+        $tunes = [];
+        $rules = [];
+
+        new Paragraph($id, $type, $data, $tunes, $rules);
+    }
+
+    public function testInvalidFootnotesTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $id = '1';
+        $type = 'paragraph';
+        $data = [
+            'text' => 'This is a test paragraph',
+        ];
+        $tunes = [
+            'footnotes' => 'not-an-array',
+        ];
+        $rules = [];
+
+        new Paragraph($id, $type, $data, $tunes, $rules);
+    }
+
+    public function testToHtml(): void
+    {
+        $id = 'test_id';
+        $type = 'paragraph';
+        $data = [
+            'text' => 'This is a test paragraph',
+        ];
+        $tunes = null;
+        $rules = [];
+
+        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
+        $html = $paragraph->toHtml();
+        $this->assertNotEmpty($html, 'HTML should not be empty');
+        $this->assertStringContainsString('<p id="test_id">This is a test paragraph</p>', $html);
+    }
+
+    public function testToHtmlWithAllowedTags(): void
+    {
+        $id = 'test_id';
+        $type = 'paragraph';
+        $data = [
+            'text' => 'This is a <strong>test</strong> paragraph with <a href="https://example.com" title="Example" rel="nofollow">link</a>',
+        ];
+        $tunes = null;
+        $rules = [];
+
+        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
+        $html = $paragraph->toHtml();
+
+        // Debug information
+        $this->assertNotEmpty($html, 'HTML output should not be empty. Output: ' . var_export($html, true));
+
+        // Check raw HTML before sanitization (using reflection to access private method)
+        $reflectionMethod = new \ReflectionMethod(Paragraph::class, 'toRawHtml');
+        $rawHtml = $reflectionMethod->invoke($paragraph, $data);
+        $this->assertNotEmpty($rawHtml, 'Raw HTML should not be empty');
+
+        // Continue with the original assertions
+        $this->assertStringContainsString('<strong>test</strong>', $html);
+        $this->assertStringContainsString('<a href="https://example.com" title="Example" rel="nofollow">link</a>', $html);
+    }
+
+    public function testToHtmlSanitizesDisallowedTags(): void
+    {
+        $id = 'test_id';
+        $type = 'paragraph';
+        $data = [
+            'text' => 'This is a <script>alert("XSS")</script> test with <iframe src="https://malicious.com"></iframe>',
+        ];
+        $tunes = null;
+        $rules = [];
+
+        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
+        $html = $paragraph->toHtml();
+
+        $this->assertStringNotContainsString('<script>', $html);
+        $this->assertStringNotContainsString('<iframe', $html);
+    }
+}

From f23aaa873f9e18d6baeeb955f38a7d80e0bef795 Mon Sep 17 00:00:00 2001
From: bernard-ng <ngandubernard@gmail.com>
Date: Sun, 23 Mar 2025 03:24:21 +0200
Subject: [PATCH 2/6] fix design

---
 src/BlockFactory.php           |  14 +-
 src/Blocks/Attaches.php        |  16 ++-
 src/Blocks/Block.php           |  22 ++--
 src/Blocks/Code.php            |  14 +-
 src/Blocks/Delimiter.php       |  12 +-
 src/Blocks/Embed.php           |  15 ++-
 src/Blocks/Header.php          |  14 +-
 src/Blocks/Image.php           |  15 ++-
 src/Blocks/Listing.php         |  14 +-
 src/Blocks/Paragraph.php       |  37 +-----
 src/Blocks/Quote.php           |  15 ++-
 src/Blocks/Raw.php             |  14 +-
 src/Blocks/Table.php           |  13 +-
 src/Blocks/Warning.php         |  15 ++-
 tests/Blocks/ParagraphTest.php | 227 +++++++++++++++++----------------
 15 files changed, 269 insertions(+), 188 deletions(-)

diff --git a/src/BlockFactory.php b/src/BlockFactory.php
index 0c192fb..3c14307 100755
--- a/src/BlockFactory.php
+++ b/src/BlockFactory.php
@@ -45,9 +45,10 @@ public static function parse(string $data, ?array $tools = null, array $allowedT
             $blocks = json_decode($data, true, flags: JSON_THROW_ON_ERROR);
             $mapper = fn (array $block): Block => self::create($block, self::getAllowedTags($block, $allowedTags));
 
-            if ($tools !== null) {
-                $blocks = self::filter($blocks['blocks'], $tools);
-            }
+            // TODO: whitelist tools and supported blocks
+            //            if ($tools !== null) {
+            //                $blocks = self::filter($blocks['blocks'], $tools);
+            //            }
 
             return array_map($mapper, $blocks['blocks']);
         } catch (\Throwable $e) {
@@ -67,12 +68,7 @@ private static function create(array $data, array $allowedTags = []): Block
     {
         try {
             // TODO: I think this may be very slow for large data need to think of a better way
-
-            //dd(self::getSchema($data['type']), $data);
-
-            $schema = Schema::import(self::getSchema($data['type']));
-
-            dd($schema);
+            // $schema = Schema::import(self::getSchema($data['type']));
 
             return match ($data['type']) {
                 'attaches' => Attaches::create($data, $allowedTags),
diff --git a/src/Blocks/Attaches.php b/src/Blocks/Attaches.php
index 781f5f8..dca63ee 100755
--- a/src/Blocks/Attaches.php
+++ b/src/Blocks/Attaches.php
@@ -27,7 +27,7 @@
  */
 final readonly class Attaches extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'attaches');
         Assert::keyExists($data, 'file');
@@ -37,6 +37,18 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
         Assert::keyExists($data['file'], 'extension');
         Assert::keyExists($data, 'title');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <div id="{$this->id}">
+                <a href="{$this->data['file']['url']}" title="{$this->data['title']}">
+                    <strong>{$this->data['file']['name']}</strong> ({$this->data['file']['size']} bytes)
+                </a>
+            </div>
+        HTML;
     }
 }
diff --git a/src/Blocks/Block.php b/src/Blocks/Block.php
index 3b9ccd9..640fed8 100755
--- a/src/Blocks/Block.php
+++ b/src/Blocks/Block.php
@@ -33,6 +33,8 @@ public function __construct(
         Assert::notEmpty($id);
     }
 
+    abstract public function toHtml(): string;
+
     public static function create(array $data, array $allowedTags = []): static
     {
         return new static(
@@ -44,18 +46,10 @@ public static function create(array $data, array $allowedTags = []): static
         );
     }
 
-    //    private function sanitize(array $data, array|string $allowedTags = []): array
-    //    {
-    //        $sanitizer = Sanitizer::create($allowedTags);
-    //
-    //        foreach ($data as $key => $value) {
-    //            if (is_array($value)) {
-    //                $data[$key] = $this->sanitize($value, $allowedTags);
-    //            } else {
-    //                $data[$key] = $sanitizer->sanitize($value);
-    //            }
-    //        }
-    //
-    //        return $data;
-    //    }
+    public function sanitize(): string
+    {
+        $sanitizer = Sanitizer::create($this->allowedTags);
+
+        return $sanitizer->sanitize($this->toHtml());
+    }
 }
diff --git a/src/Blocks/Code.php b/src/Blocks/Code.php
index d85dc5c..0451412 100755
--- a/src/Blocks/Code.php
+++ b/src/Blocks/Code.php
@@ -27,11 +27,21 @@
  */
 final readonly class Code extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'code');
         Assert::keyExists($data, 'code');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <pre id="{$this->id}">
+                <code>{$this->data['code']}</code>
+            </pre>
+        HTML;
     }
 }
diff --git a/src/Blocks/Delimiter.php b/src/Blocks/Delimiter.php
index 2fe68f5..fd37aa6 100755
--- a/src/Blocks/Delimiter.php
+++ b/src/Blocks/Delimiter.php
@@ -27,10 +27,18 @@
  */
 final readonly class Delimiter extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'delimiter');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <hr id="{$this->id}">
+        HTML;
     }
 }
diff --git a/src/Blocks/Embed.php b/src/Blocks/Embed.php
index d0c5e63..58bed35 100755
--- a/src/Blocks/Embed.php
+++ b/src/Blocks/Embed.php
@@ -27,7 +27,7 @@
  */
 final readonly class Embed extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'embed');
         Assert::keyExists($data, 'service');
@@ -37,6 +37,17 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
         Assert::keyExists($data, 'height');
         Assert::keyExists($data, 'caption');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <figure id="{$this->id}">
+                <iframe src="{$this->data['embed']}" width="{$this->data['width']}" height="{$this->data['height']}"></iframe>
+                <figcaption>{$this->data['caption']}</figcaption>
+            </figure>
+        HTML;
     }
 }
diff --git a/src/Blocks/Header.php b/src/Blocks/Header.php
index dd49115..e558663 100755
--- a/src/Blocks/Header.php
+++ b/src/Blocks/Header.php
@@ -27,13 +27,23 @@
  */
 final readonly class Header extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'header');
         Assert::keyExists($data, 'text');
         Assert::keyExists($data, 'level');
         Assert::oneOf((int) $data['level'], [1, 2, 3, 4, 5, 6]);
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <h{$this->data['level']} id="{$this->id}">
+                {$this->data['text']}
+            </h{$this->data['level']}>
+        HTML;
     }
 }
diff --git a/src/Blocks/Image.php b/src/Blocks/Image.php
index 737c957..756e9cf 100755
--- a/src/Blocks/Image.php
+++ b/src/Blocks/Image.php
@@ -27,7 +27,7 @@
  */
 final readonly class Image extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'image');
         Assert::keyExists($data, 'file');
@@ -38,6 +38,17 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
 
         Assert::keyExists($data['file'], 'url');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <figure id="{$this->id}">
+                <img src="{$this->data['file']['url']}" alt="{$this->data['caption']}" />
+                <figcaption>{$this->data['caption']}</figcaption>
+            </figure>
+        HTML;
     }
 }
diff --git a/src/Blocks/Listing.php b/src/Blocks/Listing.php
index ebd2cb2..98c0f6f 100755
--- a/src/Blocks/Listing.php
+++ b/src/Blocks/Listing.php
@@ -28,7 +28,7 @@
  */
 final readonly class Listing extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'list');
         Assert::keyExists($data, 'items');
@@ -36,6 +36,16 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
         Assert::keyExists($data, 'style');
         Assert::oneOf($data['style'], ['unordered', 'ordered', 'checklist']);
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <{$this->data['style']} id="{$this->id}">
+                {$this->data['items']}
+            </{$this->data['style']}>
+        HTML;
     }
 }
diff --git a/src/Blocks/Paragraph.php b/src/Blocks/Paragraph.php
index 17dd08d..4aa35fd 100755
--- a/src/Blocks/Paragraph.php
+++ b/src/Blocks/Paragraph.php
@@ -29,7 +29,7 @@
  */
 final readonly class Paragraph extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'paragraph');
         Assert::keyExists($data, 'text');
@@ -39,39 +39,14 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
             Assert::isArray($tunes['footnotes']);
         }
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
     }
 
+    #[\Override]
     public function toHtml(): string
     {
-        $allowedTags = [
-            'a' => ['href', 'title', 'rel'],
-            'strong' => [],
-            'em' => [],
-            'u' => [],
-            'br' => [],
-            'p' => ['id'],
-        ];
-        $rawHtml = $this->toRawHtml($this->data);
-        $sanitizedHtml = $this->sanitizeHtml($rawHtml, $allowedTags);
-        dump('Sanitized HTML:', $sanitizedHtml);
-        return $sanitizedHtml;
-    }
-
-    //convertion vers du html brut
-    private function toRawHtml(array $data)
-    {
-        return "<p id=\"{$this->id}\">{$data['text']}</p>";
-    }
-
-    //nettoyage du html
-
-    private function sanitizeHtml(string $html, array|string $allowedTags = [])
-    {
-        $sanitizer = Sanitizer::create($allowedTags);
-        dump('Input HTML:', $html);
-        dump('Sanitized HTML:', $sanitizer->sanitize($html));
-
-        return $sanitizer->sanitize($html);
+        return <<<HTML
+            <p id="{$this->id}">{$this->data['text']}</p>
+        HTML;
     }
 }
diff --git a/src/Blocks/Quote.php b/src/Blocks/Quote.php
index 90502eb..d5708fe 100755
--- a/src/Blocks/Quote.php
+++ b/src/Blocks/Quote.php
@@ -27,7 +27,7 @@
  */
 final readonly class Quote extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'quote');
         Assert::keyExists($data, 'text');
@@ -35,6 +35,17 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
         Assert::keyExists($data, 'alignment');
         Assert::oneOf($data['alignment'], ['center', 'left']);
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <blockquote id="{$this->id}" style="text-align: {$this->data['alignment']}">
+                <p>{$this->data['text']}</p>
+                <footer>{$this->data['caption']}</footer>
+            </blockquote>
+        HTML;
     }
 }
diff --git a/src/Blocks/Raw.php b/src/Blocks/Raw.php
index cce4cef..2190086 100755
--- a/src/Blocks/Raw.php
+++ b/src/Blocks/Raw.php
@@ -27,11 +27,21 @@
  */
 final readonly class Raw extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'raw');
         Assert::keyExists($data, 'html');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <div id="{$this->id}">
+                {$this->data['html']}
+            </div>
+        HTML;
     }
 }
diff --git a/src/Blocks/Table.php b/src/Blocks/Table.php
index e5795cb..c469816 100755
--- a/src/Blocks/Table.php
+++ b/src/Blocks/Table.php
@@ -27,13 +27,22 @@
  */
 final readonly class Table extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'table');
         Assert::keyExists($data, 'withHeadings');
         Assert::keyExists($data, 'stretched');
         Assert::keyExists($data, 'content');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <table id="{$this->id}">
+            </table>
+        HTML;
     }
 }
diff --git a/src/Blocks/Warning.php b/src/Blocks/Warning.php
index 46f9b97..ed5e2cc 100755
--- a/src/Blocks/Warning.php
+++ b/src/Blocks/Warning.php
@@ -29,12 +29,23 @@
  */
 final readonly class Warning extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
     {
         Assert::eq($type, 'warning');
         Assert::keyExists($data, 'title');
         Assert::keyExists($data, 'message');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <div id="{$this->id}">
+                <h2>{$this->data['title']}</h2>
+                <p>{$this->data['message']}</p>
+            </div>
+        HTML;
     }
 }
diff --git a/tests/Blocks/ParagraphTest.php b/tests/Blocks/ParagraphTest.php
index 7f73311..f58069e 100644
--- a/tests/Blocks/ParagraphTest.php
+++ b/tests/Blocks/ParagraphTest.php
@@ -4,40 +4,42 @@
 
 namespace Devscast\EditorJs\Tests\Blocks;
 
+use Devscast\EditorJs\BlockFactory;
 use Devscast\EditorJs\Blocks\Paragraph;
 use Devscast\EditorJs\Exception\EditorException;
 use PHPUnit\Framework\TestCase;
 
 class ParagraphTest extends TestCase
 {
-    public function testValidParagraphConstruction(): void
-    {
-        $id = '1';
-        $type = 'paragraph';
-        $data = [
-            'text' => 'This is a test paragraph',
-        ];
-        $tunes = null;
-        $rules = [];
-
-        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
-
-        $this->assertInstanceOf(Paragraph::class, $paragraph);
-    }
+    private const array ALLOWED_TAGS = [
+        'paragraph' => [
+            'a' => ['href', 'title', 'rel'],
+            'strong' => [],
+            'em' => [],
+            'u' => [],
+            'br' => [],
+            'p' => ['id'],
+        ],
+    ];
 
-    public function testValidParagraphWithFootnotesConstruction(): void
+    public function testValidParagraphConstruction(): void
     {
-        $id = '1';
-        $type = 'paragraph';
-        $data = [
-            'text' => 'This is a test paragraph',
-        ];
-        $tunes = [
-            'footnotes' => [],
-        ];
-        $rules = [];
-
-        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "paragraph",
+                "data": {
+                  "text": "Hey. Meet the new Editor. On this picture you can see it in action. Then, try a demo 🤓"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        $paragraph = BlockFactory::parse($data, ['paragraph'], self::ALLOWED_TAGS)[0];
 
         $this->assertInstanceOf(Paragraph::class, $paragraph);
     }
@@ -45,113 +47,114 @@ public function testValidParagraphWithFootnotesConstruction(): void
     public function testInvalidTypeConstruction(): void
     {
         $this->expectException(EditorException::class);
-        $id = '1';
-        $type = 'invalid-type';
-        $data = [
-            'text' => 'This is a test paragraph',
-        ];
-        $tunes = null;
-        $rules = [];
-
-        new Paragraph($id, $type, $data, $tunes, $rules);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "invalid-type",
+                "data": {
+                  "text": "This is a test paragraph"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['paragraph'], self::ALLOWED_TAGS);
     }
 
     public function testMissingTextConstruction(): void
     {
         $this->expectException(EditorException::class);
-        $id = '1';
-        $type = 'paragraph';
-        $data = [];
-        $tunes = null;
-        $rules = [];
-
-        new Paragraph($id, $type, $data, $tunes, $rules);
-    }
-
-    public function testMissingFootnotesInTunesConstruction(): void
-    {
-        $this->expectException(EditorException::class);
-        $id = '1';
-        $type = 'paragraph';
-        $data = [
-            'text' => 'This is a test paragraph',
-        ];
-        $tunes = [];
-        $rules = [];
-
-        new Paragraph($id, $type, $data, $tunes, $rules);
-    }
-
-    public function testInvalidFootnotesTypeConstruction(): void
-    {
-        $this->expectException(EditorException::class);
-        $id = '1';
-        $type = 'paragraph';
-        $data = [
-            'text' => 'This is a test paragraph',
-        ];
-        $tunes = [
-            'footnotes' => 'not-an-array',
-        ];
-        $rules = [];
-
-        new Paragraph($id, $type, $data, $tunes, $rules);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "invalid-type",
+                "data": {}
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['paragraph'], self::ALLOWED_TAGS);
     }
 
     public function testToHtml(): void
     {
-        $id = 'test_id';
-        $type = 'paragraph';
-        $data = [
-            'text' => 'This is a test paragraph',
-        ];
-        $tunes = null;
-        $rules = [];
-
-        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
-        $html = $paragraph->toHtml();
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "paragraph",
+                "data": {
+                  "text": "This is a test paragraph"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Paragraph $paragraph */
+        $paragraph = BlockFactory::parse($data, ['paragraph'], self::ALLOWED_TAGS)[0];
+
+        $html = $paragraph->sanitize();
         $this->assertNotEmpty($html, 'HTML should not be empty');
-        $this->assertStringContainsString('<p id="test_id">This is a test paragraph</p>', $html);
+        $this->assertStringContainsString('<p id="mhTl6ghSkV">This is a test paragraph</p>', $html);
     }
 
     public function testToHtmlWithAllowedTags(): void
     {
-        $id = 'test_id';
-        $type = 'paragraph';
-        $data = [
-            'text' => 'This is a <strong>test</strong> paragraph with <a href="https://example.com" title="Example" rel="nofollow">link</a>',
-        ];
-        $tunes = null;
-        $rules = [];
-
-        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
-        $html = $paragraph->toHtml();
-
-        // Debug information
-        $this->assertNotEmpty($html, 'HTML output should not be empty. Output: ' . var_export($html, true));
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "paragraph",
+                "data": {
+                  "text": "This is a <strong>test</strong> paragraph with <a href=\"https://example.com\" title=\"Example\" rel=\"nofollow\">link</a>"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Paragraph $paragraph */
+        $paragraph = BlockFactory::parse($data, ['paragraph'], self::ALLOWED_TAGS)[0];
+        $html = $paragraph->sanitize();
 
-        // Check raw HTML before sanitization (using reflection to access private method)
-        $reflectionMethod = new \ReflectionMethod(Paragraph::class, 'toRawHtml');
-        $rawHtml = $reflectionMethod->invoke($paragraph, $data);
-        $this->assertNotEmpty($rawHtml, 'Raw HTML should not be empty');
-
-        // Continue with the original assertions
+        $this->assertNotEmpty($html, 'HTML output should not be empty. Output: ' . var_export($html, true));
         $this->assertStringContainsString('<strong>test</strong>', $html);
         $this->assertStringContainsString('<a href="https://example.com" title="Example" rel="nofollow">link</a>', $html);
     }
 
     public function testToHtmlSanitizesDisallowedTags(): void
     {
-        $id = 'test_id';
-        $type = 'paragraph';
-        $data = [
-            'text' => 'This is a <script>alert("XSS")</script> test with <iframe src="https://malicious.com"></iframe>',
-        ];
-        $tunes = null;
-        $rules = [];
-
-        $paragraph = new Paragraph($id, $type, $data, $tunes, $rules);
-        $html = $paragraph->toHtml();
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "paragraph",
+                "data": {
+                  "text": "This is a <script>alert(\"XSS\")</script> test with <iframe src=\"https://malicious.com\"></iframe>"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Paragraph $paragraph */
+        $paragraph = BlockFactory::parse($data, ['paragraph'], self::ALLOWED_TAGS)[0];
+        $html = $paragraph->sanitize();
 
         $this->assertStringNotContainsString('<script>', $html);
         $this->assertStringNotContainsString('<iframe', $html);

From e4dc875fa74dbfe60ec8accc7eb46969c020cb86 Mon Sep 17 00:00:00 2001
From: bernard-ng <ngandubernard@gmail.com>
Date: Sun, 23 Mar 2025 04:23:35 +0200
Subject: [PATCH 3/6] fix santizer config

---
 .github/workflows/lint.yaml | 55 +++++++++++++++++++++++++------------
 .github/workflows/test.yaml | 55 +++++++++++++++++++++++++------------
 src/BlockFactory.php        | 31 ++++++++++++---------
 src/Blocks/Attaches.php     |  2 +-
 src/Blocks/Block.php        |  4 ++-
 src/Blocks/Code.php         |  2 +-
 src/Blocks/Delimiter.php    |  2 +-
 src/Blocks/Embed.php        |  2 +-
 src/Blocks/Header.php       |  2 +-
 src/Blocks/Image.php        |  2 +-
 src/Blocks/Listing.php      |  2 +-
 src/Blocks/Paragraph.php    |  6 ++--
 src/Blocks/Quote.php        |  2 +-
 src/Blocks/Raw.php          |  2 +-
 src/Blocks/Table.php        |  2 +-
 src/Blocks/Warning.php      |  2 +-
 src/Sanitizer.php           |  4 +--
 17 files changed, 111 insertions(+), 66 deletions(-)

diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml
index 9a9586a..03d2301 100755
--- a/.github/workflows/lint.yaml
+++ b/.github/workflows/lint.yaml
@@ -1,21 +1,40 @@
-name: Lint
-on: [push, pull_request]
+name: Coding standards
+on: [push]
 jobs:
-    lint:
-        name: PHP Lint
-        runs-on: ubuntu-latest
-        steps:
-            - name: Setup PHP
-              uses: shivammathur/setup-php@v2
-              with:
-                  php-version: 8.3
+  lint:
+    name: Coding standards
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        php: [ '8.3', '8.4' ]
 
-            - name: Cache Composer dependencies
-              uses: actions/cache@v4
-              with:
-                  path: /tmp/composer-cache
-                  key: ${{ runner.os }}-${{ hashFiles('**/composer.lock') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-            - uses: actions/checkout@v4
-            - name: lint
-              run: make app:lint
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          tools: composer:v2
+
+      - name: Setup cache
+        run: echo "COMPOSER_CACHE_DIR=$(composer config cache-dir)" >> $GITHUB_ENV
+
+      - name: Cache dependencies installed with composer
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.COMPOSER_CACHE_DIR }}
+          key: php${{ matrix.php }}-composer-${{ hashFiles('**/composer.json') }}
+          restore-keys: |
+            php${{ matrix.php }}-composer-latest-
+
+      - name: Update composer
+        run: composer self-update
+
+      - name: Install dependencies with composer
+        run: composer install --prefer-dist --no-interaction --no-progress --optimize-autoloader --ansi
+
+      - name: Run code quality analysis
+        run: composer app:lint
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index 08d7dc0..d82b540 100755
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -1,21 +1,40 @@
-name: Test
-on: [push, pull_request]
+name: Tests
+on: [push]
 jobs:
-    lint:
-        name: PHP Test
-        runs-on: ubuntu-latest
-        steps:
-            - name: Setup PHP
-              uses: shivammathur/setup-php@v2
-              with:
-                  php-version: 8.3
+  test:
+    name: Tests
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        php: [ '8.3', '8.4' ]
 
-            - name: Cache Composer dependencies
-              uses: actions/cache@v4
-              with:
-                  path: /tmp/composer-cache
-                  key: ${{ runner.os }}-${{ hashFiles('**/composer.lock') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-            - uses: actions/checkout@v4
-            - name: test
-              run: make app:test
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          tools: composer:v2
+
+      - name: Setup cache
+        run: echo "COMPOSER_CACHE_DIR=$(composer config cache-dir)" >> $GITHUB_ENV
+
+      - name: Cache dependencies installed with composer
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.COMPOSER_CACHE_DIR }}
+          key: php${{ matrix.php }}-composer-${{ hashFiles('**/composer.json') }}
+          restore-keys: |
+            php${{ matrix.php }}-composer-latest-
+
+      - name: Update composer
+        run: composer self-update
+
+      - name: Install dependencies with composer
+        run: composer install --prefer-dist --no-interaction --no-progress --optimize-autoloader --ansi
+
+      - name: Run tests
+        run: composer app:test
\ No newline at end of file
diff --git a/src/BlockFactory.php b/src/BlockFactory.php
index 3c14307..3893475 100755
--- a/src/BlockFactory.php
+++ b/src/BlockFactory.php
@@ -42,6 +42,7 @@
     public static function parse(string $data, ?array $tools = null, array $allowedTags = []): array
     {
         try {
+            /** @var array{time: int, blocks: array<array{id: string, type: string, data: mixed}>} $blocks */
             $blocks = json_decode($data, true, flags: JSON_THROW_ON_ERROR);
             $mapper = fn (array $block): Block => self::create($block, self::getAllowedTags($block, $allowedTags));
 
@@ -56,10 +57,10 @@ public static function parse(string $data, ?array $tools = null, array $allowedT
         }
     }
 
-    private static function filter(array $data, array $tools): array
-    {
-        return array_filter($data, fn (array $block): bool => isset($tools[$block['type']]));
-    }
+    //    private static function filter(array $data, array $tools): array
+    //    {
+    //        return array_filter($data, fn (array $block): bool => isset($tools[$block['type']]));
+    //    }
 
     /**
      * @throws EditorException
@@ -83,25 +84,29 @@ private static function create(array $data, array $allowedTags = []): Block
                 'raw' => Raw::create($data, $allowedTags),
                 'table' => Table::create($data, $allowedTags),
                 'warning' => Warning::create($data, $allowedTags),
+                default => throw new EditorException(sprintf('Block type %s not supported', $data['type'])),
             };
         } catch (\Throwable $e) {
             throw new EditorException($e->getMessage(), previous: $e);
         }
     }
 
-    private static function getAllowedTags(mixed $block, array $allowedTags): array
+    private static function getAllowedTags(array $block, array $allowedTags): array
     {
         Assert::keyExists($block, 'type');
 
         return $allowedTags[$block['type']] ?? [];
     }
 
-    private static function getSchema(string $schema): array
-    {
-        $filename = sprintf('%s/schemas/%s.schema.json', dirname(__DIR__), $schema);
-        $content = file_get_contents($filename);
-        Assert::string($content, sprintf('Schema for block type %s not found', $schema));
-
-        return json_decode($content, true);
-    }
+    //    private static function getSchema(string $schema): array
+    //    {
+    //        $filename = sprintf('%s/schemas/%s.schema.json', dirname(__DIR__), $schema);
+    //        $content = file_get_contents($filename);
+    //        Assert::string($content, sprintf('Schema for block type %s not found', $schema));
+    //
+    //        /** @var array $schema */
+    //        $schema = json_decode($content, true);
+    //
+    //        return $schema;
+    //    }
 }
diff --git a/src/Blocks/Attaches.php b/src/Blocks/Attaches.php
index dca63ee..12371f9 100755
--- a/src/Blocks/Attaches.php
+++ b/src/Blocks/Attaches.php
@@ -27,7 +27,7 @@
  */
 final readonly class Attaches extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'attaches');
         Assert::keyExists($data, 'file');
diff --git a/src/Blocks/Block.php b/src/Blocks/Block.php
index 640fed8..07c7cd2 100755
--- a/src/Blocks/Block.php
+++ b/src/Blocks/Block.php
@@ -19,6 +19,8 @@
 /**
  * Class Block.
  *
+ * @phpstan-consistent-constructor
+ *
  * @author bernard-ng <bernard@devscast.tech>
  */
 abstract readonly class Block
@@ -48,7 +50,7 @@ public static function create(array $data, array $allowedTags = []): static
 
     public function sanitize(): string
     {
-        $sanitizer = Sanitizer::create($this->allowedTags);
+        $sanitizer = Sanitizer::create($this->allowedTags ?? []);
 
         return $sanitizer->sanitize($this->toHtml());
     }
diff --git a/src/Blocks/Code.php b/src/Blocks/Code.php
index 0451412..d0a1c29 100755
--- a/src/Blocks/Code.php
+++ b/src/Blocks/Code.php
@@ -27,7 +27,7 @@
  */
 final readonly class Code extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'code');
         Assert::keyExists($data, 'code');
diff --git a/src/Blocks/Delimiter.php b/src/Blocks/Delimiter.php
index fd37aa6..d72de55 100755
--- a/src/Blocks/Delimiter.php
+++ b/src/Blocks/Delimiter.php
@@ -27,7 +27,7 @@
  */
 final readonly class Delimiter extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'delimiter');
 
diff --git a/src/Blocks/Embed.php b/src/Blocks/Embed.php
index 58bed35..a48eddc 100755
--- a/src/Blocks/Embed.php
+++ b/src/Blocks/Embed.php
@@ -27,7 +27,7 @@
  */
 final readonly class Embed extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'embed');
         Assert::keyExists($data, 'service');
diff --git a/src/Blocks/Header.php b/src/Blocks/Header.php
index e558663..c834be0 100755
--- a/src/Blocks/Header.php
+++ b/src/Blocks/Header.php
@@ -27,7 +27,7 @@
  */
 final readonly class Header extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'header');
         Assert::keyExists($data, 'text');
diff --git a/src/Blocks/Image.php b/src/Blocks/Image.php
index 756e9cf..713f61a 100755
--- a/src/Blocks/Image.php
+++ b/src/Blocks/Image.php
@@ -27,7 +27,7 @@
  */
 final readonly class Image extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'image');
         Assert::keyExists($data, 'file');
diff --git a/src/Blocks/Listing.php b/src/Blocks/Listing.php
index 98c0f6f..7f25aca 100755
--- a/src/Blocks/Listing.php
+++ b/src/Blocks/Listing.php
@@ -28,7 +28,7 @@
  */
 final readonly class Listing extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'list');
         Assert::keyExists($data, 'items');
diff --git a/src/Blocks/Paragraph.php b/src/Blocks/Paragraph.php
index 4aa35fd..c32fc4a 100755
--- a/src/Blocks/Paragraph.php
+++ b/src/Blocks/Paragraph.php
@@ -29,7 +29,7 @@
  */
 final readonly class Paragraph extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'paragraph');
         Assert::keyExists($data, 'text');
@@ -45,8 +45,8 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(<<<HTML
             <p id="{$this->id}">{$this->data['text']}</p>
-        HTML;
+        HTML);
     }
 }
diff --git a/src/Blocks/Quote.php b/src/Blocks/Quote.php
index d5708fe..fb81fa3 100755
--- a/src/Blocks/Quote.php
+++ b/src/Blocks/Quote.php
@@ -27,7 +27,7 @@
  */
 final readonly class Quote extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'quote');
         Assert::keyExists($data, 'text');
diff --git a/src/Blocks/Raw.php b/src/Blocks/Raw.php
index 2190086..f35fdaf 100755
--- a/src/Blocks/Raw.php
+++ b/src/Blocks/Raw.php
@@ -27,7 +27,7 @@
  */
 final readonly class Raw extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'raw');
         Assert::keyExists($data, 'html');
diff --git a/src/Blocks/Table.php b/src/Blocks/Table.php
index c469816..9509d44 100755
--- a/src/Blocks/Table.php
+++ b/src/Blocks/Table.php
@@ -27,7 +27,7 @@
  */
 final readonly class Table extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'table');
         Assert::keyExists($data, 'withHeadings');
diff --git a/src/Blocks/Warning.php b/src/Blocks/Warning.php
index ed5e2cc..dd1d634 100755
--- a/src/Blocks/Warning.php
+++ b/src/Blocks/Warning.php
@@ -29,7 +29,7 @@
  */
 final readonly class Warning extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, ?array $allowedTags = null)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'warning');
         Assert::keyExists($data, 'title');
diff --git a/src/Sanitizer.php b/src/Sanitizer.php
index 2891533..8ba31f3 100755
--- a/src/Sanitizer.php
+++ b/src/Sanitizer.php
@@ -34,12 +34,12 @@ public static function create(string|array $allowedTags = []): HtmlSanitizer
 
         if (is_array($allowedTags)) {
             foreach ($allowedTags as $tag => $attributes) {
-                $config->allowElement($tag, $attributes);
+                $config = $config->allowElement($tag, $attributes);
             }
         }
 
         if (is_string($allowedTags)) {
-            $config->allowElement($allowedTags);
+            $config = $config->allowElement($allowedTags);
         }
 
         return new HtmlSanitizer($config);

From beb49328c35d4ff0c4cd7276a362ae9508fff6f1 Mon Sep 17 00:00:00 2001
From: uzziahlukeka <uzziahlukeka@gmail.com>
Date: Tue, 25 Mar 2025 23:13:30 +0100
Subject: [PATCH 4/6] attachesTest amd index

---
 tests/Blocks/AttachesTest.php | 167 ++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 tests/Blocks/AttachesTest.php

diff --git a/tests/Blocks/AttachesTest.php b/tests/Blocks/AttachesTest.php
new file mode 100644
index 0000000..6e30ba4
--- /dev/null
+++ b/tests/Blocks/AttachesTest.php
@@ -0,0 +1,167 @@
+<?php
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+
+use Devscast\EditorJs\Blocks\Attaches;
+use Devscast\EditorJs\Exception\EditorException;
+use Devscast\EditorJs\BlockFactory;
+use PHPUnit\Framework\TestCase;
+
+
+class AttachesTest extends TestCase
+{
+    private const array VALID_DATA = [
+        'file' => [
+            'url' => 'https://example.com/file.pdf',
+            'size' => 1024,
+            'name' => 'document.pdf',
+            'extension' => 'pdf'
+        ],
+        'title' => 'Important Document'
+    ];
+
+    public function testValidConstruction(): void
+    {
+        $attaches = new Attaches(
+            id: 'test123',
+            type: 'attaches',
+            data: self::VALID_DATA
+        );
+
+        $this->assertInstanceOf(Attaches::class, $attaches);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        new Attaches(
+            id: 'test123',
+            type: 'invalid-type',
+            data: self::VALID_DATA
+        );
+    }
+
+    public function testMissingFileDataConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        $invalidData = self::VALID_DATA;
+        unset($invalidData['file']);
+
+        new Attaches(
+            id: 'test123',
+            type: 'attaches',
+            data: $invalidData
+        );
+    }
+
+    public function testMissingFilePropertiesConstruction(): void
+    {
+        $testCases = [
+            'missing url' => 'url',
+            'missing size' => 'size',
+            'missing name' => 'name',
+            'missing extension' => 'extension'
+        ];
+
+        foreach ($testCases as $case => $property) {
+            $this->expectException(EditorException::class);
+           // dd($case, $property);
+            $invalidData = self::VALID_DATA;
+            unset($invalidData['file'][$property]);
+            new Attaches(
+                id: 'test123',
+                type: 'attaches',
+                data: $invalidData
+            );
+        }
+    }
+    public function testMissingTitleConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $invalidData = self::VALID_DATA;
+        unset($invalidData['title']);
+        new Attaches(
+            id: 'test123',
+            type: 'attaches',
+            data: $invalidData
+        );
+    }
+    public function testToHtml(): void
+    {
+        $attaches = new Attaches(
+            id: 'test123',
+            type: 'attaches',
+            data: self::VALID_DATA
+        );
+        $html = $attaches->toHtml();
+        $this->assertStringContainsString('<div id="test123">', $html);
+        $this->assertStringContainsString(
+            'href="https://example.com/file.pdf"',
+            $html
+        );
+        $this->assertStringContainsString(
+            'title="Important Document"',
+            $html
+        );
+        $this->assertStringContainsString(
+            '<strong>document.pdf</strong> (1024 bytes)',
+            $html
+        );
+    }
+    public function testFactoryCreation(): void
+    {
+        $data = <<<JSON
+        {
+            "time": 1739980616433,
+            "blocks": [
+                {
+                    "id": "XKNT99-qqS",
+                    "type": "attaches",
+                    "data": {
+                        "file": {
+                            "url": "https://drive.google.com/user/catalog/my-file.pdf",
+                            "size": 12902,
+                            "name": "file.pdf",
+                            "extension": "pdf"
+                        },
+                        "title": "My file"
+                    }
+                }
+            ]
+        }
+        JSON;
+
+        $blocks = BlockFactory::parse($data, ['attaches']);
+        $this->assertCount(1, $blocks);
+        $this->assertInstanceOf(Attaches::class, $blocks[0]);
+    }
+
+    public function testFactoryCreationWithInvalidData(): void
+    {
+        $this->expectException(EditorException::class);
+
+        $data = <<<JSON
+        {
+            "time": 1739980616433,
+            "blocks": [
+                {
+                    "id": "XKNT99-qqS",
+                    "type": "attaches",
+                    "data": {
+                        "file": {
+                            "url": "https://drive.google.com/user/catalog/my-file.pdf",
+                            "size": 12902
+                        },
+                        "title": "My file"
+                    }
+                }
+            ]
+        }
+        JSON;
+
+        BlockFactory::parse($data, ['attaches']);
+    }
+}
\ No newline at end of file

From 82af1b7aa80f0af8468da2dfcd502494476538de Mon Sep 17 00:00:00 2001
From: uzziahlukeka <uzziahlukeka@gmail.com>
Date: Wed, 2 Apr 2025 15:17:50 +0200
Subject: [PATCH 5/6] dev step1

---
 composer.json                  |   2 +-
 src/BlockFactory.php           |  71 ++++++---
 src/Blocks/Code.php            |   6 +-
 src/Blocks/Delimiter.php       |   4 +-
 src/Blocks/Embed.php           |   6 +-
 src/Blocks/Header.php          |   4 +-
 src/Blocks/Image.php           |   4 +-
 src/Blocks/Listing.php         |  52 ++++++-
 src/Blocks/Paragraph.php       |  16 +-
 src/Blocks/Quote.php           |   4 +-
 src/Blocks/Raw.php             |   6 +-
 src/Blocks/Table.php           |  32 +++-
 src/Blocks/Warning.php         |   6 +-
 tests/Blocks/AttachesTest.php  |  19 ++-
 tests/Blocks/CodeTest.php      |  80 ++++++++++
 tests/Blocks/DelimiterTest.php |  92 ++++++++++++
 tests/Blocks/EmbedTest.php     | 111 ++++++++++++++
 tests/Blocks/HeaderTest.php    | 128 ++++++++++++++++
 tests/Blocks/ImageTest.php     | 110 ++++++++++++++
 tests/Blocks/ListingTest.php   | 213 +++++++++++++++++++++++++++
 tests/Blocks/QuoteTest.php     | 204 ++++++++++++++++++++++++++
 tests/Blocks/RawTest.php       | 193 ++++++++++++++++++++++++
 tests/Blocks/TableTest.php     | 210 ++++++++++++++++++++++++++
 tests/Blocks/WarningTest.php   | 259 +++++++++++++++++++++++++++++++++
 24 files changed, 1770 insertions(+), 62 deletions(-)
 create mode 100644 tests/Blocks/CodeTest.php
 create mode 100644 tests/Blocks/DelimiterTest.php
 create mode 100644 tests/Blocks/EmbedTest.php
 create mode 100644 tests/Blocks/HeaderTest.php
 create mode 100644 tests/Blocks/ImageTest.php
 create mode 100644 tests/Blocks/ListingTest.php
 create mode 100644 tests/Blocks/QuoteTest.php
 create mode 100644 tests/Blocks/RawTest.php
 create mode 100644 tests/Blocks/TableTest.php
 create mode 100644 tests/Blocks/WarningTest.php

diff --git a/composer.json b/composer.json
index 0c2c1fc..3d9a5bb 100755
--- a/composer.json
+++ b/composer.json
@@ -41,7 +41,7 @@
         ],
         "app:lint:fix": [
             "vendor/bin/ecs check --fix",
-            "venodr/bin/rector"
+            "vendor/bin/rector"
         ],
         "app:test": "vendor/bin/phpunit"
     }
diff --git a/src/BlockFactory.php b/src/BlockFactory.php
index 3893475..d4a54a3 100755
--- a/src/BlockFactory.php
+++ b/src/BlockFactory.php
@@ -34,8 +34,15 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-abstract readonly class BlockFactory
+abstract class BlockFactory
 {
+    /**
+     * @throws EditorException
+     *
+     * reduire la complexite de O(n) a O(1) evitant de tout le temps checker toutes les conditions
+     */
+    private static array $blockFactories = [];
+
     /**
      * @throws EditorException
      */
@@ -51,6 +58,14 @@ public static function parse(string $data, ?array $tools = null, array $allowedT
             //                $blocks = self::filter($blocks['blocks'], $tools);
             //            }
 
+            if ($tools !== null) {
+                $blocks['blocks'] = self::filter($blocks['blocks'], $tools);
+
+                if (empty($blocks['blocks'])) {
+                    throw new EditorException('No valid blocks found after filtering');
+                }
+            }
+
             return array_map($mapper, $blocks['blocks']);
         } catch (\Throwable $e) {
             throw new EditorException($e->getMessage(), previous: $e);
@@ -62,30 +77,42 @@ public static function parse(string $data, ?array $tools = null, array $allowedT
     //        return array_filter($data, fn (array $block): bool => isset($tools[$block['type']]));
     //    }
 
-    /**
-     * @throws EditorException
-     */
+    private static function filter(array $blocks, array $tools): array
+    {
+        return array_filter($blocks, fn (array $block) => in_array($block['type'], $tools, true));
+    }
+
+    private static function initializeFactories(): void
+    {
+        if (self::$blockFactories !== []) {
+            return;
+        }
+        self::$blockFactories = [
+            'attaches' => static fn (array $data, array $allowedTags) => Attaches::create($data, $allowedTags),
+            'code' => static fn (array $data, array $allowedTags) => Code::create($data, $allowedTags),
+            'delimiter' => static fn (array $data, array $allowedTags) => Delimiter::create($data, $allowedTags),
+            'embed' => static fn (array $data, array $allowedTags) => Embed::create($data, $allowedTags),
+            'header' => static fn (array $data, array $allowedTags) => Header::create($data, $allowedTags),
+            'image' => static fn (array $data, array $allowedTags) => Image::create($data, $allowedTags),
+            'list' => static fn (array $data, array $allowedTags) => Listing::create($data, $allowedTags),
+            'paragraph' => static fn (array $data, array $allowedTags) => Paragraph::create($data, $allowedTags),
+            'quote' => static fn (array $data, array $allowedTags) => Quote::create($data, $allowedTags),
+            'raw' => static fn (array $data, array $allowedTags) => Raw::create($data, $allowedTags),
+            'table' => static fn (array $data, array $allowedTags) => Table::create($data, $allowedTags),
+            'warning' => static fn (array $data, array $allowedTags) => Warning::create($data, $allowedTags),
+        ];
+    }
+
     private static function create(array $data, array $allowedTags = []): Block
     {
         try {
-            // TODO: I think this may be very slow for large data need to think of a better way
-            // $schema = Schema::import(self::getSchema($data['type']));
-
-            return match ($data['type']) {
-                'attaches' => Attaches::create($data, $allowedTags),
-                'code' => Code::create($data, $allowedTags),
-                'delimiter' => Delimiter::create($data, $allowedTags),
-                'embed' => Embed::create($data, $allowedTags),
-                'header' => Header::create($data, $allowedTags),
-                'image' => Image::create($data, $allowedTags),
-                'list' => Listing::create($data, $allowedTags),
-                'paragraph' => Paragraph::create($data, $allowedTags),
-                'quote' => Quote::create($data, $allowedTags),
-                'raw' => Raw::create($data, $allowedTags),
-                'table' => Table::create($data, $allowedTags),
-                'warning' => Warning::create($data, $allowedTags),
-                default => throw new EditorException(sprintf('Block type %s not supported', $data['type'])),
-            };
+            self::initializeFactories();
+
+            $type = $data['type'];
+            if (! isset(self::$blockFactories[$type])) {
+                throw new EditorException(sprintf('Block type %s not supported', $type));
+            }
+            return self::$blockFactories[$type]($data, $allowedTags);
         } catch (\Throwable $e) {
             throw new EditorException($e->getMessage(), previous: $e);
         }
diff --git a/src/Blocks/Code.php b/src/Blocks/Code.php
index d0a1c29..3abc133 100755
--- a/src/Blocks/Code.php
+++ b/src/Blocks/Code.php
@@ -38,10 +38,12 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(
+            <<<HTML
             <pre id="{$this->id}">
                 <code>{$this->data['code']}</code>
             </pre>
-        HTML;
+        HTML
+        );
     }
 }
diff --git a/src/Blocks/Delimiter.php b/src/Blocks/Delimiter.php
index d72de55..3d1e5ef 100755
--- a/src/Blocks/Delimiter.php
+++ b/src/Blocks/Delimiter.php
@@ -37,8 +37,8 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(<<<HTML
             <hr id="{$this->id}">
-        HTML;
+        HTML);
     }
 }
diff --git a/src/Blocks/Embed.php b/src/Blocks/Embed.php
index a48eddc..f54ce1f 100755
--- a/src/Blocks/Embed.php
+++ b/src/Blocks/Embed.php
@@ -43,11 +43,13 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(
+            <<<HTML
             <figure id="{$this->id}">
                 <iframe src="{$this->data['embed']}" width="{$this->data['width']}" height="{$this->data['height']}"></iframe>
                 <figcaption>{$this->data['caption']}</figcaption>
             </figure>
-        HTML;
+        HTML
+        );
     }
 }
diff --git a/src/Blocks/Header.php b/src/Blocks/Header.php
index c834be0..9c59ee8 100755
--- a/src/Blocks/Header.php
+++ b/src/Blocks/Header.php
@@ -40,10 +40,10 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(<<<HTML
             <h{$this->data['level']} id="{$this->id}">
                 {$this->data['text']}
             </h{$this->data['level']}>
-        HTML;
+        HTML);
     }
 }
diff --git a/src/Blocks/Image.php b/src/Blocks/Image.php
index 713f61a..fa44729 100755
--- a/src/Blocks/Image.php
+++ b/src/Blocks/Image.php
@@ -44,11 +44,11 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(<<<HTML
             <figure id="{$this->id}">
                 <img src="{$this->data['file']['url']}" alt="{$this->data['caption']}" />
                 <figcaption>{$this->data['caption']}</figcaption>
             </figure>
-        HTML;
+        HTML);
     }
 }
diff --git a/src/Blocks/Listing.php b/src/Blocks/Listing.php
index 7f25aca..5c4c4cb 100755
--- a/src/Blocks/Listing.php
+++ b/src/Blocks/Listing.php
@@ -42,10 +42,52 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
-            <{$this->data['style']} id="{$this->id}">
-                {$this->data['items']}
-            </{$this->data['style']}>
-        HTML;
+        $tag = $this->getTag();
+        $tagName = strtok($tag, ' ');
+        $items = $this->renderItems($this->data['items']);
+        return trim(<<<HTML
+            <{$tag} id="{$this->id}">
+                {$items}
+            </{$tagName}>
+        HTML);
+    }
+
+    private function getTag(): string
+    {
+        return match ($this->data['style']) {
+            'unordered' => 'ul',
+            'ordered' => 'ol',
+            'checklist' => 'ul class="checklist"',
+            default => 'ul'
+        };
+    }
+
+    private function renderItems(array $items): string
+    {
+        $html = '';
+        foreach ($items as $item) {
+            if (is_array($item) && isset($item['type']) && $item['type'] === 'list') {
+                $nestedTag = match ($item['style']) {
+                    'unordered' => 'ul',
+                    'ordered' => 'ol',
+                    'checklist' => 'ul class="checklist"',
+                    default => 'ul'
+                };
+                $nestedTagName = strtok($nestedTag, ' ');
+                $nestedItemsHtml = '';
+                foreach ($item['items'] as $nestedItem) {
+                    $content = is_array($nestedItem) ? ($nestedItem['content'] ?? '') : $nestedItem;
+                    $nestedItemsHtml .= '<li>' . $content . '</li>';
+                }
+                $nestedHtml = "<{$nestedTag}>
+                {$nestedItemsHtml}
+                </{$nestedTagName}>";
+                $html .= '<li>' . $nestedHtml . '</li>';
+            } else {
+                $content = is_array($item) ? ($item['content'] ?? '') : $item;
+                $html .= '<li>' . $content . '</li>';
+            }
+        }
+        return $html;
     }
 }
diff --git a/src/Blocks/Paragraph.php b/src/Blocks/Paragraph.php
index c32fc4a..50b73ba 100755
--- a/src/Blocks/Paragraph.php
+++ b/src/Blocks/Paragraph.php
@@ -31,12 +31,16 @@
 {
     public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'paragraph');
-        Assert::keyExists($data, 'text');
-
-        if ($tunes !== null) {
-            Assert::keyExists($tunes, 'footnotes');
-            Assert::isArray($tunes['footnotes']);
+        try {
+            Assert::eq($type, 'paragraph');
+            Assert::keyExists($data, 'text');
+
+            if ($tunes !== null) {
+                Assert::keyExists($tunes, 'footnotes');
+                Assert::isArray($tunes['footnotes']);
+            }
+        } catch (\Exception $e) {
+            throw new \Devscast\EditorJs\Exception\EditorException($e->getMessage(), 0, $e);
         }
 
         parent::__construct($id, $type, $data, $tunes, $allowedTags);
diff --git a/src/Blocks/Quote.php b/src/Blocks/Quote.php
index fb81fa3..a1a00ab 100755
--- a/src/Blocks/Quote.php
+++ b/src/Blocks/Quote.php
@@ -41,11 +41,11 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(<<<HTML
             <blockquote id="{$this->id}" style="text-align: {$this->data['alignment']}">
                 <p>{$this->data['text']}</p>
                 <footer>{$this->data['caption']}</footer>
             </blockquote>
-        HTML;
+        HTML);
     }
 }
diff --git a/src/Blocks/Raw.php b/src/Blocks/Raw.php
index f35fdaf..5e041ef 100755
--- a/src/Blocks/Raw.php
+++ b/src/Blocks/Raw.php
@@ -38,10 +38,12 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(
+            <<<HTML
             <div id="{$this->id}">
                 {$this->data['html']}
             </div>
-        HTML;
+        HTML
+        );
     }
 }
diff --git a/src/Blocks/Table.php b/src/Blocks/Table.php
index 9509d44..e0a9206 100755
--- a/src/Blocks/Table.php
+++ b/src/Blocks/Table.php
@@ -40,9 +40,33 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
-            <table id="{$this->id}">
-            </table>
-        HTML;
+        $content = $this->data['content'];
+        $withHeadings = $this->data['withHeadings'];
+        $stretched = $this->data['stretched'] ? ' class="stretched"' : '';
+
+        $html = "<table id=\"{$this->id}\"{$stretched}>";
+
+        if ($withHeadings && ! empty($content)) {
+            $html .= '<thead><tr>';
+            foreach ($content[0] as $header) {
+                $html .= "<th>{$header}</th>";
+            }
+            $html .= '</tr></thead>';
+        }
+
+        $html .= '<tbody>';
+        $startRow = $withHeadings ? 1 : 0;
+
+        for ($i = $startRow; $i < count($content); $i++) {
+            $html .= '<tr>';
+            foreach ($content[$i] as $cell) {
+                $html .= "<td>{$cell}</td>";
+            }
+            $html .= '</tr>';
+        }
+
+        $html .= '</tbody></table>';
+
+        return trim($html);
     }
 }
diff --git a/src/Blocks/Warning.php b/src/Blocks/Warning.php
index dd1d634..2a8a81d 100755
--- a/src/Blocks/Warning.php
+++ b/src/Blocks/Warning.php
@@ -41,11 +41,13 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return <<<HTML
+        return trim(
+            <<<HTML
             <div id="{$this->id}">
                 <h2>{$this->data['title']}</h2>
                 <p>{$this->data['message']}</p>
             </div>
-        HTML;
+        HTML
+        );
     }
 }
diff --git a/tests/Blocks/AttachesTest.php b/tests/Blocks/AttachesTest.php
index 6e30ba4..7dafca6 100644
--- a/tests/Blocks/AttachesTest.php
+++ b/tests/Blocks/AttachesTest.php
@@ -1,14 +1,14 @@
 <?php
 
-namespace Devscast\EditorJs\Tests\Blocks;
+declare(strict_types=1);
 
+namespace Devscast\EditorJs\Tests\Blocks;
 
+use Devscast\EditorJs\BlockFactory;
 use Devscast\EditorJs\Blocks\Attaches;
 use Devscast\EditorJs\Exception\EditorException;
-use Devscast\EditorJs\BlockFactory;
 use PHPUnit\Framework\TestCase;
 
-
 class AttachesTest extends TestCase
 {
     private const array VALID_DATA = [
@@ -16,9 +16,9 @@ class AttachesTest extends TestCase
             'url' => 'https://example.com/file.pdf',
             'size' => 1024,
             'name' => 'document.pdf',
-            'extension' => 'pdf'
+            'extension' => 'pdf',
         ],
-        'title' => 'Important Document'
+        'title' => 'Important Document',
     ];
 
     public function testValidConstruction(): void
@@ -63,12 +63,12 @@ public function testMissingFilePropertiesConstruction(): void
             'missing url' => 'url',
             'missing size' => 'size',
             'missing name' => 'name',
-            'missing extension' => 'extension'
+            'missing extension' => 'extension',
         ];
 
         foreach ($testCases as $case => $property) {
             $this->expectException(EditorException::class);
-           // dd($case, $property);
+            // dd($case, $property);
             $invalidData = self::VALID_DATA;
             unset($invalidData['file'][$property]);
             new Attaches(
@@ -78,6 +78,7 @@ public function testMissingFilePropertiesConstruction(): void
             );
         }
     }
+
     public function testMissingTitleConstruction(): void
     {
         $this->expectException(EditorException::class);
@@ -89,6 +90,7 @@ public function testMissingTitleConstruction(): void
             data: $invalidData
         );
     }
+
     public function testToHtml(): void
     {
         $attaches = new Attaches(
@@ -111,6 +113,7 @@ public function testToHtml(): void
             $html
         );
     }
+
     public function testFactoryCreation(): void
     {
         $data = <<<JSON
@@ -164,4 +167,4 @@ public function testFactoryCreationWithInvalidData(): void
 
         BlockFactory::parse($data, ['attaches']);
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Blocks/CodeTest.php b/tests/Blocks/CodeTest.php
new file mode 100644
index 0000000..18c9d1e
--- /dev/null
+++ b/tests/Blocks/CodeTest.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\Blocks\Code;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class CodeTest extends TestCase
+{
+    private const array VALID_DATA = [
+        'code' => '<?php echo "Hello World"; ?>',
+    ];
+
+    public function testValidConstruction(): void
+    {
+        $code = new Code(
+            id: 'XKNT99-qqS741',
+            type: 'code',
+            data: self::VALID_DATA
+        );
+
+        $this->assertInstanceOf(Code::class, $code);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        new Code(
+            id: 'XKNT99-qqS7878',
+            type: 'invalid-type',
+            data: self::VALID_DATA
+        );
+    }
+
+    public function testMissingCodeDataConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        new Code(
+            id: 'XKNT99-qqS154',
+            type: 'code',
+            data: []
+        );
+    }
+
+    public function testToHtml(): void
+    {
+        $code = new Code(
+            id: 'XKNT99-qqS321',
+            type: 'code',
+            data: self::VALID_DATA
+        );
+
+        $html = $code->toHtml();
+
+        $this->assertStringContainsString('<pre id="XKNT99-qqS321">', $html);
+        $this->assertStringContainsString('<code>', $html);
+        $this->assertStringContainsString('<?php echo "Hello World"; ?>', $html);
+        $this->assertStringContainsString('</code>', $html);
+        $this->assertStringContainsString('</pre>', $html);
+    }
+
+    public function testEmptyCodeContent(): void
+    {
+        $code = new Code(
+            id: 'XKNT99-qqS123',
+            type: 'code',
+            data: [
+                'code' => '',
+            ]
+        );
+
+        $html = $code->toHtml();
+        $this->assertStringContainsString('<code></code>', $html);
+    }
+}
diff --git a/tests/Blocks/DelimiterTest.php b/tests/Blocks/DelimiterTest.php
new file mode 100644
index 0000000..4e1e963
--- /dev/null
+++ b/tests/Blocks/DelimiterTest.php
@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\Blocks\Delimiter;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class DelimiterTest extends TestCase
+{
+    public function testValidConstruction(): void
+    {
+        $delimiter = new Delimiter(
+            id: 'XKNT99-q',
+            type: 'delimiter',
+            data: []
+        );
+
+        $this->assertInstanceOf(Delimiter::class, $delimiter);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        new Delimiter(
+            id: 'XKNT99-q',
+            type: 'invalid-type',
+            data: []
+        );
+    }
+
+    public function testToHtml(): void
+    {
+        $delimiter = new Delimiter(
+            id: 'XKNT99-q',
+            type: 'delimiter',
+            data: []
+        );
+        $html = $delimiter->toHtml();
+        $this->assertSame('<hr id="XKNT99-q">', $html);
+    }
+
+    public function testEmptyDataIsAllowed(): void
+    {
+        $delimiter = new Delimiter(
+            id: 'XKNT99-q',
+            type: 'delimiter',
+            data: []
+        );
+        $html = $delimiter->toHtml();
+        $this->assertStringContainsString('<hr id="XKNT99-q">', $html);
+    }
+
+    public function testNonEmptyDataIsIgnored(): void
+    {
+        $delimiter = new Delimiter(
+            id: 'XKNT99-q',
+            type: 'delimiter',
+            data: [
+                'some' => 'value',
+            ]
+        );
+
+        $html = $delimiter->toHtml();
+        $this->assertStringContainsString('<hr id="XKNT99-q">', $html);
+    }
+
+    public function testIntegrationWithEditor(): void
+    {
+        $json = <<<JSON
+        {
+            "blocks": [
+                {
+                    "id": "delimiter1",
+                    "type": "delimiter",
+                    "data": {}
+                }
+            ]
+        }
+        JSON;
+
+        $editor = new \Devscast\EditorJs\Editor($json);
+        $blocks = $editor->getBlocks();
+
+        $this->assertCount(1, $blocks);
+        $this->assertInstanceOf(Delimiter::class, $blocks[0]);
+        $this->assertSame('<hr id="delimiter1">', $blocks[0]->toHtml());
+    }
+}
diff --git a/tests/Blocks/EmbedTest.php b/tests/Blocks/EmbedTest.php
new file mode 100644
index 0000000..dfa9dfa
--- /dev/null
+++ b/tests/Blocks/EmbedTest.php
@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\Blocks\Embed;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+final class EmbedTest extends TestCase
+{
+    private const array VALID_DATA = [
+        'service' => 'youtube',
+        'source' => 'https://youtube.com/watch?v=example',
+        'embed' => 'https://youtube.com/embed/example',
+        'width' => 800,
+        'height' => 450,
+        'caption' => 'Example video',
+    ];
+
+    public function testValidConstruction(): void
+    {
+        $embed = new Embed(
+            id: 'mhTl6ghSkV-emb',
+            type: 'embed',
+            data: self::VALID_DATA
+        );
+
+        $this->assertInstanceOf(Embed::class, $embed);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        new Embed(
+            id: 'mhTl6ghSkV-emb',
+            type: 'invalid-type',
+            data: self::VALID_DATA
+        );
+    }
+
+    public function testMissingRequiredFields(): void
+    {
+        $requiredFields = ['service', 'source', 'embed', 'width', 'height', 'caption'];
+
+        foreach ($requiredFields as $field) {
+            $this->expectException(EditorException::class);
+
+            $invalidData = self::VALID_DATA;
+            unset($invalidData[$field]);
+
+            new Embed(
+                id: 'mhTl6ghSkV-emb',
+                type: 'embed',
+                data: $invalidData
+            );
+        }
+    }
+
+    public function testToHtml(): void
+    {
+        $embed = new Embed(
+            id: 'mhTl6ghSkV-emb',
+            type: 'embed',
+            data: self::VALID_DATA
+        );
+
+        $html = trim($embed->toHtml());
+
+        $expected = <<<HTML
+            <figure id="mhTl6ghSkV-emb">
+                <iframe src="https://youtube.com/embed/example" width="800" height="450"></iframe>
+                <figcaption>Example video</figcaption>
+            </figure>
+        HTML;
+
+        $this->assertEquals(trim($expected), $html);
+    }
+
+    public function testNumericWidthAndHeight(): void
+    {
+        $embed = new Embed(
+            id: 'mhTl6ghSkV-emb',
+            type: 'embed',
+            data: array_merge(self::VALID_DATA, [
+                'width' => '800',
+                'height' => '450',
+            ])
+        );
+
+        $html = $embed->toHtml();
+        $this->assertStringContainsString('width="800"', $html);
+        $this->assertStringContainsString('height="450"', $html);
+    }
+
+    public function testEmptyCaption(): void
+    {
+        $embed = new Embed(
+            id: 'mhTl6ghSkV-emb',
+            type: 'embed',
+            data: array_merge(self::VALID_DATA, [
+                'caption' => '',
+            ])
+        );
+
+        $html = $embed->toHtml();
+        $this->assertStringContainsString('<figcaption></figcaption>', $html);
+    }
+}
diff --git a/tests/Blocks/HeaderTest.php b/tests/Blocks/HeaderTest.php
new file mode 100644
index 0000000..57f6aa4
--- /dev/null
+++ b/tests/Blocks/HeaderTest.php
@@ -0,0 +1,128 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\Blocks\Header;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class HeaderTest extends TestCase
+{
+    public function testValidConstruction(): void
+    {
+        $header = new Header(
+            id: 'test123',
+            type: 'header',
+            data: [
+                'text' => 'Sample Header',
+                'level' => 2,
+            ]
+        );
+
+        $this->assertInstanceOf(Header::class, $header);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        new Header(
+            id: 'test123',
+            type: 'invalid-type',
+            data: [
+                'text' => 'Sample Header',
+                'level' => 2,
+            ]
+        );
+    }
+
+    public function testMissingRequiredFields(): void
+    {
+        $this->expectException(EditorException::class);
+        new Header(
+            id: 'test123',
+            type: 'header',
+            data: [
+                'level' => 2,
+            ] // Missing text
+        );
+
+        $this->expectException(EditorException::class);
+        new Header(
+            id: 'test123',
+            type: 'header',
+            data: [
+                'text' => 'Sample',
+            ] // Missing level
+        );
+    }
+
+    public function testInvalidHeaderLevel(): void
+    {
+        $this->expectException(EditorException::class);
+        new Header(
+            id: 'test123',
+            type: 'header',
+            data: [
+                'text' => 'Sample Header',
+                'level' => 7, // Invalid level
+            ]
+        );
+    }
+
+    public function testAllValidHeaderLevels(): void
+    {
+        foreach (range(1, 6) as $level) {
+            $header = new Header(
+                id: 'test-' . $level,
+                type: 'header',
+                data: [
+                    'text' => "Level {$level} Header",
+                    'level' => $level,
+                ]
+            );
+
+            $html = trim($header->toHtml());
+            $this->assertStringStartsWith("<h{$level}", $html);
+            $this->assertStringEndsWith("</h{$level}>", $html);
+        }
+    }
+
+    public function testToHtmlOutput(): void
+    {
+        $header = new Header(
+            id: 'main-header',
+            type: 'header',
+            data: [
+                'text' => 'Welcome to the Site',
+                'level' => 1,
+            ]
+        );
+
+        $expected = <<<HTML
+            <h1 id="main-header">
+                Welcome to the Site
+            </h1>
+        HTML;
+
+        $this->assertEquals(trim($expected), trim($header->toHtml()));
+    }
+
+    public function testEmptyHeaderText(): void
+    {
+        $header = new Header(
+            id: 'empty-header',
+            type: 'header',
+            data: [
+                'text' => '',
+                'level' => 3,
+            ]
+        );
+
+        $html = trim($header->toHtml());
+        $this->assertStringContainsString('<h3 id="empty-header">', $html);
+        $this->assertStringContainsString('</h3>', $html);
+    }
+}
diff --git a/tests/Blocks/ImageTest.php b/tests/Blocks/ImageTest.php
new file mode 100644
index 0000000..c7c5594
--- /dev/null
+++ b/tests/Blocks/ImageTest.php
@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\Blocks\Image;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class ImageTest extends TestCase
+{
+    private const array VALID_DATA = [
+        'file' => [
+            'url' => 'https://example.com/image.jpg',
+        ],
+        'caption' => 'Example image caption',
+        'withBorder' => false,
+        'withBackground' => false,
+        'stretched' => false,
+    ];
+
+    public function testValidConstruction(): void
+    {
+        $image = new Image(
+            id: 'img123',
+            type: 'image',
+            data: self::VALID_DATA
+        );
+
+        $this->assertInstanceOf(Image::class, $image);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+
+        new Image(
+            id: 'img123',
+            type: 'invalid-type',
+            data: self::VALID_DATA
+        );
+    }
+
+    public function testMissingRequiredFields(): void
+    {
+        $requiredFields = ['file', 'caption', 'withBorder', 'withBackground', 'stretched'];
+
+        foreach ($requiredFields as $field) {
+            $this->expectException(EditorException::class);
+
+            $invalidData = self::VALID_DATA;
+            unset($invalidData[$field]);
+
+            new Image(
+                id: 'img123',
+                type: 'image',
+                data: $invalidData
+            );
+        }
+    }
+
+    public function testMissingFileUrl(): void
+    {
+        $this->expectException(EditorException::class);
+
+        $invalidData = self::VALID_DATA;
+        unset($invalidData['file']['url']);
+
+        new Image(
+            id: 'img123',
+            type: 'image',
+            data: $invalidData
+        );
+    }
+
+    public function testToHtmlOutput(): void
+    {
+        $image = new Image(
+            id: 'main-image',
+            type: 'image',
+            data: self::VALID_DATA
+        );
+
+        $expected = <<<HTML
+            <figure id="main-image">
+                <img src="https://example.com/image.jpg" alt="Example image caption" />
+                <figcaption>Example image caption</figcaption>
+            </figure>
+        HTML;
+
+        $this->assertEquals(trim($expected), trim($image->toHtml()));
+    }
+
+    public function testEmptyCaption(): void
+    {
+        $data = self::VALID_DATA;
+        $data['caption'] = '';
+
+        $image = new Image(
+            id: 'empty-caption',
+            type: 'image',
+            data: $data
+        );
+
+        $html = $image->toHtml();
+        $this->assertStringContainsString('<figcaption></figcaption>', $html);
+        $this->assertStringContainsString('alt=""', $html);
+    }
+}
diff --git a/tests/Blocks/ListingTest.php b/tests/Blocks/ListingTest.php
new file mode 100644
index 0000000..c62bdd4
--- /dev/null
+++ b/tests/Blocks/ListingTest.php
@@ -0,0 +1,213 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\Blocks\Listing;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class ListingTest extends TestCase
+{
+    private const array VALID_DATA = [
+        'items' => ['Item 1', 'Item 2', 'Item 3'],
+        'style' => 'unordered',
+        'meta' => [],
+    ];
+
+    public function testValidConstruction(): void
+    {
+        $listing = new Listing(
+            id: 'list123',
+            type: 'list',
+            data: self::VALID_DATA
+        );
+
+        $this->assertSame('list123', $listing->id);
+        $this->assertSame('list', $listing->type);
+        $this->assertSame(self::VALID_DATA, $listing->data);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $this->expectExceptionMessage('Expected a value equal to "list". Got: "invalid-type"');
+
+        new Listing(
+            id: 'list123',
+            type: 'invalid-type',
+            data: self::VALID_DATA
+        );
+    }
+
+    public function testMissingRequiredFields(): void
+    {
+        $requiredFields = ['items', 'style', 'meta'];
+
+        foreach ($requiredFields as $field) {
+            $this->expectException(EditorException::class);
+
+            $invalidData = self::VALID_DATA;
+            unset($invalidData[$field]);
+
+            new Listing(
+                id: 'list123',
+                type: 'list',
+                data: $invalidData
+            );
+        }
+    }
+
+    public function testInvalidListStyle(): void
+    {
+        $this->expectException(EditorException::class);
+        $this->expectExceptionMessage('Expected one of: "unordered", "ordered", "checklist". Got: "invalid-style"');
+
+        $invalidData = self::VALID_DATA;
+        $invalidData['style'] = 'invalid-style';
+
+        new Listing(
+            id: 'list123',
+            type: 'list',
+            data: $invalidData
+        );
+    }
+
+    public function testAllValidListStyles(): void
+    {
+        $validStyles = [
+            'unordered' => 'ul',
+            'ordered' => 'ol',
+            'checklist' => 'ul class="checklist"',
+        ];
+
+        foreach ($validStyles as $style => $expectedTag) {
+            $data = self::VALID_DATA;
+            $data['style'] = $style;
+
+            $listing = new Listing(
+                id: 'list-' . $style,
+                type: 'list',
+                data: $data
+            );
+
+            $html = $listing->toHtml();
+
+            $this->assertStringStartsWith("<{$expectedTag}", $html);
+            $this->assertStringEndsWith('</' . strtok($expectedTag, ' ') . '>', $html);
+            $this->assertStringContainsString('id="list-' . $style . '"', $html);
+        }
+    }
+
+    public function testToHtmlOutput(): void
+    {
+        $listing = new Listing(
+            id: 'main-list',
+            type: 'list',
+            data: self::VALID_DATA
+        );
+
+        $expectedHtml = <<<HTML
+            <ul id="main-list">
+                <li>Item 1</li><li>Item 2</li><li>Item 3</li>
+            </ul>
+        HTML;
+
+        $this->assertXmlStringEqualsXmlString($expectedHtml, $listing->toHtml());
+    }
+
+    public function testNestedLists(): void
+    {
+        $nestedData = [
+            'style' => 'unordered',
+            'items' => [
+                'Item 1',
+                [
+                    'type' => 'list',
+                    'style' => 'ordered',
+                    'items' => ['Subitem 1', 'Subitem 2'],
+                    'meta' => [],
+                ],
+                'Item 3',
+            ],
+            'meta' => [],
+        ];
+
+        $listing = new Listing(
+            id: 'nested-list',
+            type: 'list',
+            data: $nestedData
+        );
+
+        $html = $listing->toHtml();
+
+        $this->assertStringContainsString('<ul id="nested-list"', $html);
+        $this->assertStringContainsString('<li>Item 1</li>', $html);
+        $this->assertStringContainsString('<ol>', $html);
+        $this->assertStringContainsString('<li>Subitem 1</li>', $html);
+        $this->assertStringContainsString('<li>Subitem 2</li>', $html);
+        $this->assertStringContainsString('<li>Item 3</li>', $html);
+    }
+
+    public function testEmptyList(): void
+    {
+        $emptyData = [
+            'items' => [],
+            'style' => 'ordered',
+            'meta' => [],
+        ];
+
+        $listing = new Listing(
+            id: 'empty-list',
+            type: 'list',
+            data: $emptyData
+        );
+
+        $expected = <<<HTML
+            <ol id="empty-list">
+                
+            </ol>
+        HTML;
+
+        $this->assertXmlStringEqualsXmlString($expected, $listing->toHtml());
+    }
+
+    public function testListItemsRendering(): void
+    {
+        $listing = new Listing(
+            id: 'items-test',
+            type: 'list',
+            data: [
+                'items' => ['First', 'Second', 'Third'],
+                'style' => 'unordered',
+                'meta' => [],
+            ]
+        );
+
+        $html = $listing->toHtml();
+        $this->assertStringContainsString('<li>First</li>', $html);
+        $this->assertStringContainsString('<li>Second</li>', $html);
+        $this->assertStringContainsString('<li>Third</li>', $html);
+    }
+
+    public function testChecklistRendering(): void
+    {
+        $listing = new Listing(
+            id: 'checklist-test',
+            type: 'list',
+            data: [
+                'items' => ['Task 1', 'Task 2'],
+                'style' => 'checklist',
+                'meta' => [],
+            ]
+        );
+
+        $html = $listing->toHtml();
+
+        $this->assertStringStartsWith('<ul class="checklist"', $html);
+        $this->assertStringContainsString('<li>Task 1</li>', $html);
+        $this->assertStringContainsString('<li>Task 2</li>', $html);
+        $this->assertStringEndsWith('</ul>', $html);
+    }
+}
diff --git a/tests/Blocks/QuoteTest.php b/tests/Blocks/QuoteTest.php
new file mode 100644
index 0000000..c2864e3
--- /dev/null
+++ b/tests/Blocks/QuoteTest.php
@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\BlockFactory;
+use Devscast\EditorJs\Blocks\Quote;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class QuoteTest extends TestCase
+{
+    private const array ALLOWED_TAGS = [
+        'blockquote' => ['id', 'style'],
+        'p' => [],
+        'footer' => [],
+    ];
+
+    public function testValidQuoteConstruction(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "quote",
+                "data": {
+                  "text": "This is a quote text",
+                  "caption": "Author Name",
+                  "alignment": "left"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        $quote = BlockFactory::parse($data, ['quote'], self::ALLOWED_TAGS)[0];
+
+        $this->assertInstanceOf(Quote::class, $quote);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "invalid-type",
+                "data": {
+                  "text": "This is a quote text",
+                  "caption": "Author Name",
+                  "alignment": "left"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['quote'], self::ALLOWED_TAGS);
+    }
+
+    public function testMissingRequiredFieldsConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "quote",
+                "data": {
+                  "text": "This is a quote text"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['quote'], self::ALLOWED_TAGS);
+    }
+
+    public function testInvalidAlignmentConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "quote",
+                "data": {
+                  "text": "This is a quote text",
+                  "caption": "Author Name",
+                  "alignment": "invalid-alignment"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['quote'], self::ALLOWED_TAGS);
+    }
+
+    public function testToHtml(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "quote",
+                "data": {
+                  "text": "This is a quote text",
+                  "caption": "Author Name",
+                  "alignment": "center"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Quote $quote */
+        $quote = BlockFactory::parse($data, ['quote'], self::ALLOWED_TAGS)[0];
+        $html = $quote->toHtml();
+
+        $this->assertNotEmpty($html, 'HTML should not be empty');
+        $this->assertStringContainsString('<blockquote id="mhTl6ghSkV" style="text-align: center">', $html);
+        $this->assertStringContainsString('<p>This is a quote text</p>', $html);
+        $this->assertStringContainsString('<footer>Author Name</footer>', $html);
+    }
+
+    public function testSanitizeWithAllowedTags(): void
+    {
+        $data = <<<JSON
+    {
+        "blocks": [
+            {
+                "id": "mhTl6ghSkV",
+                "type": "quote",
+                "data": {
+                    "text": "This is a <strong>quote</strong> text",
+                    "caption": "<em>Author Name</em>",
+                    "alignment": "left"
+                }
+            }
+        ]
+    }
+    JSON;
+
+        $allowedTags = [
+            'quote' => [
+                'blockquote' => ['id', 'style'],
+                'p' => [],
+                'footer' => [],
+            ],
+        ];
+
+        /** @var Quote $quote */
+        $quote = BlockFactory::parse($data, ['quote'], $allowedTags)[0];
+        $html = $quote->sanitize();
+
+        // Debug output (uncomment if needed)
+        // var_dump($html);
+
+        $this->assertNotEmpty($html);
+        $this->assertStringNotContainsString('<strong>', $html);
+        $this->assertStringNotContainsString('<em>', $html);
+    }
+
+    public function testSanitizeWithDisallowedTags(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "quote",
+                "data": {
+                  "text": "This is a <script>alert(\"XSS\")</script> quote",
+                  "caption": "Author <iframe src=\"malicious.com\"></iframe>",
+                  "alignment": "left"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Quote $quote */
+        $quote = BlockFactory::parse($data, ['quote'], self::ALLOWED_TAGS)[0];
+        $html = $quote->sanitize();
+
+        $this->assertStringNotContainsString('<script>', $html);
+        $this->assertStringNotContainsString('<iframe', $html);
+    }
+}
diff --git a/tests/Blocks/RawTest.php b/tests/Blocks/RawTest.php
new file mode 100644
index 0000000..62371b1
--- /dev/null
+++ b/tests/Blocks/RawTest.php
@@ -0,0 +1,193 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\BlockFactory;
+use Devscast\EditorJs\Blocks\Raw;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class RawTest extends TestCase
+{
+    private const array ALLOWED_TAGS = [
+        'div' => ['id'],
+        'p' => [],
+        'a' => ['href', 'title', 'rel'],
+        'strong' => [],
+        'em' => [],
+    ];
+
+    public function testValidRawConstruction(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "raw",
+                "data": {
+                  "html": "<p>This is raw HTML content</p>"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        $raw = BlockFactory::parse($data, ['raw'], self::ALLOWED_TAGS)[0];
+
+        $this->assertInstanceOf(Raw::class, $raw);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "invalid-type",
+                "data": {
+                  "html": "<p>This is raw HTML content</p>"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['raw'], self::ALLOWED_TAGS);
+    }
+
+    public function testMissingHtmlConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "raw",
+                "data": {}
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['raw'], self::ALLOWED_TAGS);
+    }
+
+    public function testToHtml(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "raw",
+                "data": {
+                  "html": "<p>This is raw HTML content</p>"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Raw $raw */
+        $raw = BlockFactory::parse($data, ['raw'], self::ALLOWED_TAGS)[0];
+        $html = $raw->toHtml();
+
+        $this->assertNotEmpty($html, 'HTML should not be empty');
+        $this->assertStringContainsString('<div id="mhTl6ghSkV">', $html);
+        $this->assertStringContainsString('<p>This is raw HTML content</p>', $html);
+    }
+
+    public function testSanitizeWithAllowedTags(): void
+    {
+        $data = <<<JSON
+    {
+        "time": 1739980616433,
+        "blocks": [
+            { 
+                "id": "mhTl6ghSkV", 
+                "type": "raw",
+                "data": {
+                    "html": "<p>This is <strong>raw</strong> HTML with <a href=\"https://example.com\" title=\"Example\">link</a></p>"
+                }
+            }
+        ]
+    }
+    JSON;
+
+        $allowedTags = [
+            'raw' => [
+                'div' => ['id'],
+                'p' => [],
+                'strong' => [],
+                'a' => ['href', 'title', 'rel'],
+            ],
+        ];
+
+        /** @var Raw $raw */
+        $raw = BlockFactory::parse($data, ['raw'], $allowedTags)[0];
+        $html = $raw->sanitize();
+
+        $this->assertNotEmpty($html, 'HTML output should not be empty');
+        $this->assertStringContainsString('<strong>raw</strong>', $html);
+    }
+
+    public function testSanitizeWithDisallowedTags(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "raw",
+                "data": {
+                  "html": "<script>alert(\"XSS\")</script><p>This is <iframe src=\"malicious.com\"></iframe> raw HTML</p>"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Raw $raw */
+        $raw = BlockFactory::parse($data, ['raw'], self::ALLOWED_TAGS)[0];
+        $html = $raw->sanitize();
+
+        $this->assertStringNotContainsString('<script>', $html);
+        $this->assertStringNotContainsString('<iframe', $html);
+
+    }
+
+    public function testSanitizeRemovesDisallowedAttributes(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "raw",
+                "data": {
+                  "html": "<p onclick=\"alert('XSS')\">This has a bad attribute</p>"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Raw $raw */
+        $raw = BlockFactory::parse($data, ['raw'], self::ALLOWED_TAGS)[0];
+        $html = $raw->sanitize();
+
+        $this->assertStringNotContainsString('onclick', $html);
+    }
+}
diff --git a/tests/Blocks/TableTest.php b/tests/Blocks/TableTest.php
new file mode 100644
index 0000000..a1702f4
--- /dev/null
+++ b/tests/Blocks/TableTest.php
@@ -0,0 +1,210 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\BlockFactory;
+use Devscast\EditorJs\Blocks\Table;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class TableTest extends TestCase
+{
+    private const array ALLOWED_TAGS = [
+        'table' => ['id'],
+        'thead' => [],
+        'tbody' => [],
+        'tr' => [],
+        'th' => [],
+        'td' => [],
+    ];
+
+    public function testValidTableConstruction(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "table",
+                "data": {
+                  "withHeadings": true,
+                  "stretched": false,
+                  "content": [
+                    ["Header 1", "Header 2"],
+                    ["Cell 1", "Cell 2"]
+                  ]
+                }
+              }
+            ]
+          }
+        JSON;
+
+        $table = BlockFactory::parse($data, ['table'], self::ALLOWED_TAGS)[0];
+
+        $this->assertInstanceOf(Table::class, $table);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "invalid-type",
+                "data": {
+                  "withHeadings": true,
+                  "stretched": false,
+                  "content": []
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['table'], self::ALLOWED_TAGS);
+    }
+
+    public function testMissingRequiredFieldsConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "table",
+                "data": {
+                  "withHeadings": true
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['table'], self::ALLOWED_TAGS);
+    }
+
+    public function testEmptyContentConstruction(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "table",
+                "data": {
+                  "withHeadings": true,
+                  "stretched": false,
+                  "content": []
+                }
+              }
+            ]
+          }
+        JSON;
+
+        $table = BlockFactory::parse($data, ['table'], self::ALLOWED_TAGS)[0];
+        $this->assertInstanceOf(Table::class, $table);
+    }
+
+    public function testToHtmlBasicTable(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "table",
+                "data": {
+                  "withHeadings": false,
+                  "stretched": false,
+                  "content": [
+                    ["Cell 1", "Cell 2"],
+                    ["Cell 3", "Cell 4"]
+                  ]
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Table $table */
+        $table = BlockFactory::parse($data, ['table'], self::ALLOWED_TAGS)[0];
+        $html = $table->toHtml();
+
+        $this->assertNotEmpty($html, 'HTML should not be empty');
+        $this->assertStringContainsString('<table id="mhTl6ghSkV">', $html);
+        $this->assertStringContainsString('<tbody>', $html);
+        $this->assertStringContainsString('<tr>', $html);
+        $this->assertStringContainsString('<td>Cell 1</td>', $html);
+        $this->assertStringContainsString('<td>Cell 2</td>', $html);
+    }
+
+    public function testToHtmlWithHeadings(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "table",
+                "data": {
+                  "withHeadings": true,
+                  "stretched": false,
+                  "content": [
+                    ["Header 1", "Header 2"],
+                    ["Cell 1", "Cell 2"]
+                  ]
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Table $table */
+        $table = BlockFactory::parse($data, ['table'], self::ALLOWED_TAGS)[0];
+        $html = $table->toHtml();
+
+        $this->assertStringContainsString('<thead>', $html);
+        $this->assertStringContainsString('<th>Header 1</th>', $html);
+        $this->assertStringContainsString('<th>Header 2</th>', $html);
+        $this->assertStringContainsString('<td>Cell 1</td>', $html);
+    }
+
+    public function testToHtmlStretchedTable(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "table",
+                "data": {
+                  "withHeadings": false,
+                  "stretched": true,
+                  "content": [
+                    ["Cell 1", "Cell 2"]
+                  ]
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Table $table */
+        $table = BlockFactory::parse($data, ['table'], self::ALLOWED_TAGS)[0];
+        $html = $table->toHtml();
+        $this->assertStringContainsString('<table id="mhTl6ghSkV"', $html);
+        $this->assertStringContainsString('class="stretched"', $html);
+    }
+}
diff --git a/tests/Blocks/WarningTest.php b/tests/Blocks/WarningTest.php
new file mode 100644
index 0000000..98c121a
--- /dev/null
+++ b/tests/Blocks/WarningTest.php
@@ -0,0 +1,259 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs\Tests\Blocks;
+
+use Devscast\EditorJs\BlockFactory;
+use Devscast\EditorJs\Blocks\Warning;
+use Devscast\EditorJs\Exception\EditorException;
+use PHPUnit\Framework\TestCase;
+
+class WarningTest extends TestCase
+{
+    private const array ALLOWED_TAGS = [
+        'div' => ['id'],
+        'h2' => [],
+        'p' => [],
+        'strong' => [],
+        'em' => [],
+        'a' => ['href', 'title', 'rel'],
+    ];
+
+    public function testValidWarningConstruction(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "warning",
+                "data": {
+                  "title": "Important Warning",
+                  "message": "This is an important message"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        $warning = BlockFactory::parse($data, ['warning'], self::ALLOWED_TAGS)[0];
+
+        $this->assertInstanceOf(Warning::class, $warning);
+    }
+
+    public function testInvalidTypeConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "invalid-type",
+                "data": {
+                  "title": "Title",
+                  "message": "Message"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['warning'], self::ALLOWED_TAGS);
+    }
+
+    public function testMissingRequiredFieldsConstruction(): void
+    {
+        $this->expectException(EditorException::class);
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "warning",
+                "data": {
+                  "title": "Title"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        BlockFactory::parse($data, ['warning'], self::ALLOWED_TAGS);
+    }
+
+    public function testToHtmlBasicWarning(): void
+    {
+        $data = <<< JSON
+          {
+            "time": 1739980616433,
+            "blocks": [
+              { 
+                "id": "mhTl6ghSkV", 
+                "type": "warning",
+                "data": {
+                  "title": "Important Warning",
+                  "message": "This is an important message"
+                }
+              }
+            ]
+          }
+        JSON;
+
+        /** @var Warning $warning */
+        $warning = BlockFactory::parse($data, ['warning'], self::ALLOWED_TAGS)[0];
+        $html = $warning->toHtml();
+
+        $this->assertNotEmpty($html, 'HTML should not be empty');
+        $this->assertStringContainsString('<div id="mhTl6ghSkV">', $html);
+        $this->assertStringContainsString('<h2>Important Warning</h2>', $html);
+        $this->assertStringContainsString('<p>This is an important message</p>', $html);
+    }
+
+    public function testToHtmlWithAllowedTags(): void
+    {
+        $data = <<<'JSON'
+    {
+        "time": 1739980616433,
+        "blocks": [
+            {
+                "id": "mhTl6ghSkV",
+                "type": "warning",
+                "data": {
+                    "title": "<strong>Important</strong> Warning",
+                    "message": "This is <em>important</em> with <a href=\"https://example.com\">link</a>"
+                }
+            }
+        ]
+    }
+    JSON;
+
+        $allowedTags = [
+            'warning' => [
+                'div' => ['id', 'class'],
+                'h2' => [],
+                'p' => [],
+                'strong' => [],
+                'em' => [],
+                'a' => ['href'],
+            ],
+        ];
+
+        /** @var Warning $warning */
+        $warning = BlockFactory::parse($data, ['warning'], $allowedTags)[0];
+        $html = $warning->sanitize();
+
+        $this->assertNotEmpty($html);
+        $this->assertStringContainsString('<h2><strong>Important</strong> Warning</h2>', $html);
+        $this->assertStringContainsString('<p>This is <em>important</em> with <a href="https://example.com">link</a></p>', $html);
+    }
+
+    public function testSanitizeWithDisallowedTags(): void
+    {
+        $data = <<<'JSON'
+    {
+        "time": 1739980616433,
+        "blocks": [
+            {
+                "id": "mhTl6ghSkV",
+                "type": "warning",
+                "data": {
+                    "title": "<script>alert('XSS')</script>Warning",
+                    "message": "This has <iframe src=\"malicious.com\"></iframe>"
+                }
+            }
+        ]
+    }
+    JSON;
+
+        $allowedTags = [
+            'warning' => [
+                'div' => ['id', 'class'],
+                'h2' => [],
+                'p' => [],
+            ],
+        ];
+
+        /** @var Warning $warning */
+        $warning = BlockFactory::parse($data, ['warning'], $allowedTags)[0];
+        $html = $warning->sanitize();
+
+        $this->assertStringNotContainsString('<script>', $html);
+        $this->assertStringNotContainsString('<iframe', $html);
+        $this->assertStringContainsString('<h2>Warning</h2>', $html);
+        $this->assertStringContainsString('<p>This has </p>', $html);
+    }
+
+    public function testSanitizePreservesAllowedAttributes(): void
+    {
+        $data = <<<'JSON'
+    {
+        "time": 1739980616433,
+        "blocks": [
+            {
+                "id": "mhTl6ghSkV",
+                "type": "warning",
+                "data": {
+                    "title": "Warning",
+                    "message": "This has <a href=\"https://example.com\" title=\"Example\" rel=\"nofollow\">link</a>"
+                }
+            }
+        ]
+    }
+    JSON;
+
+        $allowedTags = [
+            'warning' => [
+                'div' => ['id', 'class'],
+                'h2' => [],
+                'p' => [],
+                'a' => ['href', 'title', 'rel'],
+            ],
+        ];
+
+        /** @var Warning $warning */
+        $warning = BlockFactory::parse($data, ['warning'], $allowedTags)[0];
+        $html = $warning->sanitize();
+
+        $this->assertStringContainsString('<a href="https://example.com" title="Example" rel="nofollow">link</a>', $html);
+    }
+
+    public function testSanitizeRemovesDisallowedAttributes(): void
+    {
+        $data = <<<'JSON'
+    {
+        "time": 1739980616433,
+        "blocks": [
+            {
+                "id": "mhTl6ghSkV",
+                "type": "warning",
+                "data": {
+                    "title": "Warning",
+                     "message": "This has <a onclick=\"alert('XSS')\">link</a>"
+                }
+            }
+        ]
+    }
+    JSON;
+
+        $allowedTags = [
+            'warning' => [
+                'div' => ['id', 'class'],
+                'h2' => [],
+                'p' => [],
+                'a' => ['href'],
+            ],
+        ];
+
+        /** @var Warning $warning */
+        $warning = BlockFactory::parse($data, ['warning'], $allowedTags)[0];
+        $html = $warning->sanitize();
+
+        $this->assertStringContainsString('<a>link</a>', $html);
+        $this->assertStringNotContainsString('onclick', $html);
+    }
+}

From 4bcc306d32a049a04de4d87bb52f153e273fe677 Mon Sep 17 00:00:00 2001
From: bernard-ng <ngandubernard@gmail.com>
Date: Wed, 2 Apr 2025 19:24:25 +0200
Subject: [PATCH 6/6] refactoring

---
 src/{Blocks/Block.php => AbstractBlock.php} |  34 +++++--
 src/BlockFactory.php                        | 100 +++++++-------------
 src/BlockInterface.php                      |  19 ++++
 src/Blocks/Attaches.php                     |  21 ++--
 src/Blocks/Code.php                         |  21 ++--
 src/Blocks/Delimiter.php                    |  15 +--
 src/Blocks/Embed.php                        |  23 ++---
 src/Blocks/Header.php                       |  19 ++--
 src/Blocks/Image.php                        |  23 +++--
 src/Blocks/Listing.php                      |  66 ++++++-------
 src/Blocks/Paragraph.php                    |  30 +++---
 src/Blocks/Quote.php                        |  21 ++--
 src/Blocks/Raw.php                          |  21 ++--
 src/Blocks/Table.php                        |  53 ++++++-----
 src/Blocks/Warning.php                      |  27 +++---
 15 files changed, 262 insertions(+), 231 deletions(-)
 rename src/{Blocks/Block.php => AbstractBlock.php} (60%)
 create mode 100644 src/BlockInterface.php

diff --git a/src/Blocks/Block.php b/src/AbstractBlock.php
similarity index 60%
rename from src/Blocks/Block.php
rename to src/AbstractBlock.php
index 07c7cd2..38d6862 100755
--- a/src/Blocks/Block.php
+++ b/src/AbstractBlock.php
@@ -11,21 +11,20 @@
 
 declare(strict_types=1);
 
-namespace Devscast\EditorJs\Blocks;
-
-use Devscast\EditorJs\Assert;
-use Devscast\EditorJs\Sanitizer;
+namespace Devscast\EditorJs;
 
 /**
- * Class Block.
+ * Class AbstractBlock.
  *
  * @phpstan-consistent-constructor
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-abstract readonly class Block
+abstract readonly class AbstractBlock implements BlockInterface
 {
-    public function __construct(
+    public const string NAME = 'abstract';
+
+    protected function __construct(
         public string $id,
         public string $type,
         public array $data,
@@ -35,8 +34,6 @@ public function __construct(
         Assert::notEmpty($id);
     }
 
-    abstract public function toHtml(): string;
-
     public static function create(array $data, array $allowedTags = []): static
     {
         return new static(
@@ -54,4 +51,23 @@ public function sanitize(): string
 
         return $sanitizer->sanitize($this->toHtml());
     }
+
+    #[\Override]
+    public function getName(): string
+    {
+        return static::NAME;
+    }
+
+    #[\Override]
+    public function getSchema(): array
+    {
+        $filename = sprintf('%s/schemas/%s.schema.json', dirname(__DIR__), $this->getName());
+        $content = file_get_contents($filename);
+        Assert::string($content, sprintf('Schema for block type %s not found', $this->getName()));
+
+        /** @var array $schema */
+        $schema = json_decode($content, true);
+
+        return $schema;
+    }
 }
diff --git a/src/BlockFactory.php b/src/BlockFactory.php
index d4a54a3..1b62f3d 100755
--- a/src/BlockFactory.php
+++ b/src/BlockFactory.php
@@ -14,7 +14,6 @@
 namespace Devscast\EditorJs;
 
 use Devscast\EditorJs\Blocks\Attaches;
-use Devscast\EditorJs\Blocks\Block;
 use Devscast\EditorJs\Blocks\Code;
 use Devscast\EditorJs\Blocks\Delimiter;
 use Devscast\EditorJs\Blocks\Embed;
@@ -27,7 +26,6 @@
 use Devscast\EditorJs\Blocks\Table;
 use Devscast\EditorJs\Blocks\Warning;
 use Devscast\EditorJs\Exception\EditorException;
-use Swaggest\JsonSchema\Schema;
 
 /**
  * Class BlockFactory.
@@ -36,30 +34,33 @@
  */
 abstract class BlockFactory
 {
-    /**
-     * @throws EditorException
-     *
-     * reduire la complexite de O(n) a O(1) evitant de tout le temps checker toutes les conditions
-     */
-    private static array $blockFactories = [];
+    public const array SUPPORTED_BLOCKS = [
+        Attaches::NAME,
+        Code::NAME,
+        Delimiter::NAME,
+        Embed::NAME,
+        Header::NAME,
+        Image::NAME,
+        Listing::NAME,
+        Paragraph::NAME,
+        Quote::NAME,
+        Raw::NAME,
+        Table::NAME,
+        Warning::NAME,
+    ];
 
     /**
      * @throws EditorException
      */
-    public static function parse(string $data, ?array $tools = null, array $allowedTags = []): array
+    public static function parse(string $data, ?array $supportedBlocks = self::SUPPORTED_BLOCKS, array $allowedTags = []): array
     {
         try {
             /** @var array{time: int, blocks: array<array{id: string, type: string, data: mixed}>} $blocks */
             $blocks = json_decode($data, true, flags: JSON_THROW_ON_ERROR);
-            $mapper = fn (array $block): Block => self::create($block, self::getAllowedTags($block, $allowedTags));
+            $mapper = fn (array $block): AbstractBlock => self::create($block, self::getAllowedTags($block, $allowedTags));
 
-            // TODO: whitelist tools and supported blocks
-            //            if ($tools !== null) {
-            //                $blocks = self::filter($blocks['blocks'], $tools);
-            //            }
-
-            if ($tools !== null) {
-                $blocks['blocks'] = self::filter($blocks['blocks'], $tools);
+            if ($supportedBlocks !== null) {
+                $blocks['blocks'] = self::filter($blocks['blocks'], $supportedBlocks);
 
                 if (empty($blocks['blocks'])) {
                     throw new EditorException('No valid blocks found after filtering');
@@ -72,47 +73,28 @@ public static function parse(string $data, ?array $tools = null, array $allowedT
         }
     }
 
-    //    private static function filter(array $data, array $tools): array
-    //    {
-    //        return array_filter($data, fn (array $block): bool => isset($tools[$block['type']]));
-    //    }
-
-    private static function filter(array $blocks, array $tools): array
-    {
-        return array_filter($blocks, fn (array $block) => in_array($block['type'], $tools, true));
-    }
-
-    private static function initializeFactories(): void
+    private static function filter(array $blocks, array $supportedBlocks): array
     {
-        if (self::$blockFactories !== []) {
-            return;
-        }
-        self::$blockFactories = [
-            'attaches' => static fn (array $data, array $allowedTags) => Attaches::create($data, $allowedTags),
-            'code' => static fn (array $data, array $allowedTags) => Code::create($data, $allowedTags),
-            'delimiter' => static fn (array $data, array $allowedTags) => Delimiter::create($data, $allowedTags),
-            'embed' => static fn (array $data, array $allowedTags) => Embed::create($data, $allowedTags),
-            'header' => static fn (array $data, array $allowedTags) => Header::create($data, $allowedTags),
-            'image' => static fn (array $data, array $allowedTags) => Image::create($data, $allowedTags),
-            'list' => static fn (array $data, array $allowedTags) => Listing::create($data, $allowedTags),
-            'paragraph' => static fn (array $data, array $allowedTags) => Paragraph::create($data, $allowedTags),
-            'quote' => static fn (array $data, array $allowedTags) => Quote::create($data, $allowedTags),
-            'raw' => static fn (array $data, array $allowedTags) => Raw::create($data, $allowedTags),
-            'table' => static fn (array $data, array $allowedTags) => Table::create($data, $allowedTags),
-            'warning' => static fn (array $data, array $allowedTags) => Warning::create($data, $allowedTags),
-        ];
+        return array_filter($blocks, fn (array $block) => in_array($block['type'], $supportedBlocks, true));
     }
 
-    private static function create(array $data, array $allowedTags = []): Block
+    private static function create(array $data, array $allowedTags = []): AbstractBlock
     {
         try {
-            self::initializeFactories();
-
-            $type = $data['type'];
-            if (! isset(self::$blockFactories[$type])) {
-                throw new EditorException(sprintf('Block type %s not supported', $type));
-            }
-            return self::$blockFactories[$type]($data, $allowedTags);
+            return match ($data['type']) {
+                'attaches' => Attaches::create($data, $allowedTags),
+                'code' => Code::create($data, $allowedTags),
+                'delimiter' => Delimiter::create($data, $allowedTags),
+                'embed' => Embed::create($data, $allowedTags),
+                'header' => Header::create($data, $allowedTags),
+                'image' => Image::create($data, $allowedTags),
+                'list' => Listing::create($data, $allowedTags),
+                'paragraph' => Paragraph::create($data, $allowedTags),
+                'quote' => Quote::create($data, $allowedTags),
+                'raw' => Raw::create($data, $allowedTags),
+                'table' => Table::create($data, $allowedTags),
+                'warning' => Warning::create($data, $allowedTags),
+            };
         } catch (\Throwable $e) {
             throw new EditorException($e->getMessage(), previous: $e);
         }
@@ -124,16 +106,4 @@ private static function getAllowedTags(array $block, array $allowedTags): array
 
         return $allowedTags[$block['type']] ?? [];
     }
-
-    //    private static function getSchema(string $schema): array
-    //    {
-    //        $filename = sprintf('%s/schemas/%s.schema.json', dirname(__DIR__), $schema);
-    //        $content = file_get_contents($filename);
-    //        Assert::string($content, sprintf('Schema for block type %s not found', $schema));
-    //
-    //        /** @var array $schema */
-    //        $schema = json_decode($content, true);
-    //
-    //        return $schema;
-    //    }
 }
diff --git a/src/BlockInterface.php b/src/BlockInterface.php
new file mode 100644
index 0000000..51cbcd0
--- /dev/null
+++ b/src/BlockInterface.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devscast\EditorJs;
+
+/**
+ * Interface BlockInterface.
+ *
+ * @author bernard-ng <bernard@devscast.tech>
+ */
+interface BlockInterface
+{
+    public function getName(): string;
+
+    public function toHtml(): string;
+
+    public function getSchema(): array;
+}
diff --git a/src/Blocks/Attaches.php b/src/Blocks/Attaches.php
index 12371f9..35058af 100755
--- a/src/Blocks/Attaches.php
+++ b/src/Blocks/Attaches.php
@@ -13,23 +13,26 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
  * Class Attaches.
  *
- * File attachments Block for the Editor.js
+ * File attachments AbstractBlock for the Editor.js
  *
  * @see https://github.com/editor-js/attaches
  * @see https://raw.githubusercontent.com/devscast/editorjs-sanitizer/refs/heads/main/schemas/warning.schema.json
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Attaches extends Block
+final readonly class Attaches extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'attaches';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'attaches');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'file');
         Assert::keyExists($data['file'], 'url');
         Assert::keyExists($data['file'], 'size');
@@ -44,11 +47,11 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     public function toHtml(): string
     {
         return <<<HTML
-            <div id="{$this->id}">
-                <a href="{$this->data['file']['url']}" title="{$this->data['title']}">
-                    <strong>{$this->data['file']['name']}</strong> ({$this->data['file']['size']} bytes)
-                </a>
-            </div>
+        <div id="{$this->id}">
+            <a href="{$this->data['file']['url']}" title="{$this->data['title']}">
+                <strong>{$this->data['file']['name']}</strong> ({$this->data['file']['size']} bytes)
+            </a>
+        </div>
         HTML;
     }
 }
diff --git a/src/Blocks/Code.php b/src/Blocks/Code.php
index 3abc133..cdf9016 100755
--- a/src/Blocks/Code.php
+++ b/src/Blocks/Code.php
@@ -13,6 +13,7 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
@@ -25,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Code extends Block
+final readonly class Code extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'code';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'code');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'code');
 
         parent::__construct($id, $type, $data, $tunes, $allowedTags);
@@ -38,12 +41,10 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(
-            <<<HTML
-            <pre id="{$this->id}">
-                <code>{$this->data['code']}</code>
-            </pre>
-        HTML
-        );
+        return <<<HTML
+        <pre id="{$this->id}">
+            <code>{$this->data['code']}</code>
+        </pre>
+        HTML;
     }
 }
diff --git a/src/Blocks/Delimiter.php b/src/Blocks/Delimiter.php
index 3d1e5ef..237f941 100755
--- a/src/Blocks/Delimiter.php
+++ b/src/Blocks/Delimiter.php
@@ -13,6 +13,7 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
@@ -25,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Delimiter extends Block
+final readonly class Delimiter extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'delimiter';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'delimiter');
+        Assert::eq($type, self::NAME);
 
         parent::__construct($id, $type, $data, $tunes, $allowedTags);
     }
@@ -37,8 +40,8 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(<<<HTML
-            <hr id="{$this->id}">
-        HTML);
+        return <<<HTML
+        <hr id="{$this->id}">
+        HTML;
     }
 }
diff --git a/src/Blocks/Embed.php b/src/Blocks/Embed.php
index f54ce1f..7cc13e4 100755
--- a/src/Blocks/Embed.php
+++ b/src/Blocks/Embed.php
@@ -13,6 +13,7 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
@@ -25,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Embed extends Block
+final readonly class Embed extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'embed';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'embed');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'service');
         Assert::keyExists($data, 'source');
         Assert::keyExists($data, 'embed');
@@ -43,13 +46,11 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(
-            <<<HTML
-            <figure id="{$this->id}">
-                <iframe src="{$this->data['embed']}" width="{$this->data['width']}" height="{$this->data['height']}"></iframe>
-                <figcaption>{$this->data['caption']}</figcaption>
-            </figure>
-        HTML
-        );
+        return <<<HTML
+        <figure id="{$this->id}">
+            <iframe src="{$this->data['embed']}" width="{$this->data['width']}" height="{$this->data['height']}"></iframe>
+            <figcaption>{$this->data['caption']}</figcaption>
+        </figure>
+        HTML;
     }
 }
diff --git a/src/Blocks/Header.php b/src/Blocks/Header.php
index 9c59ee8..6184255 100755
--- a/src/Blocks/Header.php
+++ b/src/Blocks/Header.php
@@ -13,6 +13,7 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
@@ -25,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Header extends Block
+final readonly class Header extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'header';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'header');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'text');
         Assert::keyExists($data, 'level');
         Assert::oneOf((int) $data['level'], [1, 2, 3, 4, 5, 6]);
@@ -40,10 +43,10 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(<<<HTML
-            <h{$this->data['level']} id="{$this->id}">
-                {$this->data['text']}
-            </h{$this->data['level']}>
-        HTML);
+        return <<<HTML
+        <h{$this->data['level']} id="{$this->id}">
+            {$this->data['text']}
+        </h{$this->data['level']}>
+        HTML;
     }
 }
diff --git a/src/Blocks/Image.php b/src/Blocks/Image.php
index fa44729..1f8f143 100755
--- a/src/Blocks/Image.php
+++ b/src/Blocks/Image.php
@@ -13,23 +13,26 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
  * Class Image.
  *
- * Image Block for the Editor.js.
+ * Image AbstractBlock for the Editor.js.
  *
  * @see https://github.com/editor-js/image
  * @see https://raw.githubusercontent.com/devscast/editorjs-sanitizer/refs/heads/main/schemas/image.schema.json
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Image extends Block
+final readonly class Image extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'image';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'image');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'file');
         Assert::keyExists($data, 'caption');
         Assert::keyExists($data, 'withBorder');
@@ -44,11 +47,11 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(<<<HTML
-            <figure id="{$this->id}">
-                <img src="{$this->data['file']['url']}" alt="{$this->data['caption']}" />
-                <figcaption>{$this->data['caption']}</figcaption>
-            </figure>
-        HTML);
+        return <<<HTML
+        <figure id="{$this->id}">
+            <img src="{$this->data['file']['url']}" alt="{$this->data['caption']}" />
+            <figcaption>{$this->data['caption']}</figcaption>
+        </figure>
+        HTML;
     }
 }
diff --git a/src/Blocks/Listing.php b/src/Blocks/Listing.php
index 5c4c4cb..f8cdf8f 100755
--- a/src/Blocks/Listing.php
+++ b/src/Blocks/Listing.php
@@ -13,8 +13,8 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
-use Devscast\EditorJs\Sanitizer;
 
 /**
  * Class Listing.
@@ -26,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Listing extends Block
+final readonly class Listing extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'list';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'list');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'items');
         Assert::keyExists($data, 'meta');
         Assert::keyExists($data, 'style');
@@ -42,52 +44,50 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        $tag = $this->getTag();
-        $tagName = strtok($tag, ' ');
+        $tag = $this->getTag($this->data['items']);
         $items = $this->renderItems($this->data['items']);
+
         return trim(<<<HTML
             <{$tag} id="{$this->id}">
                 {$items}
-            </{$tagName}>
+            </{$tag}>
         HTML);
     }
 
-    private function getTag(): string
+    private function getTag(array $item): string
     {
-        return match ($this->data['style']) {
+        return match ($item['style']) {
             'unordered' => 'ul',
             'ordered' => 'ol',
-            'checklist' => 'ul class="checklist"',
+            'checklist' => 'ul class="checklist"', // inefficient, extract className from tag
             default => 'ul'
         };
     }
 
     private function renderItems(array $items): string
     {
-        $html = '';
-        foreach ($items as $item) {
+        $renderNestedList = function (array $item): string {
+            $nestedTag = $this->getTag($item);
+            $nestedItemsHtml = implode('', array_map(fn ($nestedItem) => sprintf(
+                '<li>%s</li>',
+                is_array($nestedItem) ? ($nestedItem['content'] ?? '') : $nestedItem
+            ), $item['items']));
+
+            return <<<HTML
+                <{$nestedTag}>
+                    {$nestedItemsHtml}
+                </{$nestedTag}>
+            HTML;
+        };
+
+        $renderItem = function ($item) use ($renderNestedList): string {
             if (is_array($item) && isset($item['type']) && $item['type'] === 'list') {
-                $nestedTag = match ($item['style']) {
-                    'unordered' => 'ul',
-                    'ordered' => 'ol',
-                    'checklist' => 'ul class="checklist"',
-                    default => 'ul'
-                };
-                $nestedTagName = strtok($nestedTag, ' ');
-                $nestedItemsHtml = '';
-                foreach ($item['items'] as $nestedItem) {
-                    $content = is_array($nestedItem) ? ($nestedItem['content'] ?? '') : $nestedItem;
-                    $nestedItemsHtml .= '<li>' . $content . '</li>';
-                }
-                $nestedHtml = "<{$nestedTag}>
-                {$nestedItemsHtml}
-                </{$nestedTagName}>";
-                $html .= '<li>' . $nestedHtml . '</li>';
-            } else {
-                $content = is_array($item) ? ($item['content'] ?? '') : $item;
-                $html .= '<li>' . $content . '</li>';
+                return sprintf('<li>%s</li>', $renderNestedList($item));
             }
-        }
-        return $html;
+            $content = is_array($item) ? ($item['content'] ?? '') : $item;
+            return sprintf('<li>%s</li>', $content);
+        };
+
+        return implode('', array_map($renderItem, $items));
     }
 }
diff --git a/src/Blocks/Paragraph.php b/src/Blocks/Paragraph.php
index 50b73ba..f452a3d 100755
--- a/src/Blocks/Paragraph.php
+++ b/src/Blocks/Paragraph.php
@@ -13,8 +13,8 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
-use Devscast\EditorJs\Sanitizer;
 
 /**
  * Class Paragraph.
@@ -27,20 +27,18 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Paragraph extends Block
+final readonly class Paragraph extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'paragraph';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        try {
-            Assert::eq($type, 'paragraph');
-            Assert::keyExists($data, 'text');
-
-            if ($tunes !== null) {
-                Assert::keyExists($tunes, 'footnotes');
-                Assert::isArray($tunes['footnotes']);
-            }
-        } catch (\Exception $e) {
-            throw new \Devscast\EditorJs\Exception\EditorException($e->getMessage(), 0, $e);
+        Assert::eq($type, self::NAME);
+        Assert::keyExists($data, 'text');
+
+        if ($tunes !== null) {
+            Assert::keyExists($tunes, 'footnotes');
+            Assert::isArray($tunes['footnotes']);
         }
 
         parent::__construct($id, $type, $data, $tunes, $allowedTags);
@@ -49,8 +47,8 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(<<<HTML
-            <p id="{$this->id}">{$this->data['text']}</p>
-        HTML);
+        return <<<HTML
+        <p id="{$this->id}">{$this->data['text']}</p>
+        HTML;
     }
 }
diff --git a/src/Blocks/Quote.php b/src/Blocks/Quote.php
index a1a00ab..31cc13f 100755
--- a/src/Blocks/Quote.php
+++ b/src/Blocks/Quote.php
@@ -13,6 +13,7 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
@@ -25,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Quote extends Block
+final readonly class Quote extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'quote';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'quote');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'text');
         Assert::keyExists($data, 'caption');
         Assert::keyExists($data, 'alignment');
@@ -41,11 +44,11 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(<<<HTML
-            <blockquote id="{$this->id}" style="text-align: {$this->data['alignment']}">
-                <p>{$this->data['text']}</p>
-                <footer>{$this->data['caption']}</footer>
-            </blockquote>
-        HTML);
+        return <<<HTML
+        <blockquote id="{$this->id}" style="text-align: {$this->data['alignment']}">
+            <p>{$this->data['text']}</p>
+            <footer>{$this->data['caption']}</footer>
+        </blockquote>
+        HTML;
     }
 }
diff --git a/src/Blocks/Raw.php b/src/Blocks/Raw.php
index 5e041ef..e3f58d7 100755
--- a/src/Blocks/Raw.php
+++ b/src/Blocks/Raw.php
@@ -13,6 +13,7 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
@@ -25,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Raw extends Block
+final readonly class Raw extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'raw';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'raw');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'html');
 
         parent::__construct($id, $type, $data, $tunes, $allowedTags);
@@ -38,12 +41,10 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(
-            <<<HTML
-            <div id="{$this->id}">
-                {$this->data['html']}
-            </div>
-        HTML
-        );
+        return <<<HTML
+        <div id="{$this->id}">
+            {$this->data['html']}
+        </div>
+        HTML;
     }
 }
diff --git a/src/Blocks/Table.php b/src/Blocks/Table.php
index e0a9206..6004f6f 100755
--- a/src/Blocks/Table.php
+++ b/src/Blocks/Table.php
@@ -13,6 +13,7 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
@@ -25,11 +26,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Table extends Block
+final readonly class Table extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'table';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'table');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'withHeadings');
         Assert::keyExists($data, 'stretched');
         Assert::keyExists($data, 'content');
@@ -44,29 +47,35 @@ public function toHtml(): string
         $withHeadings = $this->data['withHeadings'];
         $stretched = $this->data['stretched'] ? ' class="stretched"' : '';
 
-        $html = "<table id=\"{$this->id}\"{$stretched}>";
+        $thead = $withHeadings ? $this->renderHeadings($content[0]) : '';
+        $tbody = $this->renderRows(array_slice($content, $withHeadings ? 1 : 0));
 
-        if ($withHeadings && ! empty($content)) {
-            $html .= '<thead><tr>';
-            foreach ($content[0] as $header) {
-                $html .= "<th>{$header}</th>";
-            }
-            $html .= '</tr></thead>';
-        }
+        return <<<HTML
+        <table id="{$this->id}" {$stretched}>
+            {$thead}
+            {$tbody}
+        </table>
+        HTML;
+    }
 
-        $html .= '<tbody>';
-        $startRow = $withHeadings ? 1 : 0;
+    private function renderHeadings(array $headers): string
+    {
+        $columns = implode('', array_map(fn ($header) => "<th>{$header}</th>", $headers));
 
-        for ($i = $startRow; $i < count($content); $i++) {
-            $html .= '<tr>';
-            foreach ($content[$i] as $cell) {
-                $html .= "<td>{$cell}</td>";
-            }
-            $html .= '</tr>';
-        }
+        return <<<HTML
+        <thead>
+            <tr>{$columns}</tr>
+        </thead>
+        HTML;
+    }
 
-        $html .= '</tbody></table>';
+    private function renderRows(array $rows): string
+    {
+        $cells = fn ($row) => implode('', array_map(fn ($cell) => sprintf('<td>%s</td>', $cell), $row));
+        $html = implode('', array_map(fn ($row) => sprintf('<tr>%s</tr>', $cells($row)),  $rows));
 
-        return trim($html);
+        return <<<HTML
+        <tbody>{$html}</tbody>
+        HTML;
     }
 }
diff --git a/src/Blocks/Warning.php b/src/Blocks/Warning.php
index 2a8a81d..c5daf43 100755
--- a/src/Blocks/Warning.php
+++ b/src/Blocks/Warning.php
@@ -13,13 +13,14 @@
 
 namespace Devscast\EditorJs\Blocks;
 
+use Devscast\EditorJs\AbstractBlock;
 use Devscast\EditorJs\Assert;
 
 /**
  * Class Warning.
  *
- * Provides Warning Block for the Editor.js.
- * Block has title and message.
+ * Provides Warning AbstractBlock for the Editor.js.
+ * AbstractBlock has title and message.
  * It can be used, for example, for editorials notifications or appeals.
  *
  * @see https://github.com/editor-js/warning
@@ -27,11 +28,13 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-final readonly class Warning extends Block
+final readonly class Warning extends AbstractBlock
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
+    public const string NAME = 'warning';
+
+    protected function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
-        Assert::eq($type, 'warning');
+        Assert::eq($type, self::NAME);
         Assert::keyExists($data, 'title');
         Assert::keyExists($data, 'message');
 
@@ -41,13 +44,11 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
     #[\Override]
     public function toHtml(): string
     {
-        return trim(
-            <<<HTML
-            <div id="{$this->id}">
-                <h2>{$this->data['title']}</h2>
-                <p>{$this->data['message']}</p>
-            </div>
-        HTML
-        );
+        return <<<HTML
+        <div id="{$this->id}">
+            <h2>{$this->data['title']}</h2>
+            <p>{$this->data['message']}</p>
+        </div>
+        HTML;
     }
 }