Added more examples for the Shrink element

2022.9 Release

QuestPDF.Examples/DynamicFibonacci.cs

@@ -0,0 +1,106 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public struct FibonacciHeaderState
+    {
+        public int Previous { get; set; }
+        public int Current { get; set; }
+    }
+    
+    public class FibonacciHeader : IDynamicComponent<FibonacciHeaderState>
+    {
+        public FibonacciHeaderState State { get; set; }
+        
+        public static readonly string[] ColorsTable =
+        {
+            Colors.Red.Lighten2,
+            Colors.Orange.Lighten2,
+            Colors.Green.Lighten2,
+        };
+
+        public FibonacciHeader(int previous, int current)
+        {
+            State = new FibonacciHeaderState
+            {
+                Previous = previous,
+                Current = current
+            };
+        }
+
+        public DynamicComponentComposeResult Compose(DynamicContext context)
+        {
+            var content = context.CreateElement(container =>
+            {
+                var colorIndex = State.Current % ColorsTable.Length;
+                var color = ColorsTable[colorIndex];
+
+                var ratio = (float)State.Current / State.Previous;
+                
+                container
+                    .Background(color)
+                    .Height(50)
+                    .AlignMiddle()
+                    .AlignCenter()
+                    .Text($"{State.Current} / {State.Previous} = {ratio:N5}");
+            });
+
+            State = new FibonacciHeaderState
+            {
+                Previous = State.Current,
+                Current = State.Previous + State.Current
+            };
+            
+            return new DynamicComponentComposeResult
+            {
+                Content = content,
+                HasMoreContent = false
+            };
+        }
+    }
+    
+    public static class DynamicFibonacci
+    {
+        [Test]
+        public static void Dynamic()
+        {
+            RenderingTest
+                .Create()
+                .ShowResults()
+                .MaxPages(100)
+                .ProduceImages()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Size(PageSizes.A6);
+                        page.PageColor(Colors.White);
+                        page.Margin(1, Unit.Centimetre);
+                        page.DefaultTextStyle(x => x.FontSize(18));
+
+                        page.Header().Dynamic(new FibonacciHeader(17, 19));
+                        
+                        page.Content().Column(column =>
+                        {
+                            foreach (var i in Enumerable.Range(0, 50))
+                                column.Item().PaddingTop(25).Background(Colors.Grey.Lighten2).Height(50);
+                        });
+                        
+                        page.Footer().AlignCenter().Text(text =>
+                        {
+                            text.CurrentPageNumber();
+                            text.Span(" / ");
+                            text.TotalPages();
+                        });
+                    });
+                });
+        }
+    }
+}

QuestPDF.Examples/DynamicOptimizedExample.cs

@@ -0,0 +1,185 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class OrderItem
+    {
+        public string ItemName { get; set; } = Placeholders.Label();
+        public int Price { get; set; } = Placeholders.Random.Next(1, 11) * 10;
+        public int Count { get; set; } = Placeholders.Random.Next(1, 11);
+    }
+
+    public struct OrdersTableState
+    {
+        public int ShownItemsCount { get; set; }
+    }
+    
+    public class OptimizedOrdersTable : IDynamicComponent<OrdersTableState>
+    {
+        private ICollection<OrderItem> Items { get; }
+        public OrdersTableState State { get; set; }
+
+        public OptimizedOrdersTable(ICollection<OrderItem> items)
+        {
+            Items = items;
+
+            State = new OrdersTableState
+            {
+                ShownItemsCount = 0
+            };
+        }
+        
+        public DynamicComponentComposeResult Compose(DynamicContext context)
+        {
+            var header = ComposeHeader(context);
+            var sampleFooter = ComposeFooter(context, Enumerable.Empty<OrderItem>());
+            var decorationHeight = header.Size.Height + sampleFooter.Size.Height;
+            
+            var rows = GetItemsForPage(context, decorationHeight).ToList();
+            var footer = ComposeFooter(context, rows.Select(x => x.Item));
+
+            var content = context.CreateElement(container =>
+            {
+                container.MinimalBox().Decoration(decoration =>
+                {
+                    decoration.Header().Element(header);
+
+                    decoration.Content().Box().Stack(stack =>
+                    {
+                        foreach (var row in rows)
+                            stack.Item().Element(row.Element);
+                    });
+
+                    decoration.Footer().Element(footer);
+                });
+            });
+
+            State = new OrdersTableState
+            {
+                ShownItemsCount = State.ShownItemsCount + rows.Count
+            };
+
+            return new DynamicComponentComposeResult
+            {
+                Content = content,
+                HasMoreContent = State.ShownItemsCount < Items.Count
+            };
+        }
+
+        private IDynamicElement ComposeHeader(DynamicContext context)
+        {
+            return context.CreateElement(element =>
+            {
+                element
+                    .Width(context.AvailableSize.Width)
+                    .BorderBottom(1)
+                    .BorderColor(Colors.Grey.Darken2)
+                    .Padding(5)
+                    .Row(row =>
+                    {
+                        var textStyle = TextStyle.Default.SemiBold();
+
+                        row.ConstantItem(30).Text("#", textStyle);
+                        row.RelativeItem().Text("Item name", textStyle);
+                        row.ConstantItem(50).AlignRight().Text("Count", textStyle);
+                        row.ConstantItem(50).AlignRight().Text("Price", textStyle);
+                        row.ConstantItem(50).AlignRight().Text("Total", textStyle);
+                    });
+            });
+        }
+        
+        private IDynamicElement ComposeFooter(DynamicContext context, IEnumerable<OrderItem> items)
+        {
+            var total = items.Sum(x => x.Count * x.Price);
+
+            return context.CreateElement(element =>
+            {
+                element
+                    .Width(context.AvailableSize.Width)
+                    .Padding(5)
+                    .AlignRight()
+                    .Text($"Subtotal: {total}$", TextStyle.Default.Size(14).SemiBold());
+            });
+        }
+        
+        private IEnumerable<(OrderItem Item, IDynamicElement Element)> GetItemsForPage(DynamicContext context, float decorationHeight)
+        {
+            var totalHeight = decorationHeight;
+
+            foreach (var index in Enumerable.Range(State.ShownItemsCount, Items.Count - State.ShownItemsCount))
+            {
+                var item = Items.ElementAt(index);
+                
+                var element = context.CreateElement(content =>
+                {
+                    content
+                        .Width(context.AvailableSize.Width)
+                        .BorderBottom(1)
+                        .BorderColor(Colors.Grey.Lighten2)
+                        .Padding(5)
+                        .Row(row =>
+                        {
+                            row.ConstantItem(30).Text(index + 1);
+                            row.RelativeItem().Text(item.ItemName);
+                            row.ConstantItem(50).AlignRight().Text(item.Count);
+                            row.ConstantItem(50).AlignRight().Text($"{item.Price}$");
+                            row.ConstantItem(50).AlignRight().Text($"{item.Count*item.Price}$");
+                        });
+                });
+
+                var elementHeight = element.Size.Height;
+                    
+                if (totalHeight + elementHeight > context.AvailableSize.Height)
+                    break;
+                    
+                totalHeight += elementHeight;
+                yield return (item, element);
+            }
+        }
+    }
+    
+    public static class DynamicOptimizedExamples
+    {
+        [Test]
+        public static void Dynamic()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A5)
+                .ShowResults()
+                .Render(container =>
+                {
+                    var items = Enumerable.Range(0, 25).Select(x => new OrderItem()).ToList();
+                    
+                    container
+                        .Background(Colors.White)
+                        .Padding(25)
+                        .Decoration(decoration =>
+                        {
+                            decoration
+                                .Header()
+                                .PaddingBottom(5)
+                                .Text(text =>
+                                {
+                                    text.DefaultTextStyle(TextStyle.Default.SemiBold().FontColor(Colors.Blue.Darken2).FontSize(16));
+                                    text.Span("Page ");
+                                    text.CurrentPageNumber();
+                                    text.Span(" of ");
+                                    text.TotalPages();
+                                });
+                            
+                            decoration
+                                .Content()
+                                .Dynamic(new OptimizedOrdersTable(items));
+                        });
+                });
+        }
+    }
+}

QuestPDF.Examples/DynamicPageNumberLeftRight.cs

@@ -0,0 +1,69 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class FooterWithAlternatingAlignment : IDynamicComponent<int>
+    {
+        public int State { get; set; }
+        
+        public DynamicComponentComposeResult Compose(DynamicContext context)
+        {
+            var content = context.CreateElement(element =>
+            {
+                element
+                    .Element(x => context.PageNumber % 2 == 0 ? x.AlignLeft() : x.AlignRight())
+                    .Text(x =>
+                    {
+                        x.CurrentPageNumber();
+                        x.Span(" / ");
+                        x.TotalPages();
+                    });
+            });
+            
+            return new DynamicComponentComposeResult()
+            {
+                Content = content,
+                HasMoreContent = false
+            };
+        }
+    }
+    
+    public static class DynamicPageNumberLeftRightExamples
+    {
+        [Test]
+        public static void Dynamic()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A5)
+                .MaxPages(100)
+                .ShowResults()
+                .ProduceImages()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Size(PageSizes.A6);
+                        page.PageColor(Colors.White);
+                        page.Margin(1, Unit.Centimetre);
+                        page.DefaultTextStyle(x => x.FontSize(18));
+
+                        page.Content().Column(column =>
+                        {
+                            foreach (var i in Enumerable.Range(0, 50))
+                                column.Item().PaddingTop(25).Background(Colors.Grey.Lighten2).Height(50);
+                        });
+                        
+                        page.Footer().Dynamic(new FooterWithAlternatingAlignment());
+                    });
+                });
+        }
+    }
+}

QuestPDF.Examples/DynamicProgressHeader.cs

@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class ProgressHeader : IDynamicComponent<int>
+    {
+        public int State { get; set; }
+        
+        public DynamicComponentComposeResult Compose(DynamicContext context)
+        {
+            var content = context.CreateElement(container =>
+            {
+                var width = context.AvailableSize.Width * context.PageNumber / context.TotalPages;
+                
+                container
+                    .Background(Colors.Blue.Lighten2)
+                    .Height(25)
+                    .Width(width)
+                    .Background(Colors.Blue.Darken1);
+            });
+
+            return new DynamicComponentComposeResult
+            {
+                Content = content,
+                HasMoreContent = false
+            };
+        }
+    }
+    
+    public static class DynamicProgressHeader
+    {
+        [Test]
+        public static void Dynamic()
+        {
+            RenderingTest
+                .Create()
+                .ShowResults()
+                .MaxPages(100)
+                .ProduceImages()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Size(PageSizes.A6);
+                        page.Margin(1, Unit.Centimetre);
+                        page.PageColor(Colors.White);
+                        page.DefaultTextStyle(x => x.FontSize(20));
+
+                        page.Header().Dynamic(new ProgressHeader());
+                        
+                        page.Content().Column(column =>
+                        {
+                            foreach (var i in Enumerable.Range(0, 100))
+                                column.Item().PaddingTop(25).Background(Colors.Grey.Lighten2).Height(50);
+                        });
+
+                        page.Footer().AlignCenter().Text(text =>
+                        {
+                            text.DefaultTextStyle(x => x.FontSize(20));
+                            
+                            text.CurrentPageNumber();
+                            text.Span(" / ");
+                            text.TotalPages();
+                        });
+                    });
+                });
+        }
+    }
+}

QuestPDF.Examples/DynamicSimpleTableExample.cs

@@ -0,0 +1,157 @@
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class OrdersTable : IDynamicComponent<OrdersTableState>
+    {
+        private IList<OrderItem> Items { get; }
+        public OrdersTableState State { get; set; }
+
+        public OrdersTable(IList<OrderItem> items)
+        {
+            Items = items;
+
+            State = new OrdersTableState
+            {
+                ShownItemsCount = 0
+            };
+        }
+        
+        public DynamicComponentComposeResult Compose(DynamicContext context)
+        {
+            var possibleItems = Enumerable
+                .Range(1, Items.Count - State.ShownItemsCount)
+                .Select(itemsToDisplay => ComposeContent(context, itemsToDisplay))
+                .TakeWhile(x => x.Size.Height <= context.AvailableSize.Height)
+                .ToList();
+
+            State = new OrdersTableState
+            {
+                ShownItemsCount = State.ShownItemsCount + possibleItems.Count
+            };
+
+            return new DynamicComponentComposeResult
+            {
+                Content = possibleItems.Last(),
+                HasMoreContent = State.ShownItemsCount < Items.Count
+            };
+        }
+
+        private IDynamicElement ComposeContent(DynamicContext context, int itemsToDisplay)
+        {
+            var total = Items.Skip(State.ShownItemsCount).Take(itemsToDisplay).Sum(x => x.Count * x.Price);
+
+            return context.CreateElement(container =>
+            {
+                container
+                    .MinimalBox()
+                    .Width(context.AvailableSize.Width)
+                    .Table(table =>
+                    {
+                        table.ColumnsDefinition(columns =>
+                        {
+                            columns.ConstantColumn(30);
+                            columns.RelativeColumn();
+                            columns.ConstantColumn(50);
+                            columns.ConstantColumn(50);
+                            columns.ConstantColumn(50);
+                        });
+                        
+                        table.Header(header =>
+                        {
+                            header.Cell().Element(Style).Text("#");
+                            header.Cell().Element(Style).Text("Item name");
+                            header.Cell().Element(Style).AlignRight().Text("Count");
+                            header.Cell().Element(Style).AlignRight().Text("Price");
+                            header.Cell().Element(Style).AlignRight().Text("Total");
+
+                            IContainer Style(IContainer container)
+                            {
+                                return container
+                                    .DefaultTextStyle(x => x.SemiBold())
+                                    .BorderBottom(1)
+                                    .BorderColor(Colors.Grey.Darken2)
+                                    .Padding(5);
+                            }
+                        });
+                        
+                        table.Footer(footer =>
+                        {
+                            footer
+                                .Cell().ColumnSpan(5)
+                                .AlignRight()
+                                .PaddingTop(10)
+                                .Text($"Subtotal: {total}$", TextStyle.Default.Bold());
+                        });
+                        
+                        foreach (var index in Enumerable.Range(State.ShownItemsCount, itemsToDisplay))
+                        {
+                            var item = Items[index];
+                                
+                            table.Cell().Element(Style).Text(index + 1);
+                            table.Cell().Element(Style).Text(item.ItemName);
+                            table.Cell().Element(Style).AlignRight().Text(item.Count);
+                            table.Cell().Element(Style).AlignRight().Text($"{item.Price}$");
+                            table.Cell().Element(Style).AlignRight().Text($"{item.Count*item.Price}$");
+
+                            IContainer Style(IContainer container)
+                            {
+                                return container
+                                    .BorderBottom(1)
+                                    .BorderColor(Colors.Grey.Lighten2)
+                                    .Padding(5);
+                            }
+                        }
+                    });
+            });
+        }
+    }
+    
+    public static class DynamicSimpleTableExample
+    {
+        [Test]
+        public static void Dynamic()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A5)
+                .ShowResults()
+                .ProduceImages()
+                .Render(container =>
+                {
+                    var items = Enumerable.Range(0, 15).Select(x => new OrderItem()).ToList();
+                    
+                    container
+                        .Background(Colors.White)
+                        .Padding(25)
+                        .DefaultTextStyle(x => x.FontSize(16))
+                        .Decoration(decoration =>
+                        {
+                            decoration
+                                .Header()
+                                .PaddingBottom(5)
+                                .Text(text =>
+                                {
+                                    text.DefaultTextStyle(TextStyle.Default.SemiBold().FontColor(Colors.Blue.Darken2));
+                                    text.Span("Page ");
+                                    text.CurrentPageNumber();
+                                    text.Span(" / ");
+                                    text.TotalPages();
+                                });
+                            
+                            decoration
+                                .Content()
+                                .Dynamic(new OrdersTable(items));
+                        });
+                });
+        }
+    }
+}

QuestPDF.Examples/GenerationBenchmark.cs

@@ -0,0 +1,146 @@
+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
+            };
+        }
+    }
+}

QuestPDF.Examples/GridBenchmark.cs

@@ -0,0 +1,42 @@
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+
+namespace QuestPDF.Examples
+{
+    public class GridBenchmark
+    {
+        [Test]
+        public void Benchmark()
+        {
+            RenderingTest
+                .Create()
+                .ProducePdf()
+                .PageSize(PageSizes.A4)
+                .ShowResults()
+                .MaxPages(10_000)
+                .EnableCaching(true)
+                .EnableDebugging(false)
+                .Render(container =>
+                {
+                    container
+                        .Padding(10)
+                        .MinimalBox()
+                        .Border(1)
+                        .Grid(grid =>
+                        {
+                            const int numberOfRows = 100_000;
+                            const int numberOfColumns = 10;
+                            
+                            grid.Columns(numberOfColumns);
+                            
+                            foreach (var row in Enumerable.Range(0, numberOfRows))
+                            foreach (var column in Enumerable.Range(0, numberOfColumns))
+                                grid.Item().Background(Placeholders.BackgroundColor()).Padding(5).Text($"{row}_{column}");
+                        });
+                });
+        }
+    }
+}

QuestPDF.Examples/QuestPDF.Examples.csproj

@@ -6,12 +6,12 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+        <PackageReference Include="BenchmarkDotNet" Version="0.13.2" />
         <PackageReference Include="microcharts" Version="0.9.5.9" />
-        <PackageReference Include="nunit" Version="3.13.2" />
-        <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
-        <PackageReference Include="SkiaSharp" Version="2.80.3" />
+        <PackageReference Include="nunit" Version="3.13.3" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.1" />
+        <PackageReference Include="SkiaSharp" Version="2.80.4" />
         <PackageReference Include="Svg.Skia" Version="0.5.10" />
     </ItemGroup>
 

QuestPDF.Examples/RelativePaddingExamples.cs

@@ -0,0 +1,36 @@
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+
+namespace QuestPDF.Examples
+{
+    public class RelativePaddingExamples
+    {
+        [Test]
+        public void ItemTypes()
+        {
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .PageSize(250, 250)
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Width(250)
+                        .Height(250)
+                            
+                        .Padding(50)
+                        .Background(Colors.Grey.Lighten2)
+                        
+                        .RelativePaddingLeft(0.1f)
+                        .RelativePaddingTop(0.2f)
+                        .RelativePaddingRight(0.3f)
+                        .RelativePaddingBottom(0.4f)
+                        
+                        .Background(Colors.Grey.Darken2);
+                });
+        }
+    }
+}

