Implemented simple object cache, and updated some fluent api invocations

2022-09-12 17:09:07 +02:00
66 changed files with 461 additions and 1671 deletions
@@ -1,411 +0,0 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Elements;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 namespace QuestPDF.Examples
 {
    public class ContentDirectionExamples
    {
        private Action<IContainer> ContentDirectionTemplate(Action<IContainer> content)
        {
            return container =>
            {
                container
                    .Padding(20)
                    .MinimalBox()
                    .Border(1)
                    .ExtendHorizontal()
                    .Table(table =>
                    {
                        table.ColumnsDefinition(columns =>
                        {
                            columns.RelativeColumn();
                            columns.RelativeColumn();
                        });
                        table.Header(header =>
                        {
                            header.Cell().ContentFromLeftToRight().Element(HeaderCell("Left-to-right"));
                            header.Cell().ContentFromRightToLeft().Element(HeaderCell("Right-to-left"));
                            static Action<IContainer> HeaderCell(string label)
                            {
                                return container => container
                                    .Border(1)
                                    .BorderColor(Colors.Grey.Medium)
                                    .Background(Colors.Grey.Lighten3)
                                    .PaddingHorizontal(10)
                                    .PaddingVertical(5)
                                    .Text(label)
                                    .FontSize(18)
                                    .SemiBold();
                            }
                        });
                        table.Cell().Element(TestCell).ContentFromLeftToRight().Element(content);
                        table.Cell()
                            .Element(TestCell)
                            .ContentFromRightToLeft()
                            .Element(content);
                        static IContainer TestCell(IContainer container)
                        {
                            return container.Border(1).BorderColor(Colors.Grey.Medium).Padding(10);
                        }
                    });
            };
        }
        [Test]
        public void Page()
        {
            RenderingTest
                .Create()
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .RenderDocument(document =>
                {
                    document.Page(page =>
                    {
                        page.Size(PageSizes.A5);
                        page.Margin(20);
                        page.PageColor(Colors.White);
                        //page.ContentFromRightToLeft();
                        page.Content().Column(column =>
                        {
                            column.Spacing(20);
                            column.Item().Row(row =>
                            {
                                row.Spacing(10);
                                row.AutoItem().AlignMiddle().Width(20).Height(20).Image(Placeholders.Image);
                                row.RelativeItem()
                                    .Text("Document title")
                                    .FontSize(24).FontColor(Colors.Blue.Accent1).SemiBold();
                            });
                            column.Item().Table(table =>
                            {
                                table.ColumnsDefinition(columns =>
                                {
                                    columns.RelativeColumn();
                                    columns.RelativeColumn();
                                    columns.RelativeColumn();
                                    columns.RelativeColumn();
                                });
                                foreach (var i in Enumerable.Range(0, 9))
                                {
                                    var width = (i % 4 == 0) ? 2 : 1;
                                    table
                                        .Cell()
                                        .ColumnSpan((uint)width)
                                        .Background(i % 4 == 0 ? Colors.Grey.Lighten1 : Colors.Grey.Lighten2)
                                        .Padding(5)
                                        .AlignCenter()
                                        .Text(i)
                                        .FontSize(20);
                                }
                            });
                        });
                    });
                });
        }
        [Test]
        public void Column()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Column(column =>
                {
                    column.Spacing(5);
                    column.Item().Height(50).Width(50).Background(Colors.Red.Lighten1);
                    column.Item().Height(50).Width(100).Background(Colors.Green.Lighten1);
                    column.Item().Height(50).Width(150).Background(Colors.Blue.Lighten1);
                });
            }
        }
        [Test]
        public void Row()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Row(row =>
                {
                    row.Spacing(5);
                    row.AutoItem().Height(50).Width(50).Background(Colors.Red.Lighten1);
                    row.AutoItem().Height(50).Width(50).Background(Colors.Green.Lighten1);
                    row.AutoItem().Height(50).Width(75).Background(Colors.Blue.Lighten1);
                });
            }
        }
        [Test]
        public void Table()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Table(table =>
                {
                    table.ColumnsDefinition(columns =>
                    {
                        columns.RelativeColumn();
                        columns.RelativeColumn();
                        columns.RelativeColumn();
                    });
                    table.Cell().Height(50).Background(Colors.Red.Lighten1);
                    table.Cell().Height(50).Background(Colors.Green.Lighten1);
                    table.Cell().Height(50).Background(Colors.Blue.Lighten1);
                    table.Cell().ColumnSpan(2).Height(50).Background(Colors.Orange.Lighten1);
                });
            }
        }
        [Test]
        public void Constrained()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Width(50).Height(50).Background(Colors.Red.Lighten1);
            }
        }
        [Test]
        public void Unconstrained()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container
                    .Width(100)
                    .Height(100)
                    .Background(Colors.Grey.Lighten3)
                    .AlignCenter()
                    .AlignMiddle()
                    .Unconstrained()
                    .Width(50)
                    .Height(50)
                    .Background(Colors.Red.Lighten1);
            }
        }
        [Test]
        public void Inlined()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Column(column =>
                {
                    column.Spacing(10);
                    column.Item().Background(Colors.Grey.Lighten3).Text("Default alignment").FontSize(13);
                    column.Item().Element(ContentWithAlignment(null));
                    column.Item().Background(Colors.Grey.Lighten3).Text("Left alignment").FontSize(14);
                    column.Item().Element(ContentWithAlignment(InlinedAlignment.Left));
                    column.Item().Background(Colors.Grey.Lighten3).Text("Center alignment").FontSize(14);
                    column.Item().Element(ContentWithAlignment(InlinedAlignment.Center));
                    column.Item().Background(Colors.Grey.Lighten3).Text("Right alignment").FontSize(14);
                    column.Item().Element(ContentWithAlignment(InlinedAlignment.Right));
                });
                static Action<IContainer> ContentWithAlignment(InlinedAlignment? alignment)
                {
                    return container =>
                    {
                        container.Inlined(inlined =>
                        {
                            inlined.Spacing(5);
                            inlined.Alignment(alignment);
                            inlined.Item().Height(50).Width(50).Background(Colors.Red.Lighten1);
                            inlined.Item().Height(50).Width(75).Background(Colors.Green.Lighten1);
                            inlined.Item().Height(50).Width(100).Background(Colors.Blue.Lighten1);
                            inlined.Item().Height(50).Width(125).Background(Colors.Orange.Lighten1);
                        });
                    };
                }
            }
        }
        [Test]
        public void Text()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Column(column =>
                {
                    column.Spacing(10);
                    column.Item().Background(Colors.Grey.Lighten3).Text("Default alignment").FontSize(13);
                    column.Item().Element(ContentWithAlignment(null));
                    column.Item().Background(Colors.Grey.Lighten3).Text("Left alignment").FontSize(14);
                    column.Item().Element(ContentWithAlignment(HorizontalAlignment.Left));
                    column.Item().Background(Colors.Grey.Lighten3).Text("Center alignment").FontSize(14);
                    column.Item().Element(ContentWithAlignment(HorizontalAlignment.Center));
                    column.Item().Background(Colors.Grey.Lighten3).Text("Right alignment").FontSize(14);
                    column.Item().Element(ContentWithAlignment(HorizontalAlignment.Right));
                });
                static Action<IContainer> ContentWithAlignment(HorizontalAlignment? alignment)
                {
                    return container =>
                    {
                        container.Text(text =>
                        {
                            text.Alignment = alignment; // internal API
                            text.Span("Lorem ipsum").Bold().FontColor(Colors.Red.Medium);
                            text.Element().Width(5);
                            text.Span(Placeholders.LoremIpsum());
                        });
                    };
                }
            }
        }
        [Test]
        public void Decoration()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Decoration(decoration =>
                {
                    decoration.Before().Background(Colors.Green.Lighten1).Padding(5).Text("Before").FontSize(16);
                    decoration.Content().Background(Colors.Green.Lighten2).Padding(5).Text("Content").FontSize(16);
                    decoration.After().Background(Colors.Green.Lighten3).Padding(5).Text("After").FontSize(16);
                });
            }
        }
        [Test]
        public void Dynamic()
        {
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProduceImages()
                .ShowResults()
                .EnableDebugging()
                .Render(ContentDirectionTemplate(Content));
            void Content(IContainer container)
            {
                container.Dynamic(new SimpleDynamic());
            }
        }
        class SimpleDynamic : IDynamicComponent<int>
        {
            public int State { get; set; }
            public DynamicComponentComposeResult Compose(DynamicContext context)
            {
                var content = context.CreateElement(container =>
                {
                    container.Row(row =>
                    {
                        row.ConstantItem(50).Background(Colors.Red.Lighten2).Height(50);
                        row.ConstantItem(75).Background(Colors.Green.Lighten2).Height(50);
                        row.ConstantItem(100).Background(Colors.Blue.Lighten2).Height(50);
                    });
                });
                return new DynamicComponentComposeResult
                {
                    Content = content,
                    HasMoreContent = false
                };
            }
        }
    }
 }
@@ -65,9 +65,9 @@ namespace QuestPDF.Examples.Engine
            return this;
        }
-        public RenderingTest ShowResults()
+        public RenderingTest ShowResults(bool value = true)
        {
-            ShowResult = true;
+            ShowResult = value;
            return this;
        }
@@ -1,146 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using QuestPDF.Elements;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 namespace QuestPDF.Examples
 {
    public class ProcessRunningTime
    {
        public TimeSpan FluentTime { get; set; }
        public TimeSpan GenerationTime { get; set; }
        public float Size { get; set; }
    }
    public class GenerationBenchmark
    {
        public const int TestSize = 4096;
        [Test]
        public void BenchmarkAsync()
        {
            RunTest(() => Enumerable
                .Range(0, TestSize)
                .AsParallel() // difference
                .Select(GenerateAndCollect)
                .ToList());
        }
        [Test]
        public void BenchmarkSync()
        {
            RunTest(() => Enumerable
                .Range(0, TestSize)
                .Select(GenerateAndCollect)
                .ToList());
        }
        public void RunTest(Func<IEnumerable<ProcessRunningTime>> handler)
        {
            var totalFluentTime = TimeSpan.Zero;
            var totalGenerationTime = TimeSpan.Zero;
            var stopWatch = new Stopwatch();
            stopWatch.Start();
            var results = handler();
            stopWatch.Stop();
            foreach (var result in results)
            {
                totalFluentTime += result.FluentTime;
                totalGenerationTime += result.GenerationTime;
            }
            Console.WriteLine($"Fluent: {totalFluentTime:g}");
            Console.WriteLine($"Generation: {totalGenerationTime:g}");
            Console.WriteLine($"Total: {stopWatch.Elapsed:g}");
        }
        static ProcessRunningTime GenerateAndCollect(int attemptNumber)
        {
            var stopwatch = new Stopwatch();
            stopwatch.Start();
            var container = new Container();
            container
                .Padding(10)
                .MinimalBox()
                .Border(1)
                .Column(column =>
                {
                    column.Item().Text($"Attempts {attemptNumber}");
                    const int numberOfRows = 100;
                    const int numberOfColumns = 10;
                    for (var y = 0; y < numberOfRows; y++)
                    {
                        column.Item().Row(row =>
                        {
                            for (var x = 0; x < numberOfColumns; x++)
                            {
                                row.RelativeItem()
                                    .Background(Colors.Red.Lighten5)
                                    .Padding(3)
                                    .Background(Colors.Red.Lighten4)
                                    .Padding(3)
                                    .Background(Colors.Red.Lighten3)
                                    .Padding(3)
                                    .Background(Colors.Red.Lighten2)
                                    .Padding(3)
                                    .Background(Colors.Red.Lighten1)
                                    .Padding(3)
                                    .Background(Colors.Red.Medium)
                                    .Padding(3)
                                    .Background(Colors.Red.Darken1)
                                    .Padding(3)
                                    .Background(Colors.Red.Darken2)
                                    .Padding(3)
                                    .Background(Colors.Red.Darken3)
                                    .Padding(3)
                                    .Background(Colors.Red.Darken4)
                                    .Height(3);
                            }
                        });
                    }  
                });
            var fluentTime = stopwatch.Elapsed;
            stopwatch.Reset();
            stopwatch.Start();
            var size = Document
                .Create(x => x.Page(page => page.Content().Element(container)))
                .GeneratePdf()
                .Length;
            var generationTime = stopwatch.Elapsed;
            return new ProcessRunningTime
            {
                FluentTime = fluentTime,
                GenerationTime = generationTime,
                Size = size
            };
        }
    }
 }
@@ -1,5 +1,4 @@
-using System;
+using System.IO;
 using System.IO;
 using NUnit.Framework;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Examples.Engine;