QuestPDF.Examples/RelativePositionExamples.cs

@@ -0,0 +1,32 @@
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+
+namespace QuestPDF.Examples
+{
+    public class RelativePositionExamples
+    {
+        [Test]
+        public void ItemTypes()
+        {
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .PageSize(500, 500)
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(100)
+                        .Background(Colors.Grey.Lighten2)
+                        .RelativePositionVertical(0.5f, -0.5f)
+                        .RelativePositionHorizontal(1f, -0.5f)
+                        .RelativeWidth(0.4f)
+                        .RelativeHeight(0.6f)
+                        .Background(Colors.Grey.Darken2);
+                });
+        }
+    }
+}

QuestPDF.Examples/RelativeSizeExamples.cs

@@ -0,0 +1,38 @@
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+
+namespace QuestPDF.Examples
+{
+    public class RelativeSizeExamples
+    {
+        [Test]
+        public void ItemTypes()
+        {
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .PageSize(600, 600)
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .AlignMiddle()
+                        .AlignCenter()
+                        .Width(400)
+                        .Height(400)
+                        .Background(Colors.Grey.Lighten2)
+                        .AlignMiddle()
+                        .AlignCenter()
+                        .Container()
+                        .AlignMiddle()
+                        .AlignCenter()
+                        .RelativeWidth(0.25f)
+                        .RelativeHeight(0.5f)
+                        .Background(Colors.Grey.Darken2);
+                });
+        }
+    }
+}

QuestPDF.Examples/ShrinkExamples.cs

@@ -0,0 +1,93 @@
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+
+namespace QuestPDF.Examples
+{
+    public class ShrinkExamples
+    {
+        [Test]
+        public void Shrink_Without()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 200)
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Border(2)
+                        .Background(Colors.Grey.Lighten2)
+                        .Padding(20)
+                        .Text("This is test.")
+                        .FontSize(20);
+                });
+        }
+        
+        [Test]
+        public void Shrink_Horizontal()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 200)
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Border(2)
+                        .ShrinkHorizontal()
+                        .Background(Colors.Grey.Lighten2)
+                        .Padding(20)
+                        .Text("This is test.")
+                        .FontSize(20);
+                });
+        }
+        
+        [Test]
+        public void Shrink_Vertical()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 200)
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Border(2)
+                        .ShrinkVertical()
+                        .Background(Colors.Grey.Lighten2)
+                        .Padding(20)
+                        .Text("This is test.")
+                        .FontSize(20);
+                });
+        }
+        
+        [Test]
+        public void Shrink_Both()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 200)
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Border(2)
+                        .Shrink()
+                        .Background(Colors.Grey.Lighten2)
+                        .Padding(20)
+                        .Text("This is test.")
+                        .FontSize(20);
+                });
+        }
+    }
+}

QuestPDF.Examples/TableBenchmark.cs

@@ -0,0 +1,46 @@
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+
+namespace QuestPDF.Examples
+{
+    public class TableBenchmark
+    {
+        [Test]
+        public void Benchmark()
+        {
+            RenderingTest
+                .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))
+                            foreach (var column in Enumerable.Range(0, numberOfColumns))
+                                table.Cell().Background(Placeholders.BackgroundColor()).Padding(5).Text($"{row}_{column}");
+                        });
+                });
+        }
+    }
+}

QuestPDF.Examples/TextBenchmark.cs

@@ -31,7 +31,7 @@ namespace QuestPDF.Examples
         {
             var chapters = GetBookChapters().ToList();
   
-            var results = PerformTest(16).ToList();
+            var results = PerformTest(128).ToList();
  
             Console.WriteLine($"Min: {results.Min():F}");
             Console.WriteLine($"Max: {results.Max():F}");
@@ -111,7 +111,7 @@ namespace QuestPDF.Examples
             {
                 page.Margin(50);
                 
-                page.Content().Column(column =>
+                page.Content().PaddingVertical(10).Column(column =>
                 {
                     column.Item().Element(Title);
                     column.Item().PageBreak();

QuestPDF.Examples/TextExamples.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Text;
 using NUnit.Framework;
+using QuestPDF.Elements.Text;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
@@ -12,11 +13,11 @@ namespace QuestPDF.Examples
     public class TextExamples
     {
         [Test]
-        public void SimpleTextBlock()
+        public void SimpleText()
         {
             RenderingTest
                 .Create()
-                .PageSize(500, 300)
+                .PageSize(500, 100)
                 
                 .ProduceImages()
                 .ShowResults()
@@ -27,6 +28,27 @@ namespace QuestPDF.Examples
                         .MinimalBox()
                         .Border(1)
                         .Padding(10)
+                        .Text(Placeholders.Paragraph());
+                });
+        }
+        
+        [Test]
+        public void SimpleTextBlock()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(600, 300)
+                
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(5)
+                        .MinimalBox()
+                        .Border(1)
+                        .MaxWidth(300)
+                        .Padding(10)
                         .Text(text =>
                         {
                             text.DefaultTextStyle(TextStyle.Default.FontSize(20));
@@ -36,13 +58,162 @@ namespace QuestPDF.Examples
                         });
                 });
         }
+
+        [Test]
+        public void TextWeight()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 500)
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .MinimalBox()
+                        .Border(1)
+                        .Padding(20)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(x => x.FontFamily(Fonts.Calibri).FontSize(20));
+
+                            text.Line("Thin").Thin();
+                            text.Line("ExtraLight").ExtraLight();
+                            text.Line("Light").Light();
+                            text.Line("NormalWeight").NormalWeight();
+                            text.Line("Medium").Medium();
+                            text.Line("SemiBold").SemiBold();
+                            text.Line("Bold").Bold();
+                            text.Line("ExtraBold").ExtraBold();
+                            text.Line("Black").Black();
+                            text.Line("ExtraBlack").ExtraBlack();
+                        });
+                });
+        }
         
+        [Test]
+        public void LineHeight()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 700)
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Column(column =>
+                        {
+                            var lineHeights = new[] { 0.8f, 1f, 1.5f };
+                            var paragraph = Placeholders.Paragraph();
+
+                            foreach (var lineHeight in lineHeights)
+                            {
+                                column
+                                    .Item()
+                                    .Border(1)
+                                    .Padding(10)
+                                    .Text(paragraph)
+                                    .FontSize(16)
+                                    .LineHeight(lineHeight);
+                            }
+                        });
+                });
+        }
+        
+        [Test]
+        public void SuperscriptSubscript_Simple()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 500)
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .MinimalBox()
+                        .Border(1)
+                        .Padding(20)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(x => x.FontSize(20));
+                            text.ParagraphSpacing(10);
+
+                            var highlight = TextStyle.Default.BackgroundColor(Colors.Green.Lighten3);
+
+                            text.Span("E=mc").Style(highlight);
+                            text.Span("2").Superscript().Style(highlight);
+                            text.Span(" is the equation of mass–energy equivalence.");
+
+                            text.EmptyLine();
+                            
+                            text.Span("H").Style(highlight);
+                            text.Span("2").Subscript().Style(highlight);
+                            text.Span("O").Style(highlight);
+                            text.Span(" is the chemical formula for water.");
+                        });
+                });
+        }
+
+        [Test]
+        public void SuperscriptSubscript_Effects()
+        {
+            RenderingTest
+               .Create()
+               .PageSize(800, 400)
+               .ProduceImages()
+               .ShowResults()
+               .Render(container =>
+               {
+                   container
+                        .Padding(25)
+                        .DefaultTextStyle(x => x.FontSize(30))
+                        .Column(column =>
+                        {
+                            column.Spacing(25);
+                            
+                            column.Item().Text(text =>
+                            {
+                                text.DefaultTextStyle(x => x.Underline());
+                                
+                                text.Span("Underline of the superscript (E = mc");
+                                text.Span("2").Superscript();
+                                text.Span(") should be at the same height as for normal text.");
+                            });
+                            
+                            column.Item().Text(text =>
+                            {
+                                text.DefaultTextStyle(x => x.Underline());
+                                
+                                text.Span("Underline of the subscript(H");
+                                text.Span("2").Subscript();
+                                text.Span("O) should be slightly lower than a normal text.");
+                            });
+                            
+                            column.Item().Text(text =>
+                            {
+                                text.DefaultTextStyle(x => x.Strikethrough());
+                                
+                                text.Span("Strikethrough of both superscript (E=mc");
+                                text.Span("2").Superscript();
+                                text.Span(") and subscript(H");
+                                text.Span("2").Subscript();
+                                text.Span("O) should be visible in the middle of the text.");
+                            });
+                        });
+               });
+        }
+
         [Test]
         public void ParagraphSpacing()
         {
             RenderingTest
                 .Create()
-                .PageSize(500, 300)
+                .PageSize(500, 500)
                 .ProduceImages()
                 .ShowResults()
                 .Render(container =>
@@ -54,13 +225,7 @@ namespace QuestPDF.Examples
                         .Padding(10)
                         .Text(text =>
                         {
-                            text.ParagraphSpacing(10);
-    
-                            foreach (var i in Enumerable.Range(1, 3))
-                            {
-                                text.Span($"Paragraph {i}: ").SemiBold();
-                                text.Line(Placeholders.Paragraph());
-                            }
+                            text.Line(Placeholders.Paragraph());
                         });
                 });
         }
@@ -239,7 +404,7 @@ namespace QuestPDF.Examples
                         .Padding(10)
                         .Text(text =>
                         {
-                            text.DefaultTextStyle(TextStyle.Default.FontSize(20));
+                            text.DefaultTextStyle(TextStyle.Default.FontSize(20).BackgroundColor(Colors.Red.Lighten4));
                             text.AlignLeft();
                             text.ParagraphSpacing(10);
 
@@ -258,7 +423,7 @@ namespace QuestPDF.Examples
                             {
                                 text.Line($"{i}: {Placeholders.Paragraph()}");
 
-                                text.Hyperlink("Please visit QuestPDF website", "https://www.questpdf.com");
+                                text.Hyperlink("Please visit QuestPDF website. ", "https://www.questpdf.com");
                                 
                                 text.Span("This is page number ");
                                 text.CurrentPageNumber();
@@ -397,11 +562,100 @@ namespace QuestPDF.Examples
                                 text.DefaultTextStyle(x => x.BackgroundColor(Colors.Red.Lighten3).FontSize(24));
                                 
                                 text.Span("       " + Placeholders.LoremIpsum());
-                                text.Span(" 0123456789012345678901234567890123456789012345678901234567890123456789         ").WrapAnywhere();
+                                text.Span(" 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789         ").WrapAnywhere();
                             });
                         });
                     });
                 });
         }
+        
+        [Test]
+        public void TextShaping_Unicode()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(600, 100)
+                
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(35)
+                        .MinimalBox()
+                        .Background(Colors.Grey.Lighten2)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default.FontSize(20));
+                            
+                            text.Span("Complex Unicode structure: ");
+                            
+                            
+                            text.Span("T̶̖̔͆͆̽̔ḩ̷̼̫̐̈́̀͜͝͝ì̶͇̤͓̱̣͇͓͉̎s̵̡̟̹͍̜͉̗̾͛̈̐́͋͂͝͠ͅ ̴̨͙͍͇̭̒͗̀́͝ì̷̡̺͉̼̏̏̉̌͝s̷͍͙̗̰̖͙̈̑̂̔͑͊̌̓̊̇͜ ̶̛̼͚͊̅͘ṭ̷̨̘̣̙̖͉͌̏̂̅͑̄̽̕͝ȅ̶̲̲̙̭͈̬̣͔̝͔̈́͝s̸̢̯̪̫͓̭̮̓̀͆͜ț̸̢͉̞̥̤̏̌̓͝").FontFamily(Fonts.Calibri).FontColor(Colors.Red.Medium);
+                            
+                            
+                            text.Span(".");
+                        });
+                });
+        }
+        
+        [Test]
+        public void TextShaping_Arabic()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 100)
+                
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .MinimalBox()
+                        .Background(Colors.Grey.Lighten2)
+                        .Text("ينا الألم. في بعض الأحيان ونظراً للالتزامات التي يفرضها علينا")
+                        .FontFamily(Fonts.Calibri)
+                        .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: 😊😅🥳👍❤😍👌");
+                        });
+                    });
+                });
+        }
     }
 }

QuestPDF.Previewer.Examples/Program.cs

@@ -2,13 +2,14 @@
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 using QuestPDF.Previewer;
+using QuestPDF.ReportSample;
 using QuestPDF.ReportSample.Layouts;
 
 //ImagePlaceholder.Solid = true;
 
 // var model = DataSource.GetReport();
 // var report = new StandardReport(model);
-// report.ShowInPreviewer().Wait();
+// report.ShowInPreviewer();
 //
 // return;
 

QuestPDF.Previewer/CommunicationService.cs

@@ -1,5 +1,6 @@
 using System.Text.Json;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -29,6 +30,7 @@ class CommunicationService
     {
         var builder = WebApplication.CreateBuilder();
         builder.Services.AddLogging(x => x.ClearProviders());
+        builder.WebHost.UseKestrel(options => options.Limits.MaxRequestBodySize = null);
         Application = builder.Build();
 
         Application.MapGet("ping", HandlePing);

QuestPDF.Previewer/Helpers.cs

@@ -8,16 +8,13 @@ class Helpers
     {
         using var stream = File.Create(filePath);
             
-        var document = SKDocument.CreatePdf(stream);
+        using var document = SKDocument.CreatePdf(stream);
             
         foreach (var page in pages)
         {
             using var canvas = document.BeginPage(page.Width, page.Height);
             canvas.DrawPicture(page.Picture);
             document.EndPage();
-            canvas.Dispose();
         }
-        
-        document.Close();
     }
 }

QuestPDF.Previewer/PreviewerApp.axaml

@@ -1,6 +1,7 @@
 <Application x:Class="QuestPDF.Previewer.PreviewerApp"
              xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             Name="QuestPDF Document Preview">
 	<Application.Styles>
 		<FluentTheme Mode="Dark" />
 	</Application.Styles>

QuestPDF.Previewer/PreviewerWindowViewModel.cs

@@ -49,7 +49,7 @@ namespace QuestPDF.Previewer
             CommunicationService.Instance.OnDocumentRefreshed += HandleUpdatePreview;
             
             ShowPdfCommand = ReactiveCommand.Create(ShowPdf);
-            ShowDocumentationCommand = ReactiveCommand.Create(() => OpenLink("https://www.questpdf.com/documentation/api-reference.html"));
+            ShowDocumentationCommand = ReactiveCommand.Create(() => OpenLink("https://www.questpdf.com/api-reference/index.html"));
             SponsorProjectCommand = ReactiveCommand.Create(() => OpenLink("https://github.com/sponsors/QuestPDF"));
         }
 
@@ -63,7 +63,7 @@ namespace QuestPDF.Previewer
         
         private void OpenLink(string path)
         {
-            var openBrowserProcess = new Process
+            using var openBrowserProcess = new Process
             {
                 StartInfo = new()
                 {

QuestPDF.Previewer/QuestPDF.Previewer.csproj

@@ -4,7 +4,7 @@
         <Authors>MarcinZiabek</Authors>
         <Company>CodeFlint</Company>
         <PackageId>QuestPDF.Previewer</PackageId>
-        <Version>2022.4.1</Version>
+        <Version>2022.9.1</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>
@@ -48,7 +48,8 @@
         <PackageReference Include="Avalonia.Markup.Xaml.Loader" Version="0.10.10" />
         <PackageReference Include="Avalonia.ReactiveUI" Version="0.10.10" />
         <PackageReference Include="ReactiveUI" Version="17.1.50" />
+        <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.80.4" />
         <PackageReference Include="System.Reactive" Version="5.0.0" />
-        <PackageReference Include="SkiaSharp" Version="2.80.3" />
+        <PackageReference Include="SkiaSharp" Version="2.80.4" />
     </ItemGroup>
 </Project>

QuestPDF.ReportSample/Layouts/StandardReport.cs

@@ -55,7 +55,7 @@ namespace QuestPDF.ReportSample.Layouts
                     row.Spacing(50);
                     
                     row.RelativeItem().PaddingTop(-10).Text(Model.Title).Style(Typography.Title);
-                    row.ConstantItem(90).ExternalLink("https://www.questpdf.com").MaxHeight(30).Component<ImagePlaceholder>();
+                    row.ConstantItem(90).Hyperlink("https://www.questpdf.com").MaxHeight(30).Component<ImagePlaceholder>();
                 });
 
                 column.Item().ShowOnce().PaddingVertical(15).Border(1f).BorderColor(Colors.Grey.Lighten1).ExtendHorizontal();
@@ -88,14 +88,14 @@ namespace QuestPDF.ReportSample.Layouts
                 column.Item().PageBreak();
                 
                 foreach (var section in Model.Sections)
-                    column.Item().Location(section.Title).Component(new SectionTemplate(section));
+                    column.Item().Section(section.Title).Component(new SectionTemplate(section));
                 
                 column.Item().PageBreak();
-                column.Item().Location("Photos");
+                column.Item().Section("Photos");
                 
                 foreach (var photo in Model.Photos)
                     column.Item().Component(new PhotoTemplate(photo));
             });
         }
     }
-}
+}

QuestPDF.ReportSample/Layouts/TableOfContentsTemplate.cs

@@ -3,6 +3,7 @@ using System.Drawing;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
+using SkiaSharp;
 
 namespace QuestPDF.ReportSample.Layouts
 {
@@ -41,18 +42,31 @@ namespace QuestPDF.ReportSample.Layouts
         private void DrawLink(IContainer container, int number, string locationName)
         {
             container
-                .InternalLink(locationName)
+                .SectionLink(locationName)
                 .Row(row =>
                 {
-                    row.ConstantItem(25).Text($"{number}.");
-                    row.RelativeItem().Text(locationName);
-                    row.ConstantItem(150).AlignRight().Text(text =>
+                    row.ConstantItem(20).Text($"{number}.");
+                    row.AutoItem().Text(locationName);
+                    
+                    row.RelativeItem().PaddingHorizontal(2).AlignBottom().TranslateY(-3).Height(1).Canvas((canvas, space) =>
+                    {
+                        // best to statically cache
+                        using var paint = new SKPaint
+                        {
+                            StrokeWidth = space.Height,
+                            PathEffect = SKPathEffect.CreateDash(new float[] { 1, 3 }, 0)
+                        };
+                        
+                        canvas.DrawLine(0, 0, space.Width, 0, paint);
+                    });
+                    
+                    row.AutoItem().Text(text =>
                     {
                         text.BeginPageNumberOfSection(locationName);
                         text.Span(" - ");
                         text.EndPageNumberOfSection(locationName);
 
-                        var lengthStyle = TextStyle.Default.Color(Colors.Grey.Medium);
+                        var lengthStyle = TextStyle.Default.FontColor(Colors.Grey.Medium);
                         
                         text.Span(" (").Style(lengthStyle);
                         text.TotalPagesWithinSection(locationName).Style(lengthStyle).Format(x => x == 1 ? "1 page long" : $"{x} pages long");
@@ -61,4 +75,4 @@ namespace QuestPDF.ReportSample.Layouts
                 });
         }
     }
-}
+}

QuestPDF.ReportSample/PerformanceTests.cs

@@ -51,7 +51,7 @@ namespace QuestPDF.ReportSample
             Content = documentContainer.Compose();
 
             PageContext = new PageContext();
-            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, Metadata, null);
+            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, null);
 
             var sw = new Stopwatch();
             sw.Start();
@@ -69,7 +69,7 @@ namespace QuestPDF.ReportSample
         [Benchmark]
         public void GenerationTest()
         {
-            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, Metadata, null);
+            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, null);
         }
     }
 }

QuestPDF.ReportSample/QuestPDF.ReportSample.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>netcoreapp3.1</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
         <IsPackable>false</IsPackable>
         <LangVersion>8</LangVersion>
         <RootNamespace>QuestPDF.ReportSample</RootNamespace>
@@ -12,7 +12,7 @@
         <PackageReference Include="nunit" Version="3.13.2" />
         <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-        <PackageReference Include="SkiaSharp" Version="2.80.3" />
+        <PackageReference Include="SkiaSharp" Version="2.80.4" />
     </ItemGroup>
 
     <ItemGroup>

QuestPDF.ReportSample/Tests.cs

@@ -48,11 +48,10 @@ namespace QuestPDF.ReportSample
             Report.Compose(container);
             var content = container.Compose();
             
-            var metadata = Report.GetMetadata();
             var pageContext = new PageContext();
 
-            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, metadata, null);
-            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, metadata, null);
+            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, null);
+            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, null);
         }
     }
 }

QuestPDF.ReportSample/Typography.cs

@@ -6,8 +6,8 @@ namespace QuestPDF.ReportSample
 {
     public static class Typography
     {
-        public static TextStyle Title => TextStyle.Default.FontType(Fonts.Calibri).Color(Colors.Blue.Darken3).Size(26).Black();
-        public static TextStyle Headline => TextStyle.Default.FontType(Fonts.Calibri).Color(Colors.Blue.Medium).Size(16).SemiBold();
-        public static TextStyle Normal => TextStyle.Default.FontType(Fonts.Verdana).Color(Colors.Black).Size(10).LineHeight(1.2f);
+        public static TextStyle Title => TextStyle.Default.FontFamily(Fonts.Lato).FontColor(Colors.Blue.Darken3).FontSize(26).Black();
+        public static TextStyle Headline => TextStyle.Default.FontFamily(Fonts.Lato).FontColor(Colors.Blue.Medium).FontSize(16).SemiBold();
+        public static TextStyle Normal => TextStyle.Default.FontFamily(Fonts.Lato).FontColor(Colors.Black).FontSize(10).LineHeight(1.2f);
     }
-}
+}

QuestPDF.UnitTests/QuestPDF.UnitTests.csproj

@@ -6,11 +6,11 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="FluentAssertions" Version="6.1.0" />
+        <PackageReference Include="FluentAssertions" Version="6.7.0" />
         <PackageReference Include="nunit" Version="3.13.2" />
         <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
-        <PackageReference Include="SkiaSharp" Version="2.80.3" />
+        <PackageReference Include="SkiaSharp" Version="2.80.4" />
     </ItemGroup>
 
     <ItemGroup>

QuestPDF.UnitTests/ShrinkTests.cs