@@ -35,21 +34,6 @@ namespace QuestPDF.Examples
                });
        }
        [Test]
        public void DynamicImage()
        {
            RenderingTest
                .Create()
                .PageSize(450, 350)
                .ProducePdf()
                .ShowResults()
                .Render(page =>
                {
                    page.Padding(25)
                        .Image(Placeholders.Image);
                });
        }
        [Test]
        public void Exception()
        {
@@ -63,43 +47,5 @@ namespace QuestPDF.Examples
                    .Render(page => page.Image("non_existent.png"));
            });
        }
        [Test]
        public void ReusingTheSameImageFileShouldBePossible()
        {
            var fileName = Path.GetTempFileName() + ".jpg";
            try
            {
                var image = Placeholders.Image(300, 100);
                using var file = File.Create(fileName);
                file.Write(image);
                file.Dispose();
                RenderingTest
                    .Create()
                    .ProducePdf()
                    .PageSize(PageSizes.A4)
                    .ShowResults()
                    .Render(container =>
                    {
                        container
                            .Padding(20)
                            .Column(column =>
                            {
                                column.Spacing(20);
                                column.Item().Image(fileName);
                                column.Item().Image(fileName);
                                column.Item().Image(fileName);
                            });
                    });
            }
            finally
            {
                File.Delete(fileName);
            }
        }
    }
 }
@@ -105,41 +105,5 @@ namespace QuestPDF.Examples
                        .Row(row => { });
                });
        }
        [Test]
        public void RowElementForRelativeHeightDivision()
        {
            RenderingTest
                .Create()
                .ProduceImages()
                .ShowResults()
                .MaxPages(100)
                .PageSize(250, 400)
                .Render(container =>
                {
                    container
                        .Padding(25)
                        .AlignLeft()
                        .RotateRight()
                        .Row(row =>
                        {
                            row.Spacing(20);
                            row.RelativeItem(1).Element(Content);
                            row.RelativeItem(2).Element(Content);
                            row.RelativeItem(3).Element(Content);
                            void Content(IContainer container)
                            {
                                container
                                    .RotateLeft()
                                    .Border(1)
                                    .Background(Placeholders.BackgroundColor())
                                    .Padding(5)
                                    .Text(Placeholders.Label());
                            }
                        });
                });
        }
    }
 }
@@ -1,8 +1,13 @@
-using System.Linq;
+using System;
 using System.Diagnostics;
 using System.Linq;
 using NUnit.Framework;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 namespace QuestPDF.Examples
 {
@@ -11,36 +16,77 @@ namespace QuestPDF.Examples
        [Test]
        public void Benchmark()
        {
-            RenderingTest
+            GenerateAndCollect();
                .Create()
                .ProducePdf()
                .PageSize(PageSizes.A4)
                .ShowResults()
                .MaxPages(10_000)
                .EnableCaching(true)
                .EnableDebugging(false)
                .Render(container =>
                {
                    container
                        .Padding(10)
                        .MinimalBox()
                        .Border(1)
                        .Table(table =>
                        {
                            const int numberOfRows = 100_000;
                            const int numberOfColumns = 10;
                            table.ColumnsDefinition(columns =>
                            {
                                foreach (var _ in Enumerable.Range(0, numberOfColumns))
                                    columns.RelativeColumn();
                            });
-                            foreach (var row in Enumerable.Range(0, numberOfRows))
+            var stopwatch = new Stopwatch();
-                            foreach (var column in Enumerable.Range(0, numberOfColumns))
+            stopwatch.Start();
-                                table.Cell().Background(Placeholders.BackgroundColor()).Padding(5).Text($"{row}_{column}");
+
-                        });
+            foreach (var _ in Enumerable.Range(0, 10000))
-                });
+            {
                GenerateAndCollect();
            }
            stopwatch.Stop();
            Console.WriteLine($"Execution time: {stopwatch.Elapsed:g}");
            void GenerateAndCollect()
            {
                var container = new Container();
                container
                    .Padding(10)
                    .MinimalBox()
                    .Border(1)
                    .Column(column =>
                    {
                        const int numberOfRows = 100;
                        const int numberOfColumns = 10;
                        for (var y = 0; y < numberOfRows; y++)
                        {
                            column.Item().Row(row =>
                            {
                                for (var x = 0; x < numberOfColumns; x++)
                                {
                                    row.RelativeItem()
                                        .Background(Colors.Red.Lighten5)
                                        .Padding(3)
                                        .Background(Colors.Red.Lighten4)
                                        .Padding(3)
                                        .Background(Colors.Red.Lighten3)
                                        .Padding(3)
                                        .Background(Colors.Red.Lighten2)
                                        .Padding(3)
                                        .Background(Colors.Red.Lighten1)
                                        .Padding(3)
                                        .Background(Colors.Red.Medium)
                                        .Padding(3)
                                        .Background(Colors.Red.Darken1)
                                        .Padding(3)
                                        .Background(Colors.Red.Darken2)
                                        .Padding(3)
                                        .Background(Colors.Red.Darken3)
                                        .Padding(3)
                                        .Background(Colors.Red.Darken4)
                                        .Height(3);
                                }
                            });
                        }  
                    });
                ElementCacheManager.Collect(container);
            }
        }
    }
 }
@@ -111,7 +111,7 @@ namespace QuestPDF.Examples
            {
                page.Margin(50);
-                page.Content().PaddingVertical(10).Column(column =>
+                page.Content().Column(column =>
                {
                    column.Item().Element(Title);
                    column.Item().PageBreak();
@@ -1,8 +1,7 @@
-using System;
+using System;
 using System.Linq;
 using System.Text;
 using NUnit.Framework;
 using QuestPDF.Elements.Text;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
@@ -604,7 +603,7 @@ namespace QuestPDF.Examples
        {
            RenderingTest
                .Create()
-                .PageSize(250, 100)
+                .PageSize(500, 100)
                .ProduceImages()
                .ShowResults()
@@ -614,115 +613,9 @@ namespace QuestPDF.Examples
                        .Padding(25)
                        .MinimalBox()
                        .Background(Colors.Grey.Lighten2)
-                        .Text("خوارزمية ترتيب")
+                        .Text("ينا الألم. في بعض الأحيان ونظراً للالتزامات التي يفرضها علينا")
                        .FontFamily(Fonts.Calibri)
-                        .FontSize(30);
+                        .FontSize(20);
                });
        }
        [Test]
        public void FontFallback()
        {
            RenderingTest
                .Create()
                .ProduceImages()
                .ShowResults()
                .RenderDocument(container =>
                {
                    container.Page(page =>
                    {
                        page.Margin(50);
                        page.PageColor(Colors.White);
                        page.DefaultTextStyle(x => x
                            .Fallback(y => y.FontFamily("Segoe UI Emoji")
                                .Fallback(y => y.FontFamily("Microsoft YaHei"))));
                        page.Size(PageSizes.A4);
                        page.Content().Text(t =>
                        {
                            t.Line("This is normal text.");
                            t.EmptyLine();
                            t.Line("Following line should use font fallback:");
                            t.Line("中文文本");
                            t.EmptyLine();
                            t.Line("The following line contains a mix of known and unknown characters.");
                            t.Line("Mixed line: This 中文 is 文文 a mixed 本 本 line 本 中文文本!");
                            t.EmptyLine();
                            t.Line("Emojis work out of the box because of font fallback: 😊😅🥳👍❤😍👌");
                        });
                    });
                });
        }
        [Test]
        public void WordWrappingStability()
        {
            // instruction: check if any characters repeat when performing the word-wrapping algorithm
            RenderingTest
                .Create()
                .PageSize(PageSizes.A4)
                .ProducePdf()
                .ShowResults()
                .Render(container =>
                {
                    var text = "Lorem ipsum dolor sit amet consectetuer";
                    container
                        .Padding(20)
                        .Column(column =>
                        {
                            column.Spacing(10);
                            foreach (var width in Enumerable.Range(25, 200))
                            {
                                column
                                    .Item()
                                    .MaxWidth(width)
                                    .Background(Colors.Grey.Lighten3)
                                    .Text(text);
                            }
                        });
                });
        }
        [Test]
        public void TextDirectionality()
        {
            RenderingTest
                .Create()
                .PageSize(new PageSize(1000, 500))
                .ProducePdf()
                .ShowResults()
                .Render(container =>
                {
                    var text = "في المعلوماتية أو الرياضيات، خوارزمية الترتيب هي خوارزمية تمكن من تنظيم مجموعة عناصر حسب ترتيب محدد.";
                    container
                        .Padding(25)
                        .ContentFromRightToLeft()
                        .Column(column =>
                        {
                            column.Spacing(20);
                            foreach (var size in new[] { 36, 34, 32, 30, 15 })
                            {
                                column
                                    .Item()
                                    .ShowEntire()
                                    .MaxWidth(size * 25)
                                    .Background(Colors.Grey.Lighten3)
                                    .MinimalBox()
                                    .Background(Colors.Grey.Lighten2)
                                    .Text(text)
                                    .FontSize(20)
                                    .FontFamily("Segoe UI");
                            }
                        });
                });
        }
    }
@@ -4,7 +4,7 @@
        <Authors>MarcinZiabek</Authors>
        <Company>CodeFlint</Company>
        <PackageId>QuestPDF.Previewer</PackageId>
-        <Version>2022.11.0</Version>
+        <Version>2022.8.0</Version>
        <PackAsTool>true</PackAsTool>
        <ToolCommandName>questpdf-previewer</ToolCommandName>
        <PackageDescription>QuestPDF is an open-source, modern and battle-tested library that can help you with generating PDF documents by offering friendly, discoverable and predictable C# fluent API.</PackageDescription>
@@ -68,11 +68,9 @@ namespace QuestPDF.ReportSample.Layouts
                        var lengthStyle = TextStyle.Default.FontColor(Colors.Grey.Medium);
-                        text.TotalPagesWithinSection(locationName).Style(lengthStyle).Format(x =>
+                        text.Span(" (").Style(lengthStyle);
-                        {
+                        text.TotalPagesWithinSection(locationName).Style(lengthStyle).Format(x => x == 1 ? "1 page long" : $"{x} pages long");
-                            var formatted = x == 1 ? "1 page long" : $"{x} pages long";
+                        text.Span(")").Style(lengthStyle);
                            return $" ({formatted})";
                        });
                    });
                });
        }
@@ -153,9 +153,7 @@ namespace QuestPDF.UnitTests
                    Ratio = 2f
                })
                .DrawElement(new Size(500, 200))
                .ExpectCanvasTranslate(0, 0)
                .ExpectChildDraw(new Size(400, 200))
                .ExpectCanvasTranslate(0, 0)
                .CheckDrawResult();
        }
@@ -170,45 +168,7 @@ namespace QuestPDF.UnitTests
                    Ratio = 2f
                })
                .DrawElement(new Size(400, 300))
                .ExpectCanvasTranslate(0, 0)
                .ExpectChildDraw(new Size(400, 200))
                .ExpectCanvasTranslate(0, 0)
                .CheckDrawResult();
        } 
        [Test]
        public void DrawChild_PerWidth_RightToLeft()
        {
            TestPlan
                .For(x => new AspectRatio
                {
                    Child = x.CreateChild(),
                    Option = AspectRatioOption.FitArea,
                    Ratio = 2f,
                    ContentDirection = ContentDirection.RightToLeft
                })
                .DrawElement(new Size(500, 200))
                .ExpectCanvasTranslate(100, 0)
                .ExpectChildDraw(new Size(400, 200))
                .ExpectCanvasTranslate(-100, 0)
                .CheckDrawResult();
        }
        [Test]
        public void DrawChild_PerHeight_RightToLeft()
        {
            TestPlan
                .For(x => new AspectRatio
                {
                    Child = x.CreateChild(),
                    Option = AspectRatioOption.FitArea,
                    Ratio = 2f,
                    ContentDirection = ContentDirection.RightToLeft
                })
                .DrawElement(new Size(400, 300))
                .ExpectCanvasTranslate(0, 0)
                .ExpectChildDraw(new Size(400, 200))
                .ExpectCanvasTranslate(0, 0)
                .CheckDrawResult();
        } 
    }
@@ -35,9 +35,7 @@ namespace QuestPDF.UnitTests
                })
                .MeasureElement(new Size(400, 300))
                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.PartialRender(200, 100))
                .ExpectCanvasTranslate(0, 0)
                .ExpectChildDraw(new Size(200, 100))
                .ExpectCanvasTranslate(0, 0)
                .CheckDrawResult();
        }