@@ -7,18 +7,20 @@ using QuestPDF.UnitTests.TestEngine;
 namespace QuestPDF.UnitTests
 {
     [TestFixture]
-    public class BoxTests
+    public class ShrinkTests
     {
         [Test]
-        public void Measure() => SimpleContainerTests.Measure<MinimalBox>();
+        public void Measure() => SimpleContainerTests.Measure<Shrink>();
         
         [Test]
         public void Draw_Wrap()
         {
             TestPlan
-                .For(x => new MinimalBox
+                .For(x => new Shrink
                 {
-                    Child = x.CreateChild()
+                    Child = x.CreateChild(),
+                    ShrinkVertical = true,
+                    ShrinkHorizontal = true
                 })
                 .DrawElement(new Size(400, 300))
                 .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.Wrap())
@@ -29,9 +31,11 @@ namespace QuestPDF.UnitTests
         public void Measure_PartialRender()
         {
             TestPlan
-                .For(x => new MinimalBox
+                .For(x => new Shrink
                 {
-                    Child = x.CreateChild()
+                    Child = x.CreateChild(),
+                    ShrinkVertical = true,
+                    ShrinkHorizontal = true
                 })
                 .MeasureElement(new Size(400, 300))
                 .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.PartialRender(200, 100))
@@ -43,9 +47,11 @@ namespace QuestPDF.UnitTests
         public void Measure_FullRender()
         {
             TestPlan
-                .For(x => new MinimalBox
+                .For(x => new Shrink
                 {
-                    Child = x.CreateChild()
+                    Child = x.CreateChild(),
+                    ShrinkVertical = true,
+                    ShrinkHorizontal = true
                 })
                 .MeasureElement(new Size(500, 400))
                 .ExpectChildMeasure(expectedInput: new Size(500, 400), returns: SpacePlan.FullRender(300, 200))

QuestPDF.UnitTests/TestEngine/MockCanvas.cs

@@ -1,4 +1,5 @@
 using System;
+using QuestPDF.Drawing;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
 
@@ -10,7 +11,6 @@ namespace QuestPDF.UnitTests.TestEngine
         public Action<float> RotateFunc { get; set; }
         public Action<float, float> ScaleFunc { get; set; }
         public Action<SKImage, Position, Size> DrawImageFunc { get; set; }
-        public Action<string, Position, TextStyle> DrawTextFunc { get; set; }
         public Action<Position, Size, string> DrawRectFunc { get; set; }
 
         public void Translate(Position vector) => TranslateFunc(vector);
@@ -18,7 +18,7 @@ namespace QuestPDF.UnitTests.TestEngine
         public void Scale(float scaleX, float scaleY) => ScaleFunc(scaleX, scaleY);
 
         public void DrawRectangle(Position vector, Size size, string color) => DrawRectFunc(vector, size, color);
-        public void DrawText(string text, Position position, TextStyle style) => DrawTextFunc(text, position, style);
+        public void DrawText(SKTextBlob skTextBlob, Position position, TextStyle style) => throw new NotImplementedException();
         public void DrawImage(SKImage image, Position position, Size size) => DrawImageFunc(image, position, size);
 
         public void DrawHyperlink(string url, Size size) => throw new NotImplementedException();

QuestPDF.UnitTests/TestEngine/OperationRecordingCanvas.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using QuestPDF.Drawing;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine.Operations;
 using SkiaSharp;
@@ -15,7 +16,7 @@ namespace QuestPDF.UnitTests.TestEngine
         public void Scale(float scaleX, float scaleY) => Operations.Add(new CanvasScaleOperation(scaleX, scaleY));
 
         public void DrawRectangle(Position vector, Size size, string color) => Operations.Add(new CanvasDrawRectangleOperation(vector, size, color));
-        public void DrawText(string text, Position position, TextStyle style) => Operations.Add(new CanvasDrawTextOperation(text, position, style));
+        public void DrawText(SKTextBlob skTextBlob, Position position, TextStyle style) => throw new NotImplementedException();
         public void DrawImage(SKImage image, Position position, Size size) => Operations.Add(new CanvasDrawImageOperation(position, size));
         
         public void DrawHyperlink(string url, Size size) => throw new NotImplementedException();

QuestPDF.UnitTests/TestEngine/TestPlan.cs

@@ -82,19 +82,6 @@ namespace QuestPDF.UnitTests.TestEngine
                     
                     Assert.AreEqual(expected.Color, color, "Draw rectangle: color");
                 },
-                DrawTextFunc = (text, position, style) => 
-                {
-                    var expected = GetExpected<CanvasDrawTextOperation>();
-                    
-                    Assert.AreEqual(expected.Text, text);
-                    
-                    Assert.AreEqual(expected.Position.X, position.X, "Draw text: X");
-                    Assert.AreEqual(expected.Position.Y, position.Y, "Draw text: Y");
-                    
-                    Assert.AreEqual(expected.Style.Color, style.Color, "Draw text: color");
-                    Assert.AreEqual(expected.Style.FontFamily, style.FontFamily, "Draw text: font");
-                    Assert.AreEqual(expected.Style.Size, style.Size, "Draw text: size");
-                },
                 DrawImageFunc = (image, position, size) =>
                 {
                     var expected = GetExpected<CanvasDrawImageOperation>();
@@ -201,11 +188,6 @@ namespace QuestPDF.UnitTests.TestEngine
             return AddOperation(new CanvasDrawRectangleOperation(position, size, color));
         }
         
-        public TestPlan ExpectCanvasDrawText(string text, Position position, TextStyle style)
-        {
-            return AddOperation(new CanvasDrawTextOperation(text, position, style));
-        }
-        
         public TestPlan ExpectCanvasDrawImage(Position position, Size size)
         {
             return AddOperation(new CanvasDrawImageOperation(position, size));

QuestPDF/Drawing/DocumentGenerator.cs

@@ -66,19 +66,17 @@ namespace QuestPDF.Drawing
             var content = container.Compose();
             ApplyDefaultTextStyle(content, TextStyle.LibraryDefault);
             
-            var metadata = document.GetMetadata();
-            var pageContext = new PageContext();
-
-            var debuggingState = metadata.ApplyDebugging ? ApplyDebugging(content) : null;
+            var debuggingState = Settings.EnableDebugging ? ApplyDebugging(content) : null;
             
-            if (metadata.ApplyCaching)
+            if (Settings.EnableCaching)
                 ApplyCaching(content);
 
-            RenderPass(pageContext, new FreeCanvas(), content, metadata, debuggingState);
-            RenderPass(pageContext, canvas, content, metadata, debuggingState);
+            var pageContext = new PageContext();
+            RenderPass(pageContext, new FreeCanvas(), content, debuggingState);
+            RenderPass(pageContext, canvas, content, debuggingState);
         }
         
-        internal static void RenderPass<TCanvas>(PageContext pageContext, TCanvas canvas, Container content, DocumentMetadata documentMetadata, DebuggingState? debuggingState)
+        internal static void RenderPass<TCanvas>(PageContext pageContext, TCanvas canvas, Container content, DebuggingState? debuggingState)
             where TCanvas : ICanvas, IRenderingCanvas
         {
             content.VisitChildren(x => x?.Initialize(pageContext, canvas));
@@ -114,7 +112,7 @@ namespace QuestPDF.Drawing
 
                 canvas.EndPage();
 
-                if (currentPage >= documentMetadata.DocumentLayoutExceptionThreshold)
+                if (currentPage >= Settings.DocumentLayoutExceptionThreshold)
                 {
                     canvas.EndDocument();
                     ThrowLayoutException();
@@ -131,15 +129,14 @@ namespace QuestPDF.Drawing
             void ThrowLayoutException()
             {
                 var message = $"Composed layout generates infinite document. This may happen in two cases. " +
-                              $"1) Your document and its layout configuration is correct but the content takes more than {documentMetadata.DocumentLayoutExceptionThreshold} pages. " +
-                              $"In this case, please increase the value {nameof(DocumentMetadata)}.{nameof(DocumentMetadata.DocumentLayoutExceptionThreshold)} property configured in the {nameof(IDocument.GetMetadata)} method. " +
+                              $"1) Your document and its layout configuration is correct but the content takes more than {Settings.DocumentLayoutExceptionThreshold} pages. " +
+                              $"In this case, please increase the value {nameof(QuestPDF)}.{nameof(Settings)}.{nameof(Settings.DocumentLayoutExceptionThreshold)} static property. " +
                               $"2) The layout configuration of your document is invalid. Some of the elements require more space than is provided." +
                               $"Please analyze your documents structure to detect this element and fix its size constraints.";
-                
-                throw new DocumentLayoutException(message)
-                {
-                    ElementTrace = debuggingState?.BuildTrace() ?? "Debug trace is available only in the DEBUG mode."
-                };
+
+                var elementTrace = debuggingState?.BuildTrace() ?? "Debug trace is available only in the DEBUG mode.";
+
+                throw new DocumentLayoutException(message, elementTrace);
             }
         }
 
@@ -164,7 +161,7 @@ namespace QuestPDF.Drawing
             return debuggingState;
         }
 
-        private static void ApplyDefaultTextStyle(this Element? content, TextStyle documentDefaultTextStyle)
+        internal static void ApplyDefaultTextStyle(this Element? content, TextStyle documentDefaultTextStyle)
         {
             if (content == null)
                 return;
@@ -175,7 +172,7 @@ namespace QuestPDF.Drawing
                 {
                     if (textBlockItem is TextBlockSpan textSpan)
                     {
-                        textSpan.Style.ApplyGlobalStyle(documentDefaultTextStyle);
+                        textSpan.Style = textSpan.Style.ApplyGlobalStyle(documentDefaultTextStyle);
                     }
                     else if (textBlockItem is TextBlockElement textElement)
                     {
@@ -186,16 +183,14 @@ namespace QuestPDF.Drawing
                 return;
             }
 
-            var targetTextStyle = documentDefaultTextStyle;
+            if (content is DynamicHost dynamicHost)
+                dynamicHost.TextStyle = dynamicHost.TextStyle.ApplyGlobalStyle(documentDefaultTextStyle);
             
             if (content is DefaultTextStyle defaultTextStyleElement)
-            {
-                defaultTextStyleElement.TextStyle.ApplyParentStyle(documentDefaultTextStyle);
-                targetTextStyle = defaultTextStyleElement.TextStyle;
-            }
-            
+               documentDefaultTextStyle = defaultTextStyleElement.TextStyle.ApplyGlobalStyle(documentDefaultTextStyle);
+
             foreach (var child in content.GetChildren())
-                ApplyDefaultTextStyle(child, targetTextStyle);
+                ApplyDefaultTextStyle(child, documentDefaultTextStyle);
         }
     }
 }

QuestPDF/Drawing/DocumentMetadata.cs

@@ -1,4 +1,5 @@
 using System;
+using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Drawing
 {
@@ -18,14 +19,26 @@ namespace QuestPDF.Drawing
         public DateTime CreationDate { get; set; } = DateTime.Now;
         public DateTime ModifiedDate { get; set; } = DateTime.Now;
 
-        /// <summary>
-        /// If the number of generated pages exceeds this threshold
-        /// (likely due to infinite layout), the exception is thrown.
-        /// </summary>
-        public int DocumentLayoutExceptionThreshold { get; set; } = 250;
+        [Obsolete("This API has been moved since version 2022.9. Please use the QuestPDF.Settings.DocumentLayoutExceptionThreshold static property.")]
+        public int DocumentLayoutExceptionThreshold
+        {
+            get => Settings.DocumentLayoutExceptionThreshold;
+            set => Settings.DocumentLayoutExceptionThreshold = value;
+        }
 
-        public bool ApplyCaching { get; set; } = !System.Diagnostics.Debugger.IsAttached;
-        public bool ApplyDebugging { get; set; } = System.Diagnostics.Debugger.IsAttached;
+        [Obsolete("This API has been moved since version 2022.9. Please use the QuestPDF.Settings.EnableCaching static property.")]
+        public bool ApplyCaching
+        {
+            get => Settings.EnableCaching;
+            set => Settings.EnableCaching = value;
+        }
+        
+        [Obsolete("This API has been moved since version 2022.9. Please use the QuestPDF.Settings.EnableDebugging static property.")]
+        public bool ApplyDebugging
+        {
+            get => Settings.EnableDebugging;
+            set => Settings.EnableDebugging = value;
+        }
 
         public static DocumentMetadata Default => new DocumentMetadata();
     }

QuestPDF/Drawing/Exceptions/DocumentComposeException.cs

@@ -4,17 +4,7 @@ namespace QuestPDF.Drawing.Exceptions
 {
     public class DocumentComposeException : Exception
     {
-        public DocumentComposeException()
-        {
-            
-        }
-
-        public DocumentComposeException(string message) : base(message)
-        {
-            
-        }
-
-        public DocumentComposeException(string message, Exception inner) : base(message, inner)
+        internal DocumentComposeException(string message) : base(message)
         {
             
         }

QuestPDF/Drawing/Exceptions/DocumentDrawingException.cs

@@ -4,17 +4,12 @@ namespace QuestPDF.Drawing.Exceptions
 {
     public class DocumentDrawingException : Exception
     {
-        public DocumentDrawingException()
+        internal DocumentDrawingException(string message) : base(message)
         {
             
         }
-
-        public DocumentDrawingException(string message) : base(message)
-        {
-            
-        }
-
-        public DocumentDrawingException(string message, Exception inner) : base(message, inner)
+        
+        internal DocumentDrawingException(string message, Exception inner) : base(message, inner)
         {
             
         }

QuestPDF/Drawing/Exceptions/DocumentLayoutException.cs

@@ -4,21 +4,11 @@ namespace QuestPDF.Drawing.Exceptions
 {
     public class DocumentLayoutException : Exception
     {
-        public string ElementTrace { get; set; }
-        
-        public DocumentLayoutException()
-        {
-            
-        }
+        public string? ElementTrace { get; }
 
-        public DocumentLayoutException(string message) : base(message)
+        internal DocumentLayoutException(string message, string? elementTrace = null) : base(message)
         {
-            
-        }
-
-        public DocumentLayoutException(string message, Exception inner) : base(message, inner)
-        {
-            
+            ElementTrace = elementTrace;
         }
     }
 }

QuestPDF/Drawing/Exceptions/InitializationException.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace QuestPDF.Drawing.Exceptions
+{
+    public class InitializationException : Exception
+    {
+        internal InitializationException(string documentType, Exception innerException) : base(CreateMessage(documentType, innerException.Message), innerException)
+        {
+            
+        }
+
+        private static string CreateMessage(string documentType, string innerExceptionMessage)
+        {
+            var (libraryName, nugetConvention) = GetLibraryName();
+            
+            return $"Cannot create the {documentType} document using the {libraryName} library. " +
+                   $"This exception usually means that, on your operating system where you run the application, {libraryName} requires installing additional dependencies. " +
+                   $"Such dependencies are available as additional nuget packages, for example {nugetConvention}.Linux.NoDependencies. " +
+                   $"Some operating systems may require installing multiple nugets, e.g. MacOS may need both {nugetConvention}.macOS.NoDependencies and {nugetConvention}.Linux.NoDependencies." +
+                   $"Please refer to the {libraryName} documentation for more details. " +
+                   $"Also, please consult the inner exception that has been originally thrown by the dependency library.";
+
+            (string GetLibraryName, string nugetConvention) GetLibraryName()
+            {
+                if (innerExceptionMessage.Contains("libSkiaSharp"))
+                    return ("SkiaSharp", "SkiaSharp.NativeAssets");
+                
+                if (innerExceptionMessage.Contains("libHarfBuzzSharp"))
+                    return ("HarfBuzzSharp", "HarfBuzzSharp.NativeAssets");
+                
+                // default
+                return ("SkiaSharp-related", "*.NativeAssets");
+            }
+        }
+    }
+}

QuestPDF/Drawing/FontManager.cs

@@ -1,19 +1,32 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
+using HarfBuzzSharp;
+using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
+using SkiaSharp.HarfBuzz;
 
 namespace QuestPDF.Drawing
 {
     public static class FontManager
     {
-        private static ConcurrentDictionary<string, FontStyleSet> StyleSets = new();
-        private static ConcurrentDictionary<object, SKFontMetrics> FontMetrics = new();
-        private static ConcurrentDictionary<object, SKPaint> Paints = new();
-        private static ConcurrentDictionary<string, SKPaint> ColorPaint = new();
+        private static readonly ConcurrentDictionary<string, FontStyleSet> StyleSets = new();
+        private static readonly ConcurrentDictionary<TextStyle, SKFontMetrics> FontMetrics = new();
+        private static readonly ConcurrentDictionary<TextStyle, SKPaint> FontPaints = new();
+        private static readonly ConcurrentDictionary<string, SKPaint> ColorPaints = new();
+        private static readonly ConcurrentDictionary<TextStyle, Font> ShaperFonts = new();
+        private static readonly ConcurrentDictionary<TextStyle, SKFont> Fonts = new();
+        private static readonly ConcurrentDictionary<TextStyle, TextShaper> TextShapers = new();
 
+        static FontManager()
+        {
+            RegisterLibraryDefaultFonts();
+        }
+        
         private static void RegisterFontType(SKData fontData, string? customName = null)
         {
             foreach (var index in Enumerable.Range(0, 256))
@@ -30,8 +43,13 @@ namespace QuestPDF.Drawing
             }
         }
 
-        [Obsolete("Since version 2022.3, the FontManager class offers better font type matching support. Please use the RegisterFont(Stream stream) method.")]
+        [Obsolete("Since version 2022.8 this method has been renamed. Please use the RegisterFontWithCustomName method.")]
         public static void RegisterFontType(string fontName, Stream stream)
+        {
+            RegisterFontWithCustomName(fontName, stream);
+        }
+        
+        public static void RegisterFontWithCustomName(string fontName, Stream stream)
         {
             using var fontData = SKData.Create(stream);
             RegisterFontType(fontData);
@@ -43,10 +61,42 @@ namespace QuestPDF.Drawing
             using var fontData = SKData.Create(stream);
             RegisterFontType(fontData);
         }
+        
+        public static void RegisterFontFromEmbeddedResource(string pathName)
+        {
+            using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(pathName);
+            RegisterFont(stream);
+        }
+        
+        private static void RegisterLibraryDefaultFonts()
+        {
+            var fontFileNames = new[]
+            {
+                "Lato-Black.ttf",
+                "Lato-BlackItalic.ttf",
+                
+                "Lato-Bold.ttf",
+                "Lato-BoldItalic.ttf",
+                
+                "Lato-Regular.ttf",
+                "Lato-Italic.ttf",
+                
+                "Lato-Light.ttf",
+                "Lato-LightItalic.ttf",
+                
+                "Lato-Thin.ttf",
+                "Lato-ThinItalic.ttf"
+            };
+            
+            fontFileNames
+                .Select(x => $"QuestPDF.Resources.DefaultFont.{x}")
+                .ToList()
+                .ForEach(RegisterFontFromEmbeddedResource);
+        }
 
         internal static SKPaint ColorToPaint(this string color)
         {
-            return ColorPaint.GetOrAdd(color, Convert);
+            return ColorPaints.GetOrAdd(color, Convert);
 
             static SKPaint Convert(string color)
             {
@@ -60,7 +110,7 @@ namespace QuestPDF.Drawing
 
         internal static SKPaint ToPaint(this TextStyle style)
         {
-            return Paints.GetOrAdd(style.PaintKey, key => Convert(style));
+            return FontPaints.GetOrAdd(style, Convert);
 
             static SKPaint Convert(TextStyle style)
             {
@@ -68,7 +118,7 @@ namespace QuestPDF.Drawing
                 {
                     Color = SKColor.Parse(style.Color),
                     Typeface = GetTypeface(style),
-                    TextSize = style.Size ?? 12,
+                    TextSize = (style.Size ?? 12) * GetTextScale(style),
                     IsAntialias = true,
                 };
             }
@@ -76,6 +126,16 @@ namespace QuestPDF.Drawing
             static SKTypeface GetTypeface(TextStyle style)
             {
                 var weight = (SKFontStyleWeight)(style.FontWeight ?? FontWeight.Normal);
+
+                // superscript and subscript use slightly bolder font to match visually line thickness
+                if (style.FontPosition is FontPosition.Superscript or FontPosition.Subscript)
+                {
+                    var weightValue = (int)weight;
+                    weightValue = Math.Min(weightValue + 100, 1000);
+                    
+                    weight = (SKFontStyleWeight) (weightValue);
+                }
+
                 var slant = (style.IsItalic ?? false) ? SKFontStyleSlant.Italic : SKFontStyleSlant.Upright;
 
                 var fontStyle = new SKFontStyle(weight, SKFontStyleWidth.Normal, slant);
@@ -87,18 +147,65 @@ namespace QuestPDF.Drawing
                 
                 if (fontFromDefaultSource != null)
                     return fontFromDefaultSource;
+
+                var availableFontNames = string.Join(", ", SKFontManager.Default.GetFontFamilies());
                 
                 throw new ArgumentException(
                     $"The typeface '{style.FontFamily}' could not be found. " +
                     $"Please consider the following options: " +
                     $"1) install the font on your operating system or execution environment. " +
-                    $"2) load a font file specifically for QuestPDF usage via the QuestPDF.Drawing.FontManager.RegisterFontType(Stream fileContentStream) static method.");
+                    $"2) load a font file specifically for QuestPDF usage via the QuestPDF.Drawing.FontManager.RegisterFontType(Stream fileContentStream) static method. " +
+                    $"Available font family names: [{availableFontNames}]");
+            }
+            
+            static float GetTextScale(TextStyle style)
+            {
+                return style.FontPosition switch
+                {
+                    FontPosition.Normal => 1f,
+                    FontPosition.Subscript => 0.625f,
+                    FontPosition.Superscript => 0.625f,
+                    _ => throw new ArgumentOutOfRangeException()
+                };
             }
         }
 
         internal static SKFontMetrics ToFontMetrics(this TextStyle style)
         {
-            return FontMetrics.GetOrAdd(style.FontMetricsKey, key => style.ToPaint().FontMetrics);
+            return FontMetrics.GetOrAdd(style, key => key.NormalPosition().ToPaint().FontMetrics);
+        }
+
+        internal static Font ToShaperFont(this TextStyle style)
+        {
+            return ShaperFonts.GetOrAdd(style, key =>
+            {
+                var typeface = key.ToPaint().Typeface;
+
+                using var harfBuzzBlob = typeface.OpenStream(out var ttcIndex).ToHarfBuzzBlob();
+                
+                using var face = new Face(harfBuzzBlob, ttcIndex)
+                {
+                    Index = ttcIndex,
+                    UnitsPerEm = typeface.UnitsPerEm,
+                    GlyphCount = typeface.GlyphCount
+                };
+                
+                var font = new Font(face);
+                font.SetScale(TextShaper.FontShapingScale, TextShaper.FontShapingScale);
+                font.SetFunctionsOpenType();
+
+                return font;
+            });
+        }
+        
+        internal static TextShaper ToTextShaper(this TextStyle style)
+        {
+            return TextShapers.GetOrAdd(style, key => new TextShaper(key));
+        }
+        
+        internal static SKFont ToFont(this TextStyle style)
+        {
+            return Fonts.GetOrAdd(style, key => key.ToPaint().ToFont());
         }
     }
 }

QuestPDF/Drawing/FreeCanvas.cs

@@ -41,7 +41,7 @@ namespace QuestPDF.Drawing
             
         }
 
-        public void DrawText(string text, Position position, TextStyle style)
+        public void DrawText(SKTextBlob skTextBlob, Position position, TextStyle style)
         {
             
         }

QuestPDF/Drawing/PdfCanvas.cs

@@ -1,4 +1,6 @@
-using System.IO;
+using System;
+using System.IO;
+using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Helpers;
 using SkiaSharp;
 
@@ -7,11 +9,23 @@ namespace QuestPDF.Drawing
     internal class PdfCanvas : SkiaDocumentCanvasBase
     {
         public PdfCanvas(Stream stream, DocumentMetadata documentMetadata) 
-            : base(SKDocument.CreatePdf(stream, MapMetadata(documentMetadata)))
+            : base(CreatePdf(stream, documentMetadata))
         {
             
         }
-        
+
+        private static SKDocument CreatePdf(Stream stream, DocumentMetadata documentMetadata)
+        {
+            try
+            {
+                return SKDocument.CreatePdf(stream, MapMetadata(documentMetadata));
+            }
+            catch (TypeInitializationException exception)
+            {
+                throw new InitializationException("PDF", exception);
+            }
+        }
+
         private static SKDocumentPdfMetadata MapMetadata(DocumentMetadata metadata)
         {
             return new SKDocumentPdfMetadata

QuestPDF/Drawing/SkiaCanvasBase.cs

@@ -1,5 +1,6 @@
 using QuestPDF.Infrastructure;
 using SkiaSharp;
+using SkiaSharp.HarfBuzz;
 
 namespace QuestPDF.Drawing
 {
@@ -27,9 +28,9 @@ namespace QuestPDF.Drawing
             Canvas.DrawRect(vector.X, vector.Y, size.Width, size.Height, paint);
         }
 
-        public void DrawText(string text, Position vector, TextStyle style)
+        public void DrawText(SKTextBlob skTextBlob, Position position, TextStyle style)
         {
-            Canvas.DrawText(text, vector.X, vector.Y, style.ToPaint());
+            Canvas.DrawText(skTextBlob, position.X, position.Y, style.ToPaint());
         }
 
         public void DrawImage(SKImage image, Position vector, Size size)

QuestPDF/Drawing/TextMeasurement.cs

@@ -1,8 +0,0 @@
-namespace QuestPDF.Drawing
-{
-    internal struct TextMeasurement
-    {
-        public int LineIndex { get; set; }
-        public float FragmentWidth { get; set; }
-    }
-}

QuestPDF/Drawing/TextShaper.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Linq;
+using HarfBuzzSharp;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+using Buffer = HarfBuzzSharp.Buffer;
+
+namespace QuestPDF.Drawing
+{
+    internal class TextShaper
+    {
+        public const int FontShapingScale = 512;
+        
+        private TextStyle TextStyle { get; }
+
+        private SKFont Font => TextStyle.ToFont();
+        private Font ShaperFont => TextStyle.ToShaperFont();
+        private SKPaint Paint => TextStyle.ToPaint();
+
+        public TextShaper(TextStyle textStyle)
+        {
+            TextStyle = textStyle;
+        }
+
+        public TextShapingResult Shape(string text)
+        {
+            using var buffer = new Buffer();
+            
+            PopulateBufferWithText(buffer, text);
+            buffer.GuessSegmentProperties();
+
+            ShaperFont.Shape(buffer);
+            
+            var length = buffer.Length;
+            var glyphInfos = buffer.GlyphInfos;
+            var glyphPositions = buffer.GlyphPositions;
+            
+            var scaleY = Paint.TextSize / FontShapingScale;
+            var scaleX = scaleY * Paint.TextScaleX;
+            
+            var xOffset = 0f;
+            var yOffset = 0f;
+            
+            var glyphs = new ShapedGlyph[length];
+            
+            for (var i = 0; i < length; i++)
+            {
+                glyphs[i] = new ShapedGlyph
+                {
+                    Codepoint = (ushort)glyphInfos[i].Codepoint,
+                    Position = new SKPoint(xOffset + glyphPositions[i].XOffset * scaleX, yOffset - glyphPositions[i].YOffset * scaleY),
+                    Width = glyphPositions[i].XAdvance * scaleX
+                };
+                
+                xOffset += glyphPositions[i].XAdvance * scaleX;
+                yOffset += glyphPositions[i].YAdvance * scaleY;
+            }
+            
+            return new TextShapingResult(glyphs);
+        }
+        
+        void PopulateBufferWithText(Buffer buffer, string text)
+        {
+            var encoding = Paint.TextEncoding;
+
+            if (encoding == SKTextEncoding.Utf8)
+                buffer.AddUtf8(text);
+                
+            else if (encoding == SKTextEncoding.Utf16)
+                buffer.AddUtf16(text);
+
+            else if (encoding == SKTextEncoding.Utf32)
+                buffer.AddUtf32(text);
+
+            else
+                throw new NotSupportedException("TextEncoding of type GlyphId is not supported.");
+        }
+    }
+    
+    internal struct ShapedGlyph
+    {
+        public ushort Codepoint;
+        public SKPoint Position;
+        public float Width;
+    }
+
+    internal struct DrawTextCommand
+    {
+        public SKTextBlob SkTextBlob;
+        public float TextOffsetX;
+    }
+    
+    internal class TextShapingResult
+    {
+        public ShapedGlyph[] Glyphs { get; }
+
+        public TextShapingResult(ShapedGlyph[] glyphs)
+        {
+            Glyphs = glyphs;
+        }
+
+        public int BreakText(int startIndex, float maxWidth)
+        {
+            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)
+                    break;
+                
+                index++;
+            }
+
+            return index - 1;
+        }
+        
+        public float MeasureWidth(int startIndex, int endIndex)
+        {
+            if (Glyphs.Length == 0)
+                return 0;
+            
+            var start = Glyphs[startIndex];
+            var end = Glyphs[endIndex];
+
+            return end.Position.X - start.Position.X + end.Width;
+        }
+        
+        public DrawTextCommand? PositionText(int startIndex, int endIndex, TextStyle textStyle)
+        {
+            if (Glyphs.Length == 0)
+                return null;
+
+            if (startIndex > endIndex)
+                return null;
+            
+            using var skTextBlobBuilder = new SKTextBlobBuilder();
+            
+            var positionedRunBuffer = skTextBlobBuilder.AllocatePositionedRun(textStyle.ToFont(), endIndex - startIndex + 1);
+            var glyphSpan = positionedRunBuffer.GetGlyphSpan();
+            var positionSpan = positionedRunBuffer.GetPositionSpan();
+                
+            for (var sourceIndex = startIndex; sourceIndex <= endIndex; sourceIndex++)
+            {
+                var runIndex = sourceIndex - startIndex;
+                
+                glyphSpan[runIndex] = Glyphs[sourceIndex].Codepoint;
+                positionSpan[runIndex] = Glyphs[sourceIndex].Position;
+            }
+            
+            return new DrawTextCommand
+            {
+                SkTextBlob = skTextBlobBuilder.Build(),
+                TextOffsetX = -Glyphs[startIndex].Position.X
+            };
+        }
+    }
+    
+}

QuestPDF/Drawing/XpsCanvas.cs

@@ -1,4 +1,6 @@
-using System.IO;
+using System;
+using System.IO;
+using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Helpers;
 using SkiaSharp;
 
@@ -7,9 +9,21 @@ namespace QuestPDF.Drawing
     internal class XpsCanvas : SkiaDocumentCanvasBase
     {
         public XpsCanvas(Stream stream, DocumentMetadata documentMetadata) 
-            : base(SKDocument.CreateXps(stream, documentMetadata.RasterDpi))
+            : base(CreateXps(stream, documentMetadata))
         {
             
         }
+        
+        private static SKDocument CreateXps(Stream stream, DocumentMetadata documentMetadata)
+        {
+            try
+            {
+                return SKDocument.CreateXps(stream, documentMetadata.RasterDpi);
+            }
+            catch (TypeInitializationException exception)
+            {
+                throw new InitializationException("XPS", exception);
+            }
+        }
     }
 }

QuestPDF/Elements/Canvas.cs

@@ -1,4 +1,5 @@
 using QuestPDF.Drawing;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
 
@@ -12,7 +13,9 @@ namespace QuestPDF.Elements
         
         internal override SpacePlan Measure(Size availableSpace)
         {
-            return SpacePlan.FullRender(availableSpace);
+            return availableSpace.IsNegative() 
+                ? SpacePlan.Wrap() 
+                : SpacePlan.FullRender(availableSpace);
         }
 
         internal override void Draw(Size availableSpace)

QuestPDF/Elements/Column.cs

@@ -94,7 +94,12 @@ namespace QuestPDF.Elements
                 if (item.IsRendered)
                     continue;
 
-                var itemSpace = new Size(availableSpace.Width, availableSpace.Height - topOffset);
+                var availableHeight = availableSpace.Height - topOffset;
+                
+                if (availableHeight < 0)
+                    break;
+
+                var itemSpace = new Size(availableSpace.Width, availableHeight);
                 var measurement = item.Measure(itemSpace);
                 
                 if (measurement.Type == SpacePlanType.Wrap)

QuestPDF/Elements/Dynamic.cs

@@ -0,0 +1,106 @@
+using System;
+using QuestPDF.Drawing;
+using QuestPDF.Drawing.Exceptions;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class DynamicHost : Element, IStateResettable
+    {
+        private DynamicComponentProxy Child { get; }
+        private object InitialComponentState { get; set; }
+
+        internal TextStyle TextStyle { get; set; } = TextStyle.Default;
+
+        public DynamicHost(DynamicComponentProxy child)
+        {
+            Child = child;
+            
+            InitialComponentState = Child.GetState();
+        }
+
+        public void ResetState()
+        {
+            Child.SetState(InitialComponentState);
+        }
+        
+        internal override SpacePlan Measure(Size availableSpace)
+        {
+            var result = GetContent(availableSpace, acceptNewState: false);
+            var content = result.Content as Element ?? Empty.Instance;
+            var measurement = content.Measure(availableSpace);
+
+            if (measurement.Type != SpacePlanType.FullRender)
+                throw new DocumentLayoutException("Dynamic component generated content that does not fit on a single page.");
+            
+            return result.HasMoreContent 
+                ? SpacePlan.PartialRender(measurement) 
+                : SpacePlan.FullRender(measurement);
+        }
+
+        internal override void Draw(Size availableSpace)
+        {
+            var content = GetContent(availableSpace, acceptNewState: true).Content as Element; 
+            content?.Draw(availableSpace);
+        }
+
+        private DynamicComponentComposeResult GetContent(Size availableSize, bool acceptNewState)
+        {
+            var componentState = Child.GetState();
+            
+            var context = new DynamicContext
+            {
+                PageNumber = PageContext.CurrentPage,
+                TotalPages = PageContext.GetLocation(Infrastructure.PageContext.DocumentLocation).PageEnd,
+                PageContext = PageContext,
+                Canvas = Canvas,
+                TextStyle = TextStyle,
+                
+                AvailableSize = availableSize
+            };
+            
+            var result = Child.Compose(context);
+
+            if (!acceptNewState)
+                Child.SetState(componentState);
+
+            return result;
+        }
+    }
+
+    public class DynamicContext
+    {
+        internal IPageContext PageContext { get; set; }
+        internal ICanvas Canvas { get; set; }
+        internal TextStyle TextStyle { get; set; }
+    
+        public int PageNumber { get; internal set; }
+        public int TotalPages { get; internal set; }
+        public Size AvailableSize { get; internal set; }
+
+        public IDynamicElement CreateElement(Action<IContainer> content)
+        {
+            var container = new DynamicElement();
+            content(container);
+            
+            container.ApplyDefaultTextStyle(TextStyle);
+            container.VisitChildren(x => x?.Initialize(PageContext, Canvas));
+            container.VisitChildren(x => (x as IStateResettable)?.ResetState());
+
+            container.Size = container.Measure(Size.Max);
+            
+            return container;
+        }
+    }
+
+    public interface IDynamicElement : IElement
+    {
+        Size Size { get; }
+    }
+
+    internal class DynamicElement : ContainerElement, IDynamicElement
+    {
+        public Size Size { get; internal set; }
+    }
+}

QuestPDF/Elements/DynamicImage.cs

@@ -1,5 +1,6 @@
 using System;
 using QuestPDF.Drawing;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
 
@@ -11,7 +12,9 @@ namespace QuestPDF.Elements
         
         internal override SpacePlan Measure(Size availableSpace)
         {
-            return SpacePlan.FullRender(availableSpace.Width, availableSpace.Height);
+            return availableSpace.IsNegative() 
+                ? SpacePlan.Wrap() 
+                : SpacePlan.FullRender(availableSpace);
         }
 
         internal override void Draw(Size availableSpace)

QuestPDF/Elements/Empty.cs

@@ -1,4 +1,5 @@
 using QuestPDF.Drawing;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements
@@ -9,7 +10,9 @@ namespace QuestPDF.Elements
         
         internal override SpacePlan Measure(Size availableSpace)
         {
-            return SpacePlan.FullRender(0, 0);
+            return availableSpace.IsNegative() 
+                ? SpacePlan.Wrap() 
+                : SpacePlan.FullRender(0, 0);
         }
 
         internal override void Draw(Size availableSpace)

QuestPDF/Elements/Image.cs

@@ -1,4 +1,5 @@
 using QuestPDF.Drawing;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
 
@@ -15,7 +16,9 @@ namespace QuestPDF.Elements
         
         internal override SpacePlan Measure(Size availableSpace)
         {
-            return SpacePlan.FullRender(availableSpace);
+            return availableSpace.IsNegative() 
+                ? SpacePlan.Wrap() 
+                : SpacePlan.FullRender(availableSpace);
         }
 
         internal override void Draw(Size availableSpace)

QuestPDF/Elements/Inlined.cs

@@ -19,6 +19,12 @@ namespace QuestPDF.Elements
         Justify,
         SpaceAround
     }
+
+    internal struct InlinedMeasurement
+    {
+        public Element Element { get; set; }
+        public SpacePlan Size { get; set; }
+    }
     
     internal class Inlined : Element, IStateResettable
     {
@@ -80,10 +86,7 @@ namespace QuestPDF.Elements
             
             foreach (var line in lines)
             {
-                var height = line
-                    .Select(x => x.Measure(Size.Max))
-                    .Where(x => x.Type != SpacePlanType.Wrap)
-                    .Max(x => x.Height);
+                var height = line.Max(x => x.Size.Height);
                 
                 DrawLine(line);
 
@@ -94,24 +97,24 @@ namespace QuestPDF.Elements
             Canvas.Translate(new Position(0, -topOffset));
             lines.SelectMany(x => x).ToList().ForEach(x => ChildrenQueue.Dequeue());
 
-            void DrawLine(ICollection<InlinedElement> elements)
+            void DrawLine(ICollection<InlinedMeasurement> lineMeasurements)
             {
-                var lineSize = GetLineSize(elements);
+                var lineSize = GetLineSize(lineMeasurements);
 
                 var elementOffset = ElementOffset();
                 var leftOffset = AlignOffset();
                 Canvas.Translate(new Position(leftOffset, 0));
                 
-                foreach (var element in elements)
+                foreach (var measurement in lineMeasurements)
                 {
-                    var size = (Size)element.Measure(Size.Max);
+                    var size = (Size)measurement.Size;
                     var baselineOffset = BaselineOffset(size, lineSize.Height);
 
                     if (size.Height == 0)
                         size = new Size(size.Width, lineSize.Height);
                     
                     Canvas.Translate(new Position(0, baselineOffset));
-                    element.Draw(size);
+                    measurement.Element.Draw(size);
                     Canvas.Translate(new Position(0, -baselineOffset));
 
                     leftOffset += size.Width + elementOffset;
@@ -124,20 +127,20 @@ namespace QuestPDF.Elements
                 {
                     var difference = availableSpace.Width - lineSize.Width;
 
-                    if (elements.Count == 1)
+                    if (lineMeasurements.Count == 1)
                         return 0;
 
                     return ElementsAlignment switch
                     {
-                        InlinedAlignment.Justify => difference / (elements.Count - 1),
-                        InlinedAlignment.SpaceAround => difference / (elements.Count + 1),
+                        InlinedAlignment.Justify => difference / (lineMeasurements.Count - 1),
+                        InlinedAlignment.SpaceAround => difference / (lineMeasurements.Count + 1),
                         _ => HorizontalSpacing
                     };
                 }
 
                 float AlignOffset()
                 {
-                    var difference = availableSpace.Width - lineSize.Width - (elements.Count - 1) * HorizontalSpacing;
+                    var difference = availableSpace.Width - lineSize.Width - (lineMeasurements.Count - 1) * HorizontalSpacing;
 
                     return ElementsAlignment switch
                     {
@@ -164,24 +167,19 @@ namespace QuestPDF.Elements
             }
         }
 
-        Size GetLineSize(ICollection<InlinedElement> elements)
+        Size GetLineSize(ICollection<InlinedMeasurement> measurements)
         {
-            var sizes = elements
-                .Select(x => x.Measure(Size.Max))
-                .Where(x => x.Type != SpacePlanType.Wrap)
-                .ToList();
-            
-            var width = sizes.Sum(x => x.Width);
-            var height = sizes.Max(x => x.Height);
+            var width = measurements.Sum(x => x.Size.Width);
+            var height = measurements.Max(x => x.Size.Height);
 
             return new Size(width, height);
         }
         
         // list of lines, each line is a list of elements
-        private ICollection<ICollection<InlinedElement>> Compose(Size availableSize)
+        private ICollection<ICollection<InlinedMeasurement>> Compose(Size availableSize)
         {
             var queue = new Queue<InlinedElement>(ChildrenQueue);
-            var result = new List<ICollection<InlinedElement>>();
+            var result = new List<ICollection<InlinedMeasurement>>();
 
             var topOffset = 0f;
             
@@ -192,10 +190,7 @@ namespace QuestPDF.Elements
                 if (!line.Any())
                     break;
 
-                var height = line
-                    .Select(x => x.Measure(availableSize))
-                    .Where(x => x.Type != SpacePlanType.Wrap)
-                    .Max(x => x.Height);
+                var height = line.Max(x => x.Size.Height);
                 
                 if (topOffset + height > availableSize.Height + Size.Epsilon)
                     break;
@@ -206,9 +201,9 @@ namespace QuestPDF.Elements
 
             return result;
 
-            ICollection<InlinedElement> GetNextLine()
+            ICollection<InlinedMeasurement> GetNextLine()
             {
-                var result = new List<InlinedElement>();
+                var result = new List<InlinedMeasurement>();
                 var leftOffset = GetInitialAlignmentOffset();
                 
                 while (true)
@@ -227,7 +222,12 @@ namespace QuestPDF.Elements
 
                     queue.Dequeue();
                     leftOffset += size.Width + HorizontalSpacing;
-                    result.Add(element);    
+                    
+                    result.Add(new InlinedMeasurement
+                    {
+                        Element = element,
+                        Size = size
+                    });    
                 }
 
                 return result;

QuestPDF/Elements/Line.cs

@@ -23,6 +23,9 @@ namespace QuestPDF.Elements
         
         internal override SpacePlan Measure(Size availableSpace)
         {
+            if (availableSpace.IsNegative())
+                return SpacePlan.Wrap();
+            
             return Type switch
             {
                 LineType.Vertical when availableSpace.Width + Infrastructure.Size.Epsilon >= Size => SpacePlan.FullRender(Size, 0),

QuestPDF/Elements/MinimalBox.cs

@@ -1,18 +0,0 @@
-using QuestPDF.Drawing;
-using QuestPDF.Infrastructure;
-
-namespace QuestPDF.Elements
-{
-    internal class MinimalBox : ContainerElement
-    {
-        internal override void Draw(Size availableSpace)
-        {
-            var targetSize = base.Measure(availableSpace);
-            
-            if (targetSize.Type == SpacePlanType.Wrap)
-                return;
-            
-            base.Draw(targetSize);
-        }
-    }
-}

QuestPDF/Elements/PageBreak.cs

@@ -1,4 +1,5 @@
 using QuestPDF.Drawing;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements
@@ -14,6 +15,9 @@ namespace QuestPDF.Elements
 
         internal override SpacePlan Measure(Size availableSpace)
         {
+            if (availableSpace.IsNegative())
+                return SpacePlan.Wrap();
+            
             if (IsRendered)
                 return SpacePlan.FullRender(0, 0);
 

QuestPDF/Elements/RelativePadding.cs

@@ -0,0 +1,65 @@
+using System;
+using QuestPDF.Drawing;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class RelativePadding : ContainerElement
+    {
+        public float Top { get; set; }
+        public float Right { get; set; }
+        public float Bottom { get; set; }
+        public float Left { get; set; }
+
+        internal override SpacePlan Measure(Size availableSpace)
+        {
+            if (Child == null)
+                return SpacePlan.FullRender(0, 0);
+            
+            var internalSpace = InternalSpace(availableSpace);
+
+            if (internalSpace.Width < 0 || internalSpace.Height < 0)
+                return SpacePlan.Wrap();
+            
+            var measure = base.Measure(internalSpace);
+
+            if (measure.Type == SpacePlanType.Wrap)
+                return SpacePlan.Wrap();
+
+            if (measure.Type == SpacePlanType.PartialRender)
+                return SpacePlan.PartialRender(availableSpace);
+            
+            if (measure.Type == SpacePlanType.FullRender)
+                return SpacePlan.FullRender(availableSpace);
+            
+            throw new NotSupportedException();
+        }
+
+        internal override void Draw(Size availableSpace)
+        {
+            if (Child == null)
+                return;
+
+            var internalOffset = InternalOffset(availableSpace);
+            var internalSpace = InternalSpace(availableSpace);
+            
+            Canvas.Translate(internalOffset);
+            base.Draw(internalSpace);
+            Canvas.Translate(internalOffset.Reverse());
+        }
+
+        private Position InternalOffset(Size availableSpace)
+        {
+            return new Position(
+                availableSpace.Width * Left,
+                availableSpace.Height * Top);
+        }
+        
+        private Size InternalSpace(Size availableSpace)
+        {
+            return new Size(
+                availableSpace.Width * (1f - Left - Right),
+                availableSpace.Height * (1f - Top - Bottom));
+        }
+    }
+}

QuestPDF/Elements/RelativePosition.cs

@@ -0,0 +1,33 @@
+using System;
+using QuestPDF.Drawing;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class RelativePosition : ContainerElement
+    {
+        public float VerticalParent { get; set; }
+        public float VerticalChild { get; set; }
+        
+        public float HorizontalParent { get; set; }
+        public float HorizontalChild { get; set; } 
+        
+        internal override void Draw(Size availableSpace)
+        {
+            if (Child == null)
+                return;
+            
+            var childSize = base.Measure(availableSpace);
+            
+            if (childSize.Type == SpacePlanType.Wrap)
+                return;
+            
+            var left = availableSpace.Width * HorizontalParent + childSize.Width * HorizontalChild;
+            var top = availableSpace.Height * VerticalParent + childSize.Height * VerticalChild;
+
+            Canvas.Translate(new Position(left, top));
+            base.Draw(childSize);
+            Canvas.Translate(new Position(-left, -top));
+        }
+    }
+}

QuestPDF/Elements/RelativeSize.cs

@@ -0,0 +1,36 @@
+using System;
+using QuestPDF.Drawing;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class RelativeSize : ContainerElement
+    {
+        public float? WidthFactor { get; set; } = 1f;
+        public float? HeightFactor { get; set; } = 1f;
+
+        internal override SpacePlan Measure(Size availableSpace)
+        {
+            var internalSpace = new Size(
+                availableSpace.Width * (WidthFactor ?? 1),
+                availableSpace.Height * (HeightFactor ?? 1));
+            
+            var childSpace = Child?.Measure(internalSpace) ?? SpacePlan.FullRender(0, 0);
+
+            if (childSpace.Type == SpacePlanType.Wrap)
+                return SpacePlan.Wrap();
+
+            var targetSpace = new Size(
+                WidthFactor.HasValue ? internalSpace.Width : childSpace.Width,
+                HeightFactor.HasValue ? internalSpace.Height : childSpace.Height);
+            
+            if (childSpace.Type == SpacePlanType.PartialRender)
+                return SpacePlan.PartialRender(targetSpace);
+            
+            if (childSpace.Type == SpacePlanType.FullRender)
+                return SpacePlan.FullRender(targetSpace);
+
+            throw new ArgumentException();
+        }
+    }
+}

QuestPDF/Elements/Row.cs

@@ -102,13 +102,14 @@ namespace QuestPDF.Elements
 
         private void UpdateItemsWidth(float availableWidth)
         {
-            HandleItemsWithAutoWidth();
+            foreach (var rowItem in Items.Where(x => x.Type == RowItemType.Auto))
+                rowItem.Size = rowItem.Measure(Size.Max).Width;
             
-            var constantWidth = Items.Where(x => x.Type == RowItemType.Constant).Sum(x => x.Size);
+            var constantWidth = Items.Where(x => x.Type != RowItemType.Relative).Sum(x => x.Size);
             var relativeWidth = Items.Where(x => x.Type == RowItemType.Relative).Sum(x => x.Size);
             var spacingWidth = (Items.Count - 1) * Spacing;
 
-            foreach (var item in Items.Where(x => x.Type == RowItemType.Constant))
+            foreach (var item in Items.Where(x => x.Type != RowItemType.Relative))
                 item.Width = item.Size;
             
             if (relativeWidth <= 0)
@@ -119,16 +120,7 @@ namespace QuestPDF.Elements
             foreach (var item in Items.Where(x => x.Type == RowItemType.Relative))
                 item.Width = item.Size * widthPerRelativeUnit;
         }
-
-        private void HandleItemsWithAutoWidth()
-        {
-            foreach (var rowItem in Items.Where(x => x.Type == RowItemType.Auto))
-            {
-                rowItem.Size = rowItem.Measure(Size.Max).Width;
-                rowItem.Type = RowItemType.Constant;
-            }
-        }
-
+        
         private ICollection<RowItemRenderingCommand> PlanLayout(Size availableSpace)
         {
             var leftOffset = 0f;

QuestPDF/Elements/Shrink.cs

@@ -0,0 +1,27 @@
+using QuestPDF.Drawing;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class Shrink : ContainerElement
+    {
+        public bool ShrinkVertical { get; set; }
+        public bool ShrinkHorizontal { get; set; }
+        
+        internal override void Draw(Size availableSpace)
+        {
+            var childSize = base.Measure(availableSpace);
+
+            if (childSize.Type == SpacePlanType.Wrap)
+                return;
+            
+            var targetSize = new Size(
+                ShrinkVertical ? childSize.Width : availableSpace.Width,
+                ShrinkHorizontal ? childSize.Height : availableSpace.Height);
+            
+            // TODO: adjust offset for RTL mode
+            
+            base.Draw(targetSize);
+        }
+    }
+}

QuestPDF/Elements/Table/Table.cs

@@ -19,15 +19,22 @@ namespace QuestPDF.Elements.Table
         private int RowsCount { get; set; }
         private int CurrentRow { get; set; }
         
+        // cache that stores all cells
+        // first index: row number
+        // inner table: list of all cells that ends at the corresponding row
+        private TableCell[][] CellsCache { get; set; }
+        private int MaxRow { 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;
@@ -35,9 +42,36 @@ namespace QuestPDF.Elements.Table
 
         public void ResetState()
         {
-            Cells.ForEach(x => x.IsRendered = false);
+            foreach (var x in Cells)
+                x.IsRendered = false;
+            
             CurrentRow = 1;
         }
+
+        private void BuildCache()
+        {
+            if (CellsCache != null)
+                return;
+
+            if (Cells.Count == 0)
+            {
+                MaxRow = 0;
+                CellsCache = Array.Empty<TableCell[]>();
+                
+                return;
+            }
+            
+            var groups = Cells
+                .GroupBy(x => x.Row + x.RowSpan - 1)
+                .ToDictionary(x => x.Key, x => x.OrderBy(x => x.Column).ToArray());
+
+            MaxRow = groups.Max(x => x.Key);
+
+            CellsCache = Enumerable
+                .Range(0, MaxRow + 1)
+                .Select(x => groups.ContainsKey(x) ? groups[x] : Array.Empty<TableCell>())
+                .ToArray();
+        }
         
         internal override SpacePlan Measure(Size availableSpace)
         {
@@ -143,7 +177,10 @@ namespace QuestPDF.Elements.Table
                 var rowBottomOffsets = new DynamicDictionary<int, float>();
                 var commands = new List<TableCellRenderingCommand>();
                 
-                var cellsToTry = Cells.Where(x => x.Row + x.RowSpan - 1 >= CurrentRow);
+                var cellsToTry = Enumerable
+                    .Range(CurrentRow, MaxRow - CurrentRow + 1)
+                    .SelectMany(x => CellsCache[x]);
+                
                 var currentRow = CurrentRow;
                 var maxRenderingRow = RowsCount;
                 

QuestPDF/Elements/Table/TableLayoutPlanner.cs

@@ -5,7 +5,7 @@ using QuestPDF.Fluent;
 
 namespace QuestPDF.Elements.Table
 {
-    static class TableLayoutValidator
+    static class TableLayoutPlanner
     {
         public static void PlanCellPositions(this Table table)
         {

QuestPDF/Elements/Table/TableLayoutValidator.cs

@@ -6,7 +6,7 @@ using QuestPDF.Fluent;
 
 namespace QuestPDF.Elements.Table
 {
-    static class TableLayoutPlanner
+    static class TableLayoutValidator
     {
         public static void ValidateCellPositions(this Table table)
         {

QuestPDF/Elements/Text/Calculation/TextDrawingRequest.cs

@@ -1,4 +1,5 @@
-using QuestPDF.Infrastructure;
+using QuestPDF.Drawing;
+using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements.Text.Calculation
 {

QuestPDF/Elements/Text/Calculation/TextMeasurementResult.cs

@@ -1,4 +1,5 @@
 using System;
+using QuestPDF.Drawing;
 
 namespace QuestPDF.Elements.Text.Calculation
 {

QuestPDF/Elements/Text/FontFallback.cs

@@ -0,0 +1,150 @@
+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 TextBlockSpan textBlockSpan and not TextBlockPageNumber)
+                {
+                    if (!Settings.CheckIfAllTextGlyphsAreAvailable && textBlockSpan.Style.Fallback == null)
+                    {
+                        yield return textBlockSpan;
+                        continue;
+                    }
+                    
+                    var textRuns = textBlockSpan.Text.SplitWithFontFallback(textBlockSpan.Style);
+
+                    foreach (var textRun in textRuns)
+                    {
+                        yield return new TextBlockSpan
+                        {
+                            Text = textRun.Content,
+                            Style = textRun.Style
+                        };
+                    }
+                }
+                else
+                {
+                    yield return textBlockItem;
+                }
+            }
+        }
+    }
+}

QuestPDF/Elements/Text/Items/TextBlockPageNumber.cs

@@ -8,6 +8,7 @@ namespace QuestPDF.Elements.Text.Items
     {
         public const string PageNumberPlaceholder = "123";
         public Func<IPageContext, string> Source { get; set; } = _ => PageNumberPlaceholder;
+        protected override bool EnableTextCache => false;
         
         public override TextMeasurementResult? Measure(TextMeasurementRequest request)
         {

QuestPDF/Elements/Text/Items/TextBlockSectionLink.cs

@@ -3,7 +3,7 @@ using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements.Text.Items
 {
-    internal class TextBlockSectionlLink : TextBlockSpan
+    internal class TextBlockSectionLink : TextBlockSpan
     {
         public string SectionName { get; set; }
         

QuestPDF/Elements/Text/Items/TextBlockSpan.cs

@@ -1,20 +1,24 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using QuestPDF.Drawing;
 using QuestPDF.Elements.Text.Calculation;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
+using SkiaSharp;
+using SkiaSharp.HarfBuzz;
 using Size = QuestPDF.Infrastructure.Size;
 
 namespace QuestPDF.Elements.Text.Items
 {
     internal class TextBlockSpan : ITextBlockItem
     {
-        private const char Space = ' ';
-        
         public string Text { get; set; }
-        public TextStyle Style { get; set; } = new TextStyle();
+        public TextStyle Style { get; set; } = TextStyle.Default;
+        public TextShapingResult? TextShapingResult { get; set; }
 
         private Dictionary<(int startIndex, float availableWidth), TextMeasurementResult?> MeasureCache = new ();
+        protected virtual bool EnableTextCache => true; 
 
         public virtual TextMeasurementResult? Measure(TextMeasurementRequest request)
         {
@@ -25,11 +29,17 @@ namespace QuestPDF.Elements.Text.Items
             
             return MeasureCache[cacheKey];
         }
-        
+
         internal TextMeasurementResult? MeasureWithoutCache(TextMeasurementRequest request)
         {
+            if (!EnableTextCache)
+                TextShapingResult = null;
+            
+            TextShapingResult ??= Style.ToTextShaper().Shape(Text);
+            
             var paint = Style.ToPaint();
             var fontMetrics = Style.ToFontMetrics();
+            var spaceCodepoint = paint.ToFont().Typeface.GetGlyphs(" ")[0];
 
             var startIndex = request.StartIndex;
             
@@ -37,11 +47,11 @@ namespace QuestPDF.Elements.Text.Items
             // ignore leading spaces
             if (!request.IsFirstElementInBlock && request.IsFirstElementInLine)
             {
-                while (startIndex < Text.Length && Text[startIndex] == Space)
+                while (startIndex < TextShapingResult.Glyphs.Length && Text[startIndex] == spaceCodepoint)
                     startIndex++;
             }
-            
-            if (Text.Length == 0 || startIndex == Text.Length)
+
+            if (TextShapingResult.Glyphs.Length == 0 || startIndex == TextShapingResult.Glyphs.Length)
             {
                 return new TextMeasurementResult
                 {
@@ -54,27 +64,19 @@ namespace QuestPDF.Elements.Text.Items
             }
             
             // start breaking text from requested position
-            var text = Text.AsSpan().Slice(startIndex);
-            
-            var textLength = (int)paint.BreakText(text, request.AvailableWidth + Size.Epsilon);
+            var endIndex = TextShapingResult.BreakText(startIndex, request.AvailableWidth);
 
-            if (textLength <= 0)
+            if (endIndex < startIndex)
                 return null;
   
             // break text only on spaces
-            var wrappedTextLength = WrapText(text, textLength, request.IsFirstElementInLine);
+            var wrappedText = WrapText(startIndex, endIndex, request.IsFirstElementInLine);
 
-            if (wrappedTextLength == null)
+            if (wrappedText == null)
                 return null;
-
-            textLength = wrappedTextLength.Value.fragmentLength;
-
-            text = text.Slice(0, textLength);
-
-            var endIndex = startIndex + textLength;
-
+            
             // measure final text
-            var width = paint.MeasureText(text);
+            var width = TextShapingResult.MeasureWidth(startIndex, wrappedText.Value.endIndex);
             
             return new TextMeasurementResult
             {
@@ -86,62 +88,100 @@ namespace QuestPDF.Elements.Text.Items
                 LineHeight = Style.LineHeight ?? 1,
                 
                 StartIndex = startIndex,
-                EndIndex = endIndex,
-                NextIndex = startIndex + wrappedTextLength.Value.nextIndex,
-                TotalIndex = Text.Length
+                EndIndex = wrappedText.Value.endIndex,
+                NextIndex = wrappedText.Value.nextIndex,
+                TotalIndex = TextShapingResult.Glyphs.Length - 1
             };
         }
         
-        // TODO: consider introduce text wrapping abstraction (basic, english-like, asian-like)
-        private (int fragmentLength, int nextIndex)? WrapText(ReadOnlySpan<char> text, int textLength, bool isFirstElementInLine)
+        // TODO: consider introducing text wrapping abstraction (basic, english-like, asian-like)
+        private (int endIndex, int nextIndex)? WrapText(int startIndex, int endIndex, bool isFirstElementInLine)
         {
+            var spaceCodepoint = Style.ToPaint().ToFont().Typeface.GetGlyphs(" ")[0];
+            
             // textLength - length of the part of the text that fits in available width (creating a line)
-                
+
             // entire text fits, no need to wrap
-            if (textLength == text.Length)
-                return (textLength, textLength + 1);
+            if (endIndex == TextShapingResult.Glyphs.Length - 1)
+                return (endIndex, endIndex);
 
             // breaking anywhere
             if (Style.WrapAnywhere ?? false)
-                return (textLength, textLength);
+                return (endIndex, endIndex + 1);
                 
             // current line ends at word, next character is space, perfect place to wrap
-            if (text[textLength - 1] != Space && text[textLength] == Space)
-                return (textLength, textLength + 1);
+            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
-            var lastSpaceIndex = text.Slice(0, textLength).LastIndexOf(Space);
+            var lastSpaceIndex = endIndex;
+
+            while (lastSpaceIndex >= startIndex)
+            {
+                if (TextShapingResult.Glyphs[lastSpaceIndex].Codepoint == spaceCodepoint)
+                    break;
+
+                lastSpaceIndex--;
+            }
 
             // text contains space that can be used to wrap
-            if (lastSpaceIndex > 0)
-                return (lastSpaceIndex, lastSpaceIndex + 1);
+            if (lastSpaceIndex > 1 && lastSpaceIndex >= startIndex)
+                return (lastSpaceIndex - 1, lastSpaceIndex + 1);
                 
             // there is no available space to wrap text
             // if the item is first within the line, perform safe mode and chop the word
             // otherwise, move the item into the next line
-            return isFirstElementInLine ? (textLength, textLength + 1) : null;
+            return isFirstElementInLine ? (endIndex, endIndex + 1) : null;
         }
         
         public virtual void Draw(TextDrawingRequest request)
         {
             var fontMetrics = Style.ToFontMetrics();
 
-            var text = Text.Substring(request.StartIndex, request.EndIndex - request.StartIndex);
+            var glyphOffsetY = GetGlyphOffset();
             
-            request.Canvas.DrawRectangle(new Position(0, request.TotalAscent), new Size(request.TextSize.Width, request.TextSize.Height), Style.BackgroundColor);
-            request.Canvas.DrawText(text, Position.Zero, Style);
+            var textDrawingCommand = TextShapingResult.PositionText(request.StartIndex, request.EndIndex, Style);
+
+            if (Style.BackgroundColor != Colors.Transparent)
+                request.Canvas.DrawRectangle(new Position(0, request.TotalAscent), new Size(request.TextSize.Width, request.TextSize.Height), Style.BackgroundColor);
+            
+            if (textDrawingCommand.HasValue)
+                request.Canvas.DrawText(textDrawingCommand.Value.SkTextBlob, new Position(textDrawingCommand.Value.TextOffsetX, glyphOffsetY), Style);
 
             // draw underline
             if ((Style.HasUnderline ?? false) && fontMetrics.UnderlinePosition.HasValue)
-                DrawLine(fontMetrics.UnderlinePosition.Value, fontMetrics.UnderlineThickness ?? 1);
+            {
+                var underlineOffset = Style.FontPosition == FontPosition.Superscript ? 0 : glyphOffsetY;
+                DrawLine(fontMetrics.UnderlinePosition.Value + underlineOffset, fontMetrics.UnderlineThickness ?? 1);
+            }
             
             // draw stroke
             if ((Style.HasStrikethrough ?? false) && fontMetrics.StrikeoutPosition.HasValue)
-                DrawLine(fontMetrics.StrikeoutPosition.Value, fontMetrics.StrikeoutThickness ?? 1);
-
+            {
+                var strikeoutThickness = fontMetrics.StrikeoutThickness ?? 1;
+                strikeoutThickness *= Style.FontPosition == FontPosition.Normal ? 1f : 0.625f;
+                
+                DrawLine(fontMetrics.StrikeoutPosition.Value + glyphOffsetY, strikeoutThickness);
+            }
+            
             void DrawLine(float offset, float thickness)
             {
-                request.Canvas.DrawRectangle(new Position(0, offset - thickness / 2f), new Size(request.TextSize.Width, thickness), Style.Color);
+                request.Canvas.DrawRectangle(new Position(0, offset), new Size(request.TextSize.Width, thickness), Style.Color);
+            }
+
+            float GetGlyphOffset()
+            {
+                var fontSize = Style.Size ?? 12f;
+
+                var offsetFactor = Style.FontPosition switch
+                {
+                    FontPosition.Normal => 0,
+                    FontPosition.Subscript => 0.1f,
+                    FontPosition.Superscript => -0.35f,
+                    _ => throw new ArgumentOutOfRangeException()
+                };
+
+                return fontSize * offsetFactor;
             }
         }
     }

QuestPDF/Elements/Text/TextBlock.cs

@@ -14,14 +14,41 @@ namespace QuestPDF.Elements.Text
         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));
-        
+
         private Queue<ITextBlockItem> RenderingQueue { get; set; }
         private int CurrentElementIndex { get; set; }
 
+        private bool FontFallbackApplied { get; set; } = false;
+        
         public void ResetState()
         {
-            RenderingQueue = new Queue<ITextBlockItem>(Items);
+            ApplyFontFallback();
+            InitializeQueue();
             CurrentElementIndex = 0;
+
+            void InitializeQueue()
+            {
+                // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+                if (RenderingQueue == null)
+                {
+                    RenderingQueue = new Queue<ITextBlockItem>(Items);
+                    return;
+                }
+                
+                RenderingQueue.Clear();
+            
+                foreach (var item in Items)
+                    RenderingQueue.Enqueue(item);
+            }
+
+            void ApplyFontFallback()
+            {
+                if (FontFallbackApplied)
+                    return;
+
+                Items = Items.ApplyFontFallback().ToList();
+                FontFallbackApplied = true;
+            }
         }
 
         internal override SpacePlan Measure(Size availableSpace)
@@ -108,7 +135,7 @@ namespace QuestPDF.Elements.Text
                 .ForEach(x => RenderingQueue.Dequeue());
 
             var lastElementMeasurement = lines.Last().Elements.Last().Measurement;
-            CurrentElementIndex = lastElementMeasurement.IsLast ? 0 : lastElementMeasurement.EndIndex;
+            CurrentElementIndex = lastElementMeasurement.IsLast ? 0 : lastElementMeasurement.NextIndex;
             
             if (!RenderingQueue.Any())
                 ResetState();

QuestPDF/Fluent/DynamicComponentExtensions.cs

@@ -0,0 +1,14 @@
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Fluent
+{
+    public static class DynamicComponentExtensions
+    {
+        public static void Dynamic<TState>(this IContainer element, IDynamicComponent<TState> dynamicElement) where TState : struct
+        {
+            var componentProxy = DynamicComponentProxy.CreateFrom(dynamicElement);
+            element.Element(new DynamicHost(componentProxy));
+        }
+    }
+}

QuestPDF/Fluent/ElementExtensions.cs

@@ -154,17 +154,6 @@ namespace QuestPDF.Fluent
             });
         }
         
-        [Obsolete("This element has been renamed since version 2022.1. Please use the MinimalBox method.")]
-        public static IContainer Box(this IContainer element)
-        {
-            return element.Element(new MinimalBox());
-        }
-        
-        public static IContainer MinimalBox(this IContainer element)
-        {
-            return element.Element(new MinimalBox());
-        }
-        
         public static IContainer Unconstrained(this IContainer element)
         {
             return element.Element(new Unconstrained());

QuestPDF/Fluent/RelativePaddingExtensions.cs

@@ -0,0 +1,37 @@
+using System;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Fluent
+{
+    public static class RelativePaddingExtensions
+    {
+        private static IContainer RelativePadding(this IContainer element, Action<RelativePadding> handler)
+        {
+            var relativePadding = element as RelativePadding ?? new RelativePadding();
+            handler(relativePadding);
+            
+            return element.Element(relativePadding);
+        }
+
+        public static IContainer RelativePaddingTop(this IContainer element, float value)
+        {
+            return element.RelativePadding(x => x.Top += value);
+        }
+        
+        public static IContainer RelativePaddingBottom(this IContainer element, float value)
+        {
+            return element.RelativePadding(x => x.Bottom += value);
+        }
+        
+        public static IContainer RelativePaddingLeft(this IContainer element, float value)
+        {
+            return element.RelativePadding(x => x.Left += value);
+        }
+        
+        public static IContainer RelativePaddingRight(this IContainer element, float value)
+        {
+            return element.RelativePadding(x => x.Right += value);
+        }
+    }
+}

QuestPDF/Fluent/RelativePositionExtensions.cs

@@ -0,0 +1,35 @@
+using System;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Fluent
+{
+    public static class RelativePositionExtensions
+    {
+        private static IContainer RelativePosition(this IContainer element, Action<RelativePosition> handler)
+        {
+            var relativePosition = element as RelativePosition ?? new RelativePosition();
+            handler(relativePosition);
+            
+            return element.Element(relativePosition);
+        }
+
+        public static IContainer RelativePositionVertical(this IContainer element, float parentOffset, float childOffset)
+        {
+            return element.RelativePosition(x =>
+            {
+                x.VerticalParent = parentOffset;
+                x.VerticalChild = childOffset;
+            });
+        }
+        
+        public static IContainer RelativePositionHorizontal(this IContainer element, float parentOffset, float childOffset)
+        {
+            return element.RelativePosition(x =>
+            {
+                x.HorizontalParent = parentOffset;
+                x.HorizontalChild = childOffset;
+            });
+        }
+    }
+}

QuestPDF/Fluent/RelativeSizeExtensions.cs

@@ -0,0 +1,27 @@
+using System;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Fluent
+{
+    public static class RelativeSizeExtensions
+    {
+        private static IContainer RelativeSize(this IContainer element, Action<RelativeSize> handler)
+        {
+            var relativeSize = element as RelativeSize ?? new RelativeSize();
+            handler(relativeSize);
+            
+            return element.Element(relativeSize);
+        }
+
+        public static IContainer RelativeWidth(this IContainer element, float value)
+        {
+            return element.RelativeSize(x => x.WidthFactor = value);
+        }
+        
+        public static IContainer RelativeHeight(this IContainer element, float value)
+        {
+            return element.RelativeSize(x => x.HeightFactor = value);
+        }
+    }
+}

QuestPDF/Fluent/ShrinkExtensions.cs

@@ -0,0 +1,48 @@
+using System;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Fluent
+{
+    public static class ShrinkExtensions
+    {
+        private static IContainer Shrink(this IContainer element, Action<Shrink> handler)
+        {
+            var shrink = element as Shrink ?? new Shrink();
+            handler(shrink);
+            
+            return element.Element(shrink);
+        }
+        
+        public static IContainer Shrink(this IContainer element)
+        {
+            return element.ShrinkVertical().ShrinkHorizontal();
+        }
+        
+        public static IContainer ShrinkVertical(this IContainer element)
+        {
+            return element.Shrink(x => x.ShrinkVertical = true);
+        }
+        
+        public static IContainer ShrinkHorizontal(this IContainer element)
+        {
+            return element.Shrink(x => x.ShrinkHorizontal = true);
+        }
+
+        #region Obsolete
+        
+        [Obsolete("This element has been renamed since version 2022.1. Please use the Shrink method.")]
+        public static IContainer Box(this IContainer element)
+        {
+            return element.Element(new Shrink());
+        }
+        
+        [Obsolete("This element has been renamed since version 2022.11. Please use the Shrink method.")]
+        public static IContainer MinimalBox(this IContainer element)
+        {
+            return element.Element(new Shrink());
+        }
+
+        #endregion
+    }
+}

QuestPDF/Fluent/TextExtensions.cs

@@ -12,11 +12,18 @@ namespace QuestPDF.Fluent
 {
     public class TextSpanDescriptor
     {
-        internal TextStyle TextStyle { get; }
+        internal TextStyle TextStyle = TextStyle.Default;
+        internal Action<TextStyle> AssignTextStyle { get; }
 
-        internal TextSpanDescriptor(TextStyle textStyle)
+        internal TextSpanDescriptor(Action<TextStyle> assignTextStyle)
         {
-            TextStyle = textStyle;
+            AssignTextStyle = assignTextStyle;
+        }
+
+        internal void MutateTextStyle(Func<TextStyle, TextStyle> handler)
+        {
+            TextStyle = handler(TextStyle);
+            AssignTextStyle(TextStyle);
         }
     }
 
@@ -24,16 +31,17 @@ namespace QuestPDF.Fluent
     
     public class TextPageNumberDescriptor : TextSpanDescriptor
     {
-        internal PageNumberFormatter FormatFunction { get; private set; } = x => x?.ToString() ?? string.Empty;
-
-        internal TextPageNumberDescriptor(TextStyle textStyle) : base(textStyle)
+        internal Action<PageNumberFormatter> AssignFormatFunction { get; }
+        
+        internal TextPageNumberDescriptor(Action<TextStyle> assignTextStyle, Action<PageNumberFormatter> assignFormatFunction) : base(assignTextStyle)
         {
-            
+            AssignFormatFunction = assignFormatFunction;
+            AssignFormatFunction(x => x?.ToString());
         }
 
         public TextPageNumberDescriptor Format(PageNumberFormatter formatter)
         {
-            FormatFunction = formatter ?? FormatFunction;
+            AssignFormatFunction(formatter);
             return this;
         }
     }
@@ -41,7 +49,7 @@ namespace QuestPDF.Fluent
     public class TextDescriptor
     {
         private ICollection<TextBlock> TextBlocks { get; } = new List<TextBlock>();
-        private TextStyle DefaultStyle { get; set; } = TextStyle.Default;
+        private TextStyle? DefaultStyle { get; set; }
         internal HorizontalAlignment Alignment { get; set; } = HorizontalAlignment.Left;
         private float Spacing { get; set; } = 0f;
 
@@ -91,19 +99,15 @@ namespace QuestPDF.Fluent
         
         public TextSpanDescriptor Span(string? text)
         {
-            var style = DefaultStyle.Clone();
-            var descriptor = new TextSpanDescriptor(style);
-
             if (text == null)
-                return descriptor;
+                return new TextSpanDescriptor(_ => { });
  
             var items = text
                 .Replace("\r", string.Empty)
                 .Split(new[] { '\n' }, StringSplitOptions.None)
                 .Select(x => new TextBlockSpan
                 {
-                    Text = x,
-                    Style = style
+                    Text = x
                 })
                 .ToList();
 
@@ -118,7 +122,7 @@ namespace QuestPDF.Fluent
                 .ToList()
                 .ForEach(TextBlocks.Add);
 
-            return descriptor;
+            return new TextSpanDescriptor(x => items.ForEach(y => y.Style = x));
         }
 
         public TextSpanDescriptor Line(string? text)
@@ -134,16 +138,10 @@ namespace QuestPDF.Fluent
         
         private TextPageNumberDescriptor PageNumber(Func<IPageContext, int?> pageNumber)
         {
-            var style = DefaultStyle.Clone();
-            var descriptor = new TextPageNumberDescriptor(DefaultStyle);
+            var textBlockItem = new TextBlockPageNumber();
+            AddItemToLastTextBlock(textBlockItem);
             
-            AddItemToLastTextBlock(new TextBlockPageNumber
-            {
-                Source = context => descriptor.FormatFunction(pageNumber(context)),
-                Style = style
-            });
-            
-            return descriptor;
+            return new TextPageNumberDescriptor(x => textBlockItem.Style = x, x => textBlockItem.Source = context => x(pageNumber(context)));
         }
 
         public TextPageNumberDescriptor CurrentPageNumber()
@@ -174,7 +172,7 @@ namespace QuestPDF.Fluent
         
         public TextPageNumberDescriptor PageNumberWithinSection(string locationName)
         {
-            return PageNumber(x => x.CurrentPage + 1 - x.GetLocation(locationName)?.PageEnd);
+            return PageNumber(x => x.CurrentPage + 1 - x.GetLocation(locationName)?.PageStart);
         }
         
         public TextPageNumberDescriptor TotalPagesWithinSection(string locationName)
@@ -185,22 +183,19 @@ namespace QuestPDF.Fluent
         public TextSpanDescriptor SectionLink(string? text, string sectionName)
         {
             if (IsNullOrEmpty(sectionName))
-                throw new ArgumentException(nameof(sectionName));
+                throw new ArgumentException("Section name cannot be null or empty", nameof(sectionName));
 
-            var style = DefaultStyle.Clone();
-            var descriptor = new TextSpanDescriptor(style);
-            
             if (IsNullOrEmpty(text))
-                return descriptor;
-            
-            AddItemToLastTextBlock(new TextBlockSectionlLink
+                return new TextSpanDescriptor(_ => { });
+
+            var textBlockItem = new TextBlockSectionLink
             {
-                Style = style,
                 Text = text,
                 SectionName = sectionName
-            });
+            };
 
-            return descriptor;
+            AddItemToLastTextBlock(textBlockItem);
+            return new TextSpanDescriptor(x => textBlockItem.Style = x);
         }
         
         [Obsolete("This element has been renamed since version 2022.3. Please use the SectionLink method.")]
@@ -212,22 +207,19 @@ namespace QuestPDF.Fluent
         public TextSpanDescriptor Hyperlink(string? text, string url)
         {
             if (IsNullOrEmpty(url))
-                throw new ArgumentException(nameof(url));
-
-            var style = DefaultStyle.Clone();
-            var descriptor = new TextSpanDescriptor(style);
+                throw new ArgumentException("Url cannot be null or empty", nameof(url));
 
             if (IsNullOrEmpty(text))
-                return descriptor;
+                return new TextSpanDescriptor(_ => { });
             
-            AddItemToLastTextBlock(new TextBlockHyperlink
+            var textBlockItem = new TextBlockHyperlink
             {
-                Style = style,
                 Text = text,
                 Url = url
-            });
+            };
 
-            return descriptor;
+            AddItemToLastTextBlock(textBlockItem);
+            return new TextSpanDescriptor(x => textBlockItem.Style = x);
         }
         
         [Obsolete("This element has been renamed since version 2022.3. Please use the Hyperlink method.")]
@@ -251,14 +243,23 @@ namespace QuestPDF.Fluent
         internal void Compose(IContainer container)
         {
             TextBlocks.ToList().ForEach(x => x.Alignment = Alignment);
+            
+            if (DefaultStyle != null)
+                container = container.DefaultTextStyle(DefaultStyle);
 
-            container.DefaultTextStyle(DefaultStyle).Column(column =>
+            if (TextBlocks.Count == 1)
+            {
+                container.Element(TextBlocks.First());
+                return;
+            }
+            
+            container.Column(column =>
             {
                 column.Spacing(Spacing);
 
                 foreach (var textBlock in TextBlocks)
                     column.Item().Element(textBlock);
-            });
+            }); 
         }
     }
     

QuestPDF/Fluent/TextSpanDescriptorExtensions.cs

@@ -11,120 +11,156 @@ namespace QuestPDF.Fluent
             if (style == null)
                 return descriptor;
             
-            descriptor.TextStyle.OverrideStyle(style);
+            descriptor.MutateTextStyle(x => x.OverrideStyle(style));
             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.TextStyle.Color = value;
+            descriptor.MutateTextStyle(x => x.FontColor(value));
             return descriptor;
         }
         
         public static T BackgroundColor<T>(this T descriptor, string value) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.BackgroundColor = value;
+            descriptor.MutateTextStyle(x => x.BackgroundColor(value));
             return descriptor;
         }
         
         public static T FontFamily<T>(this T descriptor, string value) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.FontFamily = value;
+            descriptor.MutateTextStyle(x => x.FontFamily(value));
             return descriptor;
         }
         
         public static T FontSize<T>(this T descriptor, float value) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.Size = value;
+            descriptor.MutateTextStyle(x => x.FontSize(value));
             return descriptor;
         }
         
         public static T LineHeight<T>(this T descriptor, float value) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.LineHeight = value;
+            descriptor.MutateTextStyle(x => x.LineHeight(value));
             return descriptor;
         }
         
         public static T Italic<T>(this T descriptor, bool value = true) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.IsItalic = value;
+            descriptor.MutateTextStyle(x => x.Italic(value));
             return descriptor;
         }
         
         public static T Strikethrough<T>(this T descriptor, bool value = true) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.HasStrikethrough = value;
+            descriptor.MutateTextStyle(x => x.Strikethrough(value));
             return descriptor;
         }
         
         public static T Underline<T>(this T descriptor, bool value = true) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.HasUnderline = value;
+            descriptor.MutateTextStyle(x => x.Underline(value));
             return descriptor;
         }
 
         public static T WrapAnywhere<T>(this T descriptor, bool value = true) where T : TextSpanDescriptor
         {
-            descriptor.TextStyle.WrapAnywhere = value;
+            descriptor.MutateTextStyle(x => x.WrapAnywhere(value));
             return descriptor;
         }
 
         #region Weight
         
-        public static T Weight<T>(this T descriptor, FontWeight weight) where T : TextSpanDescriptor
-        {
-            descriptor.TextStyle.FontWeight = weight;
-            return descriptor;
-        }
-        
         public static T Thin<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.Thin);
+            descriptor.MutateTextStyle(x => x.Thin());
+            return descriptor;
         }
         
         public static T ExtraLight<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.ExtraLight);
+            descriptor.MutateTextStyle(x => x.ExtraLight());
+            return descriptor;
         }
         
         public static T Light<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.Light);
+            descriptor.MutateTextStyle(x => x.Light());
+            return descriptor;
         }
         
         public static T NormalWeight<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.Normal);