@@ -51,43 +49,7 @@ namespace QuestPDF.UnitTests
                })
                .MeasureElement(new Size(500, 400))
                .ExpectChildMeasure(expectedInput: new Size(500, 400), returns: SpacePlan.FullRender(300, 200))
                .ExpectCanvasTranslate(0, 0)
                .ExpectChildDraw(new Size(300, 200))
                .ExpectCanvasTranslate(0, 0)
                .CheckDrawResult();
        }
        [Test]
        public void Measure_PartialRender_RightToLeft()
        {
            TestPlan
                .For(x => new MinimalBox
                {
                    Child = x.CreateChild(),
                    ContentDirection = ContentDirection.RightToLeft
                })
                .MeasureElement(new Size(400, 300))
                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.PartialRender(200, 100))
                .ExpectCanvasTranslate(200, 0)
                .ExpectChildDraw(new Size(200, 100))
                .ExpectCanvasTranslate(-200, 0)
                .CheckDrawResult();
        }
        [Test]
        public void Measure_FullRender_RightToLeft()
        {
            TestPlan
                .For(x => new MinimalBox
                {
                    Child = x.CreateChild(),
                    ContentDirection = ContentDirection.RightToLeft
                })
                .MeasureElement(new Size(500, 400))
                .ExpectChildMeasure(expectedInput: new Size(500, 400), returns: SpacePlan.FullRender(350, 200))
                .ExpectCanvasTranslate(150, 0)
                .ExpectChildDraw(new Size(350, 200))
                .ExpectCanvasTranslate(-150, 0)
                .CheckDrawResult();
        }
    }
@@ -195,7 +195,7 @@ namespace QuestPDF.UnitTests.TestEngine
        public TestPlan CheckMeasureResult(SpacePlan expected)
        {
-            Element.InjectDependencies(null, Canvas);
+            Element.VisitChildren(x => x?.Initialize(null, Canvas));
            var actual = Element.Measure(OperationInput);
@@ -210,7 +210,7 @@ namespace QuestPDF.UnitTests.TestEngine
        public TestPlan CheckDrawResult()
        {
-            Element.InjectDependencies(null, Canvas);
+            Element.VisitChildren(x => x?.Initialize(null, Canvas));
            Element.Draw(OperationInput);
            return this;
        }
@@ -253,10 +253,10 @@ namespace QuestPDF.UnitTests.TestEngine
            availableSpace ??= new Size(400, 300);
            var canvas = new FreeCanvas();
-            value.InjectDependencies(null, canvas);
+            value.VisitChildren(x => x.Initialize(null, canvas));
            var valueMeasure = value.Measure(availableSpace.Value);
-            expected.InjectDependencies(null, canvas);
+            expected.VisitChildren(x => x.Initialize(null, canvas));
            var expectedMeasure = expected.Measure(availableSpace.Value);
            valueMeasure.Should().BeEquivalentTo(expectedMeasure);
@@ -267,11 +267,11 @@ namespace QuestPDF.UnitTests.TestEngine
            availableSpace ??= new Size(400, 300);
            var valueCanvas = new OperationRecordingCanvas();
-            value.InjectDependencies(null, valueCanvas);
+            value.VisitChildren(x => x.Initialize(null, valueCanvas));
            value.Draw(availableSpace.Value);
            var expectedCanvas = new OperationRecordingCanvas();
-            expected.InjectDependencies(null, expectedCanvas);
+            expected.VisitChildren(x => x.Initialize(null, expectedCanvas));
            expected.Draw(availableSpace.Value);
            valueCanvas.Operations.Should().BeEquivalentTo(expectedCanvas.Operations);
@@ -77,9 +77,7 @@ namespace QuestPDF.UnitTests
                })
                .DrawElement(new Size(900, 800))
                .ExpectChildMeasure(Size.Max, SpacePlan.PartialRender(1200, 1600))
                .ExpectCanvasTranslate(0, 0)
                .ExpectChildDraw(new Size(1200, 1600))
                .ExpectCanvasTranslate(0, 0)
                .CheckDrawResult();
        }
@@ -93,43 +91,7 @@ namespace QuestPDF.UnitTests
                })
                .DrawElement(new Size(900, 800))
                .ExpectChildMeasure(Size.Max, SpacePlan.FullRender(1600, 1000))
                .ExpectCanvasTranslate(0, 0)
                .ExpectChildDraw(new Size(1600, 1000))
                .ExpectCanvasTranslate(0, 0)
                .CheckDrawResult();
        }
        [Test]
        public void Draw_WhenChildPartiallyRenders_RightToLeft()
        {
            TestPlan
                .For(x => new Unconstrained
                {
                    Child = x.CreateChild(),
                    ContentDirection = ContentDirection.RightToLeft
                })
                .DrawElement(new Size(900, 800))
                .ExpectChildMeasure(Size.Max, SpacePlan.PartialRender(1200, 1600))
                .ExpectCanvasTranslate(-1200, 0)
                .ExpectChildDraw(new Size(1200, 1600))
                .ExpectCanvasTranslate(1200, 0)
                .CheckDrawResult();
        }
        [Test]
        public void Draw_WhenChildFullyRenders_RightToLeft()
        {
            TestPlan
                .For(x => new Unconstrained
                {
                    Child = x.CreateChild(),
                    ContentDirection = ContentDirection.RightToLeft
                })
                .DrawElement(new Size(900, 800))
                .ExpectChildMeasure(Size.Max, SpacePlan.FullRender(1600, 1000))
                .ExpectCanvasTranslate(-1600, 0)
                .ExpectChildDraw(new Size(1600, 1000))
                .ExpectCanvasTranslate(1600, 0)
                .CheckDrawResult();
        }
@@ -65,7 +65,6 @@ namespace QuestPDF.Drawing
            document.Compose(container);
            var content = container.Compose();
            ApplyDefaultTextStyle(content, TextStyle.LibraryDefault);
            ApplyContentDirection(content, ContentDirection.LeftToRight);
            var debuggingState = Settings.EnableDebugging ? ApplyDebugging(content) : null;
@@ -75,12 +74,14 @@ namespace QuestPDF.Drawing
            var pageContext = new PageContext();
            RenderPass(pageContext, new FreeCanvas(), content, debuggingState);
            RenderPass(pageContext, canvas, content, debuggingState);
            ElementCacheManager.Collect(content);
        }
        internal static void RenderPass<TCanvas>(PageContext pageContext, TCanvas canvas, Container content, DebuggingState? debuggingState)
            where TCanvas : ICanvas, IRenderingCanvas
        {
-            InjectDependencies(content, pageContext, canvas);
+            content.VisitChildren(x => x?.Initialize(pageContext, canvas));
            content.VisitChildren(x => (x as IStateResettable)?.ResetState());
            canvas.BeginDocument();
@@ -141,18 +142,6 @@ namespace QuestPDF.Drawing
            }
        }
        internal static void InjectDependencies(this Element content, IPageContext pageContext, ICanvas canvas)
        {
            content.VisitChildren(x =>
            {
                if (x == null)
                    return;
                x.PageContext = pageContext;
                x.Canvas = canvas;
            });
        }
        private static void ApplyCaching(Container content)
        {
            content.VisitChildren(x =>
@@ -173,24 +162,6 @@ namespace QuestPDF.Drawing
            return debuggingState;
        }
        internal static void ApplyContentDirection(this Element? content, ContentDirection direction)
        {
            if (content == null)
                return;
            if (content is ContentDirectionSetter contentDirectionSetter)
            {
                ApplyContentDirection(contentDirectionSetter.Child, contentDirectionSetter.ContentDirection);
                return;
            }
            if (content is IContentDirectionAware contentDirectionAware)
                contentDirectionAware.ContentDirection = direction;
            foreach (var child in content.GetChildren())
                ApplyContentDirection(child, direction);
        }
        internal static void ApplyDefaultTextStyle(this Element? content, TextStyle documentDefaultTextStyle)
        {
@@ -203,7 +174,7 @@ namespace QuestPDF.Drawing
                {
                    if (textBlockItem is TextBlockSpan textSpan)
                    {
-                        textSpan.Style = textSpan.Style.ApplyGlobalStyle(documentDefaultTextStyle);
+                        textSpan.Style = textSpan.Style.ApplyGlobalStyle(TextStyle.LibraryDefault);
                    }
                    else if (textBlockItem is TextBlockElement textElement)
                    {
@@ -0,0 +1,76 @@
 using System;
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using QuestPDF.Infrastructure;
 namespace QuestPDF.Drawing
 {
    internal class CircularBuffer
    {
        private const int BufferSize = 11_000;
        private object[] Buffer = new object[BufferSize];
        private int WriteIndex { get; set; } = 0;
        private int ReadIndex { get; set; } = 0;
        public T Get<T>() where T : class, new()
        {
            lock (this)
            {
                if (ReadIndex == WriteIndex)
                    return new T();
                var index = ReadIndex;
                ReadIndex = (ReadIndex + 1) % BufferSize;
                var result = Buffer[index] as T;
                Buffer[index] = null;
                return result;
            }
        }
        public void Store(object value)
        {
            lock (this)
            {
                Buffer[WriteIndex] = value;
                WriteIndex = (WriteIndex + 1) % BufferSize;
            }
        }
    }
    // performance analysis:
    // without: 115s
    // ConcurrentQueue: 28s
    // ConcurrentBag: 38s
    // CircularBuffer: 30s
    internal static class ElementCacheManager
    {
        private static ConcurrentDictionary<Type, ConcurrentQueue<object>> Cache { get; } = new();
        public static T Get<T>() where T : class, new()
        {
            var buffer = Cache.GetOrAdd(typeof(T), _=> new ConcurrentQueue<object>());
            return buffer.TryDequeue(out var result) ? result as T : new T();
        }
        public static void Store<T>(T element)
        {
            var buffer = Cache.GetOrAdd(element.GetType(), _=> new ConcurrentQueue<object>());
            buffer.Enqueue(element);
        }
        public static void Collect(Element element)
        {
            foreach (var child in element.GetChildren())
                Collect(child);
            if (element is ICollectable collectable)
            {
                collectable.Collect();
                Store(element);   
            }
        }
    }
 }
@@ -4,11 +4,6 @@ namespace QuestPDF.Drawing.Exceptions
 {
    public class DocumentDrawingException : Exception
    {
        internal DocumentDrawingException(string message) : base(message)
        {
        }
        internal DocumentDrawingException(string message, Exception inner) : base(message, inner)
        {
@@ -0,0 +1,8 @@
 namespace QuestPDF.Drawing
 {
    internal struct TextMeasurement
    {
        public int LineIndex { get; set; }
        public float FragmentWidth { get; set; }
    }
 }
@@ -29,12 +29,6 @@ namespace QuestPDF.Drawing
            PopulateBufferWithText(buffer, text);
            buffer.GuessSegmentProperties();
            if (TextStyle.Direction == TextDirection.LeftToRight)
                buffer.Direction = Direction.LeftToRight;
            if (TextStyle.Direction == TextDirection.RightToLeft)
                buffer.Direction = Direction.RightToLeft;
            ShaperFont.Shape(buffer);
            var length = buffer.Length;
@@ -61,8 +55,11 @@ namespace QuestPDF.Drawing
                xOffset += glyphPositions[i].XAdvance * scaleX;
                yOffset += glyphPositions[i].YAdvance * scaleY;
            }
            if (Settings.CheckIfAllTextGlyphsAreAvailableInSpecifiedFont)
                CheckIfAllGlyphsAreAvailable(glyphs, text);
-            return new TextShapingResult(buffer.Direction, glyphs);
+            return new TextShapingResult(glyphs);
        }
        void PopulateBufferWithText(Buffer buffer, string text)
@@ -81,6 +78,20 @@ namespace QuestPDF.Drawing
            else
                throw new NotSupportedException("TextEncoding of type GlyphId is not supported.");
        }
        void CheckIfAllGlyphsAreAvailable(ShapedGlyph[] glyphs, string originalText)
        {
            var containsMissingGlyphs = glyphs.Any(x => x.Codepoint == default);
            if (!containsMissingGlyphs)
                return;
            throw new ArgumentException(
                $"Detected missing font glyphs while rendering text. " +
                $"This means that the document contains text with characters not present in the assigned font. " +
                $"Such characters are replaced by placeholders, usually visible as empty rectangles. " +
                $"Font family used: {TextStyle.FontFamily}. Issue detected in text: '{originalText}'");
        }
    }
    internal struct ShapedGlyph
@@ -98,65 +109,29 @@ namespace QuestPDF.Drawing
    internal class TextShapingResult
    {
-        private Direction Direction { get; }
+        public ShapedGlyph[] Glyphs { get; }
        private ShapedGlyph[] Glyphs { get; }
-        public int Length => Glyphs.Length;
+        public TextShapingResult(ShapedGlyph[] glyphs)
        public ShapedGlyph this[int index] =>
            Direction == Direction.LeftToRight 
                ? Glyphs[index] 
                : Glyphs[Glyphs.Length - 1 - index];
        public TextShapingResult(Direction direction, ShapedGlyph[] glyphs)
        {
            Direction = direction;
            Glyphs = glyphs;
        }
        public int BreakText(int startIndex, float maxWidth)
        {
-            return Direction switch
+            var index = startIndex;
            maxWidth += Glyphs[startIndex].Position.X;
            while (index < Glyphs.Length)
            {
-                Direction.LeftToRight => BreakTextLeftToRight(),
+                var glyph = Glyphs[index];
                Direction.RightToLeft => BreakTextRightToLeft(),
                _ => throw new ArgumentOutOfRangeException()
            };
            int BreakTextLeftToRight()
            {
                var index = startIndex;
                maxWidth += Glyphs[startIndex].Position.X;
                while (index < Glyphs.Length)
                {
                    var glyph = Glyphs[index];
-                    if (glyph.Position.X + glyph.Width > maxWidth + Size.Epsilon)
+                if (glyph.Position.X + glyph.Width > maxWidth + Size.Epsilon)
-                        break;
+                    break;
-                    index++;
+                index++;
                }
                return index - 1;
            }
            int BreakTextRightToLeft()
            {
                var index = startIndex;
-                var startOffset = this[startIndex].Position.X + this[startIndex].Width;
+            return index - 1;
                while (index < Glyphs.Length)
                {
                    if (startOffset - this[index].Position.X > maxWidth + Size.Epsilon)
                        break;
                    index++;
                }
                return index - 1;
            }
        }
        public float MeasureWidth(int startIndex, int endIndex)
@@ -164,15 +139,10 @@ namespace QuestPDF.Drawing
            if (Glyphs.Length == 0)
                return 0;
-            var start = this[startIndex];
+            var start = Glyphs[startIndex];
-            var end = this[endIndex];
+            var end = Glyphs[endIndex];
-            return Direction switch
+            return end.Position.X - start.Position.X + end.Width;
            {
                Direction.LeftToRight => end.Position.X - start.Position.X + end.Width,
                Direction.RightToLeft => start.Position.X - end.Position.X + start.Width,
                _ => throw new NotSupportedException()
            };
        }
        public DrawTextCommand? PositionText(int startIndex, int endIndex, TextStyle textStyle)
@@ -193,18 +163,14 @@ namespace QuestPDF.Drawing
            {
                var runIndex = sourceIndex - startIndex;
-                glyphSpan[runIndex] = this[sourceIndex].Codepoint;
+                glyphSpan[runIndex] = Glyphs[sourceIndex].Codepoint;
-                positionSpan[runIndex] = this[sourceIndex].Position;
+                positionSpan[runIndex] = Glyphs[sourceIndex].Position;
            }
            var firstVisualCharacterIndex = Direction == Direction.LeftToRight
                ? startIndex
                : endIndex;
            return new DrawTextCommand
            {
                SkTextBlob = skTextBlobBuilder.Build(),
-                TextOffsetX = -this[firstVisualCharacterIndex].Position.X
+                TextOffsetX = -Glyphs[startIndex].Position.X
            };
        }
    }
@@ -4,10 +4,8 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements
 {
-    internal class AspectRatio : ContainerElement, ICacheable, IContentDirectionAware
+    internal class AspectRatio : ContainerElement, ICacheable
    {
        public ContentDirection ContentDirection { get; set; }
        public float Ratio { get; set; } = 1;
        public AspectRatioOption Option { get; set; } = AspectRatioOption.FitWidth;
@@ -44,14 +42,7 @@ namespace QuestPDF.Elements
                return;
            var size = GetTargetSize(availableSpace);
            var offset = ContentDirection == ContentDirection.LeftToRight
                ? Position.Zero
                : new Position(availableSpace.Width - size.Width, 0);
            Canvas.Translate(offset);
            base.Draw(size);
            Canvas.Translate(offset.Reverse());
        }
        private Size GetTargetSize(Size availableSpace)
@@ -41,5 +41,15 @@ namespace QuestPDF.Elements
        {
            return $"Border: Top({Top}) Right({Right}) Bottom({Bottom}) Left({Left}) Color({Color})";
        }
        public override void Collect()
        {
            base.Collect();
            Left = 0;
            Right = 0;
            Bottom = 0;
            Top = 0;
        }
    }
 }