+            descriptor.MutateTextStyle(x => x.NormalWeight());
+            return descriptor;
         }
         
         public static T Medium<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.Medium);
+            descriptor.MutateTextStyle(x => x.Medium());
+            return descriptor;
         }
         
         public static T SemiBold<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.SemiBold);
+            descriptor.MutateTextStyle(x => x.SemiBold());
+            return descriptor;
         }
         
         public static T Bold<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.Bold);
+            descriptor.MutateTextStyle(x => x.Bold());
+            return descriptor;
         }
         
         public static T ExtraBold<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.ExtraBold);
+            descriptor.MutateTextStyle(x => x.ExtraBold());
+            return descriptor;
         }
         
         public static T Black<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.Black);
+            descriptor.MutateTextStyle(x => x.Black());
+            return descriptor;
         }
         
         public static T ExtraBlack<T>(this T descriptor) where T : TextSpanDescriptor
         {
-            return descriptor.Weight(FontWeight.ExtraBlack);
+            descriptor.MutateTextStyle(x => x.ExtraBlack());
+            return descriptor;
+        }
+
+        #endregion
+
+        #region Position
+        public static T NormalPosition<T>(this T descriptor) where T : TextSpanDescriptor
+        {
+            descriptor.MutateTextStyle(x => x.NormalPosition());
+            return descriptor;
+        }
+
+        public static T Subscript<T>(this T descriptor) where T : TextSpanDescriptor
+        {
+            descriptor.MutateTextStyle(x => x.Subscript());
+            return descriptor;
+        }
+
+        public static T Superscript<T>(this T descriptor) where T : TextSpanDescriptor
+        {
+            descriptor.MutateTextStyle(x => x.Superscript());
+            return descriptor;
         }
         
         #endregion

QuestPDF/Fluent/TextStyleExtensions.cs

@@ -6,14 +6,6 @@ namespace QuestPDF.Fluent
 {
     public static class TextStyleExtensions
     {
-        private static TextStyle Mutate(this TextStyle style, Action<TextStyle> handler)
-        {
-            style = style.Clone();
-            
-            handler(style);
-            return style;
-        }
-        
         [Obsolete("This element has been renamed since version 2022.3. Please use the FontColor method.")]
         public static TextStyle Color(this TextStyle style, string value)
         {
@@ -22,12 +14,12 @@ namespace QuestPDF.Fluent
         
         public static TextStyle FontColor(this TextStyle style, string value)
         {
-            return style.Mutate(x => x.Color = value);
+            return style.Mutate(TextStyleProperty.Color, value);
         }
         
         public static TextStyle BackgroundColor(this TextStyle style, string value)
         {
-            return style.Mutate(x => x.BackgroundColor = value);
+            return style.Mutate(TextStyleProperty.BackgroundColor, value);
         }
         
         [Obsolete("This element has been renamed since version 2022.3. Please use the FontFamily method.")]
@@ -38,7 +30,7 @@ namespace QuestPDF.Fluent
         
         public static TextStyle FontFamily(this TextStyle style, string value)
         {
-            return style.Mutate(x => x.FontFamily = value);
+            return style.Mutate(TextStyleProperty.FontFamily, value);
         }
         
         [Obsolete("This element has been renamed since version 2022.3. Please use the FontSize method.")]
@@ -49,39 +41,39 @@ namespace QuestPDF.Fluent
         
         public static TextStyle FontSize(this TextStyle style, float value)
         {
-            return style.Mutate(x => x.Size = value);
+            return style.Mutate(TextStyleProperty.Size, value);
         }
         
         public static TextStyle LineHeight(this TextStyle style, float value)
         {
-            return style.Mutate(x => x.LineHeight = value);
+            return style.Mutate(TextStyleProperty.LineHeight, value);
         }
         
         public static TextStyle Italic(this TextStyle style, bool value = true)
         {
-            return style.Mutate(x => x.IsItalic = value);
+            return style.Mutate(TextStyleProperty.IsItalic, value);
         }
         
         public static TextStyle Strikethrough(this TextStyle style, bool value = true)
         {
-            return style.Mutate(x => x.HasStrikethrough = value);
+            return style.Mutate(TextStyleProperty.HasStrikethrough, value);
         }
         
         public static TextStyle Underline(this TextStyle style, bool value = true)
         {
-            return style.Mutate(x => x.HasUnderline = value);
+            return style.Mutate(TextStyleProperty.HasUnderline, value);
         }
         
         public static TextStyle WrapAnywhere(this TextStyle style, bool value = true)
         {
-            return style.Mutate(x => x.WrapAnywhere = value);
+            return style.Mutate(TextStyleProperty.WrapAnywhere, value);
         }
 
         #region Weight
         
         public static TextStyle Weight(this TextStyle style, FontWeight weight)
         {
-            return style.Mutate(x => x.FontWeight = weight);
+            return style.Mutate(TextStyleProperty.FontWeight, weight);
         }
         
         public static TextStyle Thin(this TextStyle style)
@@ -133,7 +125,45 @@ namespace QuestPDF.Fluent
         {
             return style.Weight(FontWeight.ExtraBlack);
         }
+
+        #endregion
+
+        #region Position
         
+        public static TextStyle NormalPosition(this TextStyle style)
+        {
+            return style.Position(FontPosition.Normal);
+        }
+
+        public static TextStyle Subscript(this TextStyle style)
+        {
+            return style.Position(FontPosition.Subscript);
+        }
+
+        public static TextStyle Superscript(this TextStyle style)
+        {
+            return style.Position(FontPosition.Superscript);
+        }
+
+        private static TextStyle Position(this TextStyle style, FontPosition fontPosition)
+        {
+            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
     }
 }

QuestPDF/Helpers/Fonts.cs

@@ -13,6 +13,7 @@
         public const string CourierNew = "Courier New";
         public const string Georgia = "Georgia";
         public const string Impact = "Impact";
+        public const string Lato = "Lato";
         public const string LucidaConsole = "Lucida Console";
         public const string SegoeSD = "Segoe SD";
         public const string SegoeUI = "Segoe UI";

QuestPDF/Helpers/Helpers.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text.RegularExpressions;
+using QuestPDF.Drawing;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Helpers
@@ -41,15 +42,23 @@ namespace QuestPDF.Helpers
 
         internal static string PrettifyName(this string text)
         {
-            return Regex.Replace(text, @"([a-z])([A-Z])", "$1 $2");
+            return Regex.Replace(text, @"([a-z])([A-Z])", "$1 $2", RegexOptions.Compiled);
         }
 
         internal static void VisitChildren(this Element? element, Action<Element?> handler)
         {
-            foreach (var child in element.GetChildren().Where(x => x != null))
-                VisitChildren(child, handler);
+            if (element == null)
+                return;
             
+            foreach (var child in element.GetChildren())
+                VisitChildren(child, handler);
+
             handler(element);
         }
+
+        internal static bool IsNegative(this Size size)
+        {
+            return size.Width < 0f || size.Height < 0f;
+        }
     }
 }