@@ -19,7 +19,7 @@ namespace QuestPDF.Elements
        public Position Offset { get; set; }
    }
-    internal class Column : Element, ICacheable, IStateResettable
+    internal class Column : Element, ICacheable, IStateResettable, ICollectable
    {
        internal List<ColumnItem> Items { get; } = new();
        internal float Spacing { get; set; }
@@ -74,7 +74,7 @@ namespace QuestPDF.Elements
                    command.ColumnItem.IsRendered = true;
                var targetSize = new Size(availableSpace.Width, command.Size.Height);
-
+                
                Canvas.Translate(command.Offset);
                command.ColumnItem.Draw(targetSize);
                Canvas.Translate(command.Offset.Reverse());
@@ -124,5 +124,10 @@ namespace QuestPDF.Elements
            return commands;
        }
        public void Collect()
        {
            Items.Clear();
        }
    }
 }
@@ -5,10 +5,8 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements
 {
-    internal class Constrained : ContainerElement, ICacheable, IContentDirectionAware
+    internal class Constrained : ContainerElement, ICacheable
    {
        public ContentDirection ContentDirection { get; set; }
        public float? MinWidth { get; set; }
        public float? MaxWidth { get; set; }
@@ -47,17 +45,11 @@ namespace QuestPDF.Elements
        internal override void Draw(Size availableSpace)
        {
-            var size = new Size(
+            var available = new Size(
                Min(MaxWidth, availableSpace.Width),
                Min(MaxHeight, availableSpace.Height));
-            var offset = ContentDirection == ContentDirection.LeftToRight
+            Child?.Draw(available);
                ? Position.Zero
                : new Position(availableSpace.Width - size.Width, 0);
            Canvas.Translate(offset);
            base.Draw(size);
            Canvas.Translate(offset.Reverse());
        }
        private static float Min(float? x, float y)
@@ -4,7 +4,7 @@ namespace QuestPDF.Elements
 {
    internal class Container : ContainerElement
    {
-        internal Container()
+        public Container()
        {
        }
@@ -1,9 +0,0 @@
 using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements
 {
    internal class ContentDirectionSetter : ContainerElement
    {
        public ContentDirection ContentDirection { get; set; }
    }
 }
@@ -14,10 +14,8 @@ namespace QuestPDF.Elements
        public Position Offset { get; set; }
    }
-    internal class Decoration : Element, ICacheable, IContentDirectionAware
+    internal class Decoration : Element, ICacheable
    {
        public ContentDirection ContentDirection { get; set; }
        internal Element Before { get; set; } = new Empty();
        internal Element Content { get; set; } = new Empty();
        internal Element After { get; set; } = new Empty();
@@ -66,13 +64,9 @@ namespace QuestPDF.Elements
            {
                var elementSize = new Size(width, command.Measurement.Height);
-                var offset = ContentDirection == ContentDirection.LeftToRight
+                Canvas.Translate(command.Offset);
                    ? command.Offset
                    : new Position(availableSpace.Width - width, command.Offset.Y);
                Canvas.Translate(offset);
                command.Element.Draw(elementSize);
-                Canvas.Translate(offset.Reverse());
+                Canvas.Translate(command.Offset.Reverse());
            }
        }
@@ -6,14 +6,13 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements
 {
-    internal class DynamicHost : Element, IStateResettable, IContentDirectionAware
+    internal class DynamicHost : Element, IStateResettable
    {
        private DynamicComponentProxy Child { get; }
        private object InitialComponentState { get; set; }
        internal TextStyle TextStyle { get; set; } = TextStyle.Default;
-        public ContentDirection ContentDirection { get; set; }
+
        public DynamicHost(DynamicComponentProxy child)
        {
            Child = child;
@@ -52,14 +51,12 @@ namespace QuestPDF.Elements
            var context = new DynamicContext
            {
                PageContext = PageContext,
                Canvas = Canvas,
                TextStyle = TextStyle,
                ContentDirection = ContentDirection,
                PageNumber = PageContext.CurrentPage,
                TotalPages = PageContext.GetLocation(Infrastructure.PageContext.DocumentLocation).PageEnd,
                PageContext = PageContext,
                Canvas = Canvas,
                TextStyle = TextStyle,
                AvailableSize = availableSize
            };
@@ -76,9 +73,7 @@ namespace QuestPDF.Elements
    {
        internal IPageContext PageContext { get; set; }
        internal ICanvas Canvas { get; set; }
        internal TextStyle TextStyle { get; set; }
        internal ContentDirection ContentDirection { get; set; }
        public int PageNumber { get; internal set; }
        public int TotalPages { get; internal set; }
@@ -90,9 +85,7 @@ namespace QuestPDF.Elements
            content(container);
            container.ApplyDefaultTextStyle(TextStyle);
-            container.ApplyContentDirection(ContentDirection);
+            container.VisitChildren(x => x?.Initialize(PageContext, Canvas));
            container.InjectDependencies(PageContext, Canvas);
            container.VisitChildren(x => (x as IStateResettable)?.ResetState());
            container.Size = container.Measure(Size.Max);
@@ -24,8 +24,13 @@ namespace QuestPDF.Elements
            if (imageData == null)
                return;
-            using var image = SKImage.FromEncodedData(imageData);
+            var imageElement = new Image
-            Canvas.DrawImage(image, Position.Zero, availableSpace);
+            {
                InternalImage = SKImage.FromEncodedData(imageData)
            };
            imageElement.Initialize(PageContext, Canvas);
            imageElement.Draw(availableSpace);
        }
    }
 }
@@ -26,17 +26,15 @@ namespace QuestPDF.Elements
        public SpacePlan Size { get; set; }
    }
-    internal class Inlined : Element, IStateResettable, IContentDirectionAware
+    internal class Inlined : Element, IStateResettable
    {
        public ContentDirection ContentDirection { get; set; }
        public List<InlinedElement> Elements { get; internal set; } = new List<InlinedElement>();
        private Queue<InlinedElement> ChildrenQueue { get; set; }
        internal float VerticalSpacing { get; set; }
        internal float HorizontalSpacing { get; set; }
-        internal InlinedAlignment? ElementsAlignment { get; set; }
+        internal InlinedAlignment ElementsAlignment { get; set; }
        internal VerticalAlignment BaselineAlignment { get; set; }
        public void ResetState()
@@ -51,8 +49,6 @@ namespace QuestPDF.Elements
        internal override SpacePlan Measure(Size availableSpace)
        {
            SetDefaultAlignment();   
            if (!ChildrenQueue.Any())
                return SpacePlan.FullRender(Size.Zero);
@@ -85,8 +81,6 @@ namespace QuestPDF.Elements
        internal override void Draw(Size availableSpace)
        {
            SetDefaultAlignment();
            var lines = Compose(availableSpace);
            var topOffset = 0f;
@@ -109,6 +103,7 @@ namespace QuestPDF.Elements
                var elementOffset = ElementOffset();
                var leftOffset = AlignOffset();
                Canvas.Translate(new Position(leftOffset, 0));
                foreach (var measurement in lineMeasurements)
                {
@@ -118,16 +113,15 @@ namespace QuestPDF.Elements
                    if (size.Height == 0)
                        size = new Size(size.Width, lineSize.Height);
-                    var offset = ContentDirection == ContentDirection.LeftToRight
+                    Canvas.Translate(new Position(0, baselineOffset));
                        ? new Position(leftOffset, baselineOffset)
                        : new Position(availableSpace.Width - size.Width - leftOffset, baselineOffset);
                    Canvas.Translate(offset);
                    measurement.Element.Draw(size);
-                    Canvas.Translate(offset.Reverse());
+                    Canvas.Translate(new Position(0, -baselineOffset));
                    leftOffset += size.Width + elementOffset;
                    Canvas.Translate(new Position(size.Width + elementOffset, 0));
                }
                Canvas.Translate(new Position(-leftOffset, 0));
                float ElementOffset()
                {
@@ -146,15 +140,15 @@ namespace QuestPDF.Elements
                float AlignOffset()
                {
-                    var emptySpace = availableSpace.Width - lineSize.Width - (lineMeasurements.Count - 1) * HorizontalSpacing;
+                    var difference = availableSpace.Width - lineSize.Width - (lineMeasurements.Count - 1) * HorizontalSpacing;
                    return ElementsAlignment switch
                    {
-                        InlinedAlignment.Left => ContentDirection == ContentDirection.LeftToRight ? 0 : emptySpace,
+                        InlinedAlignment.Left => 0,
                        InlinedAlignment.Justify => 0,
                        InlinedAlignment.SpaceAround => elementOffset,
-                        InlinedAlignment.Center => emptySpace / 2,
+                        InlinedAlignment.Center => difference / 2,
-                        InlinedAlignment.Right => ContentDirection == ContentDirection.LeftToRight ? emptySpace : 0,
+                        InlinedAlignment.Right => difference,
                        _ => 0
                    };
                }
@@ -173,16 +167,6 @@ namespace QuestPDF.Elements
            }
        }
        void SetDefaultAlignment()
        {
            if (ElementsAlignment.HasValue)
                return;
            ElementsAlignment = ContentDirection == ContentDirection.LeftToRight
                ? InlinedAlignment.Left
                : InlinedAlignment.Right;
        }
        Size GetLineSize(ICollection<InlinedMeasurement> measurements)
        {
            var width = measurements.Sum(x => x.Size.Width);
@@ -228,7 +212,7 @@ namespace QuestPDF.Elements
                        break;
                    var element = queue.Peek();
-                    var size = element.Measure(new Size(availableSize.Width, Size.Max.Height));
+                    var size = element.Measure(Size.Max);
                    if (size.Type == SpacePlanType.Wrap)
                        break;
@@ -3,10 +3,8 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements
 {
-    internal class MinimalBox : ContainerElement, IContentDirectionAware
+    internal class MinimalBox : ContainerElement
    {
        public ContentDirection ContentDirection { get; set; }
        internal override void Draw(Size availableSpace)
        {
            var targetSize = base.Measure(availableSpace);
@@ -14,13 +12,7 @@ namespace QuestPDF.Elements
            if (targetSize.Type == SpacePlanType.Wrap)
                return;
            var translate = ContentDirection == ContentDirection.RightToLeft
                ? new Position(availableSpace.Width - targetSize.Width, 0)
                : Position.Zero;
            Canvas.Translate(translate);
            base.Draw(targetSize);
            Canvas.Translate(translate.Reverse());
        }
    }
 }
@@ -4,7 +4,7 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements
 {
-    internal class Padding : ContainerElement, ICacheable
+    internal class Padding : ContainerElement, ICacheable, ICollectable
    {
        public float Top { get; set; }
        public float Right { get; set; }
@@ -62,5 +62,15 @@ namespace QuestPDF.Elements
        {
            return $"Padding: Top({Top}) Right({Right}) Bottom({Bottom}) Left({Left})";
        }
        public override void Collect()
        {
            base.Collect();
            Left = 0;
            Right = 0;
            Bottom = 0;
            Top = 0;
        }
    }
 }
@@ -8,8 +8,7 @@ namespace QuestPDF.Elements
 {
    internal class Page : IComponent
    {
-        public ContentDirection ContentDirection { get; set; }
+        public TextStyle DefaultTextStyle { get; set; } = new TextStyle();
        public TextStyle DefaultTextStyle { get; set; } = TextStyle.Default;
        public Size MinSize { get; set; } = PageSizes.A4;
        public Size MaxSize { get; set; } = PageSizes.A4;
@@ -31,7 +30,6 @@ namespace QuestPDF.Elements
        public void Compose(IContainer container)
        {
            container
                .ContentDirection(ContentDirection)
                .Background(BackgroundColor)
                .Layers(layers =>
                {
@@ -25,7 +25,6 @@ namespace QuestPDF.Elements
                {
                    if (string.IsNullOrWhiteSpace(Text))
                        x.MaxHeight(32).Image(ImageData, ImageScaling.FitArea);
                    else
                        x.Text(Text).FontSize(14);
                });
@@ -31,10 +31,8 @@ namespace QuestPDF.Elements
        public Position Offset { get; set; }
    }
-    internal class Row : Element, ICacheable, IStateResettable, IContentDirectionAware
+    internal class Row : Element, ICacheable, IStateResettable, ICollectable
    {
        public ContentDirection ContentDirection { get; set; }
        internal List<RowItem> Items { get; } = new();
        internal float Spacing { get; set; }
@@ -93,13 +91,9 @@ namespace QuestPDF.Elements
                if (command.Measurement.Type == SpacePlanType.Wrap)
                    continue;
-                var offset = ContentDirection == ContentDirection.LeftToRight
+                Canvas.Translate(command.Offset);
                    ? command.Offset
                    : new Position(availableSpace.Width - command.Offset.X - command.Size.Width, 0);
                Canvas.Translate(offset);
                command.RowItem.Draw(command.Size);
-                Canvas.Translate(offset.Reverse());
+                Canvas.Translate(command.Offset.Reverse());
            }
            if (Items.All(x => x.IsRendered))
@@ -162,5 +156,10 @@ namespace QuestPDF.Elements
            return renderingCommands;
        }
        public void Collect()
        {
            Items.Clear();
        }
    }
 }
@@ -9,15 +9,12 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements.Table
 {
-    internal class Table : Element, IStateResettable, IContentDirectionAware
+    internal class Table : Element, IStateResettable
    {
-        public ContentDirection ContentDirection { get; set; }
+        public List<TableColumnDefinition> Columns { get; set; } = new List<TableColumnDefinition>();
-        
+        public List<TableCell> Cells { get; set; } = new List<TableCell>();
        public List<TableColumnDefinition> Columns { get; set; } = new();
        public List<TableCell> Cells { get; set; } = new();
        public bool ExtendLastCellsToTableBottom { get; set; }
        private bool CacheInitialized { get; set; }
        private int StartingRowsCount { get; set; }
        private int RowsCount { get; set; }
        private int CurrentRow { get; set; }
@@ -27,8 +24,17 @@ namespace QuestPDF.Elements.Table
        // inner table: list of all cells that ends at the corresponding row
        private TableCell[][] CellsCache { get; set; }
        private int MaxRow { get; set; }
        private int MaxRowSpan { get; set; }
        internal override void Initialize(IPageContext pageContext, ICanvas canvas)
        {
            StartingRowsCount = Cells.Select(x => x.Row).DefaultIfEmpty(0).Max();
            RowsCount = Cells.Select(x => x.Row + x.RowSpan - 1).DefaultIfEmpty(0).Max();
            Cells = Cells.OrderBy(x => x.Row).ThenBy(x => x.Column).ToList();
            BuildCache();
            base.Initialize(pageContext, canvas);
        }
        internal override IEnumerable<Element?> GetChildren()
        {
            return Cells;
@@ -36,26 +42,11 @@ namespace QuestPDF.Elements.Table
        public void ResetState()
        {
            Initialize();
            foreach (var x in Cells)
                x.IsRendered = false;
            CurrentRow = 1;
        }
        private void Initialize()
        {
            if (CacheInitialized)
                return;
            StartingRowsCount = Cells.Select(x => x.Row).DefaultIfEmpty(0).Max();
            RowsCount = Cells.Select(x => x.Row + x.RowSpan - 1).DefaultIfEmpty(0).Max();
            Cells = Cells.OrderBy(x => x.Row).ThenBy(x => x.Column).ToList();
            BuildCache();
            CacheInitialized = true;
        }
        private void BuildCache()
        {
@@ -65,7 +56,6 @@ namespace QuestPDF.Elements.Table
            if (Cells.Count == 0)
            {
                MaxRow = 0;
                MaxRowSpan = 1;
                CellsCache = Array.Empty<TableCell[]>();
                return;
@@ -76,7 +66,6 @@ namespace QuestPDF.Elements.Table
                .ToDictionary(x => x.Key, x => x.OrderBy(x => x.Column).ToArray());
            MaxRow = groups.Max(x => x.Key);
            MaxRowSpan = Cells.Max(x => x.RowSpan);
            CellsCache = Enumerable
                .Range(0, MaxRow + 1)
@@ -120,13 +109,9 @@ namespace QuestPDF.Elements.Table
                if (command.Measurement.Type == SpacePlanType.Wrap)
                    continue;
-                var offset = ContentDirection == ContentDirection.LeftToRight
+                Canvas.Translate(command.Offset);
                    ? command.Offset
                    : new Position(availableSpace.Width - command.Offset.X - command.Size.Width, command.Offset.Y);
                Canvas.Translate(offset);
                command.Cell.Draw(command.Size);
-                Canvas.Translate(offset.Reverse());
+                Canvas.Translate(command.Offset.Reverse());
            }
            CurrentRow = FindLastRenderedRow(renderingCommands) + 1;
@@ -173,7 +158,7 @@ namespace QuestPDF.Elements.Table
            if (ExtendLastCellsToTableBottom)
                AdjustLastCellSizes(tableHeight, commands);
-            
+
            return commands;
            static float[] GetColumnLeftOffsets(IList<TableColumnDefinition> columns)
@@ -214,9 +199,9 @@ namespace QuestPDF.Elements.Table
                        currentRow = cell.Row;
                    }
-                    
+
                    // cell visibility optimizations
-                    if (cell.Row > maxRenderingRow + MaxRowSpan)
+                    if (cell.Row > maxRenderingRow)
                        break;
                    // calculate cell position / size
@@ -233,14 +218,14 @@ namespace QuestPDF.Elements.Table
                    {
                        maxRenderingRow = Math.Min(maxRenderingRow, cell.Row + cell.RowSpan - 1);
                    }
-
+                    
                    // corner case: if cell within the row want to wrap to the next page, do not attempt to render this row
                    if (cellSize.Type == SpacePlanType.Wrap)
                    {
                        maxRenderingRow = Math.Min(maxRenderingRow, cell.Row - 1);
                        continue;
                    }
-
+                    
                    // update position of the last row that cell occupies
                    var bottomRow = cell.Row + cell.RowSpan - 1;
                    rowBottomOffsets[bottomRow] = Math.Max(rowBottomOffsets[bottomRow], topOffset + cellSize.Height);
@@ -1,160 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using QuestPDF.Drawing;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Elements.Text.Items;
 using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
 namespace QuestPDF.Elements.Text
 {
    internal static class FontFallback
    {
        public struct TextRun
        {
            public string Content { get; set; }
            public TextStyle Style { get; set; }
        }
        public class FallbackOption
        {
            public TextStyle Style { get; set; }
            public SKFont Font { get; set; }
            public SKTypeface Typeface { get; set; }
        }
        private static SKFontManager FontManager => SKFontManager.Default;
        public static IEnumerable<TextRun> SplitWithFontFallback(this string text, TextStyle textStyle)
        {
            var fallbackOptions = GetFallbackOptions(textStyle).ToArray();
            var spanStartIndex = 0;
            var spanFallbackOption = fallbackOptions[0];
            for (var i = 0; i < text.Length; i += char.IsSurrogatePair(text, i) ? 2 : 1)
            {
                var codepoint = char.ConvertToUtf32(text, i);
                var newFallbackOption = MatchFallbackOption(fallbackOptions, codepoint);
                if (newFallbackOption == spanFallbackOption)
                    continue;
                yield return new TextRun
                {
                    Content = text.Substring(spanStartIndex, i - spanStartIndex),
                    Style = spanFallbackOption.Style
                };
                spanStartIndex = i;
                spanFallbackOption = newFallbackOption;
            }
            if (spanStartIndex > text.Length)
                yield break;
            yield return new TextRun
            {
                Content = text.Substring(spanStartIndex, text.Length - spanStartIndex),
                Style = spanFallbackOption.Style
            };
            static IEnumerable<FallbackOption> GetFallbackOptions(TextStyle? textStyle)
            {
                while (textStyle != null)
                {
                    var font = textStyle.ToFont();
                    yield return new FallbackOption
                    {
                        Style = textStyle,
                        Font = font,
                        Typeface = font.Typeface
                    };
                    textStyle = textStyle.Fallback;
                }
            }
            static FallbackOption MatchFallbackOption(ICollection<FallbackOption> fallbackOptions, int codepoint)
            {
                foreach (var fallbackOption in fallbackOptions)
                {
                    if (fallbackOption.Font.ContainsGlyph(codepoint))
                        return fallbackOption;
                }
                throw CreateNotMatchingFontException(codepoint);
            }
            static Exception CreateNotMatchingFontException(int codepoint)
            {
                var character = char.ConvertFromUtf32(codepoint);
                var unicode = $"U-{codepoint:X4}";
                var proposedFonts = FindFontsContainingGlyph(codepoint);
                var proposedFontsFormatted = proposedFonts.Any() ? string.Join(", ", proposedFonts) : "no fonts available";
                return new DocumentDrawingException(
                    $"Could not find an appropriate font fallback for glyph: {unicode} '{character}'. " +
                    $"Font families available on current environment that contain this glyph: {proposedFontsFormatted}. " +
                    $"Possible solutions: " +
                    $"1) Use one of the listed fonts as the primary font in your document. " +
                    $"2) Configure the fallback TextStyle using the 'TextStyle.Fallback' method with one of the listed fonts. ");
            }
            static IEnumerable<string> FindFontsContainingGlyph(int codepoint)
            {
                var fontManager = SKFontManager.Default;
                return fontManager
                    .GetFontFamilies()
                    .Select(fontManager.MatchFamily)
                    .Where(x => x.ContainsGlyph(codepoint))
                    .Select(x => x.FamilyName);
            }
        }
        public static IEnumerable<ITextBlockItem> ApplyFontFallback(this ICollection<ITextBlockItem> textBlockItems)
        {
            foreach (var textBlockItem in textBlockItems)
            {
                if (textBlockItem is TextBlockPageNumber or TextBlockElement)
                {
                    yield return textBlockItem;
                }
                else if (textBlockItem is TextBlockSpan textBlockSpan)
                {
                    if (!Settings.CheckIfAllTextGlyphsAreAvailable && textBlockSpan.Style.Fallback == null)
                    {
                        yield return textBlockSpan;
                        continue;
                    }
                    var textRuns = textBlockSpan.Text.SplitWithFontFallback(textBlockSpan.Style);
                    foreach (var textRun in textRuns)
                    {
                        var newElement = textBlockSpan switch
                        {
                            TextBlockHyperlink hyperlink => new TextBlockHyperlink { Url = hyperlink.Url },
                            TextBlockSectionLink sectionLink => new TextBlockSectionLink { SectionName = sectionLink.SectionName },
                            TextBlockSpan => new TextBlockSpan()
                        };
                        newElement.Text = textRun.Content;
                        newElement.Style = textRun.Style;
                        yield return newElement;
                    }
                }
                else
                {
                    throw new NotSupportedException();
                }
            }
        }
    }
 }
@@ -12,7 +12,7 @@ namespace QuestPDF.Elements.Text.Items
        public TextMeasurementResult? Measure(TextMeasurementRequest request)
        {
            Element.VisitChildren(x => (x as IStateResettable)?.ResetState());
-            Element.InjectDependencies(request.PageContext, request.Canvas);
+            Element.VisitChildren(x => x.Initialize(request.PageContext, request.Canvas));
            var measurement = Element.Measure(new Size(request.AvailableWidth, Size.Max.Height));
@@ -37,7 +37,7 @@ namespace QuestPDF.Elements.Text.Items
        public void Draw(TextDrawingRequest request)
        {
            Element.VisitChildren(x => (x as IStateResettable)?.ResetState());
-            Element.InjectDependencies(request.PageContext, request.Canvas);
+            Element.VisitChildren(x => x.Initialize(request.PageContext, request.Canvas));
            request.Canvas.Translate(new Position(0, request.TotalAscent));
            Element.Draw(new Size(request.TextSize.Width, -request.TotalAscent));
@@ -15,7 +15,7 @@ namespace QuestPDF.Elements.Text.Items
    {
        public string Text { get; set; }
        public TextStyle Style { get; set; } = TextStyle.Default;
-        private TextShapingResult? TextShapingResult { get; set; }
+        public TextShapingResult? TextShapingResult { get; set; }
        private Dictionary<(int startIndex, float availableWidth), TextMeasurementResult?> MeasureCache = new ();
        protected virtual bool EnableTextCache => true; 
@@ -47,11 +47,11 @@ namespace QuestPDF.Elements.Text.Items
            // ignore leading spaces
            if (!request.IsFirstElementInBlock && request.IsFirstElementInLine)
            {
-                while (startIndex < TextShapingResult.Length && Text[startIndex] == spaceCodepoint)
+                while (startIndex < TextShapingResult.Glyphs.Length && Text[startIndex] == spaceCodepoint)
                    startIndex++;
            }
-            if (TextShapingResult.Length == 0 || startIndex == TextShapingResult.Length)
+            if (TextShapingResult.Glyphs.Length == 0 || startIndex == TextShapingResult.Glyphs.Length)
            {
                return new TextMeasurementResult
                {
@@ -90,7 +90,7 @@ namespace QuestPDF.Elements.Text.Items
                StartIndex = startIndex,
                EndIndex = wrappedText.Value.endIndex,
                NextIndex = wrappedText.Value.nextIndex,
-                TotalIndex = TextShapingResult.Length - 1
+                TotalIndex = TextShapingResult.Glyphs.Length - 1
            };
        }
@@ -102,7 +102,7 @@ namespace QuestPDF.Elements.Text.Items
            // textLength - length of the part of the text that fits in available width (creating a line)
            // entire text fits, no need to wrap
-            if (endIndex == TextShapingResult.Length - 1)
+            if (endIndex == TextShapingResult.Glyphs.Length - 1)
                return (endIndex, endIndex);
            // breaking anywhere
@@ -110,7 +110,7 @@ namespace QuestPDF.Elements.Text.Items
                return (endIndex, endIndex + 1);
            // current line ends at word, next character is space, perfect place to wrap
-            if (TextShapingResult[endIndex].Codepoint != spaceCodepoint && TextShapingResult[endIndex + 1].Codepoint == spaceCodepoint)
+            if (TextShapingResult.Glyphs[endIndex].Codepoint != spaceCodepoint && TextShapingResult.Glyphs[endIndex + 1].Codepoint == spaceCodepoint)
                return (endIndex, endIndex + 2);
            // find last space within the available text to wrap
@@ -118,7 +118,7 @@ namespace QuestPDF.Elements.Text.Items
            while (lastSpaceIndex >= startIndex)
            {
-                if (TextShapingResult[lastSpaceIndex].Codepoint == spaceCodepoint)
+                if (TextShapingResult.Glyphs[lastSpaceIndex].Codepoint == spaceCodepoint)
                    break;
                lastSpaceIndex--;
@@ -8,11 +8,9 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements.Text
 {
-    internal class TextBlock : Element, IStateResettable, IContentDirectionAware
+    internal class TextBlock : Element, IStateResettable, ICollectable
    {
-        public ContentDirection ContentDirection { get; set; }
+        public HorizontalAlignment Alignment { get; set; } = HorizontalAlignment.Left;
        public HorizontalAlignment? Alignment { get; set; }
        public List<ITextBlockItem> Items { get; set; } = new List<ITextBlockItem>();
        public string Text => string.Join(" ", Items.Where(x => x is TextBlockSpan).Cast<TextBlockSpan>().Select(x => x.Text));
@@ -20,11 +18,8 @@ namespace QuestPDF.Elements.Text
        private Queue<ITextBlockItem> RenderingQueue { get; set; }
        private int CurrentElementIndex { get; set; }
        private bool FontFallbackApplied { get; set; } = false;
        public void ResetState()
        {
            ApplyFontFallback();
            InitializeQueue();
            CurrentElementIndex = 0;
@@ -42,31 +37,15 @@ namespace QuestPDF.Elements.Text
                foreach (var item in Items)
                    RenderingQueue.Enqueue(item);
            }
            void ApplyFontFallback()
            {
                if (FontFallbackApplied)
                    return;
                Items = Items.ApplyFontFallback().ToList();
                FontFallbackApplied = true;
            }
        }
-        void SetDefaultAlignment()
+        public void Collect()
        {
-            if (Alignment.HasValue)
+            Items.Clear();
                return;
            Alignment = ContentDirection == ContentDirection.LeftToRight
                ? HorizontalAlignment.Left
                : HorizontalAlignment.Right;
        }
        internal override SpacePlan Measure(Size availableSpace)
        {
            SetDefaultAlignment();
            if (!RenderingQueue.Any())
                return SpacePlan.FullRender(Size.Zero);
@@ -94,19 +73,23 @@ namespace QuestPDF.Elements.Text
        internal override void Draw(Size availableSpace)
        {
            SetDefaultAlignment();
            var lines = DivideTextItemsIntoLines(availableSpace.Width, availableSpace.Height).ToList();
            if (!lines.Any())
                return;
-            var topOffset = 0f;
+            var heightOffset = 0f;
-
+            var widthOffset = 0f;
            foreach (var line in lines)
            {
-                var leftOffset = GetAlignmentOffset(line.Width);
+                widthOffset = 0f;
                var alignmentOffset = GetAlignmentOffset(line.Width);
                Canvas.Translate(new Position(alignmentOffset, 0));
                Canvas.Translate(new Position(0, -line.Ascent));
                foreach (var item in line.Elements)
                {
                    var textDrawingRequest = new TextDrawingRequest
@@ -121,20 +104,21 @@ namespace QuestPDF.Elements.Text
                        TotalAscent = line.Ascent
                    };
                    var canvasOffset = ContentDirection == ContentDirection.LeftToRight
                        ? new Position(leftOffset, topOffset - line.Ascent)
                        : new Position(availableSpace.Width - leftOffset - item.Measurement.Width, topOffset - line.Ascent);
                    Canvas.Translate(canvasOffset);
                    item.Item.Draw(textDrawingRequest);
                    Canvas.Translate(canvasOffset.Reverse());
                    leftOffset += item.Measurement.Width;
                }
-                topOffset += line.LineHeight;
+                    Canvas.Translate(new Position(item.Measurement.Width, 0));
                    widthOffset += item.Measurement.Width;
                }
                Canvas.Translate(new Position(-alignmentOffset, 0));
                Canvas.Translate(new Position(-line.Width, line.Ascent));
                Canvas.Translate(new Position(0, line.LineHeight));
                heightOffset += line.LineHeight;
            }
-
+            
            Canvas.Translate(new Position(0, -heightOffset));
            lines
                .SelectMany(x => x.Elements)
                .GroupBy(x => x.Item)
@@ -151,15 +135,18 @@ namespace QuestPDF.Elements.Text
            float GetAlignmentOffset(float lineWidth)
            {
                if (Alignment == HorizontalAlignment.Left)
                    return 0;
                var emptySpace = availableSpace.Width - lineWidth;
-                return Alignment switch
+                if (Alignment == HorizontalAlignment.Right)
-                {
+                    return emptySpace;
-                    HorizontalAlignment.Left => ContentDirection == ContentDirection.LeftToRight ? 0 : emptySpace,
+
-                    HorizontalAlignment.Center => emptySpace / 2,
+                if (Alignment == HorizontalAlignment.Center)
-                    HorizontalAlignment.Right => ContentDirection == ContentDirection.LeftToRight ? emptySpace : 0,
+                    return emptySpace / 2;
-                    _ => 0
+
-                };
+                throw new ArgumentException();
            }
        }
@@ -3,10 +3,8 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Elements
 {
-    internal class Unconstrained : ContainerElement, IContentDirectionAware, ICacheable
+    internal class Unconstrained : ContainerElement, ICacheable
    {
        public ContentDirection ContentDirection { get; set; }
        internal override SpacePlan Measure(Size availableSpace)
        {
            var childSize = base.Measure(Size.Max);
@@ -27,13 +25,7 @@ namespace QuestPDF.Elements
            if (measurement.Type == SpacePlanType.Wrap)
                return;
            var translate = ContentDirection == ContentDirection.RightToLeft
                ? new Position(-measurement.Width, 0)
                : Position.Zero;
            Canvas.Translate(translate);
            base.Draw(measurement);
            Canvas.Translate(translate.Reverse());
        }
    }
 }
@@ -1,4 +1,5 @@
 using System;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
@@ -8,7 +9,7 @@ namespace QuestPDF.Fluent
    {
        private static IContainer Border(this IContainer element, Action<Border> handler)
        {
-            var border = element as Border ?? new Border();
+            var border = element as Border ?? ElementCacheManager.Get<Border>();
            handler(border);
            return element.Element(border);
@@ -1,12 +1,14 @@
 using System;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using Container = System.ComponentModel.Container;
 namespace QuestPDF.Fluent
 {
    public class ColumnDescriptor
    {
-        internal Column Column { get; } = new();
+        internal Column Column { get; set; }
        public void Spacing(float value, Unit unit = Unit.Point)
        {
@@ -15,14 +17,9 @@ namespace QuestPDF.Fluent
        public IContainer Item()
        {
-            var container = new Container();
+            var columnItem = ElementCacheManager.Get<ColumnItem>();
-            
+            Column.Items.Add(columnItem);
-            Column.Items.Add(new ColumnItem
+            return columnItem;
            {
                Child = container
            });
            return container;
        }
    }
@@ -36,7 +33,8 @@ namespace QuestPDF.Fluent
        public static void Column(this IContainer element, Action<ColumnDescriptor> handler)
        {
-            var descriptor = new ColumnDescriptor();
+            var descriptor = ElementCacheManager.Get<ColumnDescriptor>();
            descriptor.Column = ElementCacheManager.Get<Column>();
            handler(descriptor);
            element.Element(descriptor.Column);
        }
@@ -1,26 +0,0 @@
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 namespace QuestPDF.Fluent
 {
    public static class ContentDirectionExtensions
    {
        internal static IContainer ContentDirection(this IContainer element, ContentDirection direction)
        {
            return element.Element(new ContentDirectionSetter
            {
                ContentDirection = direction
            });
        }
        public static IContainer ContentFromLeftToRight(this IContainer element)
        {
            return element.ContentDirection(Infrastructure.ContentDirection.LeftToRight);
        }
        public static IContainer ContentFromRightToLeft(this IContainer element)
        {
            return element.ContentDirection(Infrastructure.ContentDirection.RightToLeft);
        }
    }
 }
@@ -1,4 +1,5 @@
 using System;
 using QuestPDF.Drawing;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
@@ -52,10 +53,10 @@ namespace QuestPDF.Fluent
        public static IContainer Background(this IContainer element, string color)
        {
-            return element.Element(new Background
+            var background = ElementCacheManager.Get<Background>();
-            {
+            background.Color = color;
-                Color = color
+
-            });
+            return element.Element(background);
        }
        public static void Placeholder(this IContainer element, string? text = null)
@@ -162,7 +163,7 @@ namespace QuestPDF.Fluent
        public static IContainer MinimalBox(this IContainer element)
        {
-            return element.Element(new MinimalBox());
+            return element.Element(ElementCacheManager.Get<MinimalBox>());
        }
        public static IContainer Unconstrained(this IContainer element)
@@ -55,7 +55,6 @@ namespace QuestPDF.Fluent
    public static class GridExtensions
    {
        [Obsolete("This element has been deprecated since version 2022.11. Please use the Table element, or the combination of the Row and Column elements.")]
        public static void Grid(this IContainer element, Action<GridDescriptor> handler)
        {
            var descriptor = new GridDescriptor();
@@ -30,7 +30,6 @@ namespace QuestPDF.Fluent
        public void BaselineMiddle() => Inlined.BaselineAlignment = VerticalAlignment.Middle;
        public void BaselineBottom() => Inlined.BaselineAlignment = VerticalAlignment.Bottom;
        internal void Alignment(InlinedAlignment? alignment) => Inlined.ElementsAlignment = alignment;
        public void AlignLeft() => Inlined.ElementsAlignment = InlinedAlignment.Left;
        public void AlignCenter() => Inlined.ElementsAlignment = InlinedAlignment.Center;
        public void AlignRight() => Inlined.ElementsAlignment = InlinedAlignment.Right;
@@ -1,4 +1,5 @@
 using System;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
@@ -8,7 +9,7 @@ namespace QuestPDF.Fluent
    { 
        private static IContainer Padding(this IContainer element, Action<Padding> handler)
        {
-            var padding = element as Padding ?? new Padding();
+            var padding = element as Padding ?? ElementCacheManager.Get<Padding>();
            handler(padding);
            return element.Element(padding);
@@ -10,9 +10,7 @@ namespace QuestPDF.Fluent
    {
        internal Page Page { get; } = new Page();
-        #region Size
+        public void Size(float width, float height, Unit unit = Unit.Inch)
        public void Size(float width, float height, Unit unit = Unit.Point)
        {
            var pageSize = new PageSize(width, height, unit);
@@ -41,10 +39,6 @@ namespace QuestPDF.Fluent
        {
            Page.MaxSize = pageSize;
        }
        #endregion
        #region Margin
        public void MarginLeft(float value, Unit unit = Unit.Point)
        {
@@ -84,10 +78,6 @@ namespace QuestPDF.Fluent
            MarginHorizontal(value, unit);
        }
        #endregion
        #region Properties
        public void DefaultTextStyle(TextStyle textStyle)
        {
            Page.DefaultTextStyle = textStyle;
@@ -98,16 +88,6 @@ namespace QuestPDF.Fluent
            DefaultTextStyle(handler(TextStyle.Default));
        }
        public void ContentFromLeftToRight()
        {
            Page.ContentDirection = ContentDirection.LeftToRight;
        }
        public void ContentFromRightToLeft()
        {
            Page.ContentDirection = ContentDirection.RightToLeft;
        }
        public void PageColor(string color)
        {
            Page.BackgroundColor = color;
@@ -119,10 +99,6 @@ namespace QuestPDF.Fluent
            PageColor(color);
        }
        #endregion
        #region Slots
        public IContainer Background()
        {
            var container = new Container();
@@ -157,8 +133,6 @@ namespace QuestPDF.Fluent
            Page.Footer = container;
            return container;
        }
        #endregion
    }
    public static class PageExtensions
@@ -1,4 +1,5 @@
 using System;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
@@ -6,7 +7,7 @@ namespace QuestPDF.Fluent
 {
    public class RowDescriptor
    {
-        internal Row Row { get; } = new();
+        internal Row Row { get; set; } 
        public void Spacing(float value)
        {
@@ -15,14 +16,12 @@ namespace QuestPDF.Fluent
        private IContainer Item(RowItemType type, float size = 0)
        {
-            var element = new RowItem
+            var rowItem = ElementCacheManager.Get<RowItem>();
-            {
+            rowItem.Type = type;
-                Type = type,
+            rowItem.Size = size;
                Size = size
            };
-            Row.Items.Add(element);
+            Row.Items.Add(rowItem);
-            return element;
+            return rowItem;
        }
        [Obsolete("This element has been renamed since version 2022.2. Please use the RelativeItem method.")]
@@ -57,9 +56,12 @@ namespace QuestPDF.Fluent
    {
        public static void Row(this IContainer element, Action<RowDescriptor> handler)
        {
-            var descriptor = new RowDescriptor();
+            var descriptor = ElementCacheManager.Get<RowDescriptor>();
            descriptor.Row = ElementCacheManager.Get<Row>();
            handler(descriptor);
            element.Element(descriptor.Row);
            ElementCacheManager.Store(descriptor);
        }
    }
 }
@@ -36,7 +36,6 @@ namespace QuestPDF.Fluent
        internal TextPageNumberDescriptor(Action<TextStyle> assignTextStyle, Action<PageNumberFormatter> assignFormatFunction) : base(assignTextStyle)
        {
            AssignFormatFunction = assignFormatFunction;
            AssignFormatFunction(x => x?.ToString());
        }
        public TextPageNumberDescriptor Format(PageNumberFormatter formatter)
@@ -50,7 +49,7 @@ namespace QuestPDF.Fluent
    {
        private ICollection<TextBlock> TextBlocks { get; } = new List<TextBlock>();
        private TextStyle? DefaultStyle { get; set; }
-        internal HorizontalAlignment? Alignment { get; set; }
+        internal HorizontalAlignment Alignment { get; set; } = HorizontalAlignment.Left;
        private float Spacing { get; set; } = 0f;
        public void DefaultTextStyle(TextStyle style)
@@ -62,7 +61,7 @@ namespace QuestPDF.Fluent
        {
            DefaultStyle = style(TextStyle.Default);
        }
-  
+        
        public void AlignLeft()
        {
            Alignment = HorizontalAlignment.Left;
@@ -242,7 +241,7 @@ namespace QuestPDF.Fluent
        internal void Compose(IContainer container)
        {
-            TextBlocks.ToList().ForEach(x => x.Alignment ??= Alignment);
+            TextBlocks.ToList().ForEach(x => x.Alignment = Alignment);
            if (DefaultStyle != null)
                container = container.DefaultTextStyle(DefaultStyle);
@@ -15,17 +15,6 @@ namespace QuestPDF.Fluent
            return descriptor;
        }
        public static T Fallback<T>(this T descriptor, TextStyle? value = null) where T : TextSpanDescriptor
        {
            descriptor.TextStyle.Fallback = value;
            return descriptor;
        }
        public static T Fallback<T>(this T descriptor, Func<TextStyle, TextStyle> handler) where T : TextSpanDescriptor
        {
            return descriptor.Fallback(handler(TextStyle.Default));
        }
        public static T FontColor<T>(this T descriptor, string value) where T : TextSpanDescriptor
        {
            descriptor.MutateTextStyle(x => x.FontColor(value));
@@ -164,27 +153,5 @@ namespace QuestPDF.Fluent
        }
        #endregion
        #region Direction
        public static T DirectionAuto<T>(this T descriptor) where T : TextSpanDescriptor
        {
            descriptor.MutateTextStyle(x => x.DirectionAuto());
            return descriptor;
        }
        public static T DirectionFromLeftToRight<T>(this T descriptor) where T : TextSpanDescriptor
        {
            descriptor.MutateTextStyle(x => x.DirectionFromLeftToRight());
            return descriptor;
        }
        public static T DirectionFromRightToLeft<T>(this T descriptor) where T : TextSpanDescriptor
        {
            descriptor.MutateTextStyle(x => x.DirectionFromRightToLeft());
            return descriptor;
        }
        #endregion
    }
 }
@@ -4,6 +4,8 @@ using QuestPDF.Infrastructure;
 namespace QuestPDF.Fluent
 {
    public static class TextStyleExtensions
    {
        [Obsolete("This element has been renamed since version 2022.3. Please use the FontColor method.")]
@@ -129,7 +131,6 @@ namespace QuestPDF.Fluent
        #endregion
        #region Position
        public static TextStyle NormalPosition(this TextStyle style)
        {
            return style.Position(FontPosition.Normal);
@@ -149,45 +150,6 @@ namespace QuestPDF.Fluent
        {
            return style.Mutate(TextStyleProperty.FontPosition, fontPosition);
        }
        #endregion
        #region Fallback
        public static TextStyle Fallback(this TextStyle style, TextStyle? value = null)
        {
            return style.Mutate(TextStyleProperty.Fallback, value);
        }
        public static TextStyle Fallback(this TextStyle style, Func<TextStyle, TextStyle> handler)
        {
            return style.Fallback(handler(TextStyle.Default));
        }
        #endregion
        #region Direction
        private static TextStyle TextDirection(this TextStyle style, TextDirection textDirection)
        {
            return style.Mutate(TextStyleProperty.Direction, textDirection);
        }
        public static TextStyle DirectionAuto(this TextStyle style)
        {
            return style.TextDirection(Infrastructure.TextDirection.Auto);
        }
        public static TextStyle DirectionFromLeftToRight(this TextStyle style)
        {
            return style.TextDirection(Infrastructure.TextDirection.LeftToRight);
        }
        public static TextStyle DirectionFromRightToLeft(this TextStyle style)
        {
            return style.TextDirection(Infrastructure.TextDirection.RightToLeft);
        }
        #endregion
    }
 }
@@ -5,7 +5,7 @@ using QuestPDF.Elements;
 namespace QuestPDF.Infrastructure
 {
-    internal abstract class ContainerElement : Element, IContainer
+    internal abstract class ContainerElement : Element, IContainer, ICollectable
    {
        internal Element? Child { get; set; } = Empty.Instance;
@@ -34,5 +34,10 @@ namespace QuestPDF.Infrastructure
        {
            Child?.Draw(availableSpace);
        }
        public virtual void Collect()
        {
            Child = default;
        }
    }
 }
@@ -1,8 +0,0 @@
 namespace QuestPDF.Infrastructure
 {
    internal enum ContentDirection
    {
        LeftToRight,
        RightToLeft
    }
 }
@@ -15,6 +15,12 @@ namespace QuestPDF.Infrastructure
            yield break;
        }
        internal virtual void Initialize(IPageContext pageContext, ICanvas canvas)
        {
            PageContext = pageContext;
            Canvas = canvas;
        }
        internal virtual void CreateProxy(Func<Element?, Element?> create)
        {
@@ -0,0 +1,7 @@
 namespace QuestPDF.Infrastructure
 {
    public interface ICollectable
    {
        void Collect();
    }
 }
@@ -1,7 +0,0 @@
 namespace QuestPDF.Infrastructure
 {
    internal interface IContentDirectionAware
    {
        public ContentDirection ContentDirection { get; set; }
    }
 }
@@ -1,9 +0,0 @@
 namespace QuestPDF.Infrastructure
 {
    internal enum TextDirection
    {
        Auto,
        LeftToRight,
        RightToLeft
    }
 }
@@ -16,9 +16,6 @@ namespace QuestPDF.Infrastructure
        internal bool? HasStrikethrough { get; set; }
        internal bool? HasUnderline { get; set; }
        internal bool? WrapAnywhere { get; set; }
        internal TextDirection? Direction { get; set; }
        internal TextStyle? Fallback { get; set; }
        internal static TextStyle LibraryDefault { get; } = new()
        {
@@ -32,9 +29,7 @@ namespace QuestPDF.Infrastructure
            IsItalic = false,
            HasStrikethrough = false,
            HasUnderline = false,
-            WrapAnywhere = false,
+            WrapAnywhere = false
            Direction = TextDirection.Auto,
            Fallback = null
        };
        public static TextStyle Default { get; } = new();
@@ -16,16 +16,13 @@ namespace QuestPDF.Infrastructure
        IsItalic,
        HasStrikethrough,
        HasUnderline,
-        WrapAnywhere,
+        WrapAnywhere
        Fallback,
        Direction
    }
    internal static class TextStyleManager
    {
-        private static readonly ConcurrentDictionary<(TextStyle origin, TextStyleProperty property, object value), TextStyle> TextStyleMutateCache = new();
+        public static ConcurrentDictionary<(TextStyle origin, TextStyleProperty property, object value), TextStyle> TextStyleMutateCache = new();
-        private static readonly ConcurrentDictionary<(TextStyle origin, TextStyle parent), TextStyle> TextStyleApplyGlobalCache = new();
+        public static ConcurrentDictionary<(TextStyle origin, TextStyle parent, bool overrideValue), TextStyle> TextStyleApplyCache = new();
        private static readonly ConcurrentDictionary<(TextStyle origin, TextStyle parent), TextStyle> TextStyleOverrideCache = new();
        public static TextStyle Mutate(this TextStyle origin, TextStyleProperty property, object value)
        {
@@ -33,7 +30,7 @@ namespace QuestPDF.Infrastructure
            return TextStyleMutateCache.GetOrAdd(cacheKey, x => MutateStyle(x.origin, x.property, x.value));
        }
-        private static TextStyle MutateStyle(TextStyle origin, TextStyleProperty property, object? value, bool overrideValue = true)
+        private static TextStyle MutateStyle(TextStyle origin, TextStyleProperty property, object value, bool overrideValue = true)
        {
            if (overrideValue && value == null)
                return origin;
@@ -180,83 +177,38 @@ namespace QuestPDF.Infrastructure
                return origin with { WrapAnywhere = castedValue };
            }
            if (property == TextStyleProperty.Fallback)
            {
                if (!overrideValue && origin.Fallback != null)
                    return origin;
                var castedValue = (TextStyle?)value;
                if (origin.Fallback == castedValue)
                    return origin;
                return origin with { Fallback = castedValue };
            }
            if (property == TextStyleProperty.Direction)
            {
                if (!overrideValue && origin.Direction != null)
                    return origin;
                var castedValue = (TextDirection?)value;
                if (origin.Direction == castedValue)
                    return origin;
                return origin with { Direction = castedValue };
            }
            throw new ArgumentOutOfRangeException(nameof(property), property, "Expected to mutate the TextStyle object. Provided property type is not supported.");
        }
        internal static TextStyle ApplyGlobalStyle(this TextStyle style, TextStyle parent)
        {
-            var cacheKey = (style, parent);
+            var cacheKey = (style, parent, false);
-            return TextStyleApplyGlobalCache.GetOrAdd(cacheKey, key => ApplyStyle(key.origin, key.parent, overrideStyle: false).ApplyFontFallback());
+            return TextStyleApplyCache.GetOrAdd(cacheKey, key => ApplyStyle(key.origin, key.parent, key.overrideValue));
        }
        private static TextStyle ApplyFontFallback(this TextStyle style)
        {
            var targetFallbackStyle = style
                ?.Fallback
                ?.ApplyStyle(style, overrideStyle: false, applyFallback: false)
                ?.ApplyFontFallback();
            return MutateStyle(style, TextStyleProperty.Fallback, targetFallbackStyle);
        }
        internal static TextStyle OverrideStyle(this TextStyle style, TextStyle parent)
        {
-            var cacheKey = (style, parent);
+            var cacheKey = (style, parent, true);
-            
+            return TextStyleApplyCache.GetOrAdd(cacheKey, key => ApplyStyle(key.origin, key.parent, key.overrideValue));
            return TextStyleOverrideCache.GetOrAdd(cacheKey, key =>
            {
                var result = ApplyStyle(key.origin, key.parent);
                return MutateStyle(result, TextStyleProperty.Fallback, key.parent.Fallback);
            });
        }
-        private static TextStyle ApplyStyle(this TextStyle style, TextStyle parent, bool overrideStyle = true, bool applyFallback = true)
+        private static TextStyle ApplyStyle(TextStyle style, TextStyle parent, bool overrideValue)
        {
            var result = style;
-            result = MutateStyle(result, TextStyleProperty.Color, parent.Color, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.Color, parent.Color, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.BackgroundColor, parent.BackgroundColor, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.BackgroundColor, parent.BackgroundColor, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.FontFamily, parent.FontFamily, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.FontFamily, parent.FontFamily, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.Size, parent.Size, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.Size, parent.Size, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.LineHeight, parent.LineHeight, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.LineHeight, parent.LineHeight, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.FontWeight, parent.FontWeight, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.FontWeight, parent.FontWeight, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.FontPosition, parent.FontPosition, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.FontPosition, parent.FontPosition, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.IsItalic, parent.IsItalic, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.IsItalic, parent.IsItalic, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.HasStrikethrough, parent.HasStrikethrough, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.HasStrikethrough, parent.HasStrikethrough, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.HasUnderline, parent.HasUnderline, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.HasUnderline, parent.HasUnderline, overrideValue);
-            result = MutateStyle(result, TextStyleProperty.WrapAnywhere, parent.WrapAnywhere, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.WrapAnywhere, parent.WrapAnywhere, overrideValue);
            result = MutateStyle(result, TextStyleProperty.Direction, parent.Direction, overrideStyle);
            if (applyFallback)
                result = MutateStyle(result, TextStyleProperty.Fallback, parent.Fallback, overrideStyle);
            return result;
        }
    }
@@ -19,7 +19,7 @@ namespace QuestPDF.Previewer
        public  event Action? OnPreviewerStopped;
        private const int RequiredPreviewerVersionMajor = 2022;
-        private const int RequiredPreviewerVersionMinor = 11;
+        private const int RequiredPreviewerVersionMinor = 8;
        public PreviewerService(int port)
        {
@@ -3,7 +3,7 @@
        <Authors>MarcinZiabek</Authors>
        <Company>CodeFlint</Company>
        <PackageId>QuestPDF</PackageId>
-        <Version>2022.11.0-alpha1</Version>
+        <Version>2022.8.2</Version>
        <PackageDescription>QuestPDF is an open-source, modern and battle-tested library that can help you with generating PDF documents by offering friendly, discoverable and predictable C# fluent API.</PackageDescription>
        <PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/Resources/ReleaseNotes.txt"))</PackageReleaseNotes>
        <LangVersion>9</LangVersion>
@@ -21,7 +21,7 @@ Install-Package QuestPDF
 dotnet add package QuestPDF
 // Package reference in .csproj file
-<PackageReference Include="QuestPDF" Version="2022.11.0" />
+<PackageReference Include="QuestPDF" Version="2022.3.0" />
 ```
 ## Documentation
@@ -1,3 +1,20 @@
-Added support for the right-to-left content direction.
+2022.8.0:
-Fixed: word-wrapping algorithm does not work correctly with right-to-left languages.
+
-Fixed: Page.Size() API incorrectly uses Unit.Inch as default unit. Replaced with Unit.Point for consistency.
+- Improved library performance,
 - Breaking change: changed default font from Calibri to an open-source Lato,
 - Default font files are included with the nuget package, making it safe to deploy on any environment,
 - Default font files are significantly smaller, so output document files should be smaller too (up to 20x reduction in size),
 - When requested font is not available on the runtime environment, library provides list of available fonts,
 - Fixed a rare layout overflow exception with the Inlined element,
 - Fixed a memory leak connected to the HarfBuzz library.
 2022.8.1:
 - Fixed: default text style does not always work
 - Fixed: page breaking rendering does not work in very specific corner cases
 - Stability improvements for text wrapping
 - Updated stability of rendering elements in negative space
 - Optimization for the Column element: do not measure child when available height is negative
 2022.8.2
 - Fixed: the Column element incorrectly renders zero-height elements.
@@ -3,7 +3,7 @@
    public static class Settings
    {
        /// <summary>
-        /// This value represents the maximum length of the document that the library produces.
+        /// This value represents the maximum lenght of the document that the library produces.
        /// This is useful when layout constraints are too strong, e.g. one element does not fit in another.
        /// In such cases, the library would produce document of infinite length, consuming all available resources.
        /// To break the algorithm and save the environment, the library breaks the rendering process after reaching specified length of document.
@@ -35,6 +35,6 @@
        /// However, it provides hints that used fonts are not sufficient to produce correct results.
        /// </summary>
        /// <remarks>By default, this flag is enabled only when the debugger IS attached.</remarks>
-        public static bool CheckIfAllTextGlyphsAreAvailable { get; set; } = System.Diagnostics.Debugger.IsAttached;
+        public static bool CheckIfAllTextGlyphsAreAvailableInSpecifiedFont { get; set; } = System.Diagnostics.Debugger.IsAttached;
    }
 }
@@ -17,14 +17,13 @@ It offers a layouting engine designed with a full paging support in mind. The do
 Unlike other libraries, it does not rely on the HTML-to-PDF conversion which in many cases is not reliable. Instead, it implements its own layouting engine that is optimized to cover all paging-related requirements.
-## Please help by giving a star
+## Please show the value
 Choosing a project dependency could be difficult. We need to ensure stability and maintainability of our projects. Surveys show that GitHub stars count play an important factor when assessing library quality. 
 ⭐ Please give this repository a star. It takes seconds and help thousands of developers! ⭐
-<img src="https://user-images.githubusercontent.com/9263853/190931857-8ca52ec8-cc7d-4d12-9467-4442b3342fa1.png" width="700" />
+<img src="https://user-images.githubusercontent.com/9263853/184642026-27dd7567-a46a-45d4-9594-e6a70a7193e9.png" width="700" />
 ## Please share with the community
@@ -47,7 +46,6 @@ Special thanks to all companies that decided to sponsor QuestPDF development. Th
 | Company                                                                              | Description                                                                                                                     |
 |--------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------|
 | <img src="Resources/jetbrains-logo.svg" width="100px"> | [JetBrains](https://www.jetbrains.com/) supports this project as part of the OSS Power-Ups program. Thank you!<br/>100$ / month |
 | <img src="https://avatars.githubusercontent.com/u/2712328?v=4" width="100px"> | [Mark Gould](https://github.com/markgould) supports this project. Thank you!<br/>100$ / month |
 [![Sponsor project](https://img.shields.io/badge/%E2%9D%A4%EF%B8%8F%20sponsor-QuestPDF-red)](https://github.com/sponsors/QuestPDF)
@@ -63,14 +61,14 @@ Install-Package QuestPDF
 dotnet add package QuestPDF
 // Package reference in .csproj file
-<PackageReference Include="QuestPDF" Version="2022.9.0" />
+<PackageReference Include="QuestPDF" Version="2022.6.0" />
 ```
 [![Nuget version](https://img.shields.io/badge/package%20details-QuestPDF-blue?logo=nuget)](https://www.nuget.org/packages/QuestPDF/)
 ## Documentation
-[![Getting started tutorial]( https://img.shields.io/badge/%F0%9F%9A%80%20read-getting%20started-blue)](https://www.questpdf.com/getting-started)
+[![Getting started tutorial]( https://img.shields.io/badge/%F0%9F%9A%80%20read-getting%20started-blue)](https://www.questpdf.com/getting-started.html)
 A short and easy to follow tutorial showing how to design an invoice document under 200 lines of code.
@@ -78,14 +76,14 @@ A short and easy to follow tutorial showing how to design an invoice document un
 A detailed description of behavior of all available components and how to use them with C# Fluent API.
-[![Patterns and Practices](https://img.shields.io/badge/%E2%9C%A8%20read-patterns%20and%20practices-blue)](https://www.questpdf.com/design-patterns)
+[![Patterns and Practices](https://img.shields.io/badge/%E2%9C%A8%20read-patterns%20and%20practices-blue)](https://www.questpdf.com/design-patterns.html)
 Everything that may help you designing great reports and create reusable code that is easy to maintain.
 ## QuestPDF Previewer
 The QuestPDF Previewer is a tool designed to simplify and speed up your development lifecycle. First, it shows a preview of your document. But the real magic starts with the hot-reload capability! It observes your code and updates the preview every time you change the implementation. Get real-time results without the need of code recompilation. Save time and enjoy the task!
-[![Learn more](https://img.shields.io/badge/%F0%9F%93%96%20Previewer-learn%20more-blue)](https://www.questpdf.com/document-previewer)
+[![Learn more](https://img.shields.io/badge/%F0%9F%93%96%20Previewer-learn%20more-blue)](https://www.questpdf.com/document-previewer.html)
 <img src="https://github.com/QuestPDF/QuestPDF-Documentation/blob/main/docs/public/previewer/animation.gif?raw=true" width="100%">