QuestPDF/Helpers/Placeholders.cs

@@ -7,7 +7,7 @@ namespace QuestPDF.Helpers
 {
     public static class Placeholders
     {
-        public static readonly Random Random = new();
+        public static readonly Random Random = new Random(0);
         
         #region Word Cache
 

QuestPDF/Infrastructure/FontPosition.cs

@@ -0,0 +1,9 @@
+namespace QuestPDF.Infrastructure
+{
+    internal enum FontPosition
+    {
+        Normal,
+        Subscript,
+        Superscript,
+    }
+}

QuestPDF/Infrastructure/ICanvas.cs

@@ -1,3 +1,4 @@
+using QuestPDF.Drawing;
 using SkiaSharp;
 
 namespace QuestPDF.Infrastructure
@@ -7,7 +8,7 @@ namespace QuestPDF.Infrastructure
         void Translate(Position vector);
         
         void DrawRectangle(Position vector, Size size, string color);
-        void DrawText(string text, Position position, TextStyle style);
+        void DrawText(SKTextBlob skTextBlob, Position position, TextStyle style);
         void DrawImage(SKImage image, Position position, Size size);
 
         void DrawHyperlink(string url, Size size);

QuestPDF/Infrastructure/IDynamicComponent.cs

@@ -0,0 +1,35 @@
+using System;
+using QuestPDF.Elements;
+using QuestPDF.Helpers;
+
+namespace QuestPDF.Infrastructure
+{
+    internal class DynamicComponentProxy
+    {
+        internal Action<object> SetState { get; private set; }
+        internal Func<object> GetState { get; private set; }
+        internal Func<DynamicContext, DynamicComponentComposeResult> Compose { get; private set; }
+        
+        internal static DynamicComponentProxy CreateFrom<TState>(IDynamicComponent<TState> component) where TState : struct
+        {
+            return new DynamicComponentProxy
+            {
+                GetState = () => component.State,
+                SetState = x => component.State = (TState)x,
+                Compose = component.Compose
+            };
+        }
+    }
+
+    public class DynamicComponentComposeResult
+    {
+        public IElement Content { get; set; }
+        public bool HasMoreContent { get; set; }
+    }
+    
+    public interface IDynamicComponent<TState> where TState : struct
+    {
+        TState State { get; set; }
+        DynamicComponentComposeResult Compose(DynamicContext context);
+    }
+}

QuestPDF/Infrastructure/TextStyle.cs

@@ -3,85 +3,38 @@ using QuestPDF.Helpers;
 
 namespace QuestPDF.Infrastructure
 {
-    public class TextStyle
+    public record TextStyle
     {
-        internal bool HasGlobalStyleApplied { get; private set; }
-        
         internal string? Color { get; set; }
         internal string? BackgroundColor { get; set; }
         internal string? FontFamily { get; set; }
         internal float? Size { get; set; }
         internal float? LineHeight { get; set; }
         internal FontWeight? FontWeight { get; set; }
+        internal FontPosition? FontPosition { get; set; }
         internal bool? IsItalic { get; set; }
         internal bool? HasStrikethrough { get; set; }
         internal bool? HasUnderline { get; set; }
         internal bool? WrapAnywhere { get; set; }
 
-        internal object PaintKey { get; private set; }
-        internal object FontMetricsKey { get; private set; }
-        
-        internal static TextStyle LibraryDefault => new TextStyle
+        internal TextStyle? Fallback { get; set; }
+
+        internal static TextStyle LibraryDefault { get; } = new()
         {
             Color = Colors.Black,
             BackgroundColor = Colors.Transparent,
-            FontFamily = Fonts.Calibri,
+            FontFamily = Fonts.Lato,
             Size = 12,
             LineHeight = 1.2f,
             FontWeight = Infrastructure.FontWeight.Normal,
+            FontPosition = Infrastructure.FontPosition.Normal,
             IsItalic = false,
             HasStrikethrough = false,
             HasUnderline = false,
-            WrapAnywhere = false
+            WrapAnywhere = false,
+            Fallback = null
         };
 
-        public static TextStyle Default => new TextStyle();
-        
-        internal void ApplyGlobalStyle(TextStyle globalStyle)
-        {
-            if (HasGlobalStyleApplied)
-                return;
-            
-            HasGlobalStyleApplied = true;
-
-            ApplyParentStyle(globalStyle);
-            PaintKey ??= (FontFamily, Size, FontWeight, IsItalic, Color);
-            FontMetricsKey ??= (FontFamily, Size, FontWeight, IsItalic);
-        }
-        
-        internal void ApplyParentStyle(TextStyle parentStyle)
-        {
-            Color ??= parentStyle.Color;
-            BackgroundColor ??= parentStyle.BackgroundColor;
-            FontFamily ??= parentStyle.FontFamily;
-            Size ??= parentStyle.Size;
-            LineHeight ??= parentStyle.LineHeight;
-            FontWeight ??= parentStyle.FontWeight;
-            IsItalic ??= parentStyle.IsItalic;
-            HasStrikethrough ??= parentStyle.HasStrikethrough;
-            HasUnderline ??= parentStyle.HasUnderline;
-            WrapAnywhere ??= parentStyle.WrapAnywhere;
-        }
-
-        internal void OverrideStyle(TextStyle parentStyle)
-        {
-            Color = parentStyle.Color ?? Color;
-            BackgroundColor = parentStyle.BackgroundColor ?? BackgroundColor;
-            FontFamily = parentStyle.FontFamily ?? FontFamily;
-            Size = parentStyle.Size ?? Size;
-            LineHeight = parentStyle.LineHeight ?? LineHeight;
-            FontWeight = parentStyle.FontWeight ?? FontWeight;
-            IsItalic = parentStyle.IsItalic ?? IsItalic;
-            HasStrikethrough = parentStyle.HasStrikethrough ?? HasStrikethrough;
-            HasUnderline = parentStyle.HasUnderline ?? HasUnderline;
-            WrapAnywhere = parentStyle.WrapAnywhere ?? WrapAnywhere;
-        }
-        
-        internal TextStyle Clone()
-        {
-            var clone = (TextStyle)MemberwiseClone();
-            clone.HasGlobalStyleApplied = false;
-            return clone;
-        }
+        public static TextStyle Default { get; } = new();
     }
 }

QuestPDF/Infrastructure/TextStyleManager.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Concurrent;
+using QuestPDF.Fluent;
+
+namespace QuestPDF.Infrastructure
+{
+    internal enum TextStyleProperty
+    {
+        Color,
+        BackgroundColor,
+        FontFamily,
+        Size,
+        LineHeight,
+        FontWeight,
+        FontPosition,
+        IsItalic,
+        HasStrikethrough,
+        HasUnderline,
+        WrapAnywhere,
+        Fallback
+    }
+    
+    internal static class TextStyleManager
+    {
+        private static readonly ConcurrentDictionary<(TextStyle origin, TextStyleProperty property, object value), TextStyle> TextStyleMutateCache = new();
+        private static readonly ConcurrentDictionary<(TextStyle origin, TextStyle parent), TextStyle> TextStyleApplyGlobalCache = new();
+        private static readonly ConcurrentDictionary<(TextStyle origin, TextStyle parent), TextStyle> TextStyleOverrideCache = new();
+
+        public static TextStyle Mutate(this TextStyle origin, TextStyleProperty property, object value)
+        {
+            var cacheKey = (origin, property, value);
+            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)
+        {
+            if (overrideValue && value == null)
+                return origin;
+            
+            if (property == TextStyleProperty.Color)
+            {
+                if (!overrideValue && origin.Color != null)
+                    return origin;
+                
+                var castedValue = (string?)value;
+
+                if (origin.Color == castedValue)
+                    return origin;
+
+                return origin with { Color = castedValue };
+            }
+            
+            if (property == TextStyleProperty.BackgroundColor)
+            {
+                if (!overrideValue && origin.BackgroundColor != null)
+                    return origin;
+                
+                var castedValue = (string?)value;
+                
+                if (origin.BackgroundColor == castedValue)
+                    return origin;
+
+                return origin with { BackgroundColor = castedValue };
+            }
+            
+            if (property == TextStyleProperty.FontFamily)
+            {
+                if (!overrideValue && origin.FontFamily != null)
+                    return origin;
+                
+                var castedValue = (string?)value;
+                
+                if (origin.FontFamily == castedValue)
+                    return origin;
+
+                return origin with { FontFamily = castedValue };
+            }
+            
+            if (property == TextStyleProperty.Size)
+            {
+                if (!overrideValue && origin.Size != null)
+                    return origin;
+                
+                var castedValue = (float?)value;
+                
+                if (origin.Size == castedValue)
+                    return origin;
+
+                return origin with { Size = castedValue };
+            }
+            
+            if (property == TextStyleProperty.LineHeight)
+            {
+                if (!overrideValue && origin.LineHeight != null)
+                    return origin;
+                
+                var castedValue = (float?)value;
+                
+                if (origin.LineHeight == castedValue)
+                    return origin;
+
+                return origin with { LineHeight = castedValue };
+            }
+            
+            if (property == TextStyleProperty.FontWeight)
+            {
+                if (!overrideValue && origin.FontWeight != null)
+                    return origin;
+                
+                var castedValue = (FontWeight?)value;
+                
+                if (origin.FontWeight == castedValue)
+                    return origin;
+
+                return origin with { FontWeight = castedValue };
+            }
+            
+            if (property == TextStyleProperty.FontPosition)
+            {
+                if (!overrideValue && origin.FontPosition != null)
+                    return origin;
+                
+                var castedValue = (FontPosition?)value;
+                
+                if (origin.FontPosition == castedValue)
+                    return origin;
+
+                return origin with { FontPosition = castedValue };
+            }
+            
+            if (property == TextStyleProperty.IsItalic)
+            {
+                if (!overrideValue && origin.IsItalic != null)
+                    return origin;
+                
+                var castedValue = (bool?)value;
+                
+                if (origin.IsItalic == castedValue)
+                    return origin;
+
+                return origin with { IsItalic = castedValue };
+            }
+            
+            if (property == TextStyleProperty.HasStrikethrough)
+            {
+                if (!overrideValue && origin.HasStrikethrough != null)
+                    return origin;
+                
+                var castedValue = (bool?)value;
+                
+                if (origin.HasStrikethrough == castedValue)
+                    return origin;
+
+                return origin with { HasStrikethrough = castedValue };
+            }
+            
+            if (property == TextStyleProperty.HasUnderline)
+            {
+                if (!overrideValue && origin.HasUnderline != null)
+                    return origin;
+                
+                var castedValue = (bool?)value;
+                
+                if (origin.HasUnderline == castedValue)
+                    return origin;
+
+                return origin with { HasUnderline = castedValue };
+            }
+            
+            if (property == TextStyleProperty.WrapAnywhere)
+            {
+                if (!overrideValue && origin.WrapAnywhere != null)
+                    return origin;
+
+                var castedValue = (bool?)value;
+                
+                if (origin.WrapAnywhere == castedValue)
+                    return origin;
+                
+                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 };
+            }
+
+            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);
+            return TextStyleApplyGlobalCache.GetOrAdd(cacheKey, key => ApplyStyle(key.origin, key.parent, overrideStyle: false).ApplyFontFallback());
+        }
+        
+        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);
+            
+            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)
+        {
+            var result = style;
+
+            result = MutateStyle(result, TextStyleProperty.Color, parent.Color, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.BackgroundColor, parent.BackgroundColor, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.FontFamily, parent.FontFamily, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.Size, parent.Size, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.LineHeight, parent.LineHeight, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.FontWeight, parent.FontWeight, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.FontPosition, parent.FontPosition, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.IsItalic, parent.IsItalic, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.HasStrikethrough, parent.HasStrikethrough, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.HasUnderline, parent.HasUnderline, overrideStyle);
+            result = MutateStyle(result, TextStyleProperty.WrapAnywhere, parent.WrapAnywhere, overrideStyle);
+            
+            if (applyFallback)
+                result = MutateStyle(result, TextStyleProperty.Fallback, parent.Fallback, overrideStyle);
+
+            return result;
+        }
+    }
+}

QuestPDF/Previewer/PreviewerExtensions.cs

@@ -20,7 +20,7 @@ namespace QuestPDF.Previewer
         {
             var previewerService = new PreviewerService(port);
             
-            var cancellationTokenSource = new CancellationTokenSource();
+            using var cancellationTokenSource = new CancellationTokenSource();
             previewerService.OnPreviewerStopped += () => cancellationTokenSource.Cancel();
             
             await previewerService.Connect();

QuestPDF/Previewer/PreviewerService.cs

@@ -17,6 +17,9 @@ namespace QuestPDF.Previewer
         private HttpClient HttpClient { get; }
         
         public  event Action? OnPreviewerStopped;
+
+        private const int RequiredPreviewerVersionMajor = 2022;
+        private const int RequiredPreviewerVersionMinor = 9;
         
         public PreviewerService(int port)
         {
@@ -24,7 +27,7 @@ namespace QuestPDF.Previewer
             HttpClient = new()
             {
                 BaseAddress = new Uri($"http://localhost:{port}/"), 
-                Timeout = TimeSpan.FromMilliseconds(250)
+                Timeout = TimeSpan.FromSeconds(1)
             };
         }
 
@@ -46,7 +49,7 @@ namespace QuestPDF.Previewer
         {
             try
             {
-                var result = await HttpClient.GetAsync("/ping");
+                using var result = await HttpClient.GetAsync("/ping");
                 return result.IsSuccessStatusCode;
             }
             catch
@@ -57,7 +60,7 @@ namespace QuestPDF.Previewer
         
         private async Task<Version> GetPreviewerVersion()
         {
-            var result = await HttpClient.GetAsync("/version");
+            using var result = await HttpClient.GetAsync("/version");
             return await result.Content.ReadFromJsonAsync<Version>();
         }
         
@@ -81,6 +84,7 @@ namespace QuestPDF.Previewer
                 Task.Run(async () =>
                 {
                     await process.WaitForExitAsync();
+                    process.Dispose();
                     OnPreviewerStopped?.Invoke();
                 });
             }
@@ -93,17 +97,17 @@ namespace QuestPDF.Previewer
 
         private void CheckVersionCompatibility(Version version)
         {
-            if (version.Major == 2022 && version.Minor == 4)
+            if (version.Major == RequiredPreviewerVersionMajor && version.Minor == RequiredPreviewerVersionMinor)
                 return;
             
             throw new Exception($"Previewer version is not compatible. Possible solutions: " +
                                 $"1) Update the QuestPDF library to newer version. " +
-                                $"2) Update the QuestPDF previewer tool using the following command: 'dotnet tool update --global QuestPDF.Previewer --version 2022.4'");
+                                $"2) Update the QuestPDF previewer tool using the following command: 'dotnet tool update --global QuestPDF.Previewer --version {RequiredPreviewerVersionMajor}.{RequiredPreviewerVersionMinor}'");
         }
         
         private async Task WaitForConnection()
         {
-            var cancellationTokenSource = new CancellationTokenSource();
+            using var cancellationTokenSource = new CancellationTokenSource();
             cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10));
             
             var cancellationToken = cancellationTokenSource.Token; 
@@ -124,7 +128,7 @@ namespace QuestPDF.Previewer
         
         public async Task RefreshPreview(ICollection<PreviewerPicture> pictures)
         {
-            var multipartContent = new MultipartFormDataContent();
+            using var multipartContent = new MultipartFormDataContent();
 
             var pages = new List<PreviewerRefreshCommand.Page>();
             
@@ -149,7 +153,7 @@ namespace QuestPDF.Previewer
             
             multipartContent.Add(JsonContent.Create(command), "command");
 
-            await HttpClient.PostAsync("/update/preview", multipartContent);
+            using var _ = await HttpClient.PostAsync("/update/preview", multipartContent);
 
             foreach (var picture in pictures)
                 picture.Picture.Dispose();

QuestPDF/QuestPDF.csproj

@@ -1,10 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
     <PropertyGroup>
         <Authors>MarcinZiabek</Authors>
         <Company>CodeFlint</Company>
         <PackageId>QuestPDF</PackageId>
-        <Version>2022.4.1</Version>
+        <Version>2022.9.0</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>
@@ -24,7 +23,8 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="SkiaSharp" Version="2.80.*" />
+      <PackageReference Include="SkiaSharp" Version="2.80.4" />
+      <PackageReference Include="SkiaSharp.HarfBuzz" Version="2.80.4" />
     </ItemGroup>
 
     <ItemGroup>
@@ -44,6 +44,25 @@
         <Visible>false</Visible>
         <PackagePath>\</PackagePath>
       </None>
+      <None Remove="Resources\DefaultFont\Lato-Black.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-Black.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-BlackItalic.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-BlackItalic.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-Bold.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-Bold.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-BoldItalic.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-BoldItalic.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-Italic.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-Italic.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-Light.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-Light.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-LightItalic.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-LightItalic.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-Regular.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-Regular.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-Thin.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-Thin.ttf" />
+      <None Remove="Resources\DefaultFont\Lato-ThinItalic.ttf" />
+      <EmbeddedResource Include="Resources\DefaultFont\Lato-ThinItalic.ttf" />
     </ItemGroup>
-
 </Project>