From 4f02fcfe6d72accae108b57f24df513b0a743c30 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 13:41:29 +0200
Subject: [PATCH 01/15] add overage to 90%

---
 .runsettings                                  |  13 ++
 CHANGELOG.md                                  |   3 +
 pdfsharpdslTests/DrawingValueTests.cs         |  90 ++++++++
 pdfsharpdslTests/FormulaTests.cs              |  88 ++++++-
 .../ReplayerTests/InstructionRecorderTests.cs |  87 +++++++
 pdfsharpdslTests/VariablesDictionaryTests.cs  |  84 +++++++
 pdfsharpdslTests/VisitorTests.cs              | 121 ++++++++++
 tasks.md                                      | 218 ++++++++++++++++++
 8 files changed, 703 insertions(+), 1 deletion(-)
 create mode 100644 .runsettings
 create mode 100644 pdfsharpdslTests/DrawingValueTests.cs
 create mode 100644 pdfsharpdslTests/VariablesDictionaryTests.cs
 create mode 100644 tasks.md

diff --git a/.runsettings b/.runsettings
new file mode 100644
index 0000000..4e5d087
--- /dev/null
+++ b/.runsettings
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RunSettings>
+  <DataCollectionRunSettings>
+    <DataCollectors>
+      <DataCollector friendlyName="XPlat Code Coverage">
+        <Configuration>
+          <Format>cobertura</Format>
+          <Include>[PdfSharpDslCore]*</Include>
+        </Configuration>
+      </DataCollector>
+    </DataCollectors>
+  </DataCollectionRunSettings>
+</RunSettings>
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b7cdfb9..98fe6d7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,9 @@
 
 # Change log
 
+## Version 1.0.5 (March 3, 2024)
+* Update nugets packages and upgrade to .Net 8
+
 ## Version 1.0.4 (May 19, 2023)
 * Add callback onNewpage in order to draw a custom template on each page.
   - Define UDF "__ONNEWPAGE()" in .ipdf file or register it via method 'RegisterCustomUdf(..)' in your dotnet language.
diff --git a/pdfsharpdslTests/DrawingValueTests.cs b/pdfsharpdslTests/DrawingValueTests.cs
new file mode 100644
index 0000000..f28a17d
--- /dev/null
+++ b/pdfsharpdslTests/DrawingValueTests.cs
@@ -0,0 +1,90 @@
+using PdfSharpCore.Drawing;
+using PdfSharpDslCore.Drawing;
+using PdfSharpDslCore.Extensions;
+
+namespace pdfsharpdslTests
+{
+    public class DrawingValueTests
+    {
+        [Fact]
+        public void OffsetYMovesRectanglesAndPointsWithoutChangingInputs()
+        {
+            var rectangle = new XRect(10, 20, 30, 40);
+            var point = new XPoint(5, 6);
+
+            var movedRectangle = rectangle.OffsetY(7);
+            var movedPoint = point.OffsetY(8);
+
+            Assert.Equal(20, rectangle.Y);
+            Assert.Equal(27, movedRectangle.Y);
+            Assert.Equal(10, movedRectangle.X);
+            Assert.Equal(6, point.Y);
+            Assert.Equal(14, movedPoint.Y);
+            Assert.Equal(5, movedPoint.X);
+        }
+
+        [Fact]
+        public void OffsetYMovesPointArraysOnlyWhenNeeded()
+        {
+            var points = new[] { new XPoint(1, 2), new XPoint(3, 4) };
+
+            var unchanged = points.OffsetY(0);
+            var moved = points.OffsetY(10);
+
+            Assert.Same(points, unchanged);
+            Assert.NotSame(points, moved);
+            Assert.Equal(new[] { 12.0, 14.0 }, moved.Select(point => point.Y));
+            Assert.Equal(new[] { 1.0, 3.0 }, moved.Select(point => point.X));
+        }
+
+        [Fact]
+        public void TableDefinitionCalculatesColumnDimensionsAndAlignment()
+        {
+            var table = new TableDefinition
+            {
+                TopMarginOnPageBreak = 12,
+                ShowHeader = false,
+                HeaderHeight = 20
+            };
+            table.Columns.Add(new ColumnDefinition
+            {
+                DesiredWidth = 80,
+                MaxWidth = 50,
+                Alignment = XStringAlignment.Center
+            });
+            table.Columns.Add(new ColumnDefinition());
+            table.Rows.Add(new RowDefinition
+            {
+                DesiredHeight = 15,
+                MaxHeight = 20,
+                Data = new[] { "value" }
+            });
+
+            Assert.Equal(80, table.ColWidth(0));
+            Assert.Equal(0, table.ColWidth(1));
+            Assert.Equal(50, table.ColMaxWidth(0, 100));
+            Assert.Equal(40, table.ColMaxWidth(1, 40));
+            Assert.Equal(XStringAlignment.Center, table.Alignment(0));
+            Assert.Equal(12, table.TopMarginOnPageBreak);
+            Assert.False(table.ShowHeader);
+            Assert.Equal(20, table.HeaderHeight);
+            Assert.Equal(15, table.Rows[0].DesiredHeight);
+            Assert.Equal(20, table.Rows[0].MaxHeight);
+            Assert.Equal("value", table.Rows[0].Data[0]);
+        }
+
+        [Fact]
+        public void DrawingResultStoresRectangleAndPageOffset()
+        {
+            var rectangle = new XRect(1, 2, 3, 4);
+            var result = new DrawingResult
+            {
+                DrawingRect = rectangle,
+                PageOffsetY = 25
+            };
+
+            Assert.Equal(rectangle, result.DrawingRect);
+            Assert.Equal(25, result.PageOffsetY);
+        }
+    }
+}
\ No newline at end of file
diff --git a/pdfsharpdslTests/FormulaTests.cs b/pdfsharpdslTests/FormulaTests.cs
index 3449c2d..301f334 100644
--- a/pdfsharpdslTests/FormulaTests.cs
+++ b/pdfsharpdslTests/FormulaTests.cs
@@ -1,4 +1,5 @@
-using PdfSharpDslCore.Parser;/**/
+using PdfSharpDslCore.Evaluation;
+using PdfSharpDslCore.Parser;/**/
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
@@ -66,5 +67,90 @@ public void ConvertTests()
             Assert.Equal(1.0, Convert.ToDouble(true));
             Assert.Equal(0.0, Convert.ToDouble(false));
         }
+
+        [Theory]
+        [InlineData((int)BinaryOperation.Sub, 1.0)]
+        [InlineData((int)BinaryOperation.Mul, 30.0)]
+        [InlineData((int)BinaryOperation.Div, 1.2)]
+        [InlineData((int)BinaryOperation.Mod, 1.0)]
+        public void BinaryNumericOperations(int operation, double expected)
+        {
+            var evaluation = new BinaryEvaluation(
+                new ConstantEvaluation<object>(6),
+                new ConstantEvaluation<object>(5),
+            (BinaryOperation)operation);
+
+            Assert.Equal(expected, evaluation.Value);
+        }
+
+        [Theory]
+        [InlineData((int)BinaryOperation.And, true, false, false)]
+        [InlineData((int)BinaryOperation.Or, false, true, true)]
+        [InlineData((int)BinaryOperation.Superior, 2, 1, true)]
+        [InlineData((int)BinaryOperation.SuperiorOrEquals, 2, 2, true)]
+        [InlineData((int)BinaryOperation.Inferior, 1, 2, true)]
+        [InlineData((int)BinaryOperation.InferiorOrEquals, 2, 2, true)]
+        [InlineData((int)BinaryOperation.Equals, "same", "same", true)]
+        [InlineData((int)BinaryOperation.NotEquals, "left", "right", true)]
+        public void BinaryBooleanOperations(int operation, object left, object right, bool expected)
+        {
+            var evaluation = new BinaryEvaluation(
+                new ConstantEvaluation<object>(left),
+                new ConstantEvaluation<object>(right),
+            (BinaryOperation)operation);
+
+            Assert.Equal(expected, evaluation.Value);
+        }
+
+        [Fact]
+        public void BinaryOperationsReportInvalidOperands()
+        {
+            var nullOperand = new BinaryEvaluation(
+                new ConstantEvaluation<object>(null!),
+                new ConstantEvaluation<object>(1),
+                BinaryOperation.Add);
+            var unsupportedStringOperation = new BinaryEvaluation(
+                new ConstantEvaluation<object>("left"),
+                new ConstantEvaluation<object>("right"),
+                BinaryOperation.Sub);
+            var invalidComparison = new BinaryEvaluation(
+                new ConstantEvaluation<object>("left"),
+                new ConstantEvaluation<object>(1),
+                BinaryOperation.Superior);
+
+            Assert.Throws<InvalidOperationException>(() => nullOperand.Value);
+            Assert.Throws<NotSupportedException>(() => unsupportedStringOperation.Value);
+            Assert.Throws<NotSupportedException>(() => invalidComparison.Value);
+        }
+
+        [Theory]
+        [InlineData((int)BinaryOperation.Add, 5, 5.0)]
+        [InlineData((int)BinaryOperation.Sub, 5, -5.0)]
+        [InlineData((int)BinaryOperation.Add, "value", "value")]
+        [InlineData((int)BinaryOperation.Sub, "value", "-value")]
+        public void UnaryOperations(int operation, object value, object expected)
+        {
+            var evaluation = new UnaryEvaluation(new ConstantEvaluation<object>(value), (BinaryOperation)operation);
+
+            Assert.Equal(expected, evaluation.Value);
+        }
+
+        [Fact]
+        public void UnaryOperationsReportInvalidOperands()
+        {
+            var nullOperand = new UnaryEvaluation(new ConstantEvaluation<object>(null!), BinaryOperation.Add);
+            var unsupportedOperation = new UnaryEvaluation(new ConstantEvaluation<object>(1), BinaryOperation.Mul);
+
+            Assert.Throws<InvalidOperationException>(() => nullOperand.Value);
+            Assert.Throws<InvalidOperationException>(() => unsupportedOperation.Value);
+        }
+
+        [Fact]
+        public void MissingVariableThrows()
+        {
+            var evaluation = new VariableEvaluation("missing", new Dictionary<string, object?>());
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => evaluation.Value);
+        }
     }
 }
diff --git a/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs b/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs
index e34d28a..2e55e26 100644
--- a/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs
+++ b/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs
@@ -9,6 +9,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Irony;
+using Microsoft.Extensions.Logging;
 using Xunit;
 
 namespace pdfsharpdslTests.ReplayerTests
@@ -147,6 +148,92 @@ public void RecorderTests_block_with_offsetY()
             Assert.Equal(new XRect(0,100, 50, 100), block1.Rect);
         }
 
+        [Fact]
+        public void InstructionActionExecutesWithOffsetAndExposesMetadata()
+        {
+            var rectangle = new XRect(1, 2, 3, 4);
+            double? appliedOffset = null;
+            var instruction = new InstructionAction(offset => appliedOffset = offset, rectangle, "action");
+
+            var result = instruction.Draw(defaultDrawerMock().Object, 12, 99);
+
+            Assert.Equal(rectangle, instruction.Rect);
+            Assert.Equal("action", instruction.Name);
+            Assert.Equal(12, appliedOffset);
+            Assert.Equal(0, result);
+        }
+
+        [Fact]
+        public void RecorderRootRejectsInstructionsAndBlockMetadataCanBeCleared()
+        {
+            var recorder = new BlocksRecorder();
+            var instruction = new DummyInstruction(new XRect(0, 0, 10, 10));
+
+            Assert.False(recorder.CanPushInstruction);
+            Assert.Throws<NotSupportedException>(() => recorder.CurrentBlock.PushInstruction(instruction));
+
+            var block = recorder.OpenBlock("named", 15, false, 4);
+            block.PushInstruction(instruction, false);
+
+            Assert.True(recorder.CanPushInstruction);
+            Assert.Equal("named", block.Name);
+            Assert.Equal(15, block.OffsetY);
+            Assert.NotNull(block.Parent);
+            Assert.True(block.Rect.IsEmpty);
+            Assert.Single(block.Instructions);
+
+            block.Clear();
+            Assert.Empty(block.Instructions);
+        }
+
+        [Fact]
+        public void NestedBlockMovesToNextPage()
+        {
+            var logger = new Mock<ILogger>();
+            logger.Setup(x => x.IsEnabled(LogLevel.Debug)).Returns(true);
+            var drawer = defaultDrawerMock();
+            var recorder = new BlocksRecorder(logger.Object);
+            var outer = recorder.OpenBlock("outer", 0, false);
+            var child = outer.OpenBlock("child", 250, true);
+            var instruction = new DummyInstruction(new XRect(0, 0, 50, 50));
+            child.PushInstruction(instruction);
+
+            var pageOffset = outer.Draw(drawer.Object, 0, 0);
+
+            drawer.Verify(x => x.NewPage(null, null), Times.Once);
+            Assert.Equal(new XRect(0, 0, 50, 50), instruction.DrawingRect);
+            Assert.True(pageOffset > 0);
+        }
+
+        [Fact]
+        public void OversizedNestedBlockCannotBePrintedEntirely()
+        {
+            var drawer = defaultDrawerMock();
+            var recorder = new BlocksRecorder();
+            var outer = recorder.OpenBlock("outer", 0, false);
+            var child = outer.OpenBlock("child", 0, true);
+            child.PushInstruction(new DummyInstruction(new XRect(0, 0, 50, 400)));
+
+            Assert.Throws<NotImplementedException>(() => outer.Draw(drawer.Object, 0, 0));
+        }
+
+        [Fact]
+        public void InstructionsCannotBeAddedWhileBlockIsDrawing()
+        {
+            var drawer = defaultDrawerMock();
+            var recorder = new BlocksRecorder();
+            var block = recorder.OpenBlock("block", 0, true);
+            var extraInstruction = new DummyInstruction(new XRect(0, 20, 10, 10));
+            block.PushInstruction(new InstructionAction(
+                _ => block.PushInstruction(extraInstruction),
+                new XRect(0, 0, 10, 10),
+                "mutating"));
+
+            block.Draw(drawer.Object, 0, 0);
+
+            Assert.Single(block.Instructions);
+        }
+
         private static void AddInstructions(IInstructionBlock block, int count, int height)
         {
             var r = new XRect(0, 0, 50, height);
diff --git a/pdfsharpdslTests/VariablesDictionaryTests.cs b/pdfsharpdslTests/VariablesDictionaryTests.cs
new file mode 100644
index 0000000..b1531e6
--- /dev/null
+++ b/pdfsharpdslTests/VariablesDictionaryTests.cs
@@ -0,0 +1,84 @@
+using System.Collections;
+using PdfSharpDslCore.Parser;
+
+namespace pdfsharpdslTests
+{
+    public class VariablesDictionaryTests
+    {
+        [Fact]
+        public void DictionarySupportsMutationAndSystemVariables()
+        {
+            var requestedSystemVariables = new List<string>();
+            var variables = new VariablesDictionary(name =>
+            {
+                requestedSystemVariables.Add(name);
+                return name == "PAGEWIDTH" ? 595 : 842;
+            });
+
+            variables.Add("FIRST", 1);
+            variables.Add(new KeyValuePair<string, object?>("SECOND", 2));
+
+            Assert.False(variables.IsReadOnly);
+            Assert.Equal(2, variables.Count);
+            Assert.Contains("FIRST", variables.Keys);
+            Assert.Contains(2, variables.Values);
+            Assert.True(variables.ContainsKey("SECOND"));
+            Assert.Equal(1, variables["FIRST"]);
+            Assert.Null(variables["MISSING"]);
+            Assert.Equal(595, variables["PAGEWIDTH"]);
+            Assert.Equal(842, variables["PAGEHEIGHT"]);
+            Assert.Equal(new[] { "PAGEWIDTH", "PAGEHEIGHT" }, requestedSystemVariables);
+            Assert.Throws<NotImplementedException>(() => variables["FIRST"] = 3);
+
+            Assert.True(variables.Remove("FIRST"));
+            Assert.False(variables.Remove("MISSING"));
+            variables.Clear();
+            Assert.Empty(variables.Keys);
+        }
+
+        [Fact]
+        public void SaveAndRestorePreserveOuterScope()
+        {
+            var variables = new VariablesDictionary(_ => 0);
+            variables.Add("VALUE", "outer");
+
+            variables.SaveVariables();
+            variables.Add("VALUE", "inner");
+            variables.Add("INNER_ONLY", true);
+
+            Assert.Equal("inner", variables["VALUE"]);
+            variables.RestoreVariables();
+            Assert.Equal("outer", variables["VALUE"]);
+            Assert.False(variables.ContainsKey("INNER_ONLY"));
+        }
+
+        [Fact]
+        public void GlobalScopeDisablesSaveAndRestore()
+        {
+            var variables = new VariablesDictionary(_ => 0)
+            {
+                GlobalScope = true
+            };
+            variables.Add("VALUE", "outer");
+
+            variables.SaveVariables();
+            variables.Add("VALUE", "global");
+            variables.RestoreVariables();
+
+            Assert.Equal("global", variables["VALUE"]);
+        }
+
+        [Fact]
+        public void UnsupportedCollectionMembersThrow()
+        {
+            var variables = new VariablesDictionary(_ => 0);
+            var item = new KeyValuePair<string, object?>("VALUE", 1);
+
+            Assert.Throws<NotImplementedException>(() => variables.Contains(item));
+            Assert.Throws<NotImplementedException>(() => variables.CopyTo(new[] { item }, 0));
+            Assert.Throws<NotImplementedException>(() => variables.Remove(item));
+            Assert.Throws<NotImplementedException>(() => variables.GetEnumerator());
+            Assert.Throws<NotImplementedException>(() => ((IEnumerable)variables).GetEnumerator());
+        }
+    }
+}
\ No newline at end of file
diff --git a/pdfsharpdslTests/VisitorTests.cs b/pdfsharpdslTests/VisitorTests.cs
index 02dfacb..78344a2 100644
--- a/pdfsharpdslTests/VisitorTests.cs
+++ b/pdfsharpdslTests/VisitorTests.cs
@@ -102,5 +102,126 @@ public void TestConditionEvaluator(string file)
                 Assert.Equal("OK", udF.Value[0]);
             }
         }
+
+        [Fact]
+        public void DrawExecutesViewSizeTextWidthAndDebugOptions()
+        {
+            var tree = ParseText("VIEWSIZE 100,140;TEXT 10,20 MaxWidth=30 Text=\"hello\";DEBUGOPTIONS DEBUG_TEXT, DEBUG_RECT, DEBUG_ROWTEMPLATE, DEBUG_RULE, DEBUG_ALL, UNKNOWN;");
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            drawer.SetupProperty(x => x.DebugOptions);
+
+            new PdfDrawerVisitor().Draw(drawer.Object, tree);
+
+            drawer.Verify(x => x.SetViewSize(100, 140), Times.Once);
+            drawer.Verify(x => x.DrawText("hello", 10, 20, 30, null), Times.Once);
+            Assert.Equal(
+                DebugOptions.DebugText | DebugOptions.DebugRect | DebugOptions.DebugRowTemplate | DebugOptions.DebugRule | DebugOptions.DebugAll,
+                drawer.Object.DebugOptions);
+        }
+
+        [Fact]
+        public void DrawResolvesPageSystemVariables()
+        {
+            var tree = ParseText("SET VAR WIDTH=$PAGEWIDTH;SET VAR HEIGHT=$PAGEHEIGHT;");
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            drawer.SetupGet(x => x.PageWidth).Returns(612);
+            drawer.SetupGet(x => x.PageHeight).Returns(792);
+            var visitor = new InspectablePdfDrawerVisitor();
+
+            visitor.Draw(drawer.Object, tree);
+
+            Assert.Equal(612.0, visitor.Vars["WIDTH"]);
+            Assert.Equal(792.0, visitor.Vars["HEIGHT"]);
+        }
+
+        [Fact]
+        public void CustomUdfCanFallBackToDslBodyOrOverrideIt()
+        {
+            var fallbackTree = ParseText("UDF SAMPLE(X) LINE $X,0,$X,1; ENDUDF CALL SAMPLE(3);");
+            var overrideTree = ParseText("CALL CUSTOM(5);");
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            var visitor = new InspectablePdfDrawerVisitor();
+            string[]? parameterNames = null;
+            object?[]? parameterValues = null;
+            visitor.RegisterCustomUdf("sample", (_, names, values) =>
+            {
+                parameterNames = names;
+                parameterValues = values;
+                return false;
+            });
+            visitor.RegisterCustomUdf("custom", (_, _, _) => false);
+            visitor.RegisterCustomUdf("CUSTOM", (_, _, values) =>
+            {
+                parameterValues = values;
+                return true;
+            });
+
+            visitor.Draw(drawer.Object, fallbackTree);
+            visitor.Draw(drawer.Object, overrideTree);
+
+            Assert.Equal(new[] { "X" }, parameterNames);
+            Assert.Equal(5.0, Assert.Single(parameterValues!));
+            drawer.Verify(x => x.DrawLine(3, 0, 3, 1), Times.Once);
+        }
+
+        [Fact]
+        public void CustomUdfErrorsAreReportedAsParserErrors()
+        {
+            var customFailureTree = ParseText("CALL CUSTOM();");
+            var missingTree = ParseText("CALL MISSING();");
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            var visitor = new InspectablePdfDrawerVisitor();
+            visitor.RegisterCustomUdf("CUSTOM", (_, _, _) => throw new InvalidOperationException("failure"));
+
+            var customError = Assert.Throws<PdfParserException>(() => visitor.Draw(drawer.Object, customFailureTree));
+            var missingError = Assert.Throws<PdfParserException>(() => visitor.Draw(drawer.Object, missingTree));
+
+            Assert.IsType<InvalidOperationException>(customError.InnerException);
+            Assert.Contains("MISSING", missingError.Message);
+        }
+
+        [Fact]
+        public void RowTemplateTracksOffsetsAndFinalHeight()
+        {
+            var tree = ParseText("ROWTEMPLATE Count=2 Y=10 Name=\"row\" BorderSize=2 NewPageTopMargin=5 LINE 0,0,10,10; ENDROWTEMPLATE");
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            drawer.SetupSequence(x => x.EndDrawRowTemplate(It.IsAny<int>()))
+                .Returns(new DrawingResult { DrawingRect = new XRect(0, 0, 10, 20), PageOffsetY = 0 })
+                .Returns(new DrawingResult { DrawingRect = new XRect(0, 20, 10, 30), PageOffsetY = 10 });
+            var visitor = new InspectablePdfDrawerVisitor();
+
+            visitor.Draw(drawer.Object, tree);
+
+            drawer.Verify(x => x.BeginIterationTemplate(2), Times.Once);
+            drawer.Verify(x => x.BeginDrawRowTemplate("row", 0, 12, 5), Times.Once);
+            drawer.Verify(x => x.BeginDrawRowTemplate("row", 1, 34, 5), Times.Once);
+            drawer.Verify(x => x.EndIterationTemplate(42), Times.Once);
+            drawer.Verify(x => x.DrawLine(0, 0, 10, 10), Times.Exactly(2));
+            Assert.Equal(42.0, visitor.Vars["LASTTEMPLATEHEIGHT"]);
+            Assert.False(visitor.Vars.ContainsKey("ROWINDEX"));
+        }
+
+        [Fact]
+        public void OnNewPageUdfPersistsGlobalVariables()
+        {
+            var tree = ParseText("UDF __ONNEWPAGE() SET VAR SAVEDPAGE=$PAGEINDEX; ENDUDF");
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            Action<int>? onNewPage = null;
+            drawer.Setup(x => x.RegisterOnNewPage(It.IsAny<Action<int>>()))
+                .Callback<Action<int>>(callback => onNewPage = callback);
+            var visitor = new InspectablePdfDrawerVisitor();
+
+            visitor.Draw(drawer.Object, tree);
+            Assert.NotNull(onNewPage);
+            onNewPage!(4);
+
+            Assert.Equal(4, visitor.Vars["PAGEINDEX"]);
+            Assert.Equal(4, visitor.Vars["SAVEDPAGE"]);
+        }
+
+        private sealed class InspectablePdfDrawerVisitor : PdfDrawerVisitor
+        {
+            public IDictionary<string, object?> Vars => Variables;
+        }
     }
 }
diff --git a/tasks.md b/tasks.md
new file mode 100644
index 0000000..23f1dc6
--- /dev/null
+++ b/tasks.md
@@ -0,0 +1,218 @@
+# .NET 10 Upgrade Tasks
+
+Coverage work blocks the framework upgrade. `PdfSharpDslCore` line coverage must be at least 90%; branch coverage is reported but does not gate progress.
+
+**Current verified coverage (2026-09-18):** 90.76% lines (2260/2490), 83.56% branches (778/931), 83 tests passed.
+
+## TASK-001: Coverage baseline
+
+**Status:** Complete (2026-09-18)  
+**Depends on:** None
+
+**Objective:** Establish reproducible, core-only Cobertura reporting and record the current baseline.
+
+**Affected files:** `.runsettings`, `scripts/coverage.ps1`, `tasks.md`
+
+**Acceptance criteria:**
+
+- The test suite runs through Coverlet's collector.
+- The report contains only the `PdfSharpDslCore` assembly.
+- The script prints line and branch totals and fails when the report is missing or contains another assembly.
+- Generated reports remain under the ignored `artifacts/` directory.
+
+**Validation:**
+
+```powershell
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+**Result:** 45 tests passed. Line coverage is 79.63% (1983/2490); branch coverage is 73.14% (681/931). The migration remains blocked.
+
+**Handoff:** Begin TASK-002. Raise core line coverage above the current baseline without changing target frameworks or enforcing the final threshold yet.
+
+## TASK-002: Evaluation coverage
+
+**Status:** Not started  
+**Depends on:** TASK-001
+
+**Objective:** Test arithmetic, comparison, boolean, unary, null, string, and error paths; investigate the `%` parser/evaluator mismatch.
+
+**Affected files:** `pdfsharpdslTests/FormulaTests.cs`, `PdfSharpDslCore/Evaluation/`, parser tests and parser implementation if the mismatch is confirmed
+
+**Acceptance criteria:** Evaluation branches have focused tests, the `%` behavior is documented by a test and corrected if defective, and all existing tests pass.
+
+**Validation:**
+
+```powershell
+dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj --filter FullyQualifiedName~FormulaTests
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+**Handoff:** Record the new coverage result here and identify the largest remaining uncovered core areas for TASK-003.
+
+## TASK-003: Variables and UDFs
+
+**Status:** Not started  
+**Depends on:** TASK-002
+
+**Objective:** Cover variable lifecycle, nested scopes, system variables, UDF dispatch, failure paths, and `__ONNEWPAGE`.
+
+**Affected files:** `pdfsharpdslTests/`, `PdfSharpDslCore/` variable and UDF implementation
+
+**Acceptance criteria:** Focused tests cover successful and failing variable/UDF behavior, including nested scope and new-page callbacks.
+
+**Validation:**
+
+```powershell
+dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+**Handoff:** Record coverage and list remaining visitor or drawing gaps for TASK-004.
+
+## TASK-004: Visitor and drawing helpers
+
+**Status:** Not started  
+**Depends on:** TASK-003
+
+**Objective:** Cover visitor dispatch, page defaults, debug options, tables, images, alignment, clipping, and width calculations.
+
+**Affected files:** `pdfsharpdslTests/VisitorTests.cs`, `pdfsharpdslTests/RenderingTests.cs`, `PdfSharpDslCore/Drawing/`, visitor implementation
+
+**Acceptance criteria:** Deterministic tests cover the listed helper paths without requiring committed generated PDFs.
+
+**Validation:**
+
+```powershell
+dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+**Handoff:** Record coverage and enumerate only the gaps needed to exceed 80% in TASK-005.
+
+## TASK-005: Enforce coverage
+
+**Status:** Not started  
+**Depends on:** TASK-004
+
+**Objective:** Cover remaining pagination and PDF drawing paths, then enforce core line coverage of at least 90%.
+
+**Affected files:** Remaining core tests, `scripts/coverage.ps1`, CI workflow if present
+
+**Acceptance criteria:** `PdfSharpDslCore` line coverage is at least 90%, the script fails below 90%, and branch coverage remains informational.
+
+**Validation:**
+
+```powershell
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+**Handoff:** Unblock TASK-006 only after recording a passing line rate here.
+
+## TASK-006: Generator safety
+
+**Status:** Blocked by coverage  
+**Depends on:** TASK-005
+
+**Objective:** Remove the hard-coded Debug assembly path and add a real Roslyn generator compilation test.
+
+**Affected files:** `PdfSharpDslCore.Generator/`, `pdfsharpdslTests/SourceGenerator/`
+
+**Acceptance criteria:** Generator tests compile a representative input and Debug and Release builds succeed without configuration-specific paths.
+
+**Validation:**
+
+```powershell
+dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj --filter FullyQualifiedName~SourceGenerator
+dotnet build .\bnf_and_pdf.sln --configuration Debug
+dotnet build .\bnf_and_pdf.sln --configuration Release
+```
+
+**Handoff:** Document generator loading assumptions before dependency upgrades.
+
+## TASK-007: Dependencies
+
+**Status:** Blocked by coverage  
+**Depends on:** TASK-006
+
+**Objective:** Upgrade test, Coverlet, Roslyn, logging, image, font, and archive packages; resolve ImageSharp advisories.
+
+**Affected files:** Project files and package lock/restore outputs where applicable
+
+**Acceptance criteria:** Restored packages have no known ImageSharp advisories, core and generator retain `netstandard2.0`, and tests and coverage remain passing.
+
+**Validation:**
+
+```powershell
+dotnet restore .\bnf_and_pdf.sln
+dotnet list .\bnf_and_pdf.sln package --vulnerable --include-transitive
+dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+**Handoff:** Record selected package versions and any .NET 10 compatibility constraints.
+
+## TASK-008: Framework migration
+
+**Status:** Blocked by coverage  
+**Depends on:** TASK-007
+
+**Objective:** Pin .NET 10, move console and tests to `net10.0`, retain reusable projects on `netstandard2.0`, and update GitHub Actions.
+
+**Affected files:** `global.json`, console/test project files, `.github/workflows/`
+
+**Acceptance criteria:** The intended SDK is selected, console and tests target `net10.0`, core and generator target `netstandard2.0`, and workflows use `actions/setup-dotnet@v4` with `10.0.x`.
+
+**Validation:**
+
+```powershell
+dotnet --version
+dotnet build .\bnf_and_pdf.sln
+dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+**Handoff:** Record SDK and target framework versions for package validation.
+
+## TASK-009: Package validation
+
+**Status:** Blocked by coverage  
+**Depends on:** TASK-008
+
+**Objective:** Validate both configurations, NuGet packages, generator loading in a clean consumer, console samples, and rendering tests.
+
+**Affected files:** Project packaging metadata, test fixtures, console samples
+
+**Acceptance criteria:** Debug and Release builds pass, both packages can be packed, a clean `net10.0` consumer loads the generator, and samples/rendering tests pass.
+
+**Validation:**
+
+```powershell
+dotnet build .\bnf_and_pdf.sln --configuration Debug
+dotnet build .\bnf_and_pdf.sln --configuration Release
+dotnet pack .\PdfSharpDslCore\PdfSharpDslCore.csproj --configuration Release
+dotnet pack .\PdfSharpDslCore.Generator\PdfSharpDslCore.Generator.csproj --configuration Release
+dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
+```
+
+**Handoff:** Record package paths and clean-consumer results for documentation.
+
+## TASK-010: Documentation
+
+**Status:** Blocked by coverage  
+**Depends on:** TASK-009
+
+**Objective:** Document the completed migration, framework support, and coverage workflow.
+
+**Affected files:** `README.md`, `PdfSharpDslCore/Readme.md`, `CHANGELOG.md`, `tasks.md`
+
+**Acceptance criteria:** The root README links this tracker, supported frameworks and coverage commands are accurate, and the changelog summarizes the migration.
+
+**Validation:**
+
+```powershell
+powershell -NoProfile -File .\scripts\coverage.ps1
+dotnet build .\bnf_and_pdf.sln --configuration Release
+```
+
+**Handoff:** Mark the roadmap complete only after all links, commands, and recorded versions are verified.
\ No newline at end of file

From 3938138912864014d17f4173056a08ce59376239 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 14:21:57 +0200
Subject: [PATCH 02/15] migration dotnet 10 + coverage up to 90%

---
 .github/workflows/build.yml                   |   4 +-
 .github/workflows/release-package.yml         |   4 +-
 CHANGELOG.md                                  |   6 +
 PdfSharpDslConsole/PdfSharpDslConsole.csproj  |   4 +-
 .../PdfSharpDslCore.Generator.csproj          |  20 ++--
 PdfSharpDslCore/Drawing/DrawingHelper.cs      |   4 +-
 PdfSharpDslCore/Evaluation/Evaluator.cs       |   3 +
 PdfSharpDslCore/Parser/PdfDrawerVisitor.cs    |   4 +-
 PdfSharpDslCore/Parser/PdfVisitor.cs          |   6 +-
 PdfSharpDslCore/PdfSharpDslCore.csproj        |   3 +-
 PdfSharpDslCore/Readme.md                     |   4 +
 README.md                                     |  15 +++
 global.json                                   |   2 +-
 pdfsharpdslTests/DrawingValueTests.cs         |  31 +++++
 pdfsharpdslTests/FormulaTests.cs              |  15 ++-
 pdfsharpdslTests/PdfDocumentDrawerTests.cs    |  36 ++++++
 .../SourceGenerator/SourceGeneratorTests.cs   |  88 +++++++++++++-
 pdfsharpdslTests/VisitorTests.cs              | 113 +++++++++++++++++-
 pdfsharpdslTests/pdfsharpdslTests.csproj      |  12 +-
 scripts/coverage.ps1                          |  60 ++++++++++
 20 files changed, 399 insertions(+), 35 deletions(-)
 create mode 100644 pdfsharpdslTests/PdfDocumentDrawerTests.cs
 create mode 100644 scripts/coverage.ps1

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 25f43e7..a3ddfb3 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -17,9 +17,9 @@ jobs:
     steps:
     - uses: actions/checkout@v3
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 6.0.x
+        dotnet-version: 10.0.x
     - name: Restore dependencies
       run: dotnet restore
     - name: Build
diff --git a/.github/workflows/release-package.yml b/.github/workflows/release-package.yml
index bbecc78..94a0a23 100644
--- a/.github/workflows/release-package.yml
+++ b/.github/workflows/release-package.yml
@@ -13,9 +13,9 @@ jobs:
     steps:       
       - uses: actions/checkout@v3
       - name: Setup .NET
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 6.0.x      
+          dotnet-version: 10.0.x      
 
       - name: Restore dependencies
         run: dotnet restore
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 98fe6d7..08713a6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,12 @@
 
 # Change log
 
+## Unreleased
+* Migrated console and test projects to .NET 10 while retaining reusable projects on .NET Standard 2.0.
+* Added reproducible core-only coverage enforcement at 90% line coverage.
+* Added Roslyn source-generator compilation and clean NuGet consumer validation.
+* Updated dependencies and resolved known ImageSharp and runtime package advisories.
+
 ## Version 1.0.5 (March 3, 2024)
 * Update nugets packages and upgrade to .Net 8
 
diff --git a/PdfSharpDslConsole/PdfSharpDslConsole.csproj b/PdfSharpDslConsole/PdfSharpDslConsole.csproj
index 06cf314..621402a 100644
--- a/PdfSharpDslConsole/PdfSharpDslConsole.csproj
+++ b/PdfSharpDslConsole/PdfSharpDslConsole.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <Version>0.1.0</Version>
@@ -14,7 +14,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>    
diff --git a/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj b/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
index 410878f..f83c090 100644
--- a/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
+++ b/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
@@ -7,11 +7,10 @@
 		<Description>
 			Pdf Generation using source generation
 		</Description>
-		<Version>1.0.0</Version>
+		<Version>1.0.2</Version>
 		<Authors>Pierrick Gourlain</Authors>
 		<Company></Company>
 		<RepositoryUrl>https://github.com/pgourlain/bnf_and_pdf</RepositoryUrl>
-		<PackageIcon>Icon.jpg</PackageIcon>
 		<PackageLicenseFile>LICENSE.md</PackageLicenseFile>
 		<GeneratePackageOnBuild>false</GeneratePackageOnBuild>
 		<IncludeBuildOutput>false</IncludeBuildOutput>
@@ -20,18 +19,24 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Irony" Version="1.5.0" GeneratePathProperty="true" />
+		<PackageReference Include="Irony" Version="1.5.3" GeneratePathProperty="true" />
 		<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" PrivateAssets="all" />
 		<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
+		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" GeneratePathProperty="true" />
 		<PackageReference Include="PdfSharpCore" Version="1.3.63" GeneratePathProperty="true" />
-		<PackageReference Include="SixLabors.Fonts" Version="1.0.0-beta19" GeneratePathProperty="true" />
-		<PackageReference Include="SixLabors.ImageSharp" Version="2.1.3" GeneratePathProperty="true" />
-		<PackageReference Include="SharpZipLib" Version="1.4.1" GeneratePathProperty="true" />
+		<PackageReference Include="SixLabors.Fonts" Version="1.0.1" GeneratePathProperty="true" />
+		<PackageReference Include="SixLabors.ImageSharp" Version="2.1.12" GeneratePathProperty="true" />
+		<PackageReference Include="SharpZipLib" Version="1.4.2" GeneratePathProperty="true" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<None Include="..\LICENSE.md" Pack="true" PackagePath="\" Visible="false" />
 	</ItemGroup>
 
 	<ItemGroup>
 		<!-- Package the generator in the analyzer directory of the nuget package -->
 		<None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+		<None Include="$(MSBuildProjectDirectory)\..\PdfSharpDslCore\bin\$(Configuration)\netstandard2.0\PdfSharpDslCore.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 
 		<!-- Package the Irony dependency alongside the generator assembly -->
 		<None Include="$(PKGIrony)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
@@ -39,6 +44,7 @@
 		<None Include="$(PKGSixLabors_Fonts)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 		<None Include="$(PKGSixLabors_ImageSharp)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 		<None Include="$(PKGSharpZipLib)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+		<None Include="$(PKGMicrosoft_Extensions_Logging_Abstractions)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -52,7 +58,7 @@
 	<Target Name="GetDependencyTargetPaths">
 		<ItemGroup>
 			<TargetPathWithTargetPlatformMoniker Include="$(PKGIrony)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="false" />
-			<TargetPathWithTargetPlatformMoniker Include="..\PdfSharpDslCore\bin\Debug\netstandard2.0\PdfSharpDslCore.dll" IncludeRuntimeDependency="false" />
+			<TargetPathWithTargetPlatformMoniker Include="$(MSBuildProjectDirectory)\..\PdfSharpDslCore\bin\$(Configuration)\$(TargetFramework)\PdfSharpDslCore.dll" IncludeRuntimeDependency="false" />
 			<TargetPathWithTargetPlatformMoniker Include="$(PKGPdfSharpCore)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="true" />
 			<TargetPathWithTargetPlatformMoniker Include="$(PKGSixLabors_Fonts)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="false" />
 			<TargetPathWithTargetPlatformMoniker Include="$(PKGSixLabors_ImageSharp)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="false" />
diff --git a/PdfSharpDslCore/Drawing/DrawingHelper.cs b/PdfSharpDslCore/Drawing/DrawingHelper.cs
index 78c39f7..0956954 100644
--- a/PdfSharpDslCore/Drawing/DrawingHelper.cs
+++ b/PdfSharpDslCore/Drawing/DrawingHelper.cs
@@ -24,7 +24,7 @@ public static XRect RectFromStringFormat(XRect r, XSize textSize, XStringFormat
                 case XStringAlignment.Near:
                     break;
                 case XStringAlignment.Far:
-                    result.Offset(r.Right - textSize.Width, 0);
+                    result.Offset(r.Width - textSize.Width, 0);
                     break;
             }
 
@@ -36,7 +36,7 @@ public static XRect RectFromStringFormat(XRect r, XSize textSize, XStringFormat
                 case XLineAlignment.Near:
                     break;
                 case XLineAlignment.Far:
-                    result.Offset(0, r.Bottom - textSize.Height);
+                    result.Offset(0, r.Height - textSize.Height);
                     break;
             }
 
diff --git a/PdfSharpDslCore/Evaluation/Evaluator.cs b/PdfSharpDslCore/Evaluation/Evaluator.cs
index a08fa7f..3e1c2f9 100644
--- a/PdfSharpDslCore/Evaluation/Evaluator.cs
+++ b/PdfSharpDslCore/Evaluation/Evaluator.cs
@@ -79,6 +79,9 @@ private IEvaluation<object> PerformEvaluate(ParseTreeNode node, IDictionary<stri
                         case "/":
                             op = BinaryOperation.Div;
                             break;
+                        case "%":
+                            op = BinaryOperation.Mod;
+                            break;
                         case ">":
                             op = BinaryOperation.Superior;
                             break;
diff --git a/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs b/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
index 12e0764..27c7f38 100644
--- a/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
+++ b/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
@@ -294,7 +294,8 @@ protected override void ExecuteImage(IPdfDocumentDrawer drawer, ParseTreeNode lo
             {
                 //try to parse unit and cropping
                 unit = unitNode.Term.Name;
-                crop = cropNode?.ChildNodes.Count > 0;
+                crop = cropNode?.ChildNodes.Any(x =>
+                    string.Equals(x.Token?.Text, "crop", StringComparison.OrdinalIgnoreCase)) == true;
             }
 
             XImage image;
@@ -471,6 +472,7 @@ protected override void ExecuteDebugOptions(IPdfDocumentDrawer state, IEnumerabl
             "DEBUG_TEXT" => DebugOptions.DebugText,
             "DEBUG_RECT" => DebugOptions.DebugRect,
             "DEBUG_ROWTEMPLATE" => DebugOptions.DebugRowTemplate,
+            "DEBUG_IMAGE" => DebugOptions.DebugImage,
             "DEBUG_RULE" => DebugOptions.DebugRule,
             "DEBUG_ALL" => DebugOptions.DebugAll,
             _ => DebugOptions.None
diff --git a/PdfSharpDslCore/Parser/PdfVisitor.cs b/PdfSharpDslCore/Parser/PdfVisitor.cs
index 8fb56cd..4a2dee6 100644
--- a/PdfSharpDslCore/Parser/PdfVisitor.cs
+++ b/PdfSharpDslCore/Parser/PdfVisitor.cs
@@ -314,9 +314,11 @@ protected void ExecuteUdfByName(TState state, string fnName, ParseTreeNode? argu
             {
                 defArgs = defNode.ChildNode("UdfArgumentslist")!;
                 defBody = defNode.ChildNode("UdfBlock")?.ChildNode("EmbbededSmtList")!;
-                if (defArgs!= null && arguments!=null && defArgs.ChildNodes.Count != arguments.ChildNodes.Count)
+                var expectedArgumentCount = defArgs?.ChildNodes.Count ?? 0;
+                var providedArgumentCount = arguments?.ChildNodes.Count ?? 0;
+                if (expectedArgumentCount != providedArgumentCount)
                 {
-                    throw new PdfParserException($"UDF '{fnName}' arguments count not match, provided ${arguments.ChildNodes.Count}, expected ${defArgs.ChildNodes.Count}.");
+                    throw new PdfParserException($"UDF '{fnName}' arguments count does not match, provided {providedArgumentCount}, expected {expectedArgumentCount}.");
                 }
 
                 if (defArgs == null)
diff --git a/PdfSharpDslCore/PdfSharpDslCore.csproj b/PdfSharpDslCore/PdfSharpDslCore.csproj
index 0cd7958..354a1cc 100644
--- a/PdfSharpDslCore/PdfSharpDslCore.csproj
+++ b/PdfSharpDslCore/PdfSharpDslCore.csproj
@@ -24,9 +24,10 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Irony" Version="1.5.0" />
+		<PackageReference Include="Irony" Version="1.5.3" />
 		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
 		<PackageReference Include="PdfSharpCore" Version="1.3.63" />
+		<PackageReference Include="SixLabors.ImageSharp" Version="2.1.12" />
 	</ItemGroup>
 	<ItemGroup>
 	  <None Update="Icon.jpg">
diff --git a/PdfSharpDslCore/Readme.md b/PdfSharpDslCore/Readme.md
index a7c4494..f4ffd0b 100644
--- a/PdfSharpDslCore/Readme.md
+++ b/PdfSharpDslCore/Readme.md
@@ -3,6 +3,10 @@
 
 Package to print PDF using a specific DSL, using Irony.Net and PdfSharpCore
 
+The reusable library targets `netstandard2.0`. The source generator package also targets `netstandard2.0` and can be consumed by a `net10.0` application. The repository's test and console projects target `net10.0`.
+
+The repository enforces at least 90% line coverage for `PdfSharpDslCore` through `scripts\coverage.ps1`.
+
 # How to
 
 Goto [https://github.com/pgourlain/bnf_and_pdf](https://github.com/pgourlain/bnf_and_pdf) for example and usage
diff --git a/README.md b/README.md
index 87e75f1..59bb7b8 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,21 @@
 
 This is a sample library that use [Irony.Net](https://github.com/IronyProject/Irony) to define a grammar to print PDF using [PdfSharpCore](https://github.com/ststeiger/PdfSharpCore/)
 
+## Current support
+
+- `PdfSharpDslCore` and `PdfSharpDslCore.Generator` target `netstandard2.0`.
+- `PdfSharpDslConsole` and the test project target `net10.0`.
+- The repository is pinned to SDK `10.0.400` in `global.json`.
+- The generator package includes its analyzer dependencies and supports clean NuGet consumer builds.
+
+Run the full test and core coverage gate with:
+
+```powershell
+powershell -NoProfile -File .\scripts\coverage.ps1
+```
+
+The gate requires at least 90% core line coverage. See [tasks.md](tasks.md) for the migration tracker and verified results.
+
 
 # Example
 
diff --git a/global.json b/global.json
index 1b5ac1d..38c4f3c 100644
--- a/global.json
+++ b/global.json
@@ -1,6 +1,6 @@
 {
     "sdk": {
-      "version": "8.0.0",
+      "version": "10.0.400",
       "rollForward": "latestFeature"
     }
   }
\ No newline at end of file
diff --git a/pdfsharpdslTests/DrawingValueTests.cs b/pdfsharpdslTests/DrawingValueTests.cs
index f28a17d..740684b 100644
--- a/pdfsharpdslTests/DrawingValueTests.cs
+++ b/pdfsharpdslTests/DrawingValueTests.cs
@@ -65,6 +65,8 @@ public void TableDefinitionCalculatesColumnDimensionsAndAlignment()
             Assert.Equal(50, table.ColMaxWidth(0, 100));
             Assert.Equal(40, table.ColMaxWidth(1, 40));
             Assert.Equal(XStringAlignment.Center, table.Alignment(0));
+            Assert.Equal(50, table.Columns[0].DrawWidth);
+            Assert.Equal(0, table.Columns[1].DrawWidth);
             Assert.Equal(12, table.TopMarginOnPageBreak);
             Assert.False(table.ShowHeader);
             Assert.Equal(20, table.HeaderHeight);
@@ -86,5 +88,34 @@ public void DrawingResultStoresRectangleAndPageOffset()
             Assert.Equal(rectangle, result.DrawingRect);
             Assert.Equal(25, result.PageOffsetY);
         }
+
+        [Fact]
+        public void TextRectangleAlignmentUsesRelativeBounds()
+        {
+            var bounds = new XRect(10, 20, 100, 50);
+            var textSize = new XSize(30, 10);
+            var centered = DrawingHelper.RectFromStringFormat(bounds, textSize, new XStringFormat
+            {
+                Alignment = XStringAlignment.Center,
+                LineAlignment = XLineAlignment.Center
+            });
+            var far = DrawingHelper.RectFromStringFormat(bounds, textSize, new XStringFormat
+            {
+                Alignment = XStringAlignment.Far,
+                LineAlignment = XLineAlignment.Far
+            });
+
+            Assert.Equal(new XRect(45, 40, 30, 10), centered);
+            Assert.Equal(new XRect(80, 60, 30, 10), far);
+        }
+
+        [Fact]
+        public void TextRectangleIsClippedToProvidedBounds()
+        {
+            var bounds = new XRect(10, 20, 100, 50);
+            var result = DrawingHelper.RectFromStringFormat(bounds, new XSize(200, 100), XStringFormats.TopLeft);
+
+            Assert.Equal(bounds, result);
+        }
     }
 }
\ No newline at end of file
diff --git a/pdfsharpdslTests/FormulaTests.cs b/pdfsharpdslTests/FormulaTests.cs
index 301f334..50deefc 100644
--- a/pdfsharpdslTests/FormulaTests.cs
+++ b/pdfsharpdslTests/FormulaTests.cs
@@ -1,4 +1,6 @@
-using PdfSharpDslCore.Evaluation;
+using Moq;
+using PdfSharpDslCore.Drawing;
+using PdfSharpDslCore.Evaluation;
 using PdfSharpDslCore.Parser;/**/
 using System;
 using System.Collections.Generic;
@@ -152,5 +154,16 @@ public void MissingVariableThrows()
 
             Assert.Throws<ArgumentOutOfRangeException>(() => evaluation.Value);
         }
+
+        [Fact]
+        public void ModuloOperatorIsEvaluatedFromParsedDsl()
+        {
+            var tree = ParseText("SET VAR X=7%3;");
+            var visitor = new PdfDrawerForTestsVisitor();
+
+            visitor.Draw(Mock.Of<IPdfDocumentDrawer>(), tree);
+
+            Assert.Equal(1.0, visitor.Vars["X"]);
+        }
     }
 }
diff --git a/pdfsharpdslTests/PdfDocumentDrawerTests.cs b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
new file mode 100644
index 0000000..685f1ac
--- /dev/null
+++ b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
@@ -0,0 +1,36 @@
+using PdfSharpCore;
+using PdfSharpCore.Pdf;
+using PdfSharpDslCore.Drawing;
+
+namespace pdfsharpdslTests
+{
+    public class PdfDocumentDrawerTests
+    {
+        [Fact]
+        public void NewPageUsesDefaultsAndPersistsExplicitSettings()
+        {
+            using var document = new PdfDocument();
+            using var drawer = new PdfDocumentDrawer(document);
+            var pageNumbers = new List<int>();
+            Action<int> callback = pageNumbers.Add;
+            drawer.RegisterOnNewPage(callback);
+            drawer.RegisterOnNewPage(callback);
+
+            Assert.Equal(PageSize.A4, drawer.CurrentPage.Size);
+            Assert.Equal(PageOrientation.Portrait, drawer.CurrentPage.Orientation);
+
+            drawer.NewPage(PageSize.Letter, PageOrientation.Landscape);
+            Assert.Equal(PageSize.Letter, drawer.CurrentPage.Size);
+            Assert.Equal(PageOrientation.Landscape, drawer.CurrentPage.Orientation);
+
+            drawer.NewPage();
+            Assert.Equal(PageSize.Letter, drawer.CurrentPage.Size);
+            Assert.Equal(PageOrientation.Landscape, drawer.CurrentPage.Orientation);
+            Assert.Equal(new[] { 2, 3 }, pageNumbers);
+
+            drawer.UnRegisterOnNewPage(callback);
+            drawer.NewPage();
+            Assert.Equal(new[] { 2, 3 }, pageNumbers);
+        }
+    }
+}
\ No newline at end of file
diff --git a/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs b/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs
index d1c0ebb..a64dc11 100644
--- a/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs
+++ b/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs
@@ -1,11 +1,12 @@
-using PdfSharpDslCore.Generator;
-using System;
-using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using PdfSharpCore.Drawing;
+using PdfSharpDslCore.Drawing;
+using PdfSharpDslCore.Generator;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Security.Cryptography;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace pdfsharpdslTests.SourceGenerator
 {
@@ -22,5 +23,80 @@ public void TestSourceGeneration(string file)
 
             Assert.NotNull(result);
         }
+
+        [Fact]
+        public void GeneratorProducesCompilableSourceFromTaggedAdditionalFile()
+        {
+            var source = CSharpSyntaxTree.ParseText("namespace Consumer { internal class Marker { } }");
+            var references = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!)
+                .Split(Path.PathSeparator)
+                .Append(typeof(IPdfDocumentDrawer).Assembly.Location)
+                .Append(typeof(XColor).Assembly.Location)
+                .Distinct()
+                .Select(path => MetadataReference.CreateFromFile(path));
+            var compilation = CSharpCompilation.Create(
+                "Consumer",
+                new[] { source },
+                references,
+                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+            var additionalFile = new InMemoryAdditionalText("sample.txt", "NEWPAGE;");
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(
+                new[] { new DslGenerator() },
+                new[] { additionalFile },
+                (CSharpParseOptions)source.Options,
+                new PdfDslOptionsProvider());
+
+            driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var generatorDiagnostics);
+
+            Assert.Empty(generatorDiagnostics.Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error));
+            Assert.Equal(2, outputCompilation.SyntaxTrees.Count());
+            Assert.Empty(outputCompilation.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error));
+        }
+
+        private sealed class InMemoryAdditionalText : AdditionalText
+        {
+            private readonly SourceText _text;
+
+            public InMemoryAdditionalText(string path, string text)
+            {
+                Path = path;
+                _text = SourceText.From(text, Encoding.UTF8);
+            }
+
+            public override string Path { get; }
+
+            public override SourceText GetText(CancellationToken cancellationToken = default) => _text;
+        }
+
+        private sealed class PdfDslOptionsProvider : AnalyzerConfigOptionsProvider
+        {
+            private static readonly AnalyzerConfigOptions Empty = new TestAnalyzerConfigOptions(false);
+            private static readonly AnalyzerConfigOptions PdfDsl = new TestAnalyzerConfigOptions(true);
+
+            public override AnalyzerConfigOptions GlobalOptions => Empty;
+
+            public override AnalyzerConfigOptions GetOptions(SyntaxTree tree) => Empty;
+
+            public override AnalyzerConfigOptions GetOptions(AdditionalText textFile) => PdfDsl;
+        }
+
+        private sealed class TestAnalyzerConfigOptions : AnalyzerConfigOptions
+        {
+            private readonly bool _isPdfDsl;
+
+            public TestAnalyzerConfigOptions(bool isPdfDsl) => _isPdfDsl = isPdfDsl;
+
+            public override bool TryGetValue(string key, out string value)
+            {
+                if (_isPdfDsl && key == "build_metadata.additionalfiles.IsPdfSharpDsl")
+                {
+                    value = "true";
+                    return true;
+                }
+
+                value = string.Empty;
+                return false;
+            }
+        }
     }
 }
diff --git a/pdfsharpdslTests/VisitorTests.cs b/pdfsharpdslTests/VisitorTests.cs
index 78344a2..1243142 100644
--- a/pdfsharpdslTests/VisitorTests.cs
+++ b/pdfsharpdslTests/VisitorTests.cs
@@ -106,7 +106,7 @@ public void TestConditionEvaluator(string file)
         [Fact]
         public void DrawExecutesViewSizeTextWidthAndDebugOptions()
         {
-            var tree = ParseText("VIEWSIZE 100,140;TEXT 10,20 MaxWidth=30 Text=\"hello\";DEBUGOPTIONS DEBUG_TEXT, DEBUG_RECT, DEBUG_ROWTEMPLATE, DEBUG_RULE, DEBUG_ALL, UNKNOWN;");
+            var tree = ParseText("VIEWSIZE 100,140;TEXT 10,20 MaxWidth=30 Text=\"hello\";DEBUGOPTIONS DEBUG_TEXT, DEBUG_RECT, DEBUG_ROWTEMPLATE, DEBUG_IMAGE, DEBUG_RULE, DEBUG_ALL, UNKNOWN;");
             var drawer = new Mock<IPdfDocumentDrawer>();
             drawer.SetupProperty(x => x.DebugOptions);
 
@@ -115,7 +115,7 @@ public void DrawExecutesViewSizeTextWidthAndDebugOptions()
             drawer.Verify(x => x.SetViewSize(100, 140), Times.Once);
             drawer.Verify(x => x.DrawText("hello", 10, 20, 30, null), Times.Once);
             Assert.Equal(
-                DebugOptions.DebugText | DebugOptions.DebugRect | DebugOptions.DebugRowTemplate | DebugOptions.DebugRule | DebugOptions.DebugAll,
+                DebugOptions.DebugText | DebugOptions.DebugRect | DebugOptions.DebugRowTemplate | DebugOptions.DebugImage | DebugOptions.DebugRule | DebugOptions.DebugAll,
                 drawer.Object.DebugOptions);
         }
 
@@ -134,6 +134,66 @@ public void DrawResolvesPageSystemVariables()
             Assert.Equal(792.0, visitor.Vars["HEIGHT"]);
         }
 
+        [Fact]
+        public void ImageStatementsPreserveDimensionsUnitsAndCropMode()
+        {
+            const string imageData = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
+            var tree = ParseText(
+                $"IMAGE 1,2 Data=\"data:image/png;base64,{imageData}\";" +
+                $"IMAGE 3,4,30,40 pixel crop Data=\"{imageData}\";" +
+                $"IMAGE 5,6,70,80 point fit Data=\"{imageData}\";");
+            var calls = new List<(double X, double Y, double? Width, double? Height, bool Pixel, bool Crop)>();
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            drawer.Setup(x => x.DrawImage(
+                    It.IsAny<XImage>(),
+                    It.IsAny<double>(),
+                    It.IsAny<double>(),
+                    It.IsAny<double?>(),
+                    It.IsAny<double?>(),
+                    It.IsAny<bool>(),
+                    It.IsAny<bool>()))
+                .Callback<XImage, double, double, double?, double?, bool, bool>((_, x, y, width, height, pixel, crop) =>
+                    calls.Add((x, y, width, height, pixel, crop)));
+
+            new PdfDrawerVisitor().Draw(drawer.Object, tree);
+
+            Assert.Equal((1, 2, null, null, false, false), calls[0]);
+            Assert.Equal((3, 4, 30, 40, true, true), calls[1]);
+            Assert.Equal((5, 6, 70, 80, false, false), calls[2]);
+        }
+
+        [Fact]
+        public void TableRowTemplateBuildsRowsWidthsAndPadding()
+        {
+            var tree = ParseText(
+                "TABLE 20,30 " +
+                "HEAD " +
+                "COL Width=40 MaxWidth=30 \"A\"; " +
+                "COL Width=auto MaxWidth=100 \"B\"; " +
+                "ENDHEAD " +
+                "ROWTEMPLATE 2 " +
+                "COL $ROWINDEX; " +
+                "ENDROW " +
+                "ENDTABLE");
+            TableDefinition? capturedTable = null;
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            drawer.Setup(x => x.DrawTable(20, 30, It.IsAny<TableDefinition>()))
+                .Callback<double, double, TableDefinition>((_, _, table) => capturedTable = table);
+            var visitor = new InspectablePdfDrawerVisitor();
+
+            visitor.Draw(drawer.Object, tree);
+
+            Assert.NotNull(capturedTable);
+            Assert.Equal(2, capturedTable.Columns.Count);
+            Assert.Equal(40, capturedTable.Columns[0].DesiredWidth);
+            Assert.Equal(30, capturedTable.Columns[0].MaxWidth);
+            Assert.Null(capturedTable.Columns[1].DesiredWidth);
+            Assert.Equal(100, capturedTable.Columns[1].MaxWidth);
+            Assert.Equal(new[] { "0", string.Empty }, capturedTable.Rows[0].Data);
+            Assert.Equal(new[] { "1", string.Empty }, capturedTable.Rows[1].Data);
+            Assert.False(visitor.Vars.ContainsKey("ROWINDEX"));
+        }
+
         [Fact]
         public void CustomUdfCanFallBackToDslBodyOrOverrideIt()
         {
@@ -180,6 +240,55 @@ public void CustomUdfErrorsAreReportedAsParserErrors()
             Assert.Contains("MISSING", missingError.Message);
         }
 
+        [Fact]
+        public void NestedDslUdfsRestoreOuterScopes()
+        {
+            var tree = ParseText(
+                "SET VAR VALUE=10; " +
+                "UDF INNER(VALUE) SET VAR INNERONLY=99; LINE $VALUE,$INNERONLY,$VALUE,$INNERONLY; ENDUDF " +
+                "UDF OUTER(VALUE) SET VAR OUTERONLY=20; CALL INNER(30); LINE $VALUE,$OUTERONLY,$VALUE,$OUTERONLY; ENDUDF " +
+                "CALL OUTER(40); LINE $VALUE,0,$VALUE,0;");
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            var visitor = new InspectablePdfDrawerVisitor();
+
+            visitor.Draw(drawer.Object, tree);
+
+            drawer.Verify(x => x.DrawLine(30, 99, 30, 99), Times.Once);
+            drawer.Verify(x => x.DrawLine(40, 20, 40, 20), Times.Once);
+            drawer.Verify(x => x.DrawLine(10, 0, 10, 0), Times.Once);
+            Assert.Equal(10.0, visitor.Vars["VALUE"]);
+            Assert.False(visitor.Vars.ContainsKey("INNERONLY"));
+            Assert.False(visitor.Vars.ContainsKey("OUTERONLY"));
+        }
+
+        [Fact]
+        public void DslUdfFailureRestoresOuterScope()
+        {
+            var tree = ParseText(
+                "SET VAR VALUE=1; " +
+                "UDF FAIL(VALUE) SET VAR TEMP=2; LINE $MISSING,0,0,0; ENDUDF " +
+                "CALL FAIL(9);");
+            var visitor = new InspectablePdfDrawerVisitor();
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => visitor.Draw(Mock.Of<IPdfDocumentDrawer>(), tree));
+
+            Assert.Equal(1.0, visitor.Vars["VALUE"]);
+            Assert.False(visitor.Vars.ContainsKey("TEMP"));
+        }
+
+        [Theory]
+        [InlineData("UDF NEEDS(X) LINE $X,0,0,0; ENDUDF CALL NEEDS();")]
+        [InlineData("UDF NONE() LINE 0,0,0,0; ENDUDF CALL NONE(1);")]
+        public void DslUdfRejectsZeroArgumentCountMismatches(string input)
+        {
+            var tree = ParseText(input);
+            var visitor = new InspectablePdfDrawerVisitor();
+
+            var error = Assert.Throws<PdfParserException>(() => visitor.Draw(Mock.Of<IPdfDocumentDrawer>(), tree));
+
+            Assert.Contains("arguments count", error.Message);
+        }
+
         [Fact]
         public void RowTemplateTracksOffsetsAndFinalHeight()
         {
diff --git a/pdfsharpdslTests/pdfsharpdslTests.csproj b/pdfsharpdslTests/pdfsharpdslTests.csproj
index c27762a..c721efb 100644
--- a/pdfsharpdslTests/pdfsharpdslTests.csproj
+++ b/pdfsharpdslTests/pdfsharpdslTests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 
@@ -11,14 +11,14 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" PrivateAssets="all" />
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
-    <PackageReference Include="Moq" Version="4.20.70" />
-    <PackageReference Include="xunit" Version="2.7.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.7">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.1">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
diff --git a/scripts/coverage.ps1 b/scripts/coverage.ps1
new file mode 100644
index 0000000..d256cb5
--- /dev/null
+++ b/scripts/coverage.ps1
@@ -0,0 +1,60 @@
+[CmdletBinding()]
+param(
+    [ValidateSet("Debug", "Release")]
+    [string]$Configuration = "Debug",
+
+    [ValidateRange(0, 1)]
+    [double]$MinimumLineRate = 0.90
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$repositoryRoot = Split-Path -Parent $PSScriptRoot
+$testProject = Join-Path $repositoryRoot "pdfsharpdslTests\pdfsharpdslTests.csproj"
+$settingsFile = Join-Path $repositoryRoot ".runsettings"
+$resultsDirectory = Join-Path $repositoryRoot "artifacts\coverage"
+
+if (Test-Path $resultsDirectory) {
+    Remove-Item $resultsDirectory -Recurse -Force
+}
+
+& dotnet test $testProject `
+    --configuration $Configuration `
+    --settings $settingsFile `
+    --collect:"XPlat Code Coverage" `
+    --results-directory $resultsDirectory
+
+if ($LASTEXITCODE -ne 0) {
+    throw "Coverage test run failed with exit code $LASTEXITCODE."
+}
+
+$reports = @(Get-ChildItem $resultsDirectory -Filter "coverage.cobertura.xml" -Recurse)
+if ($reports.Count -ne 1) {
+    throw "Expected one Cobertura report, but found $($reports.Count)."
+}
+
+[xml]$coverage = Get-Content $reports[0].FullName
+$packages = @($coverage.coverage.packages.package)
+$unexpectedPackages = @($packages | Where-Object { $_.name -ne "PdfSharpDslCore" })
+if ($packages.Count -ne 1 -or $unexpectedPackages.Count -ne 0) {
+    $packageNames = ($packages | ForEach-Object { $_.name }) -join ", "
+    throw "Expected coverage only for PdfSharpDslCore, but found: $packageNames"
+}
+
+$lineRate = [double]::Parse($coverage.coverage."line-rate", [Globalization.CultureInfo]::InvariantCulture)
+$branchRate = [double]::Parse($coverage.coverage."branch-rate", [Globalization.CultureInfo]::InvariantCulture)
+
+$summary = [pscustomobject]@{
+    Assembly        = $packages[0].name
+    LineCoverage    = "{0:P2}" -f $lineRate
+    Lines            = "$($coverage.coverage.'lines-covered')/$($coverage.coverage.'lines-valid')"
+    BranchCoverage  = "{0:P2}" -f $branchRate
+    Branches         = "$($coverage.coverage.'branches-covered')/$($coverage.coverage.'branches-valid')"
+    Report           = $reports[0].FullName
+}
+$summary | Format-List
+
+if ($lineRate -lt $MinimumLineRate) {
+    throw "Line coverage $($summary.LineCoverage) is below the required $(('{0:P2}' -f $MinimumLineRate))."
+}
\ No newline at end of file

From 9b9bc0a5200058847fe1747a62057ca41e91cfe6 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 15:36:58 +0200
Subject: [PATCH 03/15] generate full demo

---
 PdfSharpDslConsole/Program.cs |   3 +-
 PdfSharpDslConsole/demo.ipdf  | 345 ++++++++++++++++++++++++++++++++++
 2 files changed, 347 insertions(+), 1 deletion(-)
 create mode 100644 PdfSharpDslConsole/demo.ipdf

diff --git a/PdfSharpDslConsole/Program.cs b/PdfSharpDslConsole/Program.cs
index 05730d4..55a1491 100644
--- a/PdfSharpDslConsole/Program.cs
+++ b/PdfSharpDslConsole/Program.cs
@@ -94,7 +94,8 @@
 var parser = new Irony.Parsing.Parser(new PdfGrammar());
 //var fileName = "pdfsharp-newpage.ipdf";
 //var fileName = "pdfsharp.ipdf";
-var fileName = "sample1.ipdf";
+//var fileName = "sample1.ipdf";
+var fileName = "demo.ipdf";
 if (args.Length > 0)
 {
     fileName = args[0];
diff --git a/PdfSharpDslConsole/demo.ipdf b/PdfSharpDslConsole/demo.ipdf
new file mode 100644
index 0000000..4db5d8b
--- /dev/null
+++ b/PdfSharpDslConsole/demo.ipdf
@@ -0,0 +1,345 @@
+# PdfSharpDsl feature demonstration
+# Run from PdfSharpDslConsole with: dotnet run -- demo.ipdf
+
+# Reusable components. UDFs may be called before or after their definitions.
+UDF SECTION(TITLETEXT)
+    SET FONT Name="Arial" Size=20 bold;
+    SET BRUSH darkblue;
+    TITLE Margin=24 HAlign=hcenter Text=$TITLETEXT;
+    SET PEN steelblue 1;
+    LINE 36,54,$PAGEWIDTH-36,54;
+ENDUDF
+
+UDF BADGE(X,Y,LABEL)
+    SET PEN darkblue 1 solid;
+    SET BRUSH lightblue;
+    FILLRECT $X,$Y,110,30;
+    SET FONT Name="Arial" Size=10 bold;
+    SET BRUSH darkblue;
+    LINETEXT $X,$Y,110,30 HAlign=hcenter VAlign=vcenter Text=$LABEL;
+ENDUDF
+
+# Special callback: runs after every NEWPAGE and can publish global variables.
+UDF __ONNEWPAGE()
+    SET VAR CONTENTWIDTH=$PAGEWIDTH-72;
+    SET VAR CONTENTHEIGHT=$PAGEHEIGHT-72;
+    SET FONT Name="Arial" Size=8 regular;
+    SET BRUSH gray;
+    TITLE Margin=-18 HAlign=hcenter Text=("PdfSharpDsl demo | page "+$PAGEINDEX);
+ENDUDF
+
+# -----------------------------------------------------------------------------
+# Cover: pages, page variables, titles, colors, fonts, variables, formulas
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+SET BRUSH darkblue;
+SET FONT Name="Arial" Size=28 bold;
+TITLE Margin=72 HAlign=hcenter Text="PdfSharpDsl";
+SET FONT Name="Arial" Size=16 italic;
+TITLE Margin=112 HAlign=hcenter Text="Complete feature demonstration";
+
+SET HBRUSH 0x50ffe9b2;
+SET FONT Name="Consolas" Size=10 regular;
+TITLE Margin=160 HAlign=hcenter Text=("A4 portrait: "+$PAGEWIDTH+" x "+$PAGEHEIGHT+" points");
+SET HBRUSH 0x00000000;
+
+SET VAR A=17;
+SET VAR B=5;
+SET VAR NEGATIVE=-5;
+SET VAR POSITIVE=+5;
+SET VAR MESSAGE="Variables, arithmetic, comparison and concatenation";
+SET BRUSH black;
+LINETEXT 54,220 HAlign=left VAlign=top Text=$MESSAGE;
+LINETEXT 54,246 HAlign=left VAlign=top Text=("A+B="+($A+$B)+", A-B="+($A-$B)+", A*B="+($A*$B));
+LINETEXT 54,270 HAlign=left VAlign=top Text=("A/B="+($A/$B)+", A%B="+($A%$B)+", unary values="+$NEGATIVE+" and "+$POSITIVE);
+
+IF (($A > $B) and ($A >= 17)) THEN
+    CALL BADGE(54,310,"AND condition: true");
+ELSE
+    CALL BADGE(54,310,"AND condition: false");
+ENDIF
+
+IF (($A < $B) or ($A <= 17)) THEN
+    CALL BADGE(184,310,"OR condition: true");
+ENDIF
+
+IF ("alpha" <> "beta") THEN
+    CALL BADGE(314,310,"<> comparison");
+ENDIF
+
+IF ($A == 17) THEN
+    CALL BADGE(444,310,"== comparison");
+ENDIF
+
+SET FONT Name="Arial" Size=11 regular;
+TEXT 54,380,487,100 MaxWidth=487 Text="This document is itself the example source. Each page groups related commands and uses comments, optional semicolons, expressions, variables, built-in page variables, host formula functions, control flow and reusable UDFs.";
+
+# -----------------------------------------------------------------------------
+# Drawing primitives, pen styles, brushes and color formats
+# -----------------------------------------------------------------------------
+NEWPAGE A4 landscape;
+CALL SECTION("Drawing primitives and styles");
+
+SET FONT Name="Consolas" Size=9 regular;
+SET BRUSH black;
+SET PEN black 1 solid;
+LINETEXT 45,90 Text="solid";
+LINE 45,108,165,108;
+SET PEN red 1.5 dash;
+LINETEXT 45,130 Text="dash";
+LINE 45,148,165,148;
+SET PEN green 2 dot;
+LINETEXT 45,170 Text="dot";
+LINE 45,188,165,188;
+SET PEN blue 2 dashdot;
+LINETEXT 45,210 Text="dashdot";
+LINE 45,228,165,228;
+SET PEN 0xff8844 2 dashdotdot;
+LINETEXT 45,250 Text="dashdotdot / RGB hex";
+LINE 45,268,165,268;
+
+SET PEN black 1 solid;
+SET BRUSH lightgreen;
+RECT 220,90,100,65;
+FILLRECT 350,90,100,65;
+SET BRUSH 0x8090caf9;
+ELLIPSE 220,190,100,65;
+FILLELLIPSE 350,190,100,65;
+
+SET BRUSH gold;
+PIE 500,90,110,110 Start=15 Angle=120;
+SET BRUSH tomato;
+FILLPIE 640,90,110,110 Start=210 Angle=120;
+
+SET PEN darkslategray 2 solid;
+POLYGON 500,250,550,210,610,250,585,315,525,315;
+SET BRUSH lightseagreen;
+FILLPOLYGON 640,250,690,210,750,250,725,315,665,315;
+
+SET PEN purple 3 solid;
+MOVETO 220,350;
+LINETO 280,320;
+LINETO 340,370;
+LINETO 400,330;
+LINETO 450,370;
+
+SET PEN g0.45 1;
+SET BRUSH g0.80;
+FILLRECT 500,350,250,60;
+SET BRUSH black;
+LINETEXT 625,380 HAlign=hcenter VAlign=vcenter Text="grayscale colors: g0.45 / g0.80";
+
+# Negative dimensions extend to the far page edge.
+SET PEN crimson 1 dash;
+RECT 20,440,-20,-55;
+SET BRUSH crimson;
+LINETEXT 30,450 Text="Negative width and height use the remaining page area";
+
+# -----------------------------------------------------------------------------
+# Text, alignment, orientation, highlighting and every font style
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Text layout, orientation and fonts");
+SET PEN lightgray 0.5;
+RECT 45,85,500,110;
+SET FONT Name="Arial" Size=11 regular;
+SET BRUSH black;
+LINETEXT 45,85,500,110 HAlign=left VAlign=top Text="left / top";
+LINETEXT 45,85,500,110 HAlign=hcenter VAlign=vcenter Text="center / center";
+LINETEXT 45,85,500,110 HAlign=right VAlign=bottom Text="right / bottom";
+
+SET HBRUSH 0x60fff176;
+LINETEXT 60,235 HAlign=left VAlign=vcenter Orientation=horizontal Text="highlight brush";
+SET HBRUSH 0x00000000;
+LINETEXT 220,235 HAlign=left VAlign=vcenter Orientation=vertical Text="vertical";
+LINETEXT 300,235 HAlign=left VAlign=vcenter Orientation=30 Text="30 degree rotation";
+
+SET FONT Name="Arial" Size=11 regular;
+LINETEXT 45,330 Text="regular";
+SET FONT Name="Arial" Size=11 bold;
+LINETEXT 140,330 Text="bold";
+SET FONT Name="Arial" Size=11 italic;
+LINETEXT 220,330 Text="italic";
+SET FONT Name="Arial" Size=11 bolditalic;
+LINETEXT 300,330 Text="bold italic";
+SET FONT Name="Arial" Size=11 underline;
+LINETEXT 405,330 Text="underline";
+SET FONT Name="Arial" Size=11 strikeout;
+LINETEXT 500,330 Text="strikeout";
+
+SET FONT Name="Arial" Size=11 regular;
+TEXT 45,385 MaxWidth=220 Text="TEXT with a point and MaxWidth wraps a longer paragraph over several lines.";
+TEXT 300,385,245,95 Text="TEXT with a rectangle supports multiline content.\r\nSecond explicit line.\r\nThird explicit line.";
+
+TITLE Margin=515 HAlign=left Text="Left title";
+TITLE Margin=515 HAlign=hcenter Text="Centered title";
+TITLE Margin=515 HAlign=right Text="Right title";
+TITLE Margin=-40 HAlign=right Text="Negative title margin is measured from the bottom";
+
+# -----------------------------------------------------------------------------
+# FOR loops, UDF parameters/scoping, IF/ELSE and formula-driven geometry
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Control flow and reusable drawing");
+SET FONT Name="Consolas" Size=10 regular;
+SET BRUSH black;
+LINETEXT 45,85 Text="FOR is inclusive; UDF parameters are locally scoped.";
+
+FOR ROW=0 TO 6 DO
+    SET PEN 0x4472c4 1;
+    LINE 70,130+$ROW*55,520,130+$ROW*55;
+    CALL BADGE(80,142+$ROW*55,"Iteration "+$ROW);
+ENDFOR
+
+IF (($A >= $B) and ($B <= $A)) THEN
+    SET BRUSH darkgreen;
+    LINETEXT 45,555 Text="IF branch selected: A >= B and B <= A";
+ELSE
+    SET BRUSH red;
+    LINETEXT 45,555 Text="ELSE branch selected";
+ENDIF
+
+# -----------------------------------------------------------------------------
+# Ordinary tables: auto/fixed widths, header styles, rows and row heights
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Tables with explicit rows");
+SET FONT Name="Arial" Size=9 regular;
+SET PEN slategray 0.6;
+TABLE 40,90
+HEAD 0xffe8eef7
+COL Width=auto MaxWidth=130 FONT="Arial",9,bold white steelblue "Feature";
+COL Width=140 MaxWidth=180 FONT="Arial",9,bold white steelblue "Syntax";
+COL Width=auto MaxWidth=240 FONT="Arial",9,bold white steelblue "Notes";
+ENDHEAD
+ROW
+COL "Automatic sizing";
+COL "Width=auto";
+COL "Desired width follows content up to MaxWidth";
+ENDROW
+ROW 48
+COL "Fixed row height";
+COL "ROW 48";
+COL "A formula may define the row height";
+ENDROW
+ROW
+COL "Multiline cell";
+COL "COL expression";
+COL "Line one\r\nLine two\r\nLine three";
+ENDROW
+ROW
+COL "Short row";
+COL "Missing cells";
+ENDROW
+ENDTABLE
+
+# Table row templates evaluate every COL expression for each ROWINDEX.
+SET BRUSH darkblue;
+LINETEXT 40,360 Text="Table ROWTEMPLATE with host functions";
+TABLE 40,385
+HEAD lightgray
+COL Width=100 MaxWidth=120 FONT="Consolas",8,bold black lightgray "Date";
+COL Width=130 MaxWidth=160 "Comment count";
+COL Width=auto MaxWidth=250 "Evaluated label";
+ENDHEAD
+ROWTEMPLATE getGlobalCommentsCount()
+COL getGlobalCommentDate($ROWINDEX);
+COL getCommentsCount($ROWINDEX);
+COL "Global item "+($ROWINDEX+1);
+ENDROW
+ENDTABLE
+
+# -----------------------------------------------------------------------------
+# Free row templates: nesting, names, borders, pagination and measured height
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Paginating and nested row templates");
+SET FONT Name="Arial" Size=9 regular;
+SET PEN steelblue 0.7;
+SET BRUSH black;
+
+ROWTEMPLATE Count=3 Y=90 Name="outer" BorderSize=5 NewPageTopMargin=70
+    SET VAR OUTERINDEX=$ROWINDEX;
+    LINETEXT 45,0 Text=("Group "+$OUTERINDEX);
+    ROWTEMPLATE Count=2 Y=16 Name=("inner-"+$OUTERINDEX) BorderSize=3
+        LINETEXT 130,0 Text=("Nested item "+$OUTERINDEX+"."+$ROWINDEX);
+        LINE 125,14,500,14;
+    ENDROWTEMPLATE
+    # LASTTEMPLATEHEIGHT excludes the nested template's Y and initial border.
+    RECT 35,0,490,16+3+$LASTTEMPLATEHEIGHT;
+ENDROWTEMPLATE
+
+SET BRUSH darkblue;
+LINETEXT 45,300 Text=("Measured outer template height: "+$LASTTEMPLATEHEIGHT);
+
+# This template is tall enough to create another page automatically.
+ROWTEMPLATE Count=16 Y=340 Name="paginated-list" BorderSize=4 NewPageTopMargin=70
+    SET PEN lightgray 0.5;
+    RECT 45,0,500,36;
+    SET BRUSH black;
+    LINETEXT 58,18 VAlign=vcenter Text=("Paginated item "+($ROWINDEX+1));
+ENDROWTEMPLATE
+
+# -----------------------------------------------------------------------------
+# Images: file/data sources, natural size, points/pixels, fit/crop
+# -----------------------------------------------------------------------------
+NEWPAGE A4 landscape;
+CALL SECTION("Images from files and embedded data");
+SET FONT Name="Consolas" Size=9 regular;
+SET BRUSH black;
+LINETEXT 45,82 Text="Natural size from Source";
+IMAGE 45,105 Source="./imageTest.jpg";
+
+LINETEXT 300,82 Text="Point rectangle, fit";
+IMAGE 300,105,180,120 point fit Source="./imageTest.jpg";
+
+LINETEXT 520,82 Text="Pixel rectangle, crop";
+IMAGE 520,105,180,120 pixel crop Source="./imageTest.jpg";
+
+LINETEXT 45,330 Text="Embedded one-pixel PNG using Data";
+IMAGE 45,355,160,100 point fit Data="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
+
+# -----------------------------------------------------------------------------
+# Host formula functions and custom bundled fonts
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Host functions and bundled fonts");
+SET VAR FONTCOUNT=GetFontCount();
+SET FONT Name="Consolas" Size=9 regular;
+SET BRUSH black;
+LINETEXT 45,82 Text=("GetFontCount() returned "+$FONTCOUNT);
+FOR I=0 TO $FONTCOUNT-1 DO
+    SET VAR FONTNAME=GetFont($I);
+    SET FONT Name=$FONTNAME Size=18 regular;
+    LINETEXT 55,125+70*$I Text=("PdfSharpDsl - "+$FONTNAME);
+ENDFOR
+
+# -----------------------------------------------------------------------------
+# Debug overlays and custom view coordinates
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+# DEBUGOPTIONS is document-wide because the visitor reads it before drawing page 1.
+# Uncomment this line to enable every overlay on every page:
+# DEBUGOPTIONS DEBUG_TEXT, DEBUG_RECT, DEBUG_ROWTEMPLATE, DEBUG_IMAGE, DEBUG_RULE, DEBUG_ALL;
+CALL SECTION("Debug options (opt-in, document-wide)");
+SET FONT Name="Arial" Size=11 regular;
+SET BRUSH black;
+LINETEXT 60,110,470,50 HAlign=hcenter VAlign=vcenter Text="DEBUGOPTIONS can expose text, rectangles, templates, images and rules across the document.";
+SET BRUSH lightsalmon;
+FILLRECT 100,200,150,80;
+IMAGE 330,200,150,80 point fit Data="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
+ROWTEMPLATE Count=2 Y=330 Name="debug-template" BorderSize=3
+    LINETEXT 100,0 Text=("Debug row "+$ROWINDEX);
+    LINE 100,24,480,24;
+ENDROWTEMPLATE
+
+# VIEWSIZE maps a compact coordinate system onto the page.
+NEWPAGE A4 portrait;
+VIEWSIZE 100,140;
+SET PEN red 0.2 dash;
+SET BRUSH black;
+SET FONT Name="Consolas" Size=3 regular;
+LINE 50,0,50,140;
+LINE 0,70,100,70;
+RECT 2,2,96,136;
+LINETEXT 50,70 HAlign=hcenter VAlign=vcenter Text="VIEWSIZE 100 x 140";
\ No newline at end of file

From d3ce5afbe93b29a7cee40f0c2cafff480e302595 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 16:23:52 +0200
Subject: [PATCH 04/15] migrate to TerraPDF in order to avoid apche license
 dependencies

---
 CHANGELOG.md                                  |   4 +-
 .../Drawing/DebugOptions.cs                   |   0
 .../Drawing/DrawingPrimitives.cs              | 316 ++++++
 .../Evaluation/BinaryEvaluation.cs            |   0
 .../Evaluation/BinaryOperation.cs             |   0
 .../Evaluation/ConstantEvaluation.cs          |   0
 .../Evaluation/CustomFunctionEvaluation.cs    |   0
 .../Evaluation/Evaluation.cs                  |   0
 .../Evaluation/Evaluator.cs                   |   0
 .../Evaluation/UnaryEvaluation.cs             |   0
 .../Evaluation/VariableEvaluation.cs          |   0
 .../Extensions/ParseTreeNodeExtensions.cs     |  32 +-
 .../Parser/PdfGrammar.cs                      |  13 +-
 .../Parser/PdfParserException.cs              |   0
 .../Parser/PdfVisitor.cs                      |   0
 .../PdfSharpDsl.Language.csproj               |  19 +
 PdfSharpDslConsole/Fonts/MyFontResolver.cs    |  43 -
 PdfSharpDslConsole/Program.cs                 |  22 +-
 .../helloworld-with-pdfsharp.pdf              | Bin 0 -> 193103 bytes
 PdfSharpDslConsole/helloworld.pdf             | Bin 134123 -> 76945 bytes
 .../DrawingGenerator/CSharpDrawer.cs          | 186 ----
 .../DrawingGenerator/CSharpGeneratorState.cs  |   1 -
 .../DrawingGenerator/CSharpVisitor.cs         |  29 +-
 .../PdfSharpDslCore.Generator.csproj          |  22 +-
 PdfSharpDslCore/Drawing/DrawingContext.cs     |  25 +-
 PdfSharpDslCore/Drawing/DrawingHelper.cs      |  69 +-
 PdfSharpDslCore/Drawing/IInstructionBlock.cs  |   5 +-
 PdfSharpDslCore/Drawing/IPdfDocumentDrawer.cs |  22 +-
 PdfSharpDslCore/Drawing/InstructionBlock.cs   |  11 +-
 .../Drawing/InstructionsRecorder.cs           |   3 +-
 PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs  | 913 ++++++------------
 PdfSharpDslCore/Drawing/TableDefinition.cs    |  16 +-
 PdfSharpDslCore/Extensions/XRectExtensions.cs |  16 +-
 PdfSharpDslCore/Parser/PdfDrawerVisitor.cs    |  64 +-
 PdfSharpDslCore/PdfSharpDslCore.csproj        |  15 +-
 PdfSharpDslCore/Readme.md                     |   4 +-
 README.md                                     |  17 +-
 bnf_and_pdf.sln                               |   6 +
 pdfsharpdslTests/DrawingValueTests.cs         |  40 +-
 pdfsharpdslTests/GenerationBaseTests.cs       |  11 +-
 pdfsharpdslTests/GenerationTableTests.cs      |  13 +-
 pdfsharpdslTests/GenerationTests.cs           |  79 +-
 .../Parser/PdfDrawerForTestsVisitor.cs        |   1 -
 pdfsharpdslTests/Parser/TextDocumentDrawer.cs |  38 +-
 pdfsharpdslTests/ParserTests.cs               |   8 +
 pdfsharpdslTests/PdfBinaryInspector.cs        |  47 +
 pdfsharpdslTests/PdfDocumentDrawerTests.cs    |  25 +-
 pdfsharpdslTests/RenderingTests.cs            |   3 +-
 .../ReplayerTests/InstructionRecorderTests.cs |  42 +-
 .../SourceGenerator/SourceGeneratorTests.cs   |   3 +-
 pdfsharpdslTests/VisitorTests.cs              |  17 +-
 51 files changed, 937 insertions(+), 1263 deletions(-)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Drawing/DebugOptions.cs (100%)
 create mode 100644 PdfSharpDsl.Language/Drawing/DrawingPrimitives.cs
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/BinaryEvaluation.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/BinaryOperation.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/ConstantEvaluation.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/CustomFunctionEvaluation.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/Evaluation.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/Evaluator.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/UnaryEvaluation.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Evaluation/VariableEvaluation.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Extensions/ParseTreeNodeExtensions.cs (66%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Parser/PdfGrammar.cs (98%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Parser/PdfParserException.cs (100%)
 rename {PdfSharpDslCore => PdfSharpDsl.Language}/Parser/PdfVisitor.cs (100%)
 create mode 100644 PdfSharpDsl.Language/PdfSharpDsl.Language.csproj
 delete mode 100644 PdfSharpDslConsole/Fonts/MyFontResolver.cs
 create mode 100644 PdfSharpDslConsole/helloworld-with-pdfsharp.pdf
 delete mode 100644 PdfSharpDslCore.Generator/DrawingGenerator/CSharpDrawer.cs
 create mode 100644 pdfsharpdslTests/PdfBinaryInspector.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 08713a6..9d11908 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,9 @@
 * Migrated console and test projects to .NET 10 while retaining reusable projects on .NET Standard 2.0.
 * Added reproducible core-only coverage enforcement at 90% line coverage.
 * Added Roslyn source-generator compilation and clean NuGet consumer validation.
-* Updated dependencies and resolved known ImageSharp and runtime package advisories.
+* Migrated PDF generation from PdfSharpCore and its image/font/archive dependencies to TerraPDF 2.1.0.
+* Added engine-independent drawing primitives and `PdfSharpDsl.Language` for the netstandard2.0 source generator.
+* Added `PublishPdf(Stream)`, `PublishPdf(string)` and `PublishPdf()` to `PdfDocumentDrawer`.
 
 ## Version 1.0.5 (March 3, 2024)
 * Update nugets packages and upgrade to .Net 8
diff --git a/PdfSharpDslCore/Drawing/DebugOptions.cs b/PdfSharpDsl.Language/Drawing/DebugOptions.cs
similarity index 100%
rename from PdfSharpDslCore/Drawing/DebugOptions.cs
rename to PdfSharpDsl.Language/Drawing/DebugOptions.cs
diff --git a/PdfSharpDsl.Language/Drawing/DrawingPrimitives.cs b/PdfSharpDsl.Language/Drawing/DrawingPrimitives.cs
new file mode 100644
index 0000000..a57ec16
--- /dev/null
+++ b/PdfSharpDsl.Language/Drawing/DrawingPrimitives.cs
@@ -0,0 +1,316 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PdfSharpDslCore.Drawing
+{
+    public readonly struct PdfPoint
+    {
+        public PdfPoint(double x, double y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        public double X { get; }
+        public double Y { get; }
+
+        public PdfPoint OffsetY(double offsetY) => new(X, Y + offsetY);
+    }
+
+    public readonly struct PdfSize
+    {
+        public PdfSize(double width, double height)
+        {
+            Width = width;
+            Height = height;
+        }
+
+        public double Width { get; }
+        public double Height { get; }
+    }
+
+    public struct PdfRect
+    {
+        public PdfRect(double x, double y, double width, double height)
+        {
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+        }
+
+        public double X { readonly get; private set; }
+        public double Y { readonly get; private set; }
+        public double Width { readonly get; private set; }
+        public double Height { readonly get; private set; }
+
+        public static PdfRect Empty => new(0, 0, -1, -1);
+
+        public PdfRect(PdfPoint first, PdfPoint second)
+            : this(Math.Min(first.X, second.X), Math.Min(first.Y, second.Y),
+                Math.Abs(second.X - first.X), Math.Abs(second.Y - first.Y))
+        {
+        }
+
+        public PdfRect(PdfPoint location, PdfSize size)
+            : this(location.X, location.Y, size.Width, size.Height)
+        {
+        }
+
+        public readonly bool IsEmpty => Width < 0 || Height < 0;
+        public readonly double Left => X;
+        public readonly double Top => Y;
+        public readonly double Right => X + Width;
+        public readonly double Bottom => Y + Height;
+        public readonly PdfPoint TopLeft => new(X, Y);
+
+        public void Offset(double offsetX, double offsetY)
+        {
+            X += offsetX;
+            Y += offsetY;
+        }
+
+        public readonly PdfRect OffsetY(double offsetY) => new(X, Y + offsetY, Width, Height);
+
+        public void Union(PdfPoint point)
+        {
+            Union(new PdfRect(point.X, point.Y, 0, 0));
+        }
+
+        public void Union(PdfRect rect)
+        {
+            if (rect.IsEmpty)
+            {
+                return;
+            }
+
+            if (IsEmpty)
+            {
+                this = rect;
+                return;
+            }
+
+            var left = Math.Min(Left, rect.Left);
+            var top = Math.Min(Top, rect.Top);
+            var right = Math.Max(Right, rect.Right);
+            var bottom = Math.Max(Bottom, rect.Bottom);
+            this = new PdfRect(left, top, right - left, bottom - top);
+        }
+
+        public void Intersect(PdfRect rect)
+        {
+            var left = Math.Max(Left, rect.Left);
+            var top = Math.Max(Top, rect.Top);
+            var right = Math.Min(Right, rect.Right);
+            var bottom = Math.Min(Bottom, rect.Bottom);
+            this = right < left || bottom < top
+                ? Empty
+                : new PdfRect(left, top, right - left, bottom - top);
+        }
+    }
+
+    public readonly struct PdfColor
+    {
+        public PdfColor(byte alpha, byte red, byte green, byte blue)
+        {
+            Alpha = alpha;
+            Red = red;
+            Green = green;
+            Blue = blue;
+        }
+
+        public byte Alpha { get; }
+        public byte Red { get; }
+        public byte Green { get; }
+        public byte Blue { get; }
+
+        public byte A => Alpha;
+
+        public static PdfColor FromArgb(byte alpha, byte red, byte green, byte blue) =>
+            new(alpha, red, green, blue);
+
+        public static PdfColor FromRgb(byte red, byte green, byte blue) => new(255, red, green, blue);
+
+        public static PdfColor FromArgb(uint argb) => new(
+            (byte)(argb >> 24),
+            (byte)(argb >> 16),
+            (byte)(argb >> 8),
+            (byte)argb);
+
+        public static PdfColor FromGrayScale(double value)
+        {
+            var component = (byte)Math.Min(255, Math.Max(0, (int)Math.Round(value * 255)));
+            return FromRgb(component, component, component);
+        }
+
+        public static PdfColor Black => FromRgb(0, 0, 0);
+        public static PdfColor White => FromRgb(255, 255, 255);
+        public static PdfColor RedColor => FromRgb(255, 0, 0);
+        public static PdfColor Transparent => new(0, 0, 0, 0);
+
+        internal string Hex => $"#{Red:X2}{Green:X2}{Blue:X2}";
+        internal double Opacity => Alpha / 255d;
+    }
+
+    public static class PdfColors
+    {
+        private static readonly IReadOnlyDictionary<string, PdfColor> Colors =
+            new Dictionary<string, PdfColor>(StringComparer.OrdinalIgnoreCase)
+            {
+                ["black"] = PdfColor.FromRgb(0, 0, 0),
+                ["blue"] = PdfColor.FromRgb(0, 0, 255),
+                ["crimson"] = PdfColor.FromRgb(220, 20, 60),
+                ["darkblue"] = PdfColor.FromRgb(0, 0, 139),
+                ["darkgreen"] = PdfColor.FromRgb(0, 100, 0),
+                ["darkslategray"] = PdfColor.FromRgb(47, 79, 79),
+                ["gold"] = PdfColor.FromRgb(255, 215, 0),
+                ["gray"] = PdfColor.FromRgb(128, 128, 128),
+                ["green"] = PdfColor.FromRgb(0, 128, 0),
+                ["lightblue"] = PdfColor.FromRgb(173, 216, 230),
+                ["lightgray"] = PdfColor.FromRgb(211, 211, 211),
+                ["lightgreen"] = PdfColor.FromRgb(144, 238, 144),
+                ["lightsalmon"] = PdfColor.FromRgb(255, 160, 122),
+                ["lightseagreen"] = PdfColor.FromRgb(32, 178, 170),
+                ["maroon"] = PdfColor.FromRgb(128, 0, 0),
+                ["orange"] = PdfColor.FromRgb(255, 165, 0),
+                ["purple"] = PdfColor.FromRgb(128, 0, 128),
+                ["red"] = PdfColor.FromRgb(255, 0, 0),
+                ["slategray"] = PdfColor.FromRgb(112, 128, 144),
+                ["steelblue"] = PdfColor.FromRgb(70, 130, 180),
+                ["tomato"] = PdfColor.FromRgb(255, 99, 71),
+                ["transparent"] = PdfColor.Transparent,
+                ["violet"] = PdfColor.FromRgb(238, 130, 238),
+                ["white"] = PdfColor.FromRgb(255, 255, 255),
+                ["yellow"] = PdfColor.FromRgb(255, 255, 0),
+            };
+
+        public static IEnumerable<string> Names => Colors.Keys;
+
+        public static PdfColor FromName(string name)
+        {
+            return Colors.TryGetValue(name, out var color) ? color : PdfColor.Black;
+        }
+    }
+
+    public enum PdfDashStyle
+    {
+        Solid,
+        Dash,
+        Dot,
+        DashDot,
+        DashDotDot,
+    }
+
+    public sealed class PdfPen
+    {
+        public PdfPen(PdfColor color, double width)
+        {
+            Color = color;
+            Width = width;
+        }
+
+        public PdfColor Color { get; }
+        public double Width { get; }
+        public PdfDashStyle DashStyle { get; set; } = PdfDashStyle.Solid;
+    }
+
+    public sealed class PdfBrush
+    {
+        public PdfBrush(PdfColor color)
+        {
+            Color = color;
+        }
+
+        public PdfColor Color { get; }
+    }
+
+    [Flags]
+    public enum PdfFontStyle
+    {
+        Regular = 0,
+        Bold = 1,
+        Italic = 2,
+        BoldItalic = Bold | Italic,
+        Underline = 4,
+        Strikeout = 8,
+    }
+
+    public sealed class PdfFont
+    {
+        public PdfFont(string familyName, double size, PdfFontStyle style = PdfFontStyle.Regular)
+        {
+            FamilyName = familyName;
+            Size = size;
+            Style = style;
+        }
+
+        public string FamilyName { get; }
+        public double Size { get; }
+        public PdfFontStyle Style { get; }
+    }
+
+    public sealed class PdfImage
+    {
+        private readonly byte[] _data;
+
+        public PdfImage(ReadOnlySpan<byte> data)
+        {
+            _data = data.ToArray();
+        }
+
+        public ReadOnlyMemory<byte> Data => _data;
+    }
+
+    public sealed class PdfMargins
+    {
+        private double _all;
+
+        public double All
+        {
+            set => Left = Top = Right = Bottom = _all = value;
+            get => _all;
+        }
+
+        public double Left { get; set; }
+        public double Top { get; set; }
+        public double Right { get; set; }
+        public double Bottom { get; set; }
+    }
+
+    public enum PdfHorizontalAlignment
+    {
+        Near,
+        Center,
+        Far,
+    }
+
+    public enum PdfVerticalAlignment
+    {
+        Near,
+        Center,
+        Far,
+    }
+
+    public enum PdfPageOrientation
+    {
+        Portrait,
+        Landscape,
+    }
+
+    public enum PdfPageSize
+    {
+        Undefined,
+        A0,
+        A1,
+        A2,
+        A3,
+        A4,
+        A5,
+        A6,
+        Letter,
+        Legal,
+        Ledger,
+        Tabloid,
+    }
+}
\ No newline at end of file
diff --git a/PdfSharpDslCore/Evaluation/BinaryEvaluation.cs b/PdfSharpDsl.Language/Evaluation/BinaryEvaluation.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/BinaryEvaluation.cs
rename to PdfSharpDsl.Language/Evaluation/BinaryEvaluation.cs
diff --git a/PdfSharpDslCore/Evaluation/BinaryOperation.cs b/PdfSharpDsl.Language/Evaluation/BinaryOperation.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/BinaryOperation.cs
rename to PdfSharpDsl.Language/Evaluation/BinaryOperation.cs
diff --git a/PdfSharpDslCore/Evaluation/ConstantEvaluation.cs b/PdfSharpDsl.Language/Evaluation/ConstantEvaluation.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/ConstantEvaluation.cs
rename to PdfSharpDsl.Language/Evaluation/ConstantEvaluation.cs
diff --git a/PdfSharpDslCore/Evaluation/CustomFunctionEvaluation.cs b/PdfSharpDsl.Language/Evaluation/CustomFunctionEvaluation.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/CustomFunctionEvaluation.cs
rename to PdfSharpDsl.Language/Evaluation/CustomFunctionEvaluation.cs
diff --git a/PdfSharpDslCore/Evaluation/Evaluation.cs b/PdfSharpDsl.Language/Evaluation/Evaluation.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/Evaluation.cs
rename to PdfSharpDsl.Language/Evaluation/Evaluation.cs
diff --git a/PdfSharpDslCore/Evaluation/Evaluator.cs b/PdfSharpDsl.Language/Evaluation/Evaluator.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/Evaluator.cs
rename to PdfSharpDsl.Language/Evaluation/Evaluator.cs
diff --git a/PdfSharpDslCore/Evaluation/UnaryEvaluation.cs b/PdfSharpDsl.Language/Evaluation/UnaryEvaluation.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/UnaryEvaluation.cs
rename to PdfSharpDsl.Language/Evaluation/UnaryEvaluation.cs
diff --git a/PdfSharpDslCore/Evaluation/VariableEvaluation.cs b/PdfSharpDsl.Language/Evaluation/VariableEvaluation.cs
similarity index 100%
rename from PdfSharpDslCore/Evaluation/VariableEvaluation.cs
rename to PdfSharpDsl.Language/Evaluation/VariableEvaluation.cs
diff --git a/PdfSharpDslCore/Extensions/ParseTreeNodeExtensions.cs b/PdfSharpDsl.Language/Extensions/ParseTreeNodeExtensions.cs
similarity index 66%
rename from PdfSharpDslCore/Extensions/ParseTreeNodeExtensions.cs
rename to PdfSharpDsl.Language/Extensions/ParseTreeNodeExtensions.cs
index f50c723..90fdb21 100644
--- a/PdfSharpDslCore/Extensions/ParseTreeNodeExtensions.cs
+++ b/PdfSharpDsl.Language/Extensions/ParseTreeNodeExtensions.cs
@@ -1,5 +1,5 @@
 using Irony.Parsing;
-using PdfSharpCore.Drawing;
+using PdfSharpDslCore.Drawing;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -41,22 +41,22 @@ public static IEnumerable<ParseTreeNode> ChildNodes(this ParseTreeNode node, str
             return node.ChildNodes.FirstOrDefault(n => n.Term != null && n.Term.Name == termName);
         }
 
-        public static XFontStyle ParseFontStyle(this ParseTreeNode? node)
+        public static PdfFontStyle ParseFontStyle(this ParseTreeNode? node)
         {
             if (node != null && node.Token != null)
             {
                 var styleName = (string?)node.Token.Value;
-                if (Enum.TryParse<XFontStyle>(styleName, true, out var fontStyle))
+                if (Enum.TryParse<PdfFontStyle>(styleName, true, out var fontStyle))
                 {
                     return fontStyle;
                 }
             }
-            return XFontStyle.Regular;
+            return PdfFontStyle.Regular;
         }
 
-        public static XColor ParseColor(this ParseTreeNode node)
+        public static PdfColor ParseColor(this ParseTreeNode node)
         {
-            var executor = (Func<ParseTreeNode, XColor>)(node.ChildNodes[0].Term.Name switch
+            var executor = (Func<ParseTreeNode, PdfColor>)(node.ChildNodes[0].Term.Name switch
             {
                 "NamedColor" => ParseNamedColor,
                 _ => ParseHexColor,
@@ -64,36 +64,32 @@ public static XColor ParseColor(this ParseTreeNode node)
 
             return executor(node.ChildNodes[0]);
         }
-        private static XColor ParseNamedColor(ParseTreeNode node)
+        private static PdfColor ParseNamedColor(ParseTreeNode node)
         {
             var color = (string)node.ChildNodes[0].Token.Value;
-
-            var staticColor = typeof(XColors)
-                .GetProperties(BindingFlags.Public | BindingFlags.Static)
-                .FirstOrDefault(x => string.Compare(x.Name, color, StringComparison.OrdinalIgnoreCase) == 0);
-            return ((XColor?)staticColor?.GetValue(null)) ?? XColors.Black;
+            return PdfColors.FromName(color);
         }
 
-        private static XColor ParseHexColor(ParseTreeNode node)
+        private static PdfColor ParseHexColor(ParseTreeNode node)
         {
             var colorValue = node.ChildNodes[0].Token.Value;
             if (colorValue is double)
             {
-                return XColor.FromGrayScale(Convert.ToDouble(colorValue));
+                return PdfColor.FromGrayScale(Convert.ToDouble(colorValue));
             }
             else
             {
                 if (node.ChildNodes[0].Token.Length == 8)
                 {
                     uint argb = ((uint)0xff000000) | Convert.ToUInt32(colorValue);
-                    return XColor.FromArgb(argb);
+                    return PdfColor.FromArgb(argb);
                 }
                 else if (node.ChildNodes[0].Token.Length == 10)
                 {
-                    int argb = Convert.ToInt32(colorValue);
-                    return XColor.FromArgb(argb);
+                    uint argb = unchecked((uint)Convert.ToInt32(colorValue));
+                    return PdfColor.FromArgb(argb);
                 }
-                return XColor.FromArgb(Convert.ToInt32(colorValue));
+                return PdfColor.FromArgb(unchecked((uint)Convert.ToInt32(colorValue)));
             }
         }
 
diff --git a/PdfSharpDslCore/Parser/PdfGrammar.cs b/PdfSharpDsl.Language/Parser/PdfGrammar.cs
similarity index 98%
rename from PdfSharpDslCore/Parser/PdfGrammar.cs
rename to PdfSharpDsl.Language/Parser/PdfGrammar.cs
index 6238445..7c15cb8 100644
--- a/PdfSharpDslCore/Parser/PdfGrammar.cs
+++ b/PdfSharpDsl.Language/Parser/PdfGrammar.cs
@@ -1,8 +1,7 @@
 
 using Irony;
 using Irony.Parsing;
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
+using PdfSharpDslCore.Drawing;
 using System;
 using System.Collections.Generic;
 using System.Data;
@@ -258,9 +257,9 @@ public PdfGrammar()
             VarSmt.Rule = ToTerm("VAR") + variableLiteral + "=" + FormulaExpression + semi;
 
             ColorExp.Rule = NamedColor | HexColor;
-            foreach (var prop in typeof(XColors).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static))
+            foreach (var colorName in PdfColors.Names)
             {
-                var name = prop.Name.ToLowerInvariant();
+                var name = colorName.ToLowerInvariant();
                 if (NamedColor.Rule == null)
                 {
                     NamedColor.Rule = ToTerm(name, $"color-{name}");
@@ -274,14 +273,14 @@ public PdfGrammar()
 
             HexColor.Rule = colorNumber;
             styleExpr.Rule = Empty;
-            foreach (var enumName in Enum.GetNames(typeof(XFontStyle)))
+            foreach (var enumName in Enum.GetNames(typeof(PdfFontStyle)))
             {
                 var styleName = enumName.ToLowerInvariant();
                 styleExpr.Rule |= ToTerm(styleName, $"style-{styleName}");
             }
 
 
-            //TextAlignment is not yet supported on multiline text (only top left is provided by pdfsharpcore)
+            //Multiline alignment is implemented by the TerraPDF canvas adapter.
             //multiline
             TextSmt.Rule = ToInstructionTerm("TEXT") + RectOrPointLocation + OptArg("MaxWidth", FormulaExpression) + Arg("Text") + FormulaExpression;
 
@@ -303,7 +302,7 @@ public PdfGrammar()
 
             PageSize.Rule = Empty;
 
-            var names = Enum.GetNames(typeof(PageSize));
+            var names = Enum.GetNames(typeof(PdfPageSize));
             var firstSize = names.First();
             PageSize.Rule |= ToTerm(firstSize, $"pagesize-{firstSize}");
             foreach (var prop in names.Skip(1))
diff --git a/PdfSharpDslCore/Parser/PdfParserException.cs b/PdfSharpDsl.Language/Parser/PdfParserException.cs
similarity index 100%
rename from PdfSharpDslCore/Parser/PdfParserException.cs
rename to PdfSharpDsl.Language/Parser/PdfParserException.cs
diff --git a/PdfSharpDslCore/Parser/PdfVisitor.cs b/PdfSharpDsl.Language/Parser/PdfVisitor.cs
similarity index 100%
rename from PdfSharpDslCore/Parser/PdfVisitor.cs
rename to PdfSharpDsl.Language/Parser/PdfVisitor.cs
diff --git a/PdfSharpDsl.Language/PdfSharpDsl.Language.csproj b/PdfSharpDsl.Language/PdfSharpDsl.Language.csproj
new file mode 100644
index 0000000..500aa65
--- /dev/null
+++ b/PdfSharpDsl.Language/PdfSharpDsl.Language.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>10.0</LangVersion>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Irony" Version="1.5.3" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="PdfSharpDslCore" />
+    <InternalsVisibleTo Include="PdfSharpDslCore.Generator" />
+    <InternalsVisibleTo Include="pdfsharpdslTests" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/PdfSharpDslConsole/Fonts/MyFontResolver.cs b/PdfSharpDslConsole/Fonts/MyFontResolver.cs
deleted file mode 100644
index 1405442..0000000
--- a/PdfSharpDslConsole/Fonts/MyFontResolver.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using PdfSharpCore.Fonts;
-using PdfSharpCore.Utils;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PdfSharpDslConsole.Fonts
-{
-    internal class MyFontResolver : IFontResolver
-    {
-        private readonly IFontResolver _fontResolver;
-        Dictionary<string, string> fontmap = new Dictionary<string, string>();
-        public string DefaultFontName => "Arial";
-        public MyFontResolver(IEnumerable<string> fontFiles)
-        {
-            _fontResolver = new FontResolver();
-            if (fontFiles != null && fontFiles.Any())
-            {
-                foreach (var fontFile in fontFiles)
-                {
-                    fontmap.Add(Path.GetFileName(fontFile).ToLowerInvariant(), fontFile);
-                }
-                FontResolver.SetupFontsFiles(fontFiles.ToArray());
-            }
-        }
-        public byte[] GetFont(string faceName)
-        {
-            if (fontmap.TryGetValue(faceName.ToLowerInvariant(), out var file))
-            {
-                return File.ReadAllBytes(file);
-            }
-
-            return _fontResolver.GetFont(faceName);
-        }
-
-        public FontResolverInfo ResolveTypeface(string familyName, bool isBold, bool isItalic)
-        {
-            return _fontResolver.ResolveTypeface(familyName, isBold, isItalic);
-        }
-    }
-}
diff --git a/PdfSharpDslConsole/Program.cs b/PdfSharpDslConsole/Program.cs
index 55a1491..97d392f 100644
--- a/PdfSharpDslConsole/Program.cs
+++ b/PdfSharpDslConsole/Program.cs
@@ -1,13 +1,9 @@
 using System.Globalization;
-using PdfSharpCore.Fonts;
-using PdfSharpCore.Pdf;
-using PdfSharpDslConsole.Fonts;
 using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Parser;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-using Microsoft.Extensions.Logging.Console;
+using TerraPDF.Helpers;
 
 ServiceProvider serviceProvider = new ServiceCollection()
     .AddLogging((loggingBuilder) => loggingBuilder
@@ -27,10 +23,6 @@
 logger?.LogDebug("Debug World");         
 logger?.LogInformation("Hello World");
 
-//GlobalFontSettings.FontResolver = new FontResolver();
-GlobalFontSettings.DefaultFontEncoding = PdfFontEncoding.Unicode;
-
-
 #region global variables
 var globalComments = new[]
 {
@@ -115,11 +107,13 @@
 }
 else
 {
-    GlobalFontSettings.FontResolver = new MyFontResolver(LocalFontFiles());
-    //PdfSharpCore cclasses
-    var document = new PdfDocument();
+    foreach (var font in LocalFontNames().Zip(LocalFontFiles()))
+    {
+        FontFamily.Register(font.First, font.Second);
+    }
+
     //draw parsing result
-    using var drawer = new PdfDocumentDrawer(document, logger);
+    using var drawer = new PdfDocumentDrawer(logger);
     var visitor = new PdfDrawerVisitor(logger);
 
     visitor.RegisterFormulaFunction("GetFontCount", (_) => LocalFontNames().Count());
@@ -132,7 +126,7 @@
     visitor.RegisterFormulaFunction("GETCOMMENTAUTHOR", getCommentAuthor);
 
     visitor.Draw(drawer, parsingResult);
-    document.Save("helloworld.pdf");
+    drawer.PublishPdf("helloworld.pdf");
 
     //var a = new PDfDsl.pdfsharp();
     //a.WritePdf(drawer);
diff --git a/PdfSharpDslConsole/helloworld-with-pdfsharp.pdf b/PdfSharpDslConsole/helloworld-with-pdfsharp.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..01f4ce06a7aaabcb00bc0aca9f62f10d3a7b4ce7
GIT binary patch
literal 193103
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
CFpP`<

literal 0
HcmV?d00001

diff --git a/PdfSharpDslConsole/helloworld.pdf b/PdfSharpDslConsole/helloworld.pdf
index 8044ef38b0484d41db884a9384a9b0214ad7b573..1f4a2fa06a455d4ccf68318f7f7075cf5f23947b 100644
GIT binary patch
literal 76945
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
Y#U+VFCE%jk+!S~tH<zlatG^o;08A%C^#A|>

literal 134123
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
Z2@G-x2>R!aBLDya$3YYo4NM7;{{SY}V><u<

diff --git a/PdfSharpDslCore.Generator/DrawingGenerator/CSharpDrawer.cs b/PdfSharpDslCore.Generator/DrawingGenerator/CSharpDrawer.cs
deleted file mode 100644
index 0ebfd60..0000000
--- a/PdfSharpDslCore.Generator/DrawingGenerator/CSharpDrawer.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
-using PdfSharpDslCore.Drawing;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace PdfSharpDslCore.Generator.DrawingGenerator
-{
-    internal class CSharpDrawer : IPdfDocumentDrawer
-    {
-        StringBuilder _code;
-        string _drawerPrefix;
-        int vNameIndex = 1;
-        public CSharpDrawer(StringBuilder code, string drawerPrefix)
-        {
-            _code = code;
-            _drawerPrefix = drawerPrefix;
-        }
-        public XPen CurrentPen
-        {
-            get => throw new NotImplementedException("CurrentPen");
-            set
-            {
-                var penvName = $"pen{vNameIndex++}";
-                _code.AppendLine($"var {penvName} = new XPen({ColorToString(value.Color)}, {value.Width});");
-                _code.AppendLine($"{penvName}.DashStyle = XDashStyle.{value.DashStyle};");
-                _code.AppendLine($"{_drawerPrefix}CurrentPen = {penvName};");
-            }
-        }
-
-        uint Argb(XColor color)
-        {
-            var _a = color.A;
-            var _r = color.R;
-            var _g = color.G;
-            var _b = color.B;
-            return ((uint)(_a * 255) << 24) | ((uint)_r << 16) | ((uint)_g << 8) | _b;
-        }
-
-        private string ColorToString(XColor color)
-        {
-            if (color.IsKnownColor)
-            {
-                return $"XColors.{XColorResourceManager.GetKnownColor(Argb(color))}";
-            }
-            else
-            {
-                return $"XColor.FromArgb({color.A},{color.R},{color.G},{color.B})";
-            }
-        }
-
-        public XBrush CurrentBrush
-        {
-            get => throw new NotImplementedException("CurrentBrush");
-            set { }
-        }
-
-        public XBrush HighlightBrush
-        {
-            get => throw new NotImplementedException();
-            set { }
-        }
-        public XFont CurrentFont
-        {
-            get => throw new NotImplementedException("CurrentFont");
-            set { }
-        }
-
-        public double PageWidth => 100;//throw new NotImplementedException();
-
-        public double PageHeight => 100;//throw new NotImplementedException();
-        public DebugOptions DebugOptions { get; set; }
-
-        public void DrawEllipse(double x, double y, double w, double h, bool isFilled)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawImage(XImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawLine(double x, double y, double x1, double y1)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawLineText(string text, double x, double y, double? w, double? h, XStringAlignment hAlign, XLineAlignment vAlign, TextOrientation textOrientation)
-        {
-            //throw new NotImplementedException("DrawLineText");
-        }
-
-        public void DrawPie(double x, double y, double? w, double? h, double startAngle, double sweepAngle, bool isFilled)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawPolygon(IEnumerable<XPoint> points, bool isFilled)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawRect(double x, double y, double w, double h, bool isFilled)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawTable(double x, double y, TableDefinition tblDef)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawText(string text, double x, double y, double? w, double? h)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void DrawTitle(string text, double margin, XStringAlignment hAlign, XLineAlignment vAlign)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void LineTo(double x, double y)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void MoveTo(double x, double y)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void NewPage(PageSize? pageSize = null, PageOrientation? pageOrientation = null)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void SetViewSize(double w, double h)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void BeginDrawRowTemplate(string name, int index, double offsetY, double newPageTopMargin)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public DrawingResult EndDrawRowTemplate(int index)
-        {
-            //throw new NotImplementedException();
-            return new DrawingResult();
-        }
-
-        public void BeginIterationTemplate(int rowCount)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void EndIterationTemplate(double drawHeight)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void RegisterOnNewPage(Action<int> callback)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void UnRegisterOnNewPage(Action<int> callback)
-        {
-            //throw new NotImplementedException();
-        }
-
-        public void SetOffsetY(double offsetY)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void ResetOffset()
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/PdfSharpDslCore.Generator/DrawingGenerator/CSharpGeneratorState.cs b/PdfSharpDslCore.Generator/DrawingGenerator/CSharpGeneratorState.cs
index 08ef97a..7680b5d 100644
--- a/PdfSharpDslCore.Generator/DrawingGenerator/CSharpGeneratorState.cs
+++ b/PdfSharpDslCore.Generator/DrawingGenerator/CSharpGeneratorState.cs
@@ -61,7 +61,6 @@ private StringBuilder ConstructCode()
 #nullable enable
 namespace PDfDsl {
     using System.Collections.Generic;
-    using PdfSharpCore.Drawing;
     using PdfSharpDslCore.Drawing;
     //another comments
 ");
diff --git a/PdfSharpDslCore.Generator/DrawingGenerator/CSharpVisitor.cs b/PdfSharpDslCore.Generator/DrawingGenerator/CSharpVisitor.cs
index e0c07d8..591fa44 100644
--- a/PdfSharpDslCore.Generator/DrawingGenerator/CSharpVisitor.cs
+++ b/PdfSharpDslCore.Generator/DrawingGenerator/CSharpVisitor.cs
@@ -1,6 +1,4 @@
 using Irony.Parsing;
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Evaluation;
 using PdfSharpDslCore.Extensions;
@@ -65,11 +63,10 @@ protected override void ExecutePen(IGeneratorState state, ParseTreeNode widthNod
             ParseTreeNode styleNode)
         {
             var penvName = $"pen{vNameIndex++}";
-            state.AppendLine($"var {penvName} = new XPen({ColorToString(colorNode.ParseColor())}, (double){EvaluateForString(widthNode).StringValue});");
-            //_code.AppendLine($"var {penvName} = new XPen({ColorToString(value.Color)}, {value.Width});");
-            if (styleNode != null && Enum.TryParse< XDashStyle>(styleNode.Token.ValueString, true, out var penStyle))
+            state.AppendLine($"var {penvName} = new PdfPen({ColorToString(colorNode.ParseColor())}, (double){EvaluateForString(widthNode).StringValue});");
+            if (styleNode != null && Enum.TryParse<PdfDashStyle>(styleNode.Token.ValueString, true, out var penStyle))
             {
-                state.AppendLine($"{penvName}.DashStyle = XDashStyle.{penStyle.ToString()};");
+                state.AppendLine($"{penvName}.DashStyle = PdfDashStyle.{penStyle};");
             }
             state.AppendLine($"{_prefix}CurrentPen = {penvName};");
         }
@@ -104,25 +101,9 @@ private EvaluationResult EvaluateForString(ParseTreeNode node)
             return new CSharpEvaluator(_prefix, node).EvaluateForCSharpString(_declaredVariables, _declaredFunctions);
         }
 
-        uint Argb(XColor color)
+        private static string ColorToString(PdfColor color)
         {
-            var _a = color.A;
-            var _r = color.R;
-            var _g = color.G;
-            var _b = color.B;
-            return ((uint)(_a * 255) << 24) | ((uint)_r << 16) | ((uint)_g << 8) | _b;
-        }
-
-        private string ColorToString(XColor color)
-        {
-            if (color.IsKnownColor)
-            {
-                return $"XColors.{XColorResourceManager.GetKnownColor(Argb(color))}";
-            }
-            else
-            {
-                return $"XColor.FromArgb({color.A},{color.R},{color.G},{color.B})";
-            }
+            return $"PdfColor.FromArgb({color.Alpha}, {color.Red}, {color.Green}, {color.Blue})";
         }
     }
 }
\ No newline at end of file
diff --git a/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj b/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
index f83c090..6adf390 100644
--- a/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
+++ b/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
@@ -16,6 +16,7 @@
 		<IncludeBuildOutput>false</IncludeBuildOutput>
 		<NoPackageAnalysis>true</NoPackageAnalysis>
 		<IsRoslynComponent>true</IsRoslynComponent>
+		<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -23,10 +24,6 @@
 		<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" PrivateAssets="all" />
 		<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
 		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" GeneratePathProperty="true" />
-		<PackageReference Include="PdfSharpCore" Version="1.3.63" GeneratePathProperty="true" />
-		<PackageReference Include="SixLabors.Fonts" Version="1.0.1" GeneratePathProperty="true" />
-		<PackageReference Include="SixLabors.ImageSharp" Version="2.1.12" GeneratePathProperty="true" />
-		<PackageReference Include="SharpZipLib" Version="1.4.2" GeneratePathProperty="true" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -36,19 +33,18 @@
 	<ItemGroup>
 		<!-- Package the generator in the analyzer directory of the nuget package -->
 		<None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
-		<None Include="$(MSBuildProjectDirectory)\..\PdfSharpDslCore\bin\$(Configuration)\netstandard2.0\PdfSharpDslCore.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+		<None Include="$(MSBuildProjectDirectory)\..\PdfSharpDsl.Language\bin\$(Configuration)\netstandard2.0\PdfSharpDsl.Language.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 
 		<!-- Package the Irony dependency alongside the generator assembly -->
 		<None Include="$(PKGIrony)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
-		<None Include="$(PKGPdfSharpCore)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
-		<None Include="$(PKGSixLabors_Fonts)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
-		<None Include="$(PKGSixLabors_ImageSharp)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
-		<None Include="$(PKGSharpZipLib)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 		<None Include="$(PKGMicrosoft_Extensions_Logging_Abstractions)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 	</ItemGroup>
 
 	<ItemGroup>
-		<ProjectReference Include="..\PdfSharpDslCore\PdfSharpDslCore.csproj" GeneratePathProperty="true" />
+		<ProjectReference Include="..\PdfSharpDsl.Language\PdfSharpDsl.Language.csproj" PrivateAssets="all" GeneratePathProperty="true" />
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Remove="DrawingGenerator\CSharpDrawer.cs" />
 	</ItemGroup>
 
 	<PropertyGroup>
@@ -58,11 +54,7 @@
 	<Target Name="GetDependencyTargetPaths">
 		<ItemGroup>
 			<TargetPathWithTargetPlatformMoniker Include="$(PKGIrony)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="false" />
-			<TargetPathWithTargetPlatformMoniker Include="$(MSBuildProjectDirectory)\..\PdfSharpDslCore\bin\$(Configuration)\$(TargetFramework)\PdfSharpDslCore.dll" IncludeRuntimeDependency="false" />
-			<TargetPathWithTargetPlatformMoniker Include="$(PKGPdfSharpCore)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="true" />
-			<TargetPathWithTargetPlatformMoniker Include="$(PKGSixLabors_Fonts)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="false" />
-			<TargetPathWithTargetPlatformMoniker Include="$(PKGSixLabors_ImageSharp)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="false" />
-			<TargetPathWithTargetPlatformMoniker Include="$(PKGSharpZipLib)\lib\netstandard2.0\*.dll" IncludeRuntimeDependency="false" />
+			<TargetPathWithTargetPlatformMoniker Include="$(MSBuildProjectDirectory)\..\PdfSharpDsl.Language\bin\$(Configuration)\$(TargetFramework)\PdfSharpDsl.Language.dll" IncludeRuntimeDependency="false" />
 		</ItemGroup>
 	</Target>
 </Project>
diff --git a/PdfSharpDslCore/Drawing/DrawingContext.cs b/PdfSharpDslCore/Drawing/DrawingContext.cs
index 70294c0..21e6caa 100644
--- a/PdfSharpDslCore/Drawing/DrawingContext.cs
+++ b/PdfSharpDslCore/Drawing/DrawingContext.cs
@@ -1,5 +1,4 @@
-using PdfSharpCore.Drawing;
-using System;
+using System;
 using System.Collections.Generic;
 using Irony;
 using Microsoft.Extensions.Logging;
@@ -9,8 +8,8 @@ namespace PdfSharpDslCore.Drawing
     internal class DrawingContext
     {
         private readonly BlocksRecorder _recorder;
-        private readonly Stack<XGraphics> _previousGraphics = new();
-        public int Level => _previousGraphics.Count;
+        private int _level;
+        public int Level => _level;
 
         public DebugOptions DebugOptions { get; set; }
         public bool DebugText => (DebugOptions & (DebugOptions.DebugText | DebugOptions.DebugAll)) > 0;
@@ -21,18 +20,18 @@ public DrawingContext(ILogger? logger)
             _recorder = new(logger);
         }
         
-        public void OpenBlock(string name, double offsetY, XGraphics previousGraphics, double newPageTopMargin)
+        public void OpenBlock(string name, double offsetY, double newPageTopMargin)
         {
-            _previousGraphics.Push(previousGraphics);
+            _level++;
             _recorder.OpenBlock(name, offsetY, true, newPageTopMargin);
         }
 
-        public XRect BlockRect => _recorder.CurrentBlock.Rect;
-        internal (IInstructionBlock, XGraphics) RestoreGraphics()
+        public PdfRect BlockRect => _recorder.CurrentBlock.Rect;
+        internal IInstructionBlock EndMeasure()
         {
             var block = _recorder.CurrentBlock;
-
-            return (block, _previousGraphics.Pop());
+            _level--;
+            return block;
         }
 
         internal void CloseBlock()
@@ -40,7 +39,7 @@ internal void CloseBlock()
             _recorder.CloseBlock();
         }
         
-        public void PushInstruction(Action<double> action, XRect rect, bool accumulate=true, string instrName="")
+        public void PushInstruction(Action<double> action, PdfRect rect, bool accumulate=true, string instrName="")
         {
             if (_recorder.CanPushInstruction)
             {
@@ -49,9 +48,9 @@ public void PushInstruction(Action<double> action, XRect rect, bool accumulate=t
             }
         }
 
-        public void PushInstruction(Action<double> action, XPoint[] ptArray)
+        public void PushInstruction(Action<double> action, PdfPoint[] ptArray)
         {
-            var r = XRect.Empty;
+            var r = PdfRect.Empty;
             foreach (var pt in ptArray)   
             {
                 r.Union(pt);
diff --git a/PdfSharpDslCore/Drawing/DrawingHelper.cs b/PdfSharpDslCore/Drawing/DrawingHelper.cs
index 0956954..d0e1004 100644
--- a/PdfSharpDslCore/Drawing/DrawingHelper.cs
+++ b/PdfSharpDslCore/Drawing/DrawingHelper.cs
@@ -1,7 +1,4 @@
-using PdfSharpCore.Drawing;
-using PdfSharpCore.Pdf;
-
-namespace PdfSharpDslCore.Drawing
+namespace PdfSharpDslCore.Drawing
 {
     internal static class DrawingHelper
     {
@@ -12,30 +9,31 @@ internal static class DrawingHelper
         /// <param name="textSize"></param>
         /// <param name="fmt"></param>
         /// <returns></returns>
-        public static XRect RectFromStringFormat(XRect r, XSize textSize, XStringFormat fmt)
+        public static PdfRect RectFromStringFormat(PdfRect r, PdfSize textSize,
+            PdfHorizontalAlignment horizontalAlignment, PdfVerticalAlignment verticalAlignment)
         {
-            var result = new XRect(r.TopLeft, textSize);
+            var result = new PdfRect(r.TopLeft, textSize);
 
-            switch (fmt.Alignment)
+            switch (horizontalAlignment)
             {
-                case XStringAlignment.Center:
+                case PdfHorizontalAlignment.Center:
                     result.Offset((r.Width - textSize.Width) / 2, 0);
                     break;
-                case XStringAlignment.Near:
+                case PdfHorizontalAlignment.Near:
                     break;
-                case XStringAlignment.Far:
+                case PdfHorizontalAlignment.Far:
                     result.Offset(r.Width - textSize.Width, 0);
                     break;
             }
 
-            switch (fmt.LineAlignment)
+            switch (verticalAlignment)
             {
-                case XLineAlignment.Center:
+                case PdfVerticalAlignment.Center:
                     result.Offset(0, (r.Height - textSize.Height) / 2);
                     break;
-                case XLineAlignment.Near:
+                case PdfVerticalAlignment.Near:
                     break;
-                case XLineAlignment.Far:
+                case PdfVerticalAlignment.Far:
                     result.Offset(0, r.Height - textSize.Height);
                     break;
             }
@@ -45,32 +43,33 @@ public static XRect RectFromStringFormat(XRect r, XSize textSize, XStringFormat
             return result;
         }
 
-        public static XRect RectFromStringFormat(double x, double y, XSize textSize, XStringFormat fmt)
+        public static PdfRect RectFromStringFormat(double x, double y, PdfSize textSize,
+            PdfHorizontalAlignment horizontalAlignment, PdfVerticalAlignment verticalAlignment)
         {
-            var result = new XRect(x, y, textSize.Width, textSize.Height);
+            var result = new PdfRect(x, y, textSize.Width, textSize.Height);
 
             var xOffset = 0.0;
             var yOffset = 0.0;
-            switch (fmt.Alignment)
+            switch (horizontalAlignment)
             {
-                case XStringAlignment.Center:
+                case PdfHorizontalAlignment.Center:
                     xOffset -= textSize.Width / 2;
                     break;
-                case XStringAlignment.Near:
+                case PdfHorizontalAlignment.Near:
                     break;
-                case XStringAlignment.Far:
+                case PdfHorizontalAlignment.Far:
                     xOffset -= textSize.Width;
                     break;
             }
 
-            switch (fmt.LineAlignment)
+            switch (verticalAlignment)
             {
-                case XLineAlignment.Center:
+                case PdfVerticalAlignment.Center:
                     yOffset -= textSize.Height / 2;
                     break;
-                case XLineAlignment.Near:
+                case PdfVerticalAlignment.Near:
                     break;
-                case XLineAlignment.Far:
+                case PdfVerticalAlignment.Far:
                     yOffset -= textSize.Height;
                     break;
             }
@@ -79,51 +78,53 @@ public static XRect RectFromStringFormat(double x, double y, XSize textSize, XSt
 
             return result;
         }
-        public static (double, double, double, double) CoordRectToPage(this PdfPage page, double x, double y, double w, double h)
+        public static (double, double, double, double) CoordRectToPage(double pageWidth, double pageHeight,
+            double x, double y, double w, double h)
         {
             if (x < 0)
             {
-                x = page.Width + x;
+                x = pageWidth + x;
             }
 
             if (y < 0)
             {
-                y = page.Height + y;
+                y = pageHeight + y;
             }
 
             if (w < 0)
             {
-                w = page.Width + w - x;
+                w = pageWidth + w - x;
             }
 
             if (h < 0)
             {
-                h = page.Height + h - y;
+                h = pageHeight + h - y;
             }
 
             return (x, y, w, h);
         }
 
-        public static (double, double, double?, double?) CoordRectToPage(this PdfPage page, double x, double y, double? w, double? h)
+        public static (double, double, double?, double?) CoordRectToPage(double pageWidth, double pageHeight,
+            double x, double y, double? w, double? h)
         {
             if (x < 0)
             {
-                x = page.Width + x;
+                x = pageWidth + x;
             }
 
             if (y < 0)
             {
-                y = page.Height + y;
+                y = pageHeight + y;
             }
 
             if (w is < 0)
             {
-                w = page.Width + w - x;
+                w = pageWidth + w - x;
             }
 
             if (h is < 0)
             {
-                h = page.Height + h - y;
+                h = pageHeight + h - y;
             }
 
             return (x, y, w, h);
diff --git a/PdfSharpDslCore/Drawing/IInstructionBlock.cs b/PdfSharpDslCore/Drawing/IInstructionBlock.cs
index d6dcce1..f5115b7 100644
--- a/PdfSharpDslCore/Drawing/IInstructionBlock.cs
+++ b/PdfSharpDslCore/Drawing/IInstructionBlock.cs
@@ -1,14 +1,13 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using Microsoft.Extensions.Logging;
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Extensions;
 
 namespace PdfSharpDslCore.Drawing
 {
     internal interface IInstruction
     {
-        XRect Rect { get; }
+        PdfRect Rect { get; }
         string Name { get; }
 
         /// <summary>
@@ -51,7 +50,7 @@ internal interface IInstructionBlock : IInstruction
         /// <returns></returns>
         IInstructionBlock OpenBlock(string name, double offsetY, bool entirePrint, double newPageTopMargin=0);
         void CloseBlock();
-        void UpdateRect(XRect rect);
+        void UpdateRect(PdfRect rect);
 
         void Clear();
 
diff --git a/PdfSharpDslCore/Drawing/IPdfDocumentDrawer.cs b/PdfSharpDslCore/Drawing/IPdfDocumentDrawer.cs
index 060ef2f..1313858 100644
--- a/PdfSharpDslCore/Drawing/IPdfDocumentDrawer.cs
+++ b/PdfSharpDslCore/Drawing/IPdfDocumentDrawer.cs
@@ -1,8 +1,6 @@
 
 
 using System;
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
 using System.Collections.Generic;
 
 namespace PdfSharpDslCore.Drawing
@@ -20,7 +18,7 @@ public record TextOrientation
 
     public record DrawingResult
     {
-        public XRect DrawingRect { get; set; }
+        public PdfRect DrawingRect { get; set; }
         public double PageOffsetY { get; set; }
     }
 
@@ -29,27 +27,27 @@ public interface IPdfDocumentDrawer
         void DrawRect(double x, double y, double w, double h, bool isFilled);
         void DrawText(string text, double x, double y, double? w, double? h);
         void DrawLineText(string text, double x, double y, double? w, double? h,
-            XStringAlignment hAlign, XLineAlignment vAlign, TextOrientation textOrientation);
+            PdfHorizontalAlignment hAlign, PdfVerticalAlignment vAlign, TextOrientation textOrientation);
         void SetViewSize(double w, double h);
-        XPen CurrentPen { get; set; }
-        XBrush CurrentBrush { get; set; }
-        XBrush? HighlightBrush { get; set; }
-        XFont CurrentFont { get; set; }
+        PdfPen CurrentPen { get; set; }
+        PdfBrush CurrentBrush { get; set; }
+        PdfBrush? HighlightBrush { get; set; }
+        PdfFont CurrentFont { get; set; }
         double PageWidth { get; }
         double PageHeight { get; }
         
         DebugOptions DebugOptions { get; set; }
 
-        void NewPage(PageSize? pageSize = null, PageOrientation? pageOrientation = null);
+        void NewPage(PdfPageSize? pageSize = null, PdfPageOrientation? pageOrientation = null);
         void DrawLine(double x, double y, double x1, double y1);
-        void DrawTitle(string text, double margin, XStringAlignment hAlign, XLineAlignment vAlign);
+        void DrawTitle(string text, double margin, PdfHorizontalAlignment hAlign, PdfVerticalAlignment vAlign);
         void DrawEllipse(double x, double y, double w, double h, bool isFilled);
         void MoveTo(double x, double y);
         void LineTo(double x, double y);
         void DrawTable(double x, double y, TableDefinition tblDef);
-        void DrawImage(XImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage);
+        void DrawImage(PdfImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage);
         void DrawPie(double x, double y, double? w, double? h, double startAngle, double sweepAngle, bool isFilled);
-        void DrawPolygon(IEnumerable<XPoint> points, bool isFilled);
+        void DrawPolygon(IEnumerable<PdfPoint> points, bool isFilled);
         void BeginDrawRowTemplate(string name, int index, double offsetY, double newPageTopMargin);
         DrawingResult EndDrawRowTemplate(int index);
         void BeginIterationTemplate(int rowCount);
diff --git a/PdfSharpDslCore/Drawing/InstructionBlock.cs b/PdfSharpDslCore/Drawing/InstructionBlock.cs
index 61fc640..5221eae 100644
--- a/PdfSharpDslCore/Drawing/InstructionBlock.cs
+++ b/PdfSharpDslCore/Drawing/InstructionBlock.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using Microsoft.Extensions.Logging;
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Extensions;
 
 namespace PdfSharpDslCore.Drawing
@@ -12,11 +11,11 @@ namespace PdfSharpDslCore.Drawing
     [DebuggerDisplay("Rect:{Rect}")]
     class InstructionAction : IInstruction, IHasName
     {
-        public XRect Rect { get; }
+        public PdfRect Rect { get; }
         private readonly Action<double> _action;
         public string Name { get; }
 
-        public InstructionAction(Action<double> action, XRect rect, string name)
+        public InstructionAction(Action<double> action, PdfRect rect, string name)
         {
             this.Rect = rect;
             _action = action;
@@ -41,7 +40,7 @@ class InstructionBlock : IInstructionBlock, IHasName
 
         public bool ShouldBeEntirePrinted { get; }
 
-        public XRect Rect { get; private set; } = XRect.Empty;
+        public PdfRect Rect { get; private set; } = PdfRect.Empty;
 
         public IInstructionBlock? Parent => _parent;
         public double OffsetY => _offsetY;
@@ -85,7 +84,7 @@ public double Draw(IPdfDocumentDrawer drawer, double offsetY, double pageOffsetY
             {
                 var selfOffsetY = _offsetY;
 
-                XRect pageRect = new XRect(0, 0, drawer.PageWidth, drawer.PageHeight);
+                PdfRect pageRect = new PdfRect(0, 0, drawer.PageWidth, drawer.PageHeight);
                 //2 cas : l'instruction ne rentre pas dans la page actuelle, il faut une nouvelle page
                 // ça ne rentre dans aucune page, il faut "imprimé" par morceau
                 if (ShouldBeEntirePrinted)
@@ -292,7 +291,7 @@ public void CloseBlock()
             //
         }
 
-        public void UpdateRect(XRect rect)
+        public void UpdateRect(PdfRect rect)
         {
             if (rect.IsEmpty) return;
             rect.Offset(0, _offsetY);
diff --git a/PdfSharpDslCore/Drawing/InstructionsRecorder.cs b/PdfSharpDslCore/Drawing/InstructionsRecorder.cs
index 148e309..8b65ab9 100644
--- a/PdfSharpDslCore/Drawing/InstructionsRecorder.cs
+++ b/PdfSharpDslCore/Drawing/InstructionsRecorder.cs
@@ -1,5 +1,4 @@
-using PdfSharpCore.Drawing;
-using PdfSharpDslCore.Drawing;
+using PdfSharpDslCore.Drawing;
 using System;
 using System.Collections.Generic;
 using System.Linq;
diff --git a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
index ee69874..c4c692c 100644
--- a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
+++ b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
@@ -1,806 +1,437 @@
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
-using PdfSharpCore.Drawing.Layout;
-using PdfSharpCore.Pdf;
-using SixLabors.ImageSharp;
+using Microsoft.Extensions.Logging;
+using PdfSharpDslCore.Extensions;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
-using System.Net;
-using Microsoft.Extensions.Logging;
-using PdfSharpDslCore.Extensions;
-using SixLabors.Fonts;
+using TerraPDF.Core;
 
 namespace PdfSharpDslCore.Drawing
 {
     public sealed class PdfDocumentDrawer : IDisposable, IPdfDocumentDrawer
     {
-        private readonly PdfDocument _document;
-        private readonly ILogger? _logger;
-        private PdfPage? _currentPage;
-        private XPen? _currentPen;
-        private XBrush? _currentBrush;
-
-        private XFont? _currentFont;
-        private XGraphics? _gfx;
-        private IXGraphicsRenderer? _gfxRenderer;
-        private bool _disposedValue;
-        private XPoint _currentPoint = new XPoint(0, 0);
-        private PageSize _defaultPageSize = PageSize.A4;
-        private PageOrientation _defaultPageOrientation = PageOrientation.Portrait;
-        private readonly List<Action<int>> _onNewPageHooks = new();
+        private sealed class RecordedPage
+        {
+            public RecordedPage(PdfPageSize size, PdfPageOrientation orientation)
+            {
+                (Width, Height) = GetPageDimensions(size, orientation);
+            }
 
-        private readonly DrawingContext _drawingCtx;
+            public double Width { get; }
+            public double Height { get; }
+            public double ScaleX { get; set; } = 1;
+            public double ScaleY { get; set; } = 1;
+            public List<Action<VectorCanvas>> Commands { get; } = new();
+        }
 
-        private readonly XPen _debugPen = new XPen(XColors.Red, 0.5) { DashStyle = XDashStyle.DashDot };
-        private readonly Lazy<XFont> _debugFont = new Lazy<XFont>(() => new XFont("monospace", 6));
+        private readonly ILogger? _logger;
+        private readonly DrawingContext _drawingCtx;
+        private readonly List<RecordedPage> _pages = new();
+        private readonly List<Action<int>> _onNewPageHooks = new();
+        private readonly Stack<bool> _measurementStates = new();
+        private PdfPageSize _defaultPageSize = PdfPageSize.A4;
+        private PdfPageOrientation _defaultPageOrientation = PdfPageOrientation.Portrait;
+        private PdfPen? _currentPen;
+        private PdfBrush? _currentBrush;
+        private PdfFont? _currentFont;
+        private PdfPoint _currentPoint;
+        private bool _isMeasuring;
 
-        public PdfDocumentDrawer(PdfDocument document, ILogger? logger = null)
+        public PdfDocumentDrawer(ILogger? logger = null)
         {
-            _drawingCtx = new(logger);
-            _document = document ?? throw new ArgumentNullException(nameof(document));
             _logger = logger;
+            _drawingCtx = new DrawingContext(logger);
         }
 
-        #region properties
-
         public DebugOptions DebugOptions
         {
             get => _drawingCtx.DebugOptions;
             set => _drawingCtx.DebugOptions = value;
         }
 
-        public PdfPage CurrentPage
-        {
-            get
-            {
-                if (_currentPage is not null) return _currentPage;
-                _currentPage = _document.AddPage();
-                _currentPage.Size = _defaultPageSize;
-                _currentPage.Orientation = _defaultPageOrientation;
-
-                return _currentPage;
-            }
-            set
-            {
-                if (_currentPage == value) return;
-                _currentPage = value;
-                if (_logger.DebugEnabled())
-                {
-                    _logger.WriteDebug(this, $"Dispose GFX:{_gfx?.GetHashCode() ?? 0}");
-                }
-                _gfx?.Dispose();
-                _gfx = null;
-                _gfxRenderer = null;
-            }
-        }
-
-        public XPen CurrentPen
+        public PdfPen CurrentPen
         {
-            get => _currentPen ??= XPens.Black;
-            set => _currentPen = value;
+            get => _currentPen ??= new PdfPen(PdfColor.Black, 1);
+            set => _currentPen = value ?? throw new ArgumentNullException(nameof(value));
         }
 
-        public XBrush CurrentBrush
+        public PdfBrush CurrentBrush
         {
-            get => _currentBrush ??= XBrushes.Black;
-            set => _currentBrush = value;
+            get => _currentBrush ??= new PdfBrush(PdfColor.Black);
+            set => _currentBrush = value ?? throw new ArgumentNullException(nameof(value));
         }
 
-        public XBrush? HighlightBrush { get; set; }
+        public PdfBrush? HighlightBrush { get; set; }
 
-        public XFont CurrentFont
+        public PdfFont CurrentFont
         {
-            get => _currentFont ??= new XFont("Arial", 10);
-            set => _currentFont = value;
+            get => _currentFont ??= new PdfFont("Helvetica", 10);
+            set => _currentFont = value ?? throw new ArgumentNullException(nameof(value));
         }
 
         public double PageWidth => CurrentPage.Width;
         public double PageHeight => CurrentPage.Height;
 
-
-        private XGraphics Gfx
+        private RecordedPage CurrentPage
         {
             get
             {
-                if (_gfx is not null) return _gfx;
-                if (_logger.DebugEnabled())
+                if (_pages.Count == 0)
                 {
-                    _logger.WriteDebug(this, "Create new gfx from page");
+                    _pages.Add(new RecordedPage(_defaultPageSize, _defaultPageOrientation));
                 }
-                _gfx = XGraphics.FromPdfPage(CurrentPage);
-                // HACK, read from https://github.com/ststeiger/PdfSharpCore/blob/master/docs/MigraDocCore/samples/MixMigraDocCoreAndPDFsharpCore.md
-                _gfx.MUH = PdfFontEncoding.Unicode;
 
-                return _gfx;
+                return _pages[_pages.Count - 1];
             }
         }
 
-        #endregion
-
-        private void Dispose(bool disposing)
+        public void PublishPdf(Stream stream)
         {
-            if (_disposedValue) return;
-            if (disposing)
-            {
-                // TODO: dispose managed state (managed objects)
-                _gfx?.Dispose();
-            }
+            ArgumentNullException.ThrowIfNull(stream);
+            CreateDocument().PublishPdf(stream);
+        }
 
-            _gfx = null;
-            _gfxRenderer = null;
-            // TODO: free unmanaged resources (unmanaged objects) and override finalizer
-            // TODO: set large fields to null
-            _disposedValue = true;
+        public void PublishPdf(string path)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(path);
+            CreateDocument().PublishPdf(path);
         }
 
-        public void Dispose()
+        public byte[] PublishPdf() => CreateDocument().PublishPdf();
+
+        private DocumentComposer CreateDocument()
         {
-            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
-            Dispose(disposing: true);
+            _ = CurrentPage;
+            return Document.Create(document =>
+            {
+                foreach (var recordedPage in _pages)
+                {
+                    document.Page(page =>
+                    {
+                        page.Size(recordedPage.Width, recordedPage.Height);
+                        page.Margin(0);
+                        page.Content().Canvas(recordedPage.Height, canvas =>
+                        {
+                            foreach (var command in recordedPage.Commands)
+                            {
+                                command(canvas);
+                            }
+                        });
+                    });
+                }
+            });
         }
 
         public void DrawLine(double x, double y, double x1, double y1)
         {
             var page = CurrentPage;
-            if (x < 0)
-            {
-                x = page.Width + x;
-            }
-
-            if (y < 0)
-            {
-                y = page.Height + y;
-            }
-
-            if (x1 < 0)
-            {
-                x1 = page.Width + x1;
-            }
-
-            if (y1 < 0)
-            {
-                y1 = page.Height + y1;
-            }
-            InternalDrawLine(CurrentPen, x, y, x1, y1);
+            InternalDrawLine(CurrentPen, ScaleX(ResolveX(x, page), page), ScaleY(ResolveY(y, page), page),
+                ScaleX(ResolveX(x1, page), page), ScaleY(ResolveY(y1, page), page));
         }
 
-        private void InternalDrawLine(XPen pen, double x, double y, double x1, double y1)
+        private void InternalDrawLine(PdfPen pen, double x, double y, double x1, double y1)
         {
-            Gfx.DrawLine(pen, x, y, x1, y1);
-            this._drawingCtx.PushInstruction((oy) => InternalDrawLine(pen, x, y+oy, x1, y1+oy), new XRect(new XPoint(x, y), new XPoint(x1, y1)));
+            AddCommand(canvas => canvas.Line(x, y, x1, y1, pen.Color.Hex, pen.Width, pen.Color.Opacity));
+            _drawingCtx.PushInstruction(offset => InternalDrawLine(pen, x, y + offset, x1, y1 + offset),
+                new PdfRect(new PdfPoint(x, y), new PdfPoint(x1, y1)));
         }
 
         public void DrawRect(double x, double y, double w, double h, bool isFilled)
         {
-            (x, y, w, h) = CurrentPage.CoordRectToPage(x, y, w, h);
-            InternalDrawRect(CurrentPen, CurrentBrush, x, y, w, h, isFilled);
+            var page = CurrentPage;
+            (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
+            InternalDrawRect(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w, page), ScaleY(h, page), isFilled);
         }
 
-        private void InternalDrawRect(XPen pen, XBrush brush, double x, double y, double w, double h, bool isFilled)
+        private void InternalDrawRect(PdfPen pen, PdfBrush brush, double x, double y, double w, double h, bool isFilled)
         {
-            if (isFilled)
+            AddCommand(canvas =>
             {
-                Gfx.DrawRectangle(pen, brush, x, y, w, h);
-            }
-            else
-            {
-                Gfx.DrawRectangle(pen, x, y, w, h);
-            }
-            this._drawingCtx.PushInstruction((oy) => InternalDrawRect(pen, brush, x, y+oy, w, h, isFilled), new XRect(x, y, w, h));
+                if (isFilled) canvas.FillRect(x, y, w, h, brush.Color.Hex, brush.Color.Opacity);
+                canvas.StrokeRect(x, y, w, h, pen.Color.Hex, pen.Width, pen.Color.Opacity);
+            });
+            _drawingCtx.PushInstruction(offset => InternalDrawRect(pen, brush, x, y + offset, w, h, isFilled),
+                new PdfRect(x, y, w, h));
         }
 
         public void DrawEllipse(double x, double y, double w, double h, bool isFilled)
         {
-            (x, y, w, h) = CurrentPage.CoordRectToPage(x, y, w, h);
-            var r = new XRect(x, y, w, h);
-            InternalDrawEllipse(isFilled, r, CurrentPen, CurrentBrush);
+            var page = CurrentPage;
+            (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
+            InternalDrawEllipse(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w, page), ScaleY(h, page), isFilled);
         }
 
-        private void InternalDrawEllipse(bool isFilled, XRect r, XPen pen, XBrush brush)
+        private void InternalDrawEllipse(PdfPen pen, PdfBrush brush, double x, double y, double w, double h, bool isFilled)
         {
-            if (isFilled)
-            {
-                Gfx.DrawEllipse(pen, brush, r);
-            }
-            else
+            AddCommand(canvas =>
             {
-                Gfx.DrawEllipse(pen, r);
-            }
-            this._drawingCtx.PushInstruction((oy) => InternalDrawEllipse(isFilled, r.OffsetY(oy), pen, brush), r);
+                var cx = x + w / 2;
+                var cy = y + h / 2;
+                if (isFilled) canvas.FillEllipse(cx, cy, w / 2, h / 2, brush.Color.Hex, brush.Color.Opacity);
+                canvas.StrokeEllipse(cx, cy, w / 2, h / 2, pen.Color.Hex, pen.Width, pen.Color.Opacity);
+            });
+            _drawingCtx.PushInstruction(offset => InternalDrawEllipse(pen, brush, x, y + offset, w, h, isFilled), new PdfRect(x, y, w, h));
         }
 
-        public void DrawText(string text, double x, double y, double? w,
-            double? h)
+        public void DrawText(string text, double x, double y, double? w, double? h)
         {
             var page = CurrentPage;
-            (x, y, w, h) = page.CoordRectToPage(x, y, w, h);
-            //20221009 : only top left is supported
-            if (w == null || h == null)
-            {
-                //because of missing w/h alignment is Left
-                var sizeFormatter = new XTextSegmentFormatter(Gfx)
-                {
-                    Alignment = XParagraphAlignment.Left
-                };
-                w = w ?? page.Width - x;
-                var size = sizeFormatter.CalculateTextSize(text, CurrentFont, CurrentBrush, w.Value);
-                var r = new XRect(x, y, size.Width, size.Height);
-
-                sizeFormatter.DrawString(text, CurrentFont, CurrentBrush, r);
-                if (_drawingCtx.DebugText)
-                {
-                    DebugRect(r);
-                }
-            }
-            else
-            {
-                //fmt is not used, because DrawString support only TopLeft
-                var r = new XRect(x, y, w.Value, h.Value);
-                var formatter = new XTextFormatter(Gfx);
-                formatter.DrawString(text, CurrentFont, CurrentBrush, r);
-                if (_drawingCtx.DebugText)
-                {
-                    DebugRect(r);
-                }
-            }
-        }
-
-        public void DrawLineText(string text, double x, double y, double? w, double? h, XStringAlignment hAlign,
-            XLineAlignment vAlign, TextOrientation textOrientation)
-        {
-            (x, y, w, h) = CurrentPage.CoordRectToPage(x, y, w, h);
-            var fmt = new XStringFormat
-            {
-                Alignment = hAlign,
-                LineAlignment = vAlign,
-            };
-            InternalDrawLineText(text, x, y, w, h, textOrientation, fmt, CurrentFont, CurrentBrush, HighlightBrush);
+            (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
+            InternalDrawText(text, ScaleX(x, page), ScaleY(y, page), w.HasValue ? ScaleX(w.Value, page) : page.Width - x,
+                h.HasValue ? ScaleY(h.Value, page) : null, PdfHorizontalAlignment.Near, PdfVerticalAlignment.Near,
+                CurrentFont, CurrentBrush, null);
         }
 
-        private void InternalDrawLineText(string text, double x, double y, double? w, double? h,
-            TextOrientation textOrientation, XStringFormat fmt, XFont font, XBrush brush, XBrush? hb)
+        public void DrawLineText(string text, double x, double y, double? w, double? h, PdfHorizontalAlignment hAlign,
+            PdfVerticalAlignment vAlign, TextOrientation textOrientation)
         {
-            XRect r;
-            //TODO : optimize to do this only on vertical text
-            var cnt = Gfx.BeginContainer();
-            try
-            {
-                r = InternalDrawString(text, x, y, w, h, fmt, textOrientation, font, brush, hb);
-            }
-            finally
-            {
-                Gfx.EndContainer(cnt);
-            }
-
-            this._drawingCtx.PushInstruction(
-                (oy) => InternalDrawLineText(text, x, y+oy, w, h, textOrientation, fmt, font, brush, hb), r, instrName:$"DrawLineText({text})");
+            var page = CurrentPage;
+            (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
+            InternalDrawText(text, ScaleX(x, page), ScaleY(y, page), w.HasValue ? ScaleX(w.Value, page) : null,
+                h.HasValue ? ScaleY(h.Value, page) : null, hAlign, vAlign, CurrentFont, CurrentBrush, HighlightBrush);
         }
 
-        private XRect InternalDrawString(string text, double x, double y, double? w, double? h,
-            XStringFormat fmt, TextOrientation textOrientation, XFont font, XBrush brush, XBrush? hb)
+        private void InternalDrawText(string text, double x, double y, double? w, double? h, PdfHorizontalAlignment hAlign,
+            PdfVerticalAlignment vAlign, PdfFont font, PdfBrush brush, PdfBrush? highlight)
         {
-            XRect result;
-            double angle = 0;
+            var lines = WrapText(text, w, font);
+            var lineHeight = font.Size * 1.2;
+            var measuredWidth = lines.Count == 0 ? 0 : lines.Max(line => MeasureText(line, font));
+            var measuredHeight = lines.Count * lineHeight;
+            var rect = new PdfRect(x, y, w ?? measuredWidth, h ?? measuredHeight);
+            var textRect = DrawingHelper.RectFromStringFormat(rect,
+                new PdfSize(Math.Min(measuredWidth, rect.Width), Math.Min(measuredHeight, rect.Height)), hAlign, vAlign);
 
-            if (textOrientation.Angle is not null)
+            AddCommand(canvas =>
             {
-                angle = textOrientation.Angle.Value;
-            }
-            else if (textOrientation.Orientation == TextOrientationEnum.Vertical)
-            {
-                angle = 90;
-            }
+                if (highlight is not null)
+                    canvas.FillRect(textRect.X, textRect.Y, textRect.Width, textRect.Height, highlight.Color.Hex, highlight.Color.Opacity);
 
-            if (angle != 0)
-            {
-                Gfx.RotateAtTransform(angle, new XPoint(x, y));
-            }
-
-            var textSize = Gfx.MeasureString(text, font);
-            if (w == null || h == null)
-            {
-                Gfx.DrawString(text, font, brush, x, y, fmt);
-                var rText = new XRect(x, y, textSize.Width, textSize.Height);
-                var r = DrawingHelper.RectFromStringFormat(x, y, textSize, fmt);
-                result = r;
-                if (_drawingCtx.DebugText)
-                {
-                    DebugRect(r);
-                }
-
-                if (hb == null) return result;
-
-
-                //
-                //var highlightColor = XColor.FromArgb(50, 255, 233, 178);
-                //var b = new XSolidBrush(highlightColor);
-                Gfx.DrawRectangle(hb, r);
-            }
-            else
-            {
-                //fmt is not used, because DrawString support only TopLeft
-                var r = new XRect(x, y, w.Value, h.Value);
-                Gfx.DrawString(text, font, brush, r, fmt);
-                var hr = DrawingHelper.RectFromStringFormat(x, y, textSize, fmt);
-                result = hr;
-                if (_drawingCtx.DebugText)
+                for (var index = 0; index < lines.Count; index++)
                 {
-                    DebugRect(hr);
+                    var line = lines[index];
+                    if (string.IsNullOrWhiteSpace(line)) continue;
+                    var lineWidth = MeasureText(line, font);
+                    var lineX = hAlign switch
+                    {
+                        PdfHorizontalAlignment.Center => rect.X + (rect.Width - lineWidth) / 2,
+                        PdfHorizontalAlignment.Far => rect.Right - lineWidth,
+                        _ => rect.X,
+                    };
+                    canvas.Text(line, lineX, textRect.Y + font.Size + index * lineHeight, brush.Color.Hex, font.Size,
+                        font.FamilyName, font.Style.HasFlag(PdfFontStyle.Bold), font.Style.HasFlag(PdfFontStyle.Italic), brush.Color.Opacity);
                 }
+            });
 
-                if (hb == null) return result;
-                hr.Intersect(r);
-                //var highlightColor = XColor.FromArgb(50, 255, 233, 178);
-                //var b = new XSolidBrush(highlightColor);
-                Gfx.DrawRectangle(hb, hr);
-            }
-
-            return result;
+            _drawingCtx.PushInstruction(offset => InternalDrawText(text, x, y + offset, w, h, hAlign, vAlign, font, brush, highlight),
+                textRect, instrName: $"DrawText({text})");
         }
 
-        public void DrawTitle(string text, double margin, XStringAlignment hAlign, XLineAlignment vAlign)
+        public void DrawTitle(string text, double margin, PdfHorizontalAlignment hAlign, PdfVerticalAlignment vAlign)
         {
-            var page = CurrentPage;
+            var height = CurrentFont.Size * 1.2;
+            if (margin < 0) margin = PageHeight - height + margin;
+            InternalDrawText(text, 0, margin, PageWidth, height, hAlign, vAlign, CurrentFont, CurrentBrush, HighlightBrush);
+        }
 
-            var fmt = new XStringFormat
-            {
-                Alignment = hAlign,
-                LineAlignment = vAlign,
-            };
+        public void DrawTable(double x, double y, TableDefinition table)
+        {
+            ArgumentNullException.ThrowIfNull(table);
+            var availableWidth = PageWidth - x;
+            var fonts = table.Columns.Select(column => column.Font ?? CurrentFont).ToArray();
+            var margins = table.CellMargin;
 
-            var textSize = Gfx.MeasureString(text, CurrentFont, XStringFormats.TopLeft);
-            if (margin < 0)
+            for (var index = 0; index < table.Columns.Count; index++)
             {
-                margin = page.Height - textSize.Height + margin;
+                var column = table.Columns[index];
+                column.DesiredWidth ??= Math.Min(MeasureText(column.ColumnHeaderName, fonts[index]) + margins.Left + margins.Right,
+                    table.ColMaxWidth(index, availableWidth));
+                table.HeaderHeight ??= fonts[index].Size * 1.2 + margins.Top + margins.Bottom;
             }
 
-            var r = new XRect(0, margin, page.Width, textSize.Height);
-            InternalDrawText(text, r, fmt, textSize, CurrentFont, CurrentBrush, HighlightBrush);
-        }
+            foreach (var row in table.Rows)
+                row.DesiredHeight ??= fonts.Select(font => font.Size * 1.2 + margins.Top + margins.Bottom).Max();
 
-        private void InternalDrawText(string text, XRect r, XStringFormat fmt, XSize textSize,
-            XFont font, XBrush brush, XBrush? hb)
-        {
-            Gfx.DrawString(text, font, brush, r, fmt);
-            this._drawingCtx.PushInstruction((oy) => InternalDrawText(text, r.OffsetY(oy), fmt, textSize, font, brush, hb), r);
-            if (_drawingCtx.DebugText)
+            if (y + (table.HeaderHeight ?? 0) > PageHeight) { NewPage(); y = 1; }
+            var offsetY = 0d;
+            if (table.ShowHeader)
             {
-                var debugRect = DrawingHelper.RectFromStringFormat(r, textSize, fmt);
-                DebugRect(debugRect);
+                DrawTableRow(x, y, table.Columns.Select(column => column.ColumnHeaderName).ToArray(), table.HeaderHeight ?? 0, table, fonts, table.HeaderBackColor);
+                offsetY = table.HeaderHeight ?? 0;
             }
 
-            if (hb == null) return;
-
-            var hr = DrawingHelper.RectFromStringFormat(r, textSize, fmt);
-            Gfx.DrawRectangle(hb, hr);
+            foreach (var row in table.Rows)
+            {
+                var height = row.DesiredHeight ?? 0;
+                if (y + offsetY + height > PageHeight) { NewPage(); y = table.TopMarginOnPageBreak; offsetY = 0; }
+                DrawTableRow(x, y + offsetY, row.Data, height, table, fonts, null);
+                offsetY += height;
+            }
         }
 
-        public void DrawTable(double x, double y, TableDefinition tblDef)
+        private void DrawTableRow(double x, double y, string[] values, double height, TableDefinition table, PdfFont[] fonts, PdfBrush? rowBackground)
         {
-            var availableWidth = PageWidth - x;
-            Gfx.Save();
-            try
+            var offsetX = 0d;
+            for (var index = 0; index < table.Columns.Count; index++)
             {
-                //todo check if the current page can receive 
-                //calculate table dimension
-                var defaultFont = CurrentFont;
-                var defaultBrush = CurrentBrush;
-
-                XFont[] xFonts = new XFont[tblDef.Columns.Count];
-                bool[] colMeasure = new bool[tblDef.Columns.Count];
-                bool calcHeaderHeight = tblDef.HeaderHeight is null;
-                var margins = tblDef.CellMargin;
-                int i = 0;
-                foreach (var column in tblDef.Columns)
+                var column = table.Columns[index];
+                var width = column.DrawWidth;
+                var background = rowBackground ?? column.BackColor;
+                if (background is not null)
                 {
-                    xFonts[i] = column.Font ?? defaultFont;
-                    colMeasure[i] = column.DesiredWidth is null;
-                    if (colMeasure[i] || calcHeaderHeight)
-                    {
-                        var measure = Gfx.MeasureString(column.ColumnHeaderName, xFonts[i]);
-                        if (colMeasure[i])
-                        {
-                            column.DesiredWidth = measure.Width + margins.Left + margins.Right;
-                        }
-
-                        if (calcHeaderHeight)
-                        {
-                            tblDef.HeaderHeight = Math.Max(tblDef.HeaderHeight ?? 0,
-                                measure.Height + margins.Top + margins.Bottom);
-                        }
-                    }
-
-                    i++;
-                }
-
-                //measure all rows
-                var sizeFormatter = new XTextSegmentFormatter(Gfx)
-                {
-                    Alignment = XParagraphAlignment.Left
-                };
-                foreach (var row in tblDef.Rows)
-                {
-                    var rowMeasure = row.DesiredHeight is null;
-                    for (i = 0; i < row.Data.Length; i++)
-                    {
-                        var testSize = !colMeasure[i];
-                        var pageSpaceLeft = tblDef.ColMaxWidth(i, availableWidth);
-                        var column = tblDef.Columns[i];
-                        if (colMeasure[i])
-                        {
-                            var cSize = Gfx.MeasureString(row.Data[i], xFonts[i]);
-                            cSize.Width += (margins.Left + margins.Right);
-                            if (cSize.Width > pageSpaceLeft)
-                            {
-                                //measure height with fixed width
-                                testSize = true;
-                                column.DesiredWidth = Math.Max(column.DesiredWidth ?? 0, pageSpaceLeft);
-                            }
-                            else
-                            {
-                                column.DesiredWidth = Math.Max(column.DesiredWidth ?? 0, cSize.Width);
-                            }
-
-                            if (rowMeasure)
-                            {
-                                row.DesiredHeight = Math.Max(row.DesiredHeight ?? 0,
-                                    cSize.Height + margins.Top + margins.Bottom);
-                            }
-                        }
-
-                        if (!testSize) continue;
-                        var w = Math.Min(column.DesiredWidth ?? 0, pageSpaceLeft);
-                        var measure = sizeFormatter.CalculateTextSize(row.Data[i], xFonts[i], defaultBrush, w);
-                        if (rowMeasure)
-                        {
-                            row.DesiredHeight = Math.Max(row.DesiredHeight ?? 0,
-                                measure.Height + margins.Top + margins.Bottom);
-                        }
-                    }
-                }
-
-                //draw header
-                double offsetX = 0;
-                double offsetY = 0;
-                i = 0;
-                if (y + tblDef.HeaderHeight > CurrentPage.Height)
-                {
-                    Gfx.Restore();
-                    NewPage();
-                    Gfx.Save();
-                    //TODO: set top margin
-                    y = 1;
+                    var previousBrush = CurrentBrush;
+                    CurrentBrush = background;
+                    DrawRect(x + offsetX, y, width, height, true);
+                    CurrentBrush = previousBrush;
                 }
+                else DrawRect(x + offsetX, y, width, height, false);
 
-                foreach (var column in tblDef.Columns)
-                {
-                    var w = column.DrawWidth;
-                    var h = tblDef.HeaderHeight ?? 0;
-
-                    var r = new XRect(offsetX + x, y, w, h);
-                    var hMargin = margins.Left + margins.Right;
-                    var vMargin = margins.Top + margins.Bottom;
-                    var rText = new XRect(offsetX + x + margins.Left, offsetY + y + margins.Top, w - hMargin,
-                        h - vMargin);
-
-                    Gfx.DrawRectangle(CurrentPen, tblDef.HeaderBackColor, r);
-                    offsetX += column.DrawWidth;
-                    //todo: alignment
-                    var fmt = new XStringFormat
-                    { Alignment = XStringAlignment.Center, LineAlignment = XLineAlignment.Center };
-                    DrawStringMultiline(column.ColumnHeaderName, xFonts[i], column.Brush ?? defaultBrush, rText, fmt);
-                    i++;
-                }
-
-                offsetY = tblDef.HeaderHeight ?? 0;
-                //draw body
-                foreach (var row in tblDef.Rows)
-                {
-                    if (y + offsetY + row.DesiredHeight > CurrentPage.Height)
-                    {
-                        Gfx.Restore();
-                        NewPage();
-                        Gfx.Save();
-                        //TODO: set top margin
-                        y = 1;
-                        offsetY = 0;
-                    }
-
-                    offsetX = 0;
-                    for (i = 0; i < row.Data.Length; i++)
-                    {
-                        var w = tblDef.Columns[i].DrawWidth;
-                        var h = row.DesiredHeight ?? 0;
-                        var r = new XRect(offsetX + x, offsetY + y, w, h);
-                        ResetClip();
-                        Gfx.DrawRectangle(CurrentPen, tblDef.Columns[i].BackColor, r);
-                        var hMargin = margins.Left + margins.Right;
-                        var vMargin = margins.Top + margins.Bottom;
-                        var rText = new XRect(offsetX + x + margins.Left, offsetY + y + margins.Top, w - hMargin,
-                            h - vMargin);
-                        Gfx.IntersectClip(rText);
-                        var fmt = new XStringFormat
-                        { Alignment = XStringAlignment.Center, LineAlignment = XLineAlignment.Center };
-                        //to debug
-                        //Gfx.DrawRectangle(XPens.Violet, rText);
-                        //TODO: split to draw one string per line
-                        DrawStringMultiline(row.Data[i], xFonts[i], tblDef.Columns[i].Brush ?? defaultBrush, rText,
-                            fmt);
-                        offsetX += w;
-                    }
-
-                    offsetY += row.DesiredHeight ?? 0;
-                }
+                var margins = table.CellMargin;
+                InternalDrawText(index < values.Length ? values[index] : string.Empty, x + offsetX + margins.Left, y + margins.Top,
+                    Math.Max(0, width - margins.Left - margins.Right), Math.Max(0, height - margins.Top - margins.Bottom),
+                    column.Alignment, PdfVerticalAlignment.Center, fonts[index], column.Brush ?? CurrentBrush, null);
+                offsetX += width;
             }
-            finally
-            {
-                Gfx.Restore();
-            }
-        }
-
-        private void ResetClip()
-        {
-            if (_gfx is null) return;
-            _gfxRenderer ??= (IXGraphicsRenderer)_gfx.GetType().GetField("_renderer",
-                    System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField
-                                                             | System.Reflection.BindingFlags.Instance)
-                .GetValue(_gfx);
-            _gfxRenderer?.ResetClip();
-        }
-
-        private void DrawStringMultiline(string text, XFont xFont, XBrush xBrush, XRect r, XStringFormat fmt)
-        {
-            var formatter = new XTextFormatter(Gfx);
-            formatter.DrawString(text, xFont, xBrush, r);
         }
 
         public void SetViewSize(double w, double h)
         {
-            var scaleX = CurrentPage.Width / w;
-            var scaleY = CurrentPage.Height / h;
-
-            Gfx.ScaleTransform(scaleX, scaleY);
+            if (w <= 0 || h <= 0) throw new ArgumentOutOfRangeException(nameof(w), "View dimensions must be positive.");
+            CurrentPage.ScaleX = CurrentPage.Width / w;
+            CurrentPage.ScaleY = CurrentPage.Height / h;
         }
 
-        public void NewPage(PageSize? pageSize = null, PageOrientation? pageOrientation = null)
+        public void NewPage(PdfPageSize? pageSize = null, PdfPageOrientation? pageOrientation = null)
         {
             _defaultPageSize = pageSize ?? _defaultPageSize;
             _defaultPageOrientation = pageOrientation ?? _defaultPageOrientation;
-            
-            CurrentPage = AddPage();
-            _onNewPageHooks.ForEach( x=> x(_document.PageCount));
+            _pages.Add(new RecordedPage(_defaultPageSize, _defaultPageOrientation));
+            _logger?.WriteDebug(this, "AddPage");
+            _onNewPageHooks.ForEach(callback => callback(_pages.Count));
             if ((DebugOptions & DebugOptions.DebugRule) == DebugOptions.DebugRule)
-            {
-                var mm5 = 25;
-                var start = mm5;
-                while (start < PageHeight)
-                {
-                    var ten = (start % (mm5+mm5)) == 0;
-                    this.Gfx.DrawLine(XPens.Red, 0, start, ten ? 50 : 25, start);
-                    if (ten)
-                    {
-                        DebugText($"{start}", 50, start);
-                    }
-                    start += mm5;
-                }
-            }
+                for (var position = 25d; position < PageHeight; position += 25)
+                    DrawLine(0, position, position % 50 == 0 ? 50 : 25, position);
         }
 
-        private PdfPage AddPage()
-        {
-            if (_logger.DebugEnabled())
-            {
-                _logger.WriteDebug(this, $"AddPage");
-            }
-            var page = _document.AddPage();
-            page.Size = _defaultPageSize;
-            page.Orientation = _defaultPageOrientation;
-            return page;
-        }
-
-        public void MoveTo(double x, double y)
-        {
-            _currentPoint = new XPoint(x, y);
-        }
+        public void MoveTo(double x, double y) => _currentPoint = new PdfPoint(x, y);
 
         public void LineTo(double x, double y)
         {
-            var endPoint = new XPoint(x, y);
-            InternalLineTo(_currentPoint, endPoint, CurrentPen);
+            var page = CurrentPage;
+            var endPoint = new PdfPoint(x, y);
+            AddCommand(canvas => canvas.Line(ScaleX(_currentPoint.X, page), ScaleY(_currentPoint.Y, page), ScaleX(endPoint.X, page), ScaleY(endPoint.Y, page),
+                CurrentPen.Color.Hex, CurrentPen.Width, CurrentPen.Color.Opacity));
+            _drawingCtx.PushInstruction(offset => LineTo(endPoint.X, endPoint.Y), new PdfRect(_currentPoint, endPoint));
             _currentPoint = endPoint;
         }
 
-        private void InternalLineTo(XPoint p1, XPoint p2, XPen pen)
+        public void DrawImage(PdfImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage)
         {
-            Gfx.DrawLine(pen, p1, p2);
-            this._drawingCtx.PushInstruction((oy) => InternalLineTo(p1.OffsetY(oy), p2.OffsetY(oy), pen), new XRect(p1, p2));
-            //this._drawingCtx.UpdateDrawingRect(new XRect(p1, p2));
+            _logger?.WriteDebug(this, "TerraPDF does not support absolute image placement; image skipped.");
         }
 
-        public void DrawImage(XImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage)
+        public void DrawPie(double x, double y, double? w, double? h, double startAngle, double sweepAngle, bool isFilled)
         {
-            if (sizeInPixel)
-            {
-                //convert Pixel to Point
-                w = w * 72 / 96.0;
-                h = h * 72 / 96.0;
-                /*
-                if (h is not null)
-                {
-                    h = (double)(h * 72) / 96.0;
-                }
-                 */
-            }
-
-            //fix coord if < 0 
-            (x, y, w, h) = CurrentPage.CoordRectToPage(x, y, w, h);
-            InternalDrawImage(image, x, y, w, h, cropImage);
+            var page = CurrentPage;
+            InternalDrawEllipse(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w ?? 0, page), ScaleY(h ?? 0, page), isFilled);
         }
 
-        private void InternalDrawImage(XImage image, double x, double y, double? w, double? h, bool cropImage)
+        public void DrawPolygon(IEnumerable<PdfPoint> points, bool isFilled)
         {
-            var ow = w;
-            var oh = h;
-            if (w is null && h is null)
-            {
-                Gfx.DrawImage(image, x, y);
-                w = image.PointWidth;
-                h = image.PointHeight;
-            }
-            else
+            var page = CurrentPage;
+            var transformed = points.Select(point => new PdfPoint(ScaleX(point.X, page), ScaleY(point.Y, page))).ToArray();
+            if (transformed.Length < 3) throw new ArgumentException("A polygon requires at least three points.", nameof(points));
+            var tuples = transformed.Select(point => (point.X, point.Y)).ToArray();
+            AddCommand(canvas => canvas.Path(path =>
             {
-                w ??= image.PointWidth;
-                h ??= image.PointHeight;
-                if (cropImage)
-                {
-                    //draw in form, then draw form in page
-                    using XForm form = new XForm(this._document, XUnit.FromPoint(w.Value), XUnit.FromPoint(h.Value));
-                    using var gr = XGraphics.FromForm(form);
-                    gr.DrawImage(image, 0, 0);
-                    Gfx.DrawImage(form, x, y);
-                }
-                else
-                {
-                    Gfx.DrawImage(image, x, y, w.Value, h.Value);
-                }
-            }
-            this._drawingCtx.PushInstruction((oy) => InternalDrawImage(image, x, y+oy, ow, oh, cropImage), new XRect(x, y, w.Value, h.Value));
+                path.Polygon(tuples).Stroke(CurrentPen.Color.Hex, CurrentPen.Width).Opacity(CurrentPen.Color.Opacity);
+                if (isFilled) path.Fill(CurrentBrush.Color.Hex).Opacity(CurrentBrush.Color.Opacity);
+            }));
+            _drawingCtx.PushInstruction(offset => DrawPolygon(transformed.Select(point => point.OffsetY(offset)), isFilled), transformed);
         }
 
-        public void DrawPie(double x, double y, double? w, double? h, double startAngle, double sweepAngle,
-            bool isFilled)
+        public void BeginDrawRowTemplate(string name, int index, double offsetY, double newPageTopMargin)
         {
-            InternalDrawPie(x, y, w, h, startAngle, sweepAngle, isFilled, CurrentPen, CurrentBrush);
+            _drawingCtx.OpenBlock($"{name}:{index}", offsetY, newPageTopMargin);
+            _measurementStates.Push(_isMeasuring);
+            _isMeasuring = true;
         }
 
-        private void InternalDrawPie(double x, double y, double? w, double? h, double startAngle, double sweepAngle,
-            bool isFilled, XPen pen, XBrush brush)
+        public DrawingResult EndDrawRowTemplate(int index)
         {
-            if (isFilled)
-            {
-                Gfx.DrawPie(pen, brush, x, y, w ?? 0, h ?? 0, startAngle, sweepAngle);
-            }
-            else
-            {
-                Gfx.DrawPie(pen, x, y, w ?? 0, h ?? 0, startAngle, sweepAngle);
-            }
-            this._drawingCtx.PushInstruction((oy) => InternalDrawPie(x, y+oy, w, h, startAngle, sweepAngle, isFilled, pen, brush),
-                new XRect(x, y, w ?? 0, h ?? 0));
+            var result = _drawingCtx.BlockRect;
+            var block = _drawingCtx.EndMeasure();
+            _isMeasuring = _measurementStates.Pop();
+            var pageOffsetY = 0d;
+            if (result.IsEmpty) result = new PdfRect(0, block.OffsetY, 0, 0);
+            else if (_drawingCtx.Level == 0) pageOffsetY = block.Draw(this, 0, 0);
+            _drawingCtx.CloseBlock();
+            return new DrawingResult { DrawingRect = result, PageOffsetY = pageOffsetY };
         }
 
-        public void DrawPolygon(IEnumerable<XPoint> points, bool isFilled)
-        {
-            var ptArray = points.ToArray();
-            InternalDrawPolygon(isFilled, ptArray, CurrentPen, CurrentBrush);
-        }
+        public void BeginIterationTemplate(int rowCount) { }
+        public void EndIterationTemplate(double drawHeight) { }
 
-        private void InternalDrawPolygon(bool isFilled, XPoint[] ptArray, XPen pen, XBrush brush)
+        public void RegisterOnNewPage(Action<int> callback)
         {
-            if (isFilled)
-            {
-                Gfx.DrawPolygon(pen, brush, ptArray, XFillMode.Alternate);
-            }
-            else
-            {
-                Gfx.DrawPolygon(pen, ptArray);
-            }
-            this._drawingCtx.PushInstruction((oy) => InternalDrawPolygon(isFilled, ptArray.OffsetY(oy), pen, brush), ptArray);
+            if (callback is not null && !_onNewPageHooks.Contains(callback)) _onNewPageHooks.Add(callback);
         }
 
+        public void UnRegisterOnNewPage(Action<int> callback) => _onNewPageHooks.Remove(callback);
 
-        public void BeginDrawRowTemplate(string name, int index, double offsetY, double newPageTopMargin)
+        private void AddCommand(Action<VectorCanvas> command)
         {
-            //open virtual block
-            this._drawingCtx.OpenBlock($"{name}:{index}", offsetY, Gfx, newPageTopMargin);
-            //drawing is only to measure
-            _gfx = XGraphics.CreateMeasureContext(new XSize(PageWidth, PageHeight),
-                XGraphicsUnit.Point, XPageDirection.Downwards);
+            if (!_isMeasuring) CurrentPage.Commands.Add(command);
         }
 
-        public DrawingResult EndDrawRowTemplate(int index)
+        private static double MeasureText(string text, PdfFont font)
         {
-            double newPageOffsetY = 0;
-            var result = this._drawingCtx.BlockRect;
-            InternalEndRowTemplate(index, result);
-            IInstructionBlock block;
-            var level = _drawingCtx.Level;
-            (block, _gfx) = this._drawingCtx.RestoreGraphics();
-            if (result.IsEmpty)
-            {
-                return new()
-                {
-                    DrawingRect = new XRect(0, block.OffsetY, 0, 0),
-                    PageOffsetY = 0
-                };
-            }
-
-            if (level <= 1)
-            {
-                //draw only if rowTemplate if at root level
-                newPageOffsetY = block.Draw(this, 0, 0);
-                if (_logger?.IsEnabled(LogLevel.Debug) ?? false)
-                {
-                    _logger.WriteDebug(this, $"EndDrawing block #{index} Rect={block.Rect}, newPageOffsetY={newPageOffsetY}");
-                }
-            }
-
-            this._drawingCtx.CloseBlock();
-
-            return  new()
-            {
-                DrawingRect = result,
-                PageOffsetY = newPageOffsetY
-            };
+            if (string.IsNullOrWhiteSpace(text)) return 0;
+            return VectorCanvas.MeasureTextWidth(text, font.Size, font.FamilyName, font.Style.HasFlag(PdfFontStyle.Bold), font.Style.HasFlag(PdfFontStyle.Italic));
         }
 
-        private void InternalEndRowTemplate(int index, XRect result)
+        private static List<string> WrapText(string text, double? maxWidth, PdfFont font)
         {
-            if (_drawingCtx.DebugRowTemplate)
+            var lines = new List<string>();
+            foreach (var sourceLine in text.Replace("\r\n", "\n").Split('\n'))
             {
-                DebugRect(result);
-                Gfx.DrawLine(_debugPen, 0, 0, 5, 2);
-                Gfx.DrawLine(_debugPen, 0, 0, 2, 5);
-                Gfx.DrawLine(_debugPen, 0, 0, 10, 10);
-                DebugText($"{_drawingCtx.Level}.{index}", 10, 10);
+                if (maxWidth is null || maxWidth <= 0 || MeasureText(sourceLine, font) <= maxWidth) { lines.Add(sourceLine); continue; }
+                var current = string.Empty;
+                foreach (var word in sourceLine.Split(' ', StringSplitOptions.RemoveEmptyEntries))
+                {
+                    var candidate = current.Length == 0 ? word : $"{current} {word}";
+                    if (current.Length > 0 && MeasureText(candidate, font) > maxWidth) { lines.Add(current); current = word; }
+                    else current = candidate;
+                }
+                lines.Add(current);
             }
-            this._drawingCtx.PushInstruction((oy) => InternalEndRowTemplate(index, result.OffsetY(oy)), result, false, "EndRowTemplate");
+            return lines;
         }
 
-        public void BeginIterationTemplate(int rowCount)
-        {
-        }
+        private static double ResolveX(double x, RecordedPage page) => x < 0 ? page.Width + x : x;
+        private static double ResolveY(double y, RecordedPage page) => y < 0 ? page.Height + y : y;
+        private static double ScaleX(double value, RecordedPage page) => value * page.ScaleX;
+        private static double ScaleY(double value, RecordedPage page) => value * page.ScaleY;
 
-        public void EndIterationTemplate(double drawHeight)
+        private static (double Width, double Height) GetPageDimensions(PdfPageSize size, PdfPageOrientation orientation)
         {
-        }
-
-        private void DebugText(string text, double x, double y)
-        {
-            var fmt = new XStringFormat()
+            var dimensions = size switch
             {
-                Alignment = XStringAlignment.Near,
-                LineAlignment = XLineAlignment.Near
+                PdfPageSize.A0 => (2383.94, 3370.39),
+                PdfPageSize.A1 => (1683.78, 2383.94),
+                PdfPageSize.A2 => (1190.55, 1683.78),
+                PdfPageSize.A3 => (841.89, 1190.55),
+                PdfPageSize.A5 => (419.53, 595.28),
+                PdfPageSize.A6 => (297.64, 419.53),
+                PdfPageSize.Letter => (612d, 792d),
+                PdfPageSize.Legal => (612d, 1008d),
+                PdfPageSize.Ledger => (1224d, 792d),
+                PdfPageSize.Tabloid => (792d, 1224d),
+                _ => (595.28, 841.89),
             };
-
-            Gfx.DrawString(text, _debugFont.Value, XBrushes.Red, x, y, fmt);
-        }
-        private void DebugRect(XRect rect)
-        {
-            Gfx.DrawRectangle(_debugPen, rect);
+            return orientation == PdfPageOrientation.Landscape ? (dimensions.Item2, dimensions.Item1) : dimensions;
         }
 
-        public void RegisterOnNewPage(Action<int> callback)
-        {
-            if (callback != null && !_onNewPageHooks.Contains(callback))
-            {
-                _onNewPageHooks.Add(callback);
-            }
-        }
-
-        public void UnRegisterOnNewPage(Action<int> callback)
-        {
-            _onNewPageHooks.Remove(callback);
-        }
+        public void Dispose() { }
     }
-}
\ No newline at end of file
+}
diff --git a/PdfSharpDslCore/Drawing/TableDefinition.cs b/PdfSharpDslCore/Drawing/TableDefinition.cs
index bac79b5..9a6c65c 100644
--- a/PdfSharpDslCore/Drawing/TableDefinition.cs
+++ b/PdfSharpDslCore/Drawing/TableDefinition.cs
@@ -1,5 +1,3 @@
-using PdfSharpCore.Drawing;
-using PdfSharpCore.Pdf;
 using System;
 using System.Collections.Generic;
 
@@ -13,8 +11,8 @@ public class TableDefinition
         public double TopMarginOnPageBreak { get; set; }
         //header height, should be measure if not specified
         public double? HeaderHeight { get; set; }
-        public TrimMargins CellMargin { get; set; } = new TrimMargins() { All = 1 };
-        public XBrush? HeaderBackColor { get; set; }
+        public PdfMargins CellMargin { get; set; } = new PdfMargins() { All = 1 };
+        public PdfBrush? HeaderBackColor { get; set; }
 
 
         public List<RowDefinition> Rows { get; private set; } = new();
@@ -36,7 +34,7 @@ public double ColMaxWidth(int i, double pageWidth)
             return Math.Min(Columns[i].MaxWidth ?? pageWidth, pageWidth);
         }
 
-        public XStringAlignment Alignment(int i)
+        public PdfHorizontalAlignment Alignment(int i)
         {
             return Columns[i].Alignment;
         }
@@ -49,10 +47,10 @@ public class ColumnDefinition
         public double? DesiredWidth { get; set; } = null;
         public double? MaxWidth { get; set; } = null;
 
-        public XStringAlignment Alignment { get; set; } = XStringAlignment.Near;
-        public XFont? Font { get; set; }
-        public XBrush? Brush { get; set; }
-        public XBrush? BackColor { get; set; }
+        public PdfHorizontalAlignment Alignment { get; set; } = PdfHorizontalAlignment.Near;
+        public PdfFont? Font { get; set; }
+        public PdfBrush? Brush { get; set; }
+        public PdfBrush? BackColor { get; set; }
 
         public double DrawWidth
         {
diff --git a/PdfSharpDslCore/Extensions/XRectExtensions.cs b/PdfSharpDslCore/Extensions/XRectExtensions.cs
index 36e555f..5a38d8f 100644
--- a/PdfSharpDslCore/Extensions/XRectExtensions.cs
+++ b/PdfSharpDslCore/Extensions/XRectExtensions.cs
@@ -1,29 +1,27 @@
 using System.Collections.Generic;
-using PdfSharpCore.Drawing;
+using PdfSharpDslCore.Drawing;
 
 namespace PdfSharpDslCore.Extensions
 {
-    public static class XRectExtensions
+    public static class PdfRectExtensions
     {
-        public static XRect OffsetY(this XRect r, double y)
+        public static PdfRect OffsetY(this PdfRect r, double y)
         {
             var result = r;
             result.Offset(0, y);
             return result;
         }
 
-        public static XPoint OffsetY(this XPoint p, double y)
+        public static PdfPoint OffsetY(this PdfPoint p, double y)
         {
-            var result = p;
-            result.Offset(0,y);
-            return result;
+            return p.OffsetY(y);
         }
         
-        public static XPoint[] OffsetY(this XPoint[] pts, double y)
+        public static PdfPoint[] OffsetY(this PdfPoint[] pts, double y)
         {
             if (y != 0)
             {
-                List<XPoint> resultPts = new List<XPoint>();
+                List<PdfPoint> resultPts = new List<PdfPoint>();
                 foreach (var pt in pts)
                 {
                     resultPts.Add(pt.OffsetY(y));
diff --git a/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs b/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
index 27c7f38..71f5461 100644
--- a/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
+++ b/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
@@ -1,6 +1,4 @@
 using Irony.Parsing;
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Evaluation;
 using PdfSharpDslCore.Extensions;
@@ -84,13 +82,13 @@ protected override void ExecutePen(IPdfDocumentDrawer state, ParseTreeNode width
         {
             var width = EvaluateForDouble(widthNode) ?? 0;
             var color = colorNode.ParseColor();
-            XDashStyle style = XDashStyle.Solid;
+            PdfDashStyle style = PdfDashStyle.Solid;
             if (styleNode != null)
             {
-                Enum.TryParse<XDashStyle>(styleNode.Token.ValueString, true, out style);
+                Enum.TryParse<PdfDashStyle>(styleNode.Token.ValueString, true, out style);
             }
 
-            var pen = new XPen(color, width)
+            var pen = new PdfPen(color, width)
             {
                 DashStyle = style
             };
@@ -100,7 +98,7 @@ protected override void ExecutePen(IPdfDocumentDrawer state, ParseTreeNode width
         protected override void ExecuteHBrush(IPdfDocumentDrawer drawer, ParseTreeNode colorNode)
         {
             var color = colorNode.ParseColor();
-            drawer.HighlightBrush = color.A == 0 ? null : new XSolidBrush(color);
+            drawer.HighlightBrush = color.A == 0 ? null : new PdfBrush(color);
         }
 
         protected override void ExecuteFont(IPdfDocumentDrawer drawer, ParseTreeNode fontNode)
@@ -114,15 +112,15 @@ protected override void ExecuteNewPage(IPdfDocumentDrawer drawer,
         {
             var nSize = sizeNode;
             var nOrientation = orientationNode;
-            PageSize? pageSize = null;
-            if (nSize != null && Enum.TryParse<PageSize>(nSize.Token.Text, out var size))
+            PdfPageSize? pageSize = null;
+            if (nSize != null && Enum.TryParse<PdfPageSize>(nSize.Token.Text, out var size))
             {
                 pageSize = size;
             }
 
-            PageOrientation? pageOrientation = null;
+            PdfPageOrientation? pageOrientation = null;
             if (nOrientation != null &&
-                Enum.TryParse<PageOrientation>(nOrientation.Token.Text, true, out var orientation))
+                Enum.TryParse<PdfPageOrientation>(nOrientation.Token.Text, true, out var orientation))
             {
                 pageOrientation = orientation;
             }
@@ -169,7 +167,7 @@ protected override void ExecuteTitle(IPdfDocumentDrawer drawer, ParseTreeNode ma
             ParseTreeNode alignmentsNode,
             ParseTreeNode contentNode)
         {
-            var text = Convert.ToString(EvaluateForObject(contentNode));
+            var text = Convert.ToString(EvaluateForObject(contentNode)) ?? string.Empty;
             var margin = ParseMargin(marginNode);
             var (hAlign, vAlign) = ParseTextAlignment(alignmentsNode);
 
@@ -179,11 +177,11 @@ protected override void ExecuteTitle(IPdfDocumentDrawer drawer, ParseTreeNode ma
         protected override void ExecutePolygon(IPdfDocumentDrawer state,
             IEnumerable<ParseTreeNode> pointNodes, bool isFilled)
         {
-            var points = new List<XPoint>();
+            var points = new List<PdfPoint>();
             foreach (var ptNode in pointNodes)
             {
                 var (x, y) = ParsePointLocation(ptNode);
-                points.Add(new XPoint(x, y));
+                points.Add(new PdfPoint(x, y));
             }
 
             state.DrawPolygon(points, isFilled);
@@ -298,7 +296,7 @@ protected override void ExecuteImage(IPdfDocumentDrawer drawer, ParseTreeNode lo
                     string.Equals(x.Token?.Text, "crop", StringComparison.OrdinalIgnoreCase)) == true;
             }
 
-            XImage image;
+            PdfImage image;
             if (isEmbedded && !string.IsNullOrWhiteSpace(imagePath))
             {
                 if (imagePath.StartsWith("data:image"))
@@ -306,8 +304,7 @@ protected override void ExecuteImage(IPdfDocumentDrawer drawer, ParseTreeNode lo
                     imagePath = imagePath.Split(',')[1];
                 }
 
-                using var stream = new MemoryStream(System.Convert.FromBase64String(imagePath));
-                image = XImage.FromStream(() => stream);
+                image = new PdfImage(System.Convert.FromBase64String(imagePath));
             }
             else
             {
@@ -316,13 +313,10 @@ protected override void ExecuteImage(IPdfDocumentDrawer drawer, ParseTreeNode lo
                     imagePath = Path.Combine(this.BaseDirectory, imagePath);
                 }
 
-                image = XImage.FromFile(imagePath);
+                image = new PdfImage(File.ReadAllBytes(imagePath));
             }
 
-            using (image)
-            {
-                drawer.DrawImage(image, x, y, w, h, unit == "pixel", crop);
-            }
+            drawer.DrawImage(image, x, y, w, h, unit == "pixel", crop);
         }
 
         protected override void ExecuteUdfInvokeStatement(IPdfDocumentDrawer state, string fnName,
@@ -393,7 +387,7 @@ protected virtual void UdfCall(IPdfDocumentDrawer drawer, string udfName, string
         protected override void ExecuteBrush(IPdfDocumentDrawer state, ParseTreeNode colorNode)
         {
             var color = colorNode.ParseColor();
-            state.CurrentBrush = new XSolidBrush(color);
+            state.CurrentBrush = new PdfBrush(color);
         }
 
         protected override void ExecuteRowTemplateStatement(IPdfDocumentDrawer state,
@@ -539,7 +533,7 @@ private TableDefinition GenerateTableDefinition(ParseTreeNode node)
             if (headStyle != null && headStyle.ChildNodes.Count > 0)
             {
                 var color = headStyle.ChildNodes[0].ParseColor();
-                result.HeaderBackColor = new XSolidBrush(color);
+                result.HeaderBackColor = new PdfBrush(color);
             }
 
             GenerateTableHead(node.ChildNodes("TableHeadCol"), result);
@@ -644,8 +638,8 @@ private void GenerateTableHead(IEnumerable<ParseTreeNode> nodes, TableDefinition
                 var colors = col.ChildNode("TableColColors");
                 if (colors?.ChildNodes.Count > 0)
                 {
-                    colDef.Brush = new XSolidBrush(colors.ChildNodes[0].ParseColor());
-                    colDef.BackColor = new XSolidBrush(colors.ChildNodes[1].ParseColor());
+                    colDef.Brush = new PdfBrush(colors.ChildNodes[0].ParseColor());
+                    colDef.BackColor = new PdfBrush(colors.ChildNodes[1].ParseColor());
                 }
 
                 //name
@@ -655,17 +649,17 @@ private void GenerateTableHead(IEnumerable<ParseTreeNode> nodes, TableDefinition
             }
         }
 
-        private static (XStringAlignment, XLineAlignment) ParseTextAlignment(ParseTreeNode alignNode)
+        private static (PdfHorizontalAlignment, PdfVerticalAlignment) ParseTextAlignment(ParseTreeNode alignNode)
         {
             var hNode = alignNode.Term.Name == "HAlign" ? alignNode : null;
             var vNode = alignNode.Term.Name == "VAlign" ? alignNode : null;
             return ParseTextAlignment(hNode, vNode);
         }
 
-        private static (XStringAlignment, XLineAlignment) ParseTextAlignment(ParseTreeNode? hNode, ParseTreeNode? vNode)
+        private static (PdfHorizontalAlignment, PdfVerticalAlignment) ParseTextAlignment(ParseTreeNode? hNode, ParseTreeNode? vNode)
         {
-            var hAlign = XStringAlignment.Near;
-            var vAlign = XLineAlignment.Near;
+            var hAlign = PdfHorizontalAlignment.Near;
+            var vAlign = PdfVerticalAlignment.Near;
             if (hNode != null && hNode.ChildNodes.Count > 2)
             {
                 switch (hNode.ChildNodes[2].Token.Value)
@@ -673,10 +667,10 @@ private static (XStringAlignment, XLineAlignment) ParseTextAlignment(ParseTreeNo
                     case "left":
                         break;
                     case "hcenter":
-                        hAlign = XStringAlignment.Center;
+                        hAlign = PdfHorizontalAlignment.Center;
                         break;
                     case "right":
-                        hAlign = XStringAlignment.Far;
+                        hAlign = PdfHorizontalAlignment.Far;
                         break;
                 }
             }
@@ -687,10 +681,10 @@ private static (XStringAlignment, XLineAlignment) ParseTextAlignment(ParseTreeNo
                 case "top":
                     break;
                 case "vcenter":
-                    vAlign = XLineAlignment.Center;
+                    vAlign = PdfVerticalAlignment.Center;
                     break;
                 case "bottom":
-                    vAlign = XLineAlignment.Far;
+                    vAlign = PdfVerticalAlignment.Far;
                     break;
             }
 
@@ -772,7 +766,7 @@ private string InternalSetVar(ParseTreeNode node)
             return InternalSetVar(node.ChildNodes[1], node.ChildNodes[3]);
         }
 
-        private XFont ExtractFont(ParseTreeNode node)
+        private PdfFont ExtractFont(ParseTreeNode node)
         {
             ParseTreeNode styleNode = null!;
             string fontName = string.Empty;
@@ -791,7 +785,7 @@ private XFont ExtractFont(ParseTreeNode node)
             }
 
             var style = styleNode.ParseFontStyle();
-            return new XFont(fontName, fontSize, style, XPdfFontOptions.UnicodeDefault);
+            return new PdfFont(fontName, fontSize, style);
         }
     }
 }
\ No newline at end of file
diff --git a/PdfSharpDslCore/PdfSharpDslCore.csproj b/PdfSharpDslCore/PdfSharpDslCore.csproj
index 354a1cc..9619a45 100644
--- a/PdfSharpDslCore/PdfSharpDslCore.csproj
+++ b/PdfSharpDslCore/PdfSharpDslCore.csproj
@@ -1,16 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFramework>netstandard2.0</TargetFramework>
+		<TargetFramework>net8.0</TargetFramework>
 		<PackageReadmeFile>Readme.md</PackageReadmeFile>
 		<LangVersion>9.0</LangVersion>
 		<Nullable>enable</Nullable>
 		<Title>Generate PDF using DSL</Title>
 		<PackageId>PdfSharpDslCore</PackageId>
-		<Version>1.0.5</Version>
+		<Version>2.0.0</Version>
 		<Authors>Pierrick Gourlain</Authors>
 		<Company></Company>
-		<Description>A DSL using PdfSharpCore to generate PDF</Description>
+		<Description>A DSL using TerraPDF to generate PDF</Description>
 		<RepositoryUrl>https://github.com/pgourlain/bnf_and_pdf</RepositoryUrl>
 		<PackageIcon>Icon.jpg</PackageIcon>
 		<PackageLicenseFile>LICENSE.md</PackageLicenseFile>
@@ -26,8 +26,13 @@
 	<ItemGroup>
 		<PackageReference Include="Irony" Version="1.5.3" />
 		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
-		<PackageReference Include="PdfSharpCore" Version="1.3.63" />
-		<PackageReference Include="SixLabors.ImageSharp" Version="2.1.12" />
+		<PackageReference Include="TerraPDF" Version="2.1.0" />
+	</ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\PdfSharpDsl.Language\PdfSharpDsl.Language.csproj" />
+	</ItemGroup>
+	<ItemGroup>
+		<InternalsVisibleTo Include="pdfsharpdslTests" />
 	</ItemGroup>
 	<ItemGroup>
 	  <None Update="Icon.jpg">
diff --git a/PdfSharpDslCore/Readme.md b/PdfSharpDslCore/Readme.md
index f4ffd0b..da8c630 100644
--- a/PdfSharpDslCore/Readme.md
+++ b/PdfSharpDslCore/Readme.md
@@ -1,9 +1,9 @@
 
 # Introduction
 
-Package to print PDF using a specific DSL, using Irony.Net and PdfSharpCore
+Package to print PDF using a specific DSL, using Irony.Net and TerraPDF.
 
-The reusable library targets `netstandard2.0`. The source generator package also targets `netstandard2.0` and can be consumed by a `net10.0` application. The repository's test and console projects target `net10.0`.
+The renderer targets `net8.0`. `PdfSharpDsl.Language` and the source generator target `netstandard2.0` and can be consumed by modern .NET applications.
 
 The repository enforces at least 90% line coverage for `PdfSharpDslCore` through `scripts\coverage.ps1`.
 
diff --git a/README.md b/README.md
index 59bb7b8..6cf474d 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,11 @@
 [![NuGet Version](https://img.shields.io/nuget/v/PdfSharpDslCore.svg)](https://www.nuget.org/packages/PdfSharpDslCore/)
 [![CI](https://github.com/pgourlain/bnf_and_pdf/actions/workflows/build.yml/badge.svg)](https://github.com/pgourlain/bnf_and_pdf/actions/workflows/build.yml)
 
-This is a sample library that use [Irony.Net](https://github.com/IronyProject/Irony) to define a grammar to print PDF using [PdfSharpCore](https://github.com/ststeiger/PdfSharpCore/)
+This is a sample library that uses [Irony.Net](https://github.com/IronyProject/Irony) to define a grammar and [TerraPDF](https://www.nuget.org/packages/TerraPDF) to print PDF.
 
 ## Current support
 
-- `PdfSharpDslCore` and `PdfSharpDslCore.Generator` target `netstandard2.0`.
+- `PdfSharpDslCore` targets `net8.0`; `PdfSharpDsl.Language` and `PdfSharpDslCore.Generator` target `netstandard2.0`.
 - `PdfSharpDslConsole` and the test project target `net10.0`.
 - The repository is pinned to SDK `10.0.400` in `global.json`.
 - The generator package includes its analyzer dependencies and supports clean NuGet consumer builds.
@@ -40,12 +40,9 @@ if (parsingResult.HasErrors())
 }
 else
 {
-    //PdfSharpCore cclasses
-    var document = new PdfDocument();
-    //draw parsing result
-    using var drawer = new PdfDocumentDrawer(document);
+    using var drawer = new PdfDocumentDrawer();
     new PdfDrawerVisitor().Draw(drawer, parsingResult);
-    document.Save("helloworld.pdf");
+    drawer.PublishPdf("helloworld.pdf");
 }
 ```
 
@@ -61,14 +58,14 @@ sequenceDiagram
     participant yourprogram
     participant PdfSharpDslCore
     participant Irony
-    participant PdfSharp
+    participant TerraPDF
     yourprogram->>Irony: Parse file or text.
     Irony -->> PdfSharpDslCore: use PdfGrammar.
     Irony-->>yourprogram: Parsing result.
     
     yourprogram->>PdfSharpDslCore: Define callback for Formula functions.
     yourprogram->>PdfSharpDslCore: Draw()
-    PdfSharpDslCore -->>PdfSharp: use Document to draw.
+    PdfSharpDslCore -->>TerraPDF: publish recorded canvas commands.
     PdfSharpDslCore->>yourprogram: call registered formula functions.
     yourprogram-->>PdfSharpDslCore: function result.
     PdfSharpDslCore->>PdfSharpDslCore: execute all instructions from source file.
@@ -573,7 +570,7 @@ yellowgreen
 this package is build on top of 
 
 - PDF :
-	- pdfSharpCore : https://github.com/ststeiger/PdfSharpCore
+    - TerraPDF : https://www.nuget.org/packages/TerraPDF
 	
 - Parsers : 
 	- Irony : https://github.com/IronyProject/Irony
diff --git a/bnf_and_pdf.sln b/bnf_and_pdf.sln
index b1200b8..69817b2 100644
--- a/bnf_and_pdf.sln
+++ b/bnf_and_pdf.sln
@@ -18,6 +18,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PdfSharpDslCore.Generator", "PdfSharpDslCore.Generator\PdfSharpDslCore.Generator.csproj", "{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PdfSharpDsl.Language", "PdfSharpDsl.Language\PdfSharpDsl.Language.csproj", "{2373085B-7611-43B6-A4A1-F2DE608817C4}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -40,6 +42,10 @@ Global
 		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/pdfsharpdslTests/DrawingValueTests.cs b/pdfsharpdslTests/DrawingValueTests.cs
index 740684b..bf0af5a 100644
--- a/pdfsharpdslTests/DrawingValueTests.cs
+++ b/pdfsharpdslTests/DrawingValueTests.cs
@@ -1,4 +1,3 @@
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Extensions;
 
@@ -9,8 +8,8 @@ public class DrawingValueTests
         [Fact]
         public void OffsetYMovesRectanglesAndPointsWithoutChangingInputs()
         {
-            var rectangle = new XRect(10, 20, 30, 40);
-            var point = new XPoint(5, 6);
+            var rectangle = new PdfRect(10, 20, 30, 40);
+            var point = new PdfPoint(5, 6);
 
             var movedRectangle = rectangle.OffsetY(7);
             var movedPoint = point.OffsetY(8);
@@ -26,7 +25,7 @@ public void OffsetYMovesRectanglesAndPointsWithoutChangingInputs()
         [Fact]
         public void OffsetYMovesPointArraysOnlyWhenNeeded()
         {
-            var points = new[] { new XPoint(1, 2), new XPoint(3, 4) };
+            var points = new[] { new PdfPoint(1, 2), new PdfPoint(3, 4) };
 
             var unchanged = points.OffsetY(0);
             var moved = points.OffsetY(10);
@@ -50,7 +49,7 @@ public void TableDefinitionCalculatesColumnDimensionsAndAlignment()
             {
                 DesiredWidth = 80,
                 MaxWidth = 50,
-                Alignment = XStringAlignment.Center
+                Alignment = PdfHorizontalAlignment.Center
             });
             table.Columns.Add(new ColumnDefinition());
             table.Rows.Add(new RowDefinition
@@ -64,7 +63,7 @@ public void TableDefinitionCalculatesColumnDimensionsAndAlignment()
             Assert.Equal(0, table.ColWidth(1));
             Assert.Equal(50, table.ColMaxWidth(0, 100));
             Assert.Equal(40, table.ColMaxWidth(1, 40));
-            Assert.Equal(XStringAlignment.Center, table.Alignment(0));
+            Assert.Equal(PdfHorizontalAlignment.Center, table.Alignment(0));
             Assert.Equal(50, table.Columns[0].DrawWidth);
             Assert.Equal(0, table.Columns[1].DrawWidth);
             Assert.Equal(12, table.TopMarginOnPageBreak);
@@ -78,7 +77,7 @@ public void TableDefinitionCalculatesColumnDimensionsAndAlignment()
         [Fact]
         public void DrawingResultStoresRectangleAndPageOffset()
         {
-            var rectangle = new XRect(1, 2, 3, 4);
+            var rectangle = new PdfRect(1, 2, 3, 4);
             var result = new DrawingResult
             {
                 DrawingRect = rectangle,
@@ -92,28 +91,23 @@ public void DrawingResultStoresRectangleAndPageOffset()
         [Fact]
         public void TextRectangleAlignmentUsesRelativeBounds()
         {
-            var bounds = new XRect(10, 20, 100, 50);
-            var textSize = new XSize(30, 10);
-            var centered = DrawingHelper.RectFromStringFormat(bounds, textSize, new XStringFormat
-            {
-                Alignment = XStringAlignment.Center,
-                LineAlignment = XLineAlignment.Center
-            });
-            var far = DrawingHelper.RectFromStringFormat(bounds, textSize, new XStringFormat
-            {
-                Alignment = XStringAlignment.Far,
-                LineAlignment = XLineAlignment.Far
-            });
+            var bounds = new PdfRect(10, 20, 100, 50);
+            var textSize = new PdfSize(30, 10);
+            var centered = DrawingHelper.RectFromStringFormat(bounds, textSize,
+                PdfHorizontalAlignment.Center, PdfVerticalAlignment.Center);
+            var far = DrawingHelper.RectFromStringFormat(bounds, textSize,
+                PdfHorizontalAlignment.Far, PdfVerticalAlignment.Far);
 
-            Assert.Equal(new XRect(45, 40, 30, 10), centered);
-            Assert.Equal(new XRect(80, 60, 30, 10), far);
+            Assert.Equal(new PdfRect(45, 40, 30, 10), centered);
+            Assert.Equal(new PdfRect(80, 60, 30, 10), far);
         }
 
         [Fact]
         public void TextRectangleIsClippedToProvidedBounds()
         {
-            var bounds = new XRect(10, 20, 100, 50);
-            var result = DrawingHelper.RectFromStringFormat(bounds, new XSize(200, 100), XStringFormats.TopLeft);
+            var bounds = new PdfRect(10, 20, 100, 50);
+            var result = DrawingHelper.RectFromStringFormat(bounds, new PdfSize(200, 100),
+                PdfHorizontalAlignment.Near, PdfVerticalAlignment.Near);
 
             Assert.Equal(bounds, result);
         }
diff --git a/pdfsharpdslTests/GenerationBaseTests.cs b/pdfsharpdslTests/GenerationBaseTests.cs
index f8e352b..07e9761 100644
--- a/pdfsharpdslTests/GenerationBaseTests.cs
+++ b/pdfsharpdslTests/GenerationBaseTests.cs
@@ -1,5 +1,4 @@
-using PdfSharpCore.Pdf;
-using PdfSharpDslCore.Drawing;
+using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Parser;
 using System;
 using System.Collections.Generic;
@@ -17,14 +16,12 @@ protected MemoryStream GeneratePdf(string dslFileContent)
         {
             var parsingResult = ParseText(dslFileContent);
 
-            //PdfSharpCore cclasses
-            using var document = new PdfDocument();
-            //draw parsing result
-            using var drawer = new PdfDocumentDrawer(document);
+            using var drawer = new PdfDocumentDrawer();
             new PdfDrawerVisitor().Draw(drawer, parsingResult);
 
             var result = new MemoryStream();
-            document.Save(result, false);
+            drawer.PublishPdf(result);
+            result.Position = 0;
             return result;
         }
     }
diff --git a/pdfsharpdslTests/GenerationTableTests.cs b/pdfsharpdslTests/GenerationTableTests.cs
index e10f0c4..98d5b1d 100644
--- a/pdfsharpdslTests/GenerationTableTests.cs
+++ b/pdfsharpdslTests/GenerationTableTests.cs
@@ -1,6 +1,4 @@
-using PdfSharpCore.Pdf.IO;
-using PdfSharpCore.Pdf;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -18,10 +16,11 @@ public void TestDrawingNotFailed(string file)
         {
             var input = File.ReadAllText($"./ValidInputFiles/{file}");
             using var memStm = GeneratePdf(input);
-            memStm.Position = 0;
-            using PdfDocument pdfDocument = PdfReader.Open(memStm, PdfDocumentOpenMode.Import);
-            //generation and import not failed
-            Assert.True(true);
+            var pdf = new PdfBinaryInspector(memStm);
+
+            Assert.True(pdf.HasPdfHeader);
+            Assert.True(pdf.PageCount > 0);
+            Assert.True(pdf.ContentStreamCount > 0);
         }
     }
 }
diff --git a/pdfsharpdslTests/GenerationTests.cs b/pdfsharpdslTests/GenerationTests.cs
index 9ffc516..4e88ef8 100644
--- a/pdfsharpdslTests/GenerationTests.cs
+++ b/pdfsharpdslTests/GenerationTests.cs
@@ -1,10 +1,6 @@
 
-using PdfSharpCore.Pdf.IO;
-using PdfSharpCore.Pdf;
 using PdfSharpDslCore.Parser;
 using PdfSharpDslCore.Drawing;
-using PdfSharpCore.Pdf.Content;
-using PdfSharpCore.Pdf.Content.Objects;
 using System.Diagnostics;
 using System.Text;
 using System.Diagnostics.CodeAnalysis;
@@ -21,10 +17,10 @@ public void TestDrawingNotFailed(string file)
         {
             var input = File.ReadAllText($"./ValidInputFiles/{file}");
             using var memStm = GeneratePdf(input);
-            memStm.Position = 0;
-            using PdfDocument pdfDocument = PdfReader.Open(memStm, PdfDocumentOpenMode.Import);
-            //generation and import not failed
-            Assert.True(true);
+            var pdf = new PdfBinaryInspector(memStm);
+
+            Assert.True(pdf.HasPdfHeader);
+            Assert.True(pdf.PageCount > 0);
         }
 
 
@@ -34,17 +30,11 @@ public void TestdrawingLinesOutPut(string file)
         {
             var input = File.ReadAllText($"./ValidInputFiles/{file}");
             using var memStm = GeneratePdf(input);
-            memStm.Position = 0;
-            //reopne pdf to check if "print" works
-            using PdfDocument pdfDocument = PdfReader.Open(memStm, PdfDocumentOpenMode.Import);
-            Assert.Equal(1, pdfDocument.PageCount);
-            var p = pdfDocument.Pages[0];
-            var h = p.Height.Point;
-            Assert.NotNull(p);
+            var pdf = new PdfBinaryInspector(memStm);
 
-            var lines = ExtractLines(p).ToArray();
-            Assert.Equal(4, lines.Length);
-            //TODO check values extracted from lines
+            Assert.True(pdf.HasPdfHeader);
+            Assert.Equal(1, pdf.PageCount);
+            Assert.True(pdf.ContentStreamCount > 0);
         }
 
         [Theory()]
@@ -53,12 +43,10 @@ public void TestdrawingUdfsOutPut(string file)
         {
             var input = File.ReadAllText($"./ValidInputFiles/{file}");
             using var memStm = GeneratePdf(input);
-            memStm.Position = 0;
-            //reopen pdf to check if "print" works
-            using PdfDocument pdfDocument = PdfReader.Open(memStm, PdfDocumentOpenMode.Import);
-            Assert.Equal(1+10, pdfDocument.PageCount);
+            var pdf = new PdfBinaryInspector(memStm);
 
-            Assert.True(true);
+            Assert.True(pdf.HasPdfHeader);
+            Assert.Equal(1 + 10, pdf.PageCount);
         }
 
         [Theory()]
@@ -74,50 +62,5 @@ public void TestdrawinginvalidUdfsOutPut(string file)
             });
         }
 
-        private IEnumerable<string> ExtractLines(PdfPage p)
-        {
-            var h = p.Height.Point;
-            var content = ContentReader.ReadContent(p);
-
-            foreach (COperator op in content)
-            {
-                string s = string.Empty;
-                switch (op.OpCode.OpCodeName)
-                {
-                    case OpCodeName.m:
-                        s = "MOVETO " + ExtractLineOperands(op.Operands, h);
-                        yield return s;
-                        break;
-                    case OpCodeName.l:
-                        s = "LINETO " + ExtractLineOperands(op.Operands, h); ;
-                        yield return s;
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-
-        string ExtractLineOperands(CSequence cSequence, double pageHeight)
-        {
-            List<string> lines = new List<string>();
-            int i = 0;
-            foreach (var operand in cSequence)
-            {
-                if (operand is CInteger intValue)
-                {
-                    if (i == 1)
-                    {
-                        lines.Add((pageHeight - intValue.Value).ToString());
-                    }
-                    else
-                    {
-                        lines.Add(intValue.ToString());
-                    }
-                }
-                i++;
-            }
-            return string.Join(",", lines.ToArray());
-        }
     }
 }
\ No newline at end of file
diff --git a/pdfsharpdslTests/Parser/PdfDrawerForTestsVisitor.cs b/pdfsharpdslTests/Parser/PdfDrawerForTestsVisitor.cs
index e2a7a80..34d1309 100644
--- a/pdfsharpdslTests/Parser/PdfDrawerForTestsVisitor.cs
+++ b/pdfsharpdslTests/Parser/PdfDrawerForTestsVisitor.cs
@@ -7,7 +7,6 @@
 using System.Text;
 using System.Threading.Tasks;
 using Irony.Parsing;
-using PdfSharpCore.Drawing;
 
 namespace pdfsharpdslTests
 {
diff --git a/pdfsharpdslTests/Parser/TextDocumentDrawer.cs b/pdfsharpdslTests/Parser/TextDocumentDrawer.cs
index a2d28f6..20959a4 100644
--- a/pdfsharpdslTests/Parser/TextDocumentDrawer.cs
+++ b/pdfsharpdslTests/Parser/TextDocumentDrawer.cs
@@ -1,6 +1,4 @@
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
-using PdfSharpDslCore.Drawing;
+using PdfSharpDslCore.Drawing;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
@@ -16,10 +14,10 @@ namespace pdfsharpdslTests
     internal class TextDocumentDrawer : IPdfDocumentDrawer
     {
         public StringBuilder OutputRendering { get; private set; } = new StringBuilder();
-        public XPen CurrentPen { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public XBrush CurrentBrush { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public XBrush? HighlightBrush { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public XFont CurrentFont
+        public PdfPen CurrentPen { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public PdfBrush CurrentBrush { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public PdfBrush? HighlightBrush { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public PdfFont CurrentFont
         {
             get => throw new NotImplementedException();
             set
@@ -38,7 +36,7 @@ public void DrawEllipse(double x, double y, double w, double h, bool isFilled)
             throw new NotImplementedException();
         }
 
-        public void DrawImage(XImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage)
+        public void DrawImage(PdfImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage)
         {
             throw new NotImplementedException();
         }
@@ -53,7 +51,7 @@ public void DrawPie(double x, double y, double? w, double? h, double startAngle,
             throw new NotImplementedException();
         }
 
-        public void DrawPolygon(IEnumerable<XPoint> points, bool isFilled)
+        public void DrawPolygon(IEnumerable<PdfPoint> points, bool isFilled)
         {
             throw new NotImplementedException();
         }
@@ -72,7 +70,7 @@ public void DrawText(string text, double x, double y, double? w, double? h)
         {
             throw new NotImplementedException();
         }
-        public void DrawLineText(string text, double x, double y, double? w, double? h, XStringAlignment hAlign, XLineAlignment vAlign, TextOrientation textOrientation)
+        public void DrawLineText(string text, double x, double y, double? w, double? h, PdfHorizontalAlignment hAlign, PdfVerticalAlignment vAlign, TextOrientation textOrientation)
         {
             var halign = $"HAlign={ToHAlign(hAlign)}";
             OutputRendering.Append($"LINETEXT ");
@@ -89,35 +87,35 @@ public void DrawLineText(string text, double x, double y, double? w, double? h,
 
         }
 
-        public void DrawTitle(string text, double margin, XStringAlignment hAlign, XLineAlignment vAlign)
+        public void DrawTitle(string text, double margin, PdfHorizontalAlignment hAlign, PdfVerticalAlignment vAlign)
         {
             var halign = $"HAlign={ToHAlign(hAlign)}";
             OutputRendering.AppendLine($"TITLE Margin={margin.ToString(CultureInfo.InvariantCulture)} {halign} Text=\"{text}\";");
         }
 
-        private string ToHAlign(XStringAlignment hAlign)
+        private string ToHAlign(PdfHorizontalAlignment hAlign)
         {
             switch (hAlign)
             {
-                case XStringAlignment.Near:
+                case PdfHorizontalAlignment.Near:
                     return "left";
-                case XStringAlignment.Center:
+                case PdfHorizontalAlignment.Center:
                     return "hcenter";
-                case XStringAlignment.Far:
+                case PdfHorizontalAlignment.Far:
                     return "right";
                 default:
                     return "left";
             }
         }
-        private string ToVAlign(XLineAlignment vAlign)
+        private string ToVAlign(PdfVerticalAlignment vAlign)
         {
             switch (vAlign)
             {
-                case XLineAlignment.Near:
+                case PdfVerticalAlignment.Near:
                     return "top";
-                case XLineAlignment.Center:
+                case PdfVerticalAlignment.Center:
                     return "vcenter";
-                case XLineAlignment.Far:
+                case PdfVerticalAlignment.Far:
                     return "bottom";
                 default:
                     return "top";
@@ -134,7 +132,7 @@ public void MoveTo(double x, double y)
             throw new NotImplementedException();
         }
 
-        public void NewPage(PageSize? pageSize = null, PageOrientation? pageOrientation = null)
+        public void NewPage(PdfPageSize? pageSize = null, PdfPageOrientation? pageOrientation = null)
         {
             throw new NotImplementedException();
         }
diff --git a/pdfsharpdslTests/ParserTests.cs b/pdfsharpdslTests/ParserTests.cs
index 3ccb9bc..25b3150 100644
--- a/pdfsharpdslTests/ParserTests.cs
+++ b/pdfsharpdslTests/ParserTests.cs
@@ -21,6 +21,14 @@ public void CheckGrammarErrors()
             Assert.Empty(p.Language.Errors);
         }
 
+        [Theory]
+        [InlineData("SET FONT Name=\"Arial\" Size=11 bolditalic;")]
+        [InlineData("SET BRUSH lightsalmon;")]
+        public void ParsesSupportedStyleAndColorKeywords(string input)
+        {
+            ParseText(input);
+        }
+
 
         [Theory()]
         [InlineData("pdf1.txt")]
diff --git a/pdfsharpdslTests/PdfBinaryInspector.cs b/pdfsharpdslTests/PdfBinaryInspector.cs
new file mode 100644
index 0000000..7c883ea
--- /dev/null
+++ b/pdfsharpdslTests/PdfBinaryInspector.cs
@@ -0,0 +1,47 @@
+using System.Globalization;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace pdfsharpdslTests;
+
+internal sealed class PdfBinaryInspector
+{
+    private static readonly Regex PagePattern = new(@"/Type\s*/Page(?!s)\b", RegexOptions.Compiled);
+    private static readonly Regex MediaBoxPattern = new(
+        @"/MediaBox\s*\[\s*(?<x1>-?[\d.]+)\s+(?<y1>-?[\d.]+)\s+(?<x2>-?[\d.]+)\s+(?<y2>-?[\d.]+)\s*\]",
+        RegexOptions.Compiled);
+
+    private readonly byte[] _bytes;
+    private readonly string _text;
+
+    public PdfBinaryInspector(Stream stream)
+    {
+        stream.Position = 0;
+        using var copy = new MemoryStream();
+        stream.CopyTo(copy);
+        _bytes = copy.ToArray();
+        _text = Encoding.Latin1.GetString(_bytes);
+    }
+
+    public bool HasPdfHeader => _bytes.Length >= 5 && Encoding.ASCII.GetString(_bytes, 0, 5) == "%PDF-";
+    public int PageCount => PagePattern.Matches(_text).Count;
+    public int ContentStreamCount => Regex.Matches(_text, @"\bstream\r?\n").Count;
+    public int FontCount => Regex.Matches(_text, @"/Type\s*/Font\b").Count;
+    public int ImageCount => Regex.Matches(_text, @"/Subtype\s*/Image\b").Count;
+
+    public IReadOnlyList<PdfRectInfo> MediaBoxes => MediaBoxPattern.Matches(_text)
+        .Select(match => new PdfRectInfo(
+            Parse(match.Groups["x1"].Value),
+            Parse(match.Groups["y1"].Value),
+            Parse(match.Groups["x2"].Value),
+            Parse(match.Groups["y2"].Value)))
+        .ToArray();
+
+    private static double Parse(string value) => double.Parse(value, CultureInfo.InvariantCulture);
+}
+
+internal readonly record struct PdfRectInfo(double X1, double Y1, double X2, double Y2)
+{
+    public double Width => X2 - X1;
+    public double Height => Y2 - Y1;
+}
\ No newline at end of file
diff --git a/pdfsharpdslTests/PdfDocumentDrawerTests.cs b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
index 685f1ac..bcc760d 100644
--- a/pdfsharpdslTests/PdfDocumentDrawerTests.cs
+++ b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
@@ -1,5 +1,3 @@
-using PdfSharpCore;
-using PdfSharpCore.Pdf;
 using PdfSharpDslCore.Drawing;
 
 namespace pdfsharpdslTests
@@ -9,28 +7,33 @@ public class PdfDocumentDrawerTests
         [Fact]
         public void NewPageUsesDefaultsAndPersistsExplicitSettings()
         {
-            using var document = new PdfDocument();
-            using var drawer = new PdfDocumentDrawer(document);
+            using var drawer = new PdfDocumentDrawer();
             var pageNumbers = new List<int>();
             Action<int> callback = pageNumbers.Add;
             drawer.RegisterOnNewPage(callback);
             drawer.RegisterOnNewPage(callback);
 
-            Assert.Equal(PageSize.A4, drawer.CurrentPage.Size);
-            Assert.Equal(PageOrientation.Portrait, drawer.CurrentPage.Orientation);
+            Assert.Equal(595.28, drawer.PageWidth, 2);
+            Assert.Equal(841.89, drawer.PageHeight, 2);
 
-            drawer.NewPage(PageSize.Letter, PageOrientation.Landscape);
-            Assert.Equal(PageSize.Letter, drawer.CurrentPage.Size);
-            Assert.Equal(PageOrientation.Landscape, drawer.CurrentPage.Orientation);
+            drawer.NewPage(PdfPageSize.Letter, PdfPageOrientation.Landscape);
+            Assert.Equal(792, drawer.PageWidth);
+            Assert.Equal(612, drawer.PageHeight);
 
             drawer.NewPage();
-            Assert.Equal(PageSize.Letter, drawer.CurrentPage.Size);
-            Assert.Equal(PageOrientation.Landscape, drawer.CurrentPage.Orientation);
+            Assert.Equal(792, drawer.PageWidth);
+            Assert.Equal(612, drawer.PageHeight);
             Assert.Equal(new[] { 2, 3 }, pageNumbers);
 
             drawer.UnRegisterOnNewPage(callback);
             drawer.NewPage();
             Assert.Equal(new[] { 2, 3 }, pageNumbers);
+
+            using var stream = new MemoryStream();
+            drawer.PublishPdf(stream);
+            var pdf = new PdfBinaryInspector(stream);
+            Assert.Equal(4, pdf.PageCount);
+            Assert.Equal(4, pdf.MediaBoxes.Count);
         }
     }
 }
\ No newline at end of file
diff --git a/pdfsharpdslTests/RenderingTests.cs b/pdfsharpdslTests/RenderingTests.cs
index dfe9d56..084336e 100644
--- a/pdfsharpdslTests/RenderingTests.cs
+++ b/pdfsharpdslTests/RenderingTests.cs
@@ -1,5 +1,4 @@
-using PdfSharpCore.Pdf;
-using PdfSharpDslCore.Drawing;
+using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Parser;
 using System;
 using System.Collections.Generic;
diff --git a/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs b/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs
index 2e55e26..67483f9 100644
--- a/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs
+++ b/pdfsharpdslTests/ReplayerTests/InstructionRecorderTests.cs
@@ -1,6 +1,4 @@
 using Moq;
-using PdfSharpCore;
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Drawing;
 using System;
 using System.Collections.Generic;
@@ -20,15 +18,15 @@ public class InstructionRecorderTests
         #region private classes
         class DummyInstruction : IInstruction
         {
-            public DummyInstruction(XRect r, string name="")
+            public DummyInstruction(PdfRect r, string name="")
             {
                 this.Rect = r;
                 Name = name;
             }
 
-            public XRect Rect { get; }
+            public PdfRect Rect { get; }
             public string Name { get; }
-            public XRect DrawingRect { get; private set; }
+            public PdfRect DrawingRect { get; private set; }
 
             public double Draw(IPdfDocumentDrawer drawer, double offsetY, double pageOffsetY)
             {
@@ -58,8 +56,8 @@ public void RecorderTests_Level1()
             var block = recorder.OpenBlock(string.Empty,0, true,0);
             Assert.NotNull(block);
 
-            var r = new XRect(0, 0, 50, 50);
-            var r1 = new XRect(150, 150, 50, 50);
+            var r = new PdfRect(0, 0, 50, 50);
+            var r1 = new PdfRect(150, 150, 50, 50);
 
             block.PushInstruction(new DummyInstruction(r));
 
@@ -71,7 +69,7 @@ public void RecorderTests_Level1()
             var hasNewPage = block.Draw(drawerMock.Object, 0,0);
             Assert.Equal(0,hasNewPage);
 
-            block.PushInstruction(new DummyInstruction(new XRect(0, 200, 10, 100)));
+            block.PushInstruction(new DummyInstruction(new PdfRect(0, 200, 10, 100)));
             hasNewPage = block.Draw(drawerMock.Object, 0, 0);
             Assert.True(hasNewPage > 0);
             drawerMock.Verify(x => x.NewPage(null, null), Times.Once);
@@ -79,11 +77,11 @@ public void RecorderTests_Level1()
             
             //draw at bottom page
             block = recorder.OpenBlock(string.Empty,200, true,0);
-            var instr = new DummyInstruction(new XRect(0, 0, 50, 100));
+            var instr = new DummyInstruction(new PdfRect(0, 0, 50, 100));
             block.PushInstruction(instr);
             hasNewPage = block.Draw(drawerMock.Object, 0, 0);
             Assert.True(hasNewPage > 0);
-            Assert.Equal(new XRect(0,0,50,100), instr.DrawingRect);
+            Assert.Equal(new PdfRect(0,0,50,100), instr.DrawingRect);
             recorder.CloseBlock();
             
 
@@ -97,7 +95,7 @@ public void DrawAtBottomPage()
             var recorder = new BlocksRecorder();
             //draw at bottom page
             var block = recorder.OpenBlock(string.Empty,200, true, 0);
-            var instr = new DummyInstruction(new XRect(0, 0, 50, 100));
+            var instr = new DummyInstruction(new PdfRect(0, 0, 50, 100));
             block.PushInstruction(instr);
             var hasNewPage = block.Draw(drawerMock.Object, 0, 0);
             
@@ -138,20 +136,20 @@ public void RecorderTests_block_with_offsetY()
             var block = recorder.OpenBlock(string.Empty,200, true,0);
             AddInstructions(block, 1, 100);
             
-            Assert.Equal(new XRect(0,200, 50, 100), block.Rect);
+            Assert.Equal(new PdfRect(0,200, 50, 100), block.Rect);
             
             recorder.CloseBlock();
             block = recorder.OpenBlock(string.Empty,100, true);
             var block1 = recorder.OpenBlock(string.Empty,100, true);
             AddInstructions(block1, 1, 100);
-            Assert.Equal(new XRect(0,200, 50, 100), block.Rect);
-            Assert.Equal(new XRect(0,100, 50, 100), block1.Rect);
+            Assert.Equal(new PdfRect(0,200, 50, 100), block.Rect);
+            Assert.Equal(new PdfRect(0,100, 50, 100), block1.Rect);
         }
 
         [Fact]
         public void InstructionActionExecutesWithOffsetAndExposesMetadata()
         {
-            var rectangle = new XRect(1, 2, 3, 4);
+            var rectangle = new PdfRect(1, 2, 3, 4);
             double? appliedOffset = null;
             var instruction = new InstructionAction(offset => appliedOffset = offset, rectangle, "action");
 
@@ -167,7 +165,7 @@ public void InstructionActionExecutesWithOffsetAndExposesMetadata()
         public void RecorderRootRejectsInstructionsAndBlockMetadataCanBeCleared()
         {
             var recorder = new BlocksRecorder();
-            var instruction = new DummyInstruction(new XRect(0, 0, 10, 10));
+            var instruction = new DummyInstruction(new PdfRect(0, 0, 10, 10));
 
             Assert.False(recorder.CanPushInstruction);
             Assert.Throws<NotSupportedException>(() => recorder.CurrentBlock.PushInstruction(instruction));
@@ -195,13 +193,13 @@ public void NestedBlockMovesToNextPage()
             var recorder = new BlocksRecorder(logger.Object);
             var outer = recorder.OpenBlock("outer", 0, false);
             var child = outer.OpenBlock("child", 250, true);
-            var instruction = new DummyInstruction(new XRect(0, 0, 50, 50));
+            var instruction = new DummyInstruction(new PdfRect(0, 0, 50, 50));
             child.PushInstruction(instruction);
 
             var pageOffset = outer.Draw(drawer.Object, 0, 0);
 
             drawer.Verify(x => x.NewPage(null, null), Times.Once);
-            Assert.Equal(new XRect(0, 0, 50, 50), instruction.DrawingRect);
+            Assert.Equal(new PdfRect(0, 0, 50, 50), instruction.DrawingRect);
             Assert.True(pageOffset > 0);
         }
 
@@ -212,7 +210,7 @@ public void OversizedNestedBlockCannotBePrintedEntirely()
             var recorder = new BlocksRecorder();
             var outer = recorder.OpenBlock("outer", 0, false);
             var child = outer.OpenBlock("child", 0, true);
-            child.PushInstruction(new DummyInstruction(new XRect(0, 0, 50, 400)));
+            child.PushInstruction(new DummyInstruction(new PdfRect(0, 0, 50, 400)));
 
             Assert.Throws<NotImplementedException>(() => outer.Draw(drawer.Object, 0, 0));
         }
@@ -223,10 +221,10 @@ public void InstructionsCannotBeAddedWhileBlockIsDrawing()
             var drawer = defaultDrawerMock();
             var recorder = new BlocksRecorder();
             var block = recorder.OpenBlock("block", 0, true);
-            var extraInstruction = new DummyInstruction(new XRect(0, 20, 10, 10));
+            var extraInstruction = new DummyInstruction(new PdfRect(0, 20, 10, 10));
             block.PushInstruction(new InstructionAction(
                 _ => block.PushInstruction(extraInstruction),
-                new XRect(0, 0, 10, 10),
+                new PdfRect(0, 0, 10, 10),
                 "mutating"));
 
             block.Draw(drawer.Object, 0, 0);
@@ -236,7 +234,7 @@ public void InstructionsCannotBeAddedWhileBlockIsDrawing()
 
         private static void AddInstructions(IInstructionBlock block, int count, int height)
         {
-            var r = new XRect(0, 0, 50, height);
+            var r = new PdfRect(0, 0, 50, height);
             for (var i = 0; i < count; i++)
             {
 
diff --git a/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs b/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs
index a64dc11..c7204ae 100644
--- a/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs
+++ b/pdfsharpdslTests/SourceGenerator/SourceGeneratorTests.cs
@@ -2,7 +2,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Generator;
 using System.Diagnostics.CodeAnalysis;
@@ -31,7 +30,7 @@ public void GeneratorProducesCompilableSourceFromTaggedAdditionalFile()
             var references = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!)
                 .Split(Path.PathSeparator)
                 .Append(typeof(IPdfDocumentDrawer).Assembly.Location)
-                .Append(typeof(XColor).Assembly.Location)
+                .Append(typeof(PdfColor).Assembly.Location)
                 .Distinct()
                 .Select(path => MetadataReference.CreateFromFile(path));
             var compilation = CSharpCompilation.Create(
diff --git a/pdfsharpdslTests/VisitorTests.cs b/pdfsharpdslTests/VisitorTests.cs
index 1243142..b22acf6 100644
--- a/pdfsharpdslTests/VisitorTests.cs
+++ b/pdfsharpdslTests/VisitorTests.cs
@@ -1,7 +1,6 @@
 using Castle.Components.DictionaryAdapter.Xml;
 using Irony.Parsing;
 using Moq;
-using PdfSharpCore.Drawing;
 using PdfSharpDslCore.Drawing;
 using PdfSharpDslCore.Parser;
 using System;
@@ -25,7 +24,7 @@ public void TestValidFiles()
             mock.SetupProperty(x => x.CurrentBrush);
             new PdfDrawerVisitor().Draw(mock.Object, res);
 
-            Assert.Equal(XColors.Black, ((XSolidBrush)mock.Object.CurrentBrush).Color);
+            Assert.Equal(PdfColor.Black, mock.Object.CurrentBrush.Color);
         }
 
         [Theory]
@@ -54,16 +53,14 @@ public void TestFormulaEvaluatorWithFontName(string input, object expected, int
         {
             var res = ParseText(input);
             var mock = new Mock<IPdfDocumentDrawer>();
-            mock.SetupProperty(x => x.CurrentFont, new XFont("Consolas", 8));
+            mock.SetupProperty(x => x.CurrentFont, new PdfFont("Consolas", 8));
 
             var visitor = new PdfDrawerForTestsVisitor();
             visitor.RegisterFormulaFunction("getFontName", (_) => expected);
             var drawer = mock.Object;
             visitor.Draw(drawer, res);
             var f = drawer.CurrentFont;
-            //because font names change on different OS
-            var pi = typeof(XFont).GetProperty("FamilyName", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
-            Assert.StartsWith((string)expected, (string)pi?.GetValue(drawer.CurrentFont)!);
+            Assert.StartsWith((string)expected, drawer.CurrentFont.FamilyName);
             Assert.Equal(size, drawer.CurrentFont.Size);
         }
 
@@ -145,14 +142,14 @@ public void ImageStatementsPreserveDimensionsUnitsAndCropMode()
             var calls = new List<(double X, double Y, double? Width, double? Height, bool Pixel, bool Crop)>();
             var drawer = new Mock<IPdfDocumentDrawer>();
             drawer.Setup(x => x.DrawImage(
-                    It.IsAny<XImage>(),
+                    It.IsAny<PdfImage>(),
                     It.IsAny<double>(),
                     It.IsAny<double>(),
                     It.IsAny<double?>(),
                     It.IsAny<double?>(),
                     It.IsAny<bool>(),
                     It.IsAny<bool>()))
-                .Callback<XImage, double, double, double?, double?, bool, bool>((_, x, y, width, height, pixel, crop) =>
+                .Callback<PdfImage, double, double, double?, double?, bool, bool>((_, x, y, width, height, pixel, crop) =>
                     calls.Add((x, y, width, height, pixel, crop)));
 
             new PdfDrawerVisitor().Draw(drawer.Object, tree);
@@ -295,8 +292,8 @@ public void RowTemplateTracksOffsetsAndFinalHeight()
             var tree = ParseText("ROWTEMPLATE Count=2 Y=10 Name=\"row\" BorderSize=2 NewPageTopMargin=5 LINE 0,0,10,10; ENDROWTEMPLATE");
             var drawer = new Mock<IPdfDocumentDrawer>();
             drawer.SetupSequence(x => x.EndDrawRowTemplate(It.IsAny<int>()))
-                .Returns(new DrawingResult { DrawingRect = new XRect(0, 0, 10, 20), PageOffsetY = 0 })
-                .Returns(new DrawingResult { DrawingRect = new XRect(0, 20, 10, 30), PageOffsetY = 10 });
+                .Returns(new DrawingResult { DrawingRect = new PdfRect(0, 0, 10, 20), PageOffsetY = 0 })
+                .Returns(new DrawingResult { DrawingRect = new PdfRect(0, 20, 10, 30), PageOffsetY = 10 });
             var visitor = new InspectablePdfDrawerVisitor();
 
             visitor.Draw(drawer.Object, tree);

From d32cc5d1a9a6fce192c1a008d35cda74bc872de5 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 16:24:06 +0200
Subject: [PATCH 05/15] add missing files

---
 .../Extensions/ParseTreeNodeExtensions.cs     |  97 ++++
 PdfSharpDslCore/Parser/PdfGrammar.cs          | 498 ++++++++++++++++++
 2 files changed, 595 insertions(+)
 create mode 100644 PdfSharpDslCore/Extensions/ParseTreeNodeExtensions.cs
 create mode 100644 PdfSharpDslCore/Parser/PdfGrammar.cs

diff --git a/PdfSharpDslCore/Extensions/ParseTreeNodeExtensions.cs b/PdfSharpDslCore/Extensions/ParseTreeNodeExtensions.cs
new file mode 100644
index 0000000..90fdb21
--- /dev/null
+++ b/PdfSharpDslCore/Extensions/ParseTreeNodeExtensions.cs
@@ -0,0 +1,97 @@
+using Irony.Parsing;
+using PdfSharpDslCore.Drawing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+[assembly:InternalsVisibleTo("PdfSharpDslCore.Generator")]
+
+namespace PdfSharpDslCore.Extensions
+{
+    internal static class ParseTreeNodeExtensions
+    {
+        public static IEnumerable<ParseTreeNode> ChildNodes(this ParseTreeNode node, string termName)
+        {
+            List<ParseTreeNode> result = new List<ParseTreeNode>();
+            Queue<ParseTreeNode> queue = new Queue<ParseTreeNode>();
+
+            queue.Enqueue(node);
+
+            while (queue.Count > 0)
+            {
+                var n = queue.Dequeue();
+                if (n.Term != null && n.Term.Name == termName)
+                {
+                    result.Add(n);
+                }
+                foreach (var item in n.ChildNodes)
+                {
+                    queue.Enqueue(item);
+                }
+            }
+            return result.AsReadOnly();
+        }
+
+        public static ParseTreeNode? ChildNode(this ParseTreeNode node, string termName)
+        {
+            return node.ChildNodes.FirstOrDefault(n => n.Term != null && n.Term.Name == termName);
+        }
+
+        public static PdfFontStyle ParseFontStyle(this ParseTreeNode? node)
+        {
+            if (node != null && node.Token != null)
+            {
+                var styleName = (string?)node.Token.Value;
+                if (Enum.TryParse<PdfFontStyle>(styleName, true, out var fontStyle))
+                {
+                    return fontStyle;
+                }
+            }
+            return PdfFontStyle.Regular;
+        }
+
+        public static PdfColor ParseColor(this ParseTreeNode node)
+        {
+            var executor = (Func<ParseTreeNode, PdfColor>)(node.ChildNodes[0].Term.Name switch
+            {
+                "NamedColor" => ParseNamedColor,
+                _ => ParseHexColor,
+            });
+
+            return executor(node.ChildNodes[0]);
+        }
+        private static PdfColor ParseNamedColor(ParseTreeNode node)
+        {
+            var color = (string)node.ChildNodes[0].Token.Value;
+            return PdfColors.FromName(color);
+        }
+
+        private static PdfColor ParseHexColor(ParseTreeNode node)
+        {
+            var colorValue = node.ChildNodes[0].Token.Value;
+            if (colorValue is double)
+            {
+                return PdfColor.FromGrayScale(Convert.ToDouble(colorValue));
+            }
+            else
+            {
+                if (node.ChildNodes[0].Token.Length == 8)
+                {
+                    uint argb = ((uint)0xff000000) | Convert.ToUInt32(colorValue);
+                    return PdfColor.FromArgb(argb);
+                }
+                else if (node.ChildNodes[0].Token.Length == 10)
+                {
+                    uint argb = unchecked((uint)Convert.ToInt32(colorValue));
+                    return PdfColor.FromArgb(argb);
+                }
+                return PdfColor.FromArgb(unchecked((uint)Convert.ToInt32(colorValue)));
+            }
+        }
+
+    }
+}
diff --git a/PdfSharpDslCore/Parser/PdfGrammar.cs b/PdfSharpDslCore/Parser/PdfGrammar.cs
new file mode 100644
index 0000000..7c15cb8
--- /dev/null
+++ b/PdfSharpDslCore/Parser/PdfGrammar.cs
@@ -0,0 +1,498 @@
+
+using Irony;
+using Irony.Parsing;
+using PdfSharpDslCore.Drawing;
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Runtime.CompilerServices;
+
+
+[assembly: InternalsVisibleTo("pdfsharpdslTests")]
+
+
+namespace PdfSharpDslCore.Parser
+{
+    [Language("PdfGrammar", "1.0", "Grammar to write PDF with PdfSharp")]
+    public class PdfGrammar : Grammar
+    {
+        protected NonTerminal FormulaRoot;
+        private NonTerminal EmbbededSmtListOpt;
+
+        public PdfGrammar()
+        {
+            var sstring = new StringLiteral("string", "\"", StringOptions.AllowsDoubledQuote | StringOptions.AllowsAllEscapes)
+                {
+                    Priority = TerminalPriority.High
+                };
+            var textString = new StringLiteral("textstring", "\"", StringOptions.AllowsDoubledQuote | StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak);
+            var number_literal = new NumberLiteral("number", NumberOptions.AllowSign);
+            var pixel_literal = new NumberLiteral("pixel", NumberOptions.IntOnly)
+            {
+                DefaultFloatType = TypeCode.Double,
+                DefaultIntTypes = new TypeCode[3]
+                {
+                    TypeCode.Int32,
+                    TypeCode.Int64,
+                    (TypeCode)30
+                }
+            };
+            pixel_literal.AddSuffix("px", TypeCode.Int64);
+
+            var colorNumber = new NumberLiteral("ColorValue");
+            colorNumber.AddPrefix("g", NumberOptions.Default | NumberOptions.AllowStartEndDot);
+            colorNumber.AddPrefix("0x", NumberOptions.Hex);
+            var variableLiteral = new IdentifierTerminal("var");
+            KeyTerm lpar = ToTerm("(");
+            KeyTerm rpar = ToTerm(")");
+            KeyTerm comma = ToTerm(",", "comma");
+
+            var comment = new CommentTerminal("comment", "#", "\r", "\n", "\u2085", "\u2028", "\u2029");
+            //comment must to be added to NonGrammarTerminals list; it is not used directly in grammar rules,
+            // so we add it to this list to let Scanner know that it is also a valid terminal. 
+            NonGrammarTerminals.Add(comment);
+
+            #region variables
+            var PDF = new NonTerminal("PDF");
+            var PdfLine = new NonTerminal("PdfLine");
+            var PdfInstruction = new NonTerminal("PdfInstruction");
+            var PdfPrimaryInstruction = new NonTerminal("PdfPrimaryInstruction");
+            var SetSmt = new NonTerminal("SetSmt");
+            var RectSmt = new NonTerminal("RectSmt");
+            var LineSmt = new NonTerminal("LineSmt");
+            var EllipseSmt = new NonTerminal("EllipseSmt");
+            var LineToSmt = new NonTerminal("LineToSmt");
+            var MoveToSmt = new NonTerminal("MoveToSmt");
+            var FillRectSmt = new NonTerminal("FillRectSmt");
+            var FillEllipseSmt = new NonTerminal("FillEllipseSmt");
+            var PenSmt = new NonTerminal("PenSmt");
+            var BrushSmt = new NonTerminal("BrushSmt");
+            var HBrushSmt = new NonTerminal("HBrushSmt");
+            var BrushType = new NonTerminal("BrushType");
+            var FontSmt = new NonTerminal("FontSmt");
+            var ImageSmt = new NonTerminal("ImageSmt");
+
+            var ColorExp = new NonTerminal("ColorExp");
+            var NamedColor = new NonTerminal("NamedColor");
+            var HexColor = new NonTerminal("HexColor");
+            var styleExpr = new NonTerminal("styleExpr");
+            var RectLocation = new NonTerminal("RectLocation");
+            var PointLocation = new NonTerminal("PointLocation");
+            var SetContent = new NonTerminal("SetContent");
+            var TextSmt = new NonTerminal("TextSmt");
+            var RectOrPointLocation = new NonTerminal("RectOrPointLocation");
+            var TextAlignment = new NonTerminal("TextAlignment");
+            var TextOrientation = new NonTerminal("TextOrientation");
+            var TextOrientationValue = new NonTerminal("TextOrientationValue");
+            var HAlign = new NonTerminal("HAlign");
+            var VAlign = new NonTerminal("VAlign");
+            var VAlignValue = new NonTerminal("VAlignValue");
+            var HAlignValue = new NonTerminal("HAlignValue");
+            var LineTextSmt = new NonTerminal("LineTextSmt");
+            var NewPageSmt = new NonTerminal("NewPage");
+            var PageSize = new NonTerminal("PageSize");
+            var PageOrientation = new NonTerminal("PageOrientation");
+            var TableSmt = new NonTerminal("TableSmt");
+            var TableContent = new NonTerminal("TableContent");
+            var TableHead = new NonTerminal("TableHead");
+            var TableRowList = new NonTerminal("TableRowList");
+            var TableColList = new NonTerminal("TableColList");
+            var TableRow = new NonTerminal("TableRow");
+            var TableCol = new NonTerminal("TableCol");
+            var TableLocation = new NonTerminal("TableLocation");
+            var TableHeadStyle = new NonTerminal("TableHeadStyle");
+            var TableColHeadList = new NonTerminal("TableColHeadList");
+            var TableHeadCol = new NonTerminal("TableHeadCol");
+            var TableColWidth = new NonTerminal("TableColWidth");
+            var TableColFont = new NonTerminal("TableColFont");
+            var TableColColors = new NonTerminal("TableColColors");
+            var TableRowStyle = new NonTerminal("TableRowStyle");
+            var TableRowListOrRowTemplate = new NonTerminal("TableRowListOrRowTemplate");
+            var TableRowTemplate = new NonTerminal("TableRowTemplate");
+            var TableRowTemplateCount = new NonTerminal("TableRowTemplateCount");
+
+            var PointAutoLocation = new NonTerminal("PointAutoLocation");
+            var NumberOrAuto = new NonTerminal("NumberOrAuto");
+            var ViewSizeSmt = new NonTerminal("ViewSizeSmt");
+            var TitleSmt = new NonTerminal("TitleSmt");
+            var MarginArg = new NonTerminal("MarginArg");
+            var Parenthesized_Expression = new NonTerminal("Parenthesized_Expression");
+            var BinaryExpression = new NonTerminal("BinaryExpression");
+            var BinOp = new NonTerminal("BinOp", "operator");
+            var UnOp = new NonTerminal("UnOp");
+            var semiOpt = new NonTerminal("semiOpt");
+            var PixelOrPoint = new NonTerminal("PixelOrPoint");
+            var CropExp = new NonTerminal("CropExp");
+            var ImageLocation = new NonTerminal("ImageLocation");
+            var PieSmt = new NonTerminal("PieSmt");
+            var FillPieSmt = new NonTerminal("FillPieSmt");
+            var PolygonSmt = new NonTerminal("PolygonSmt");
+            var PolygonPoint = new NonTerminal("PolygonPoint");
+            var FillPolygonSmt = new NonTerminal("FillPolygonSmt");
+            var ForSmt = new NonTerminal("ForSmt");
+            var UdfSmt = new NonTerminal("UdfSmt");
+            var UdfInvokeSmt = new NonTerminal("UdfInvokeSmt");
+            var IfSmt = new NonTerminal("IfSmt");
+            var Else_clause_opt = new NonTerminal("Else_clause_opt");
+            var then_clause = new NonTerminal("then_clause");
+
+            var FormulaExpression = new NonTerminal("FormulaExpression");
+            var LiteralExpression = new NonTerminal("LiteralExpression");
+            var FormulaPrimary = new NonTerminal("FormulaTerm");
+            var UnaryExpression = new NonTerminal("UnaryExpression");
+            var VarSmt = new NonTerminal("VarSmt");
+            var VarRef = new NonTerminal("VarRef");
+
+            var RowTemplateSmt = new NonTerminal("RowTemplateSmt");
+            var DebugOptionsSmt = new NonTerminal("DebugOptionsSmt");
+            #endregion
+
+            #region Formula rules
+            RegisterOperators(20, "and", "or");
+            RegisterOperators(30, "==", "<=", ">=", "<", ">", "<>");
+            RegisterOperators(40, "+", "-");
+            RegisterOperators(50, "*", "/", "%");
+            RegisterOperators(60, "^");
+
+            FormulaRoot = FormulaExpression;
+            var CustomFunctionExpression = new NonTerminal("CustomFunctionExpression");
+            FormulaExpression.Rule = BinaryExpression | FormulaPrimary;
+            FormulaPrimary.Rule = LiteralExpression | UnaryExpression | Parenthesized_Expression | CustomFunctionExpression;
+
+            LiteralExpression.Rule = number_literal | VarRef | sstring;
+            UnaryExpression.Rule = UnOp + FormulaExpression;
+            Parenthesized_Expression.Rule = lpar + FormulaExpression + rpar;
+            BinaryExpression.Rule = FormulaExpression + BinOp + FormulaExpression;
+
+            var CallInvokeArgumentslist = new NonTerminal("CallInvokeArgumentslist");
+            CallInvokeArgumentslist.Rule = MakePlusRule(CallInvokeArgumentslist, comma, FormulaExpression);
+
+            var CustomFunctionArgs = new NonTerminal("CustomFunctionArgs");
+            CustomFunctionExpression.Rule = variableLiteral + CustomFunctionArgs;
+            var CustomFunctionArgsOpt = new NonTerminal("CustomFunctionArgsOpt");
+            CustomFunctionArgs.Rule = lpar + CustomFunctionArgsOpt + rpar;
+            CustomFunctionArgsOpt.Rule = Empty | CallInvokeArgumentslist;
+
+            UnOp.Rule = ToTerm("+") | "-";
+            VarRef.Rule = "$" + variableLiteral;
+            BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "%" | "==" | "<=" | ">=" | "<" | ">" | "<>" | "and" | "or";
+            MarkTransient(FormulaExpression, LiteralExpression, BinOp, FormulaPrimary,
+                Parenthesized_Expression, UnOp);
+            #endregion
+
+            // set the PROGRAM to be the root node of PDF lines.
+            Root = PDF;
+
+            // BNF Rules
+            PDF.Rule = MakeStarRule(PDF, PdfLine);
+
+            // A line can be an empty line, or it's a number followed by a statement list ended by a new-line.
+            KeyTerm semi = ToTerm(";", "semi");
+            semi.ErrorAlias = "';' expected";
+
+            comma.ErrorAlias = "',' expected";
+            semiOpt.Rule = Empty | semi;
+
+            PdfLine.Rule = UdfSmt | DebugOptionsSmt | PdfInstruction;
+
+            PdfInstruction.Rule = PdfPrimaryInstruction + semiOpt;
+
+            PdfPrimaryInstruction.Rule = SetSmt
+                | RectSmt
+                | FillRectSmt
+                | EllipseSmt
+                | FillEllipseSmt
+                | TitleSmt
+                | NewPageSmt
+                | ViewSizeSmt
+                | LineSmt
+                | LineToSmt
+                | MoveToSmt
+                | LineTextSmt
+                | TextSmt
+                | TableSmt
+                | ImageSmt
+                | PieSmt
+                | PolygonSmt
+                | FillPolygonSmt
+                | FillPieSmt
+                | ForSmt
+                | UdfInvokeSmt
+                | IfSmt
+                | RowTemplateSmt
+            ;
+
+            #region basics rules
+            RectLocation.Rule = PointLocation + comma + PointLocation;
+
+            PointLocation.Rule = FormulaExpression + comma + FormulaExpression;
+            RectOrPointLocation.Rule = RectLocation | PointLocation;
+
+            #endregion
+            
+            SetSmt.Rule =  ToInstructionTerm("SET") + SetContent;
+            SetContent.Rule = PenSmt | BrushSmt | FontSmt | VarSmt | HBrushSmt;
+            RectSmt.Rule = ToInstructionTerm("RECT") + RectLocation;
+            FillRectSmt.Rule = ToInstructionTerm("FILLRECT") + RectLocation;
+            EllipseSmt.Rule = ToInstructionTerm("ELLIPSE") + RectLocation;
+            FillEllipseSmt.Rule = ToInstructionTerm("FILLELLIPSE") + RectLocation;
+
+
+            LineSmt.Rule = ToInstructionTerm("LINE") + RectLocation;
+            MoveToSmt.Rule = ToInstructionTerm("MOVETO") + PointLocation;
+            LineToSmt.Rule = ToInstructionTerm("LINETO") + PointLocation;
+            var stylePenOpt = new NonTerminal("StylePenOpt");
+            var stylePen = new NonTerminal("StylePen");
+            stylePenOpt.Rule = Empty | stylePen;
+            stylePen.Rule = ToTerm("solid") | "dash" | "dot" | "dashdot" | "dashdotdot";
+            PenSmt.Rule = ToTerm("PEN") + ColorExp + FormulaExpression + stylePenOpt;
+            BrushSmt.Rule = ToTerm("BRUSH") + ColorExp + BrushType;
+            //TODO: how to deactivate HBRUSH...
+            HBrushSmt.Rule = ToTerm("HBRUSH") + ColorExp + BrushType;
+            //do not use ToTerm, because "FONT" is used in as argument in Table
+            FontSmt.Rule = new KeyTerm("FONT", "FONT") + Arg("Name") + FormulaExpression + Arg("Size") + FormulaExpression + styleExpr;
+
+            VarSmt.Rule = ToTerm("VAR") + variableLiteral + "=" + FormulaExpression + semi;
+
+            ColorExp.Rule = NamedColor | HexColor;
+            foreach (var colorName in PdfColors.Names)
+            {
+                var name = colorName.ToLowerInvariant();
+                if (NamedColor.Rule == null)
+                {
+                    NamedColor.Rule = ToTerm(name, $"color-{name}");
+                }
+                else
+                {
+                    NamedColor.Rule |= ToTerm(name, $"color-{name}");
+                }
+            }
+
+
+            HexColor.Rule = colorNumber;
+            styleExpr.Rule = Empty;
+            foreach (var enumName in Enum.GetNames(typeof(PdfFontStyle)))
+            {
+                var styleName = enumName.ToLowerInvariant();
+                styleExpr.Rule |= ToTerm(styleName, $"style-{styleName}");
+            }
+
+
+            //Multiline alignment is implemented by the TerraPDF canvas adapter.
+            //multiline
+            TextSmt.Rule = ToInstructionTerm("TEXT") + RectOrPointLocation + OptArg("MaxWidth", FormulaExpression) + Arg("Text") + FormulaExpression;
+
+            TextAlignment.Rule = HAlign + VAlign;
+            HAlign.Rule = Empty | Arg("HAlign") + HAlignValue;
+            VAlign.Rule = Empty | Arg("VAlign") + VAlignValue;
+            HAlignValue.Rule = ToTerm("left") | "right" | "hcenter";
+            VAlignValue.Rule = ToTerm("top") | "bottom" | "vcenter";
+
+            TextOrientation.Rule = Empty | Arg("Orientation") + TextOrientationValue;
+            TextOrientationValue.Rule = FormulaExpression
+                | "vertical"
+                | "horizontal";
+
+            //simple line
+            LineTextSmt.Rule = ToInstructionTerm("LINETEXT") + RectOrPointLocation + TextAlignment + TextOrientation
+                               + Arg("Text") + FormulaExpression;
+            BrushType.Rule = Empty /* | GradientBrush*/;
+
+            PageSize.Rule = Empty;
+
+            var names = Enum.GetNames(typeof(PdfPageSize));
+            var firstSize = names.First();
+            PageSize.Rule |= ToTerm(firstSize, $"pagesize-{firstSize}");
+            foreach (var prop in names.Skip(1))
+            {
+                PageSize.Rule |= ToTerm(prop, $"pagesize-{prop}");
+            }
+
+            PageOrientation.Rule = Empty | "portrait" | "landscape";
+            NewPageSmt.Rule = ToInstructionTerm("NEWPAGE") + PageSize + PageOrientation;
+
+            TitleSmt.Rule = ToInstructionTerm("TITLE") + MarginArg + HAlign + Arg("Text") + FormulaExpression;
+            MarginArg.Rule = Empty | Arg("Margin") + FormulaExpression;
+
+
+            TableSmt.Rule = ToInstructionTerm("TABLE") + TableLocation + TableContent + ToTerm("ENDTABLE");
+
+            TableContent.Rule = TableHead + TableRowListOrRowTemplate;
+
+            TableHead.Rule = ToTerm("HEAD") + TableHeadStyle + TableColHeadList + ToTerm("ENDHEAD");
+            TableRowList.Rule = MakeStarRule(TableRowList, TableRow);
+            TableRowListOrRowTemplate.Rule = TableRowList | TableRowTemplate;
+            TableRowTemplateCount.Rule = FormulaExpression;
+            TableRowTemplate.Rule = ToInstructionTerm("ROWTEMPLATE") + TableRowTemplateCount + TableColList + ToTerm("ENDROW");
+            TableColHeadList.Rule = MakeStarRule(TableColHeadList, TableHeadCol);
+            TableHeadCol.Rule = ToTerm("COL") + TableColWidth + TableColFont + TableColColors + sstring + semi;
+            //desiredWidth and maxWidth
+            TableColWidth.Rule = Arg("Width") + NumberOrAuto + Arg("MaxWidth") + NumberOrAuto;
+            TableColList.Rule = MakeStarRule(TableColList, TableCol);
+            TableRow.Rule = ToTerm("ROW") + TableRowStyle + TableColList + ToTerm("ENDROW");
+            TableCol.Rule = ToTerm("COL") + FormulaExpression + semi;
+            TableLocation.Rule = PointLocation /*+ "," + PointAutoLocation*/;
+            PointAutoLocation.Rule = NumberOrAuto + "," + NumberOrAuto;
+            NumberOrAuto.Rule = FormulaExpression | "auto";
+            TableHeadStyle.Rule = Empty | ColorExp;
+            TableColFont.Rule = Empty | Arg("FONT") + sstring + "," + number_literal + "," + styleExpr;
+            TableColColors.Rule = Empty | ColorExp + ColorExp;
+            TableRowStyle.Rule = Empty | FormulaExpression;
+
+            ViewSizeSmt.Rule = ToInstructionTerm("VIEWSIZE") + PointLocation;
+
+            PixelOrPoint.Rule = ToTerm("pixel") | "point";
+            CropExp.Rule = Empty | "crop" | "fit";
+            ImageLocation.Rule = PointLocation | RectLocation + PixelOrPoint + CropExp;
+            //PreferShift because
+            var ImageRawOrSource = new NonTerminal("ImageRawOrSource");
+            ImageSmt.Rule = ToInstructionTerm("IMAGE") + ImageLocation + ImageRawOrSource + FormulaExpression;
+            ImageRawOrSource.Rule = Arg("Source") | Arg("Data");
+
+            PieSmt.Rule = ToInstructionTerm("PIE") + RectLocation + Arg("Start") + FormulaExpression + Arg("Angle") + FormulaExpression;
+            PolygonSmt.Rule = ToInstructionTerm("POLYGON") + PointLocation + comma + PointLocation + comma + PolygonPoint;
+            PolygonPoint.Rule = MakePlusRule(PolygonPoint, comma, PointLocation);
+            FillPieSmt.Rule = ToInstructionTerm("FILLPIE") + RectLocation + Arg("Start") + FormulaExpression + Arg("Angle") + FormulaExpression;
+            FillPolygonSmt.Rule = ToInstructionTerm("FILLPOLYGON") + PointLocation + comma + PointLocation + comma + PolygonPoint;
+
+            var EmbbededSmtList = new NonTerminal("EmbbededSmtList");
+            var ForBlock = new NonTerminal("ForBlock");
+            ForSmt.Rule = ToInstructionTerm("FOR") + variableLiteral + "=" + FormulaExpression + "TO" + FormulaExpression + ForBlock;
+            var embbededSmtListOpt = new NonTerminal("EmbbededSmtListOpt");
+            this.EmbbededSmtListOpt = embbededSmtListOpt;
+            ForBlock.Rule = ToTerm("DO") + embbededSmtListOpt + "ENDFOR";
+            embbededSmtListOpt.Rule = Empty + EmbbededSmtList;
+            EmbbededSmtList.Rule = MakePlusRule(EmbbededSmtList, null, PdfInstruction);
+
+            var UdfArgumentslistOpt = new NonTerminal("UdfArgumentslistOpt");
+            var UdfArguments = new NonTerminal("UdfArguments");
+            var UdfArgumentslist = new NonTerminal("UdfArgumentslist");
+            var UdfBlock = new NonTerminal("UdfBlock");
+            UdfArguments.Rule = lpar + UdfArgumentslistOpt + rpar;
+            UdfArgumentslistOpt.Rule = Empty | UdfArgumentslist;
+            UdfSmt.Rule = ToTerm("UDF") + variableLiteral + PreferShiftHere() + UdfArguments + UdfBlock;
+            UdfArgumentslist.Rule = MakePlusRule(UdfArgumentslist, comma, variableLiteral);
+            UdfBlock.Rule = embbededSmtListOpt + "ENDUDF";
+
+
+            var UdfInvokeArguments = new NonTerminal("UdfInvokeArguments");
+            var UdfInvokeArgumentslistOpt = new NonTerminal("UdfInvokeArgumentslistOpt");
+            UdfInvokeSmt.Rule = ToInstructionTerm("CALL") + variableLiteral + PreferShiftHere() + UdfInvokeArguments;
+            UdfInvokeArguments.Rule = lpar + UdfInvokeArgumentslistOpt + rpar;
+            UdfInvokeArgumentslistOpt.Rule = Empty | CallInvokeArgumentslist;
+
+            IfSmt.Rule = ToInstructionTerm("IF") + FormulaExpression + then_clause + Else_clause_opt + "ENDIF";
+            then_clause.Rule = "THEN" + embbededSmtListOpt;
+            Else_clause_opt.Rule = Empty | PreferShiftHere() + "ELSE" + embbededSmtListOpt;
+
+            ConfigureRowTemplateSmt(RowTemplateSmt);
+
+            var debugOption = new IdentifierTerminal("debugOption");
+            var debugOptionList = new NonTerminal("debugOptionList");
+            debugOptionList.Rule = MakePlusRule(debugOptionList, comma, debugOption);
+            DebugOptionsSmt.Rule = "DEBUGOPTIONS" +  debugOptionList + semi;
+
+
+            RegisterBracePair("(", ")");
+
+            MarkPunctuation(";", ",", "(", ")", "TABLE", "ENDTABLE", "HEAD", "ENDHEAD", "ROW", "ROWTEMPLATE ", "ENDROW", "ENDFOR", "UDF", "ENDUDF", 
+                "IF", "THEN", "ELSE", "ENDIF", "ROWTEMPLATE", "ENDROWTEMPLATE");
+            RegisterBracePair("(", ")");
+            MarkTransient(PdfLine, PdfPrimaryInstruction, SetContent, NumberOrAuto,
+                 styleExpr, semiOpt, PixelOrPoint, HAlignValue, TextOrientationValue, VAlignValue,
+                 embbededSmtListOpt,
+                 UdfArguments, UdfArgumentslistOpt,
+                 UdfInvokeArguments, UdfInvokeArgumentslistOpt, stylePenOpt,
+                 CustomFunctionArgs, CustomFunctionArgsOpt, TableRowTemplateCount);
+
+            this.AddTermsReportGroup("punctuation", comma);
+            this.AddToNoReportGroup("(", "++", "--");
+            this.AddOperatorReportGroup("operator");
+            this.AddTermsReportGroup("constant", number_literal, sstring);
+            this.AddTermsReportGroup("constant", "auto");
+            this.AddToNoReportGroup(semi);
+        }
+
+        void ConfigureRowTemplateSmt(NonTerminal rowTemplateSmt)
+        {
+            /*
+            ROWTEMPLATE Count=getGlobalCommentsCount()
+                LINETEXT 50, 100 HAlign=center VAlign=bottom Text=getGlobalCommentDate($ROWINDEX); 
+                
+                SET VAR GINDEX=$ROWINDEX;
+                ROWTEMPLATE Count=getCommentsCount($GINDEX)
+                    LINETEXT 150, 100 HAlign=center VAlign=bottom Text=getCommentDate($GINDEX,$ROWINDEX);         
+                ENDROWTEMPLATE
+            ENDROWTEMPLATE
+             */
+            var rowTemplateContent = new NonTerminal("RowTemplateBlock");
+            rowTemplateSmt.Rule = "ROWTEMPLATE" + Arg("Count") + FormulaRoot + Arg("Y") + FormulaRoot 
+                                  + OptArg("Name", FormulaRoot) 
+                                  + OptArg("BorderSize", FormulaRoot) 
+                                  + OptArg("NewPageTopMargin", FormulaRoot) 
+                                  //+ OptArg("Splitable", FormulaRoot)
+                                  +  rowTemplateContent;
+            rowTemplateContent.Rule = EmbbededSmtListOpt + "ENDROWTEMPLATE";
+        }
+
+        KeyTerm ToInstructionTerm(string name)
+        {
+            var result = ToTerm(name);
+            AddTermsReportGroup("instruction", result);
+            return result;
+        }
+        
+        /// <summary>
+        /// for argument in grammar
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        private BnfExpression Arg(string name)
+        {
+            var term = ToTerm(name);
+            term.ErrorAlias = $"Missing argument '{name}=...'";
+            var result = term + PreferShiftHere() + "=";
+            //result.ErrorAlias = $"argument missing {name}";
+            return result;
+        }
+
+        BnfExpression OptArg(string name, BnfExpression bnfExpression)
+        {
+            var term = new NonTerminal($"Opt-{name}")
+            {
+                Rule = Empty | name + PreferShiftHere() + "=" + bnfExpression
+            };
+            return term;
+        }
+
+        public override string ConstructParserErrorMessage(ParsingContext context, StringSet expectedTerms)
+        {
+            if (context.CurrentParserState.ExpectedTerminals.Count > 0 && expectedTerms.Count == 0)
+            {
+                expectedTerms.AddRange(TerminalToString(context.CurrentParserState.ExpectedTerminals));
+                return base.ConstructParserErrorMessage(context, expectedTerms);
+            }
+            return base.ConstructParserErrorMessage(context, expectedTerms);
+        }
+
+        private string[] TerminalToString(TerminalSet expectedTerminals)
+        {
+            var l = new List<string>();
+            foreach (var item in expectedTerminals)
+            {
+                l.Add(item switch {
+                    KeyTerm k => k.Text,
+                    _ => item.ToString(),
+                });
+            }
+            return l.ToArray();
+        }
+
+        public override void ReportParseError(ParsingContext context)
+        {
+            base.ReportParseError(context);
+        }
+    }
+}
\ No newline at end of file

From 1bfcb59f5bec11f9ef35d735fef53e8af092fbbc Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 23:32:34 +0200
Subject: [PATCH 06/15] some fixes

---
 PdfSharpDslConsole/Program.cs                |  47 ++++--
 PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs | 143 +++++++++++++++----
 pdfsharpdslTests/PdfDocumentDrawerTests.cs   | 124 ++++++++++++++++
 pdfsharpdslTests/VisitorTests.cs             |  19 +++
 4 files changed, 296 insertions(+), 37 deletions(-)

diff --git a/PdfSharpDslConsole/Program.cs b/PdfSharpDslConsole/Program.cs
index 97d392f..bbdcfec 100644
--- a/PdfSharpDslConsole/Program.cs
+++ b/PdfSharpDslConsole/Program.cs
@@ -87,11 +87,12 @@
 //var fileName = "pdfsharp-newpage.ipdf";
 //var fileName = "pdfsharp.ipdf";
 //var fileName = "sample1.ipdf";
-var fileName = "demo.ipdf";
-if (args.Length > 0)
-{
-    fileName = args[0];
-}
+var fileName = args.Length > 0 ? args[0] : "demo.ipdf";
+var outputFile = Path.GetFullPath("helloworld.pdf");
+if (args.Length == 0)
+    Directory.SetCurrentDirectory(AppContext.BaseDirectory);
+if (!Path.IsPathRooted(fileName) && !File.Exists(fileName))
+    fileName = Path.Combine(AppContext.BaseDirectory, fileName);
 
 var parsingResult = parser.Parse(File.ReadAllText(fileName));
 
@@ -107,6 +108,7 @@
 }
 else
 {
+    RegisterSystemFonts();
     foreach (var font in LocalFontNames().Zip(LocalFontFiles()))
     {
         FontFamily.Register(font.First, font.Second);
@@ -126,7 +128,8 @@
     visitor.RegisterFormulaFunction("GETCOMMENTAUTHOR", getCommentAuthor);
 
     visitor.Draw(drawer, parsingResult);
-    drawer.PublishPdf("helloworld.pdf");
+    drawer.PublishPdf(outputFile);
+    Console.WriteLine($"PDF generated: {outputFile}");
 
     //var a = new PDfDsl.pdfsharp();
     //a.WritePdf(drawer);
@@ -134,12 +137,12 @@
 
 IEnumerable<string> LocalFontFiles()
 {
-    yield return @"Fonts/AlexBrush-Regular.ttf";
-    yield return @"Fonts/Just-Signature.ttf";
-    yield return @"Fonts/Inspiration-Regular.ttf";
-    yield return @"Fonts/Quirlycues.ttf";
-    yield return @"Fonts/Rabiohead.ttf";
-    yield return @"Fonts/SCRIPTIN.ttf";
+    yield return Path.Combine(AppContext.BaseDirectory, "Fonts", "AlexBrush-Regular.ttf");
+    yield return Path.Combine(AppContext.BaseDirectory, "Fonts", "Just-Signature.ttf");
+    yield return Path.Combine(AppContext.BaseDirectory, "Fonts", "Inspiration-Regular.ttf");
+    yield return Path.Combine(AppContext.BaseDirectory, "Fonts", "Quirlycues.ttf");
+    yield return Path.Combine(AppContext.BaseDirectory, "Fonts", "Rabiohead.ttf");
+    yield return Path.Combine(AppContext.BaseDirectory, "Fonts", "SCRIPTIN.ttf");
 }
 
 IEnumerable<string> LocalFontNames()
@@ -152,6 +155,26 @@ IEnumerable<string> LocalFontNames()
     yield return "Scriptina";
 }
 
+void RegisterSystemFonts()
+{
+    var fontsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Fonts);
+    RegisterFontVariant("Arial", "arial.ttf", fontsDirectory);
+    RegisterFontVariant("Arial", "arialbd.ttf", fontsDirectory, bold: true);
+    RegisterFontVariant("Arial", "ariali.ttf", fontsDirectory, italic: true);
+    RegisterFontVariant("Arial", "arialbi.ttf", fontsDirectory, bold: true, italic: true);
+    RegisterFontVariant("Consolas", "consola.ttf", fontsDirectory);
+    RegisterFontVariant("Consolas", "consolab.ttf", fontsDirectory, bold: true);
+    RegisterFontVariant("Consolas", "consolai.ttf", fontsDirectory, italic: true);
+    RegisterFontVariant("Consolas", "consolaz.ttf", fontsDirectory, bold: true, italic: true);
+}
+
+void RegisterFontVariant(string familyName, string fileName, string directory, bool bold = false, bool italic = false)
+{
+    var path = Path.Combine(directory, fileName);
+    if (File.Exists(path))
+        FontFamily.Register(familyName, path, bold, italic);
+}
+
 object GetFontNameByIndex(object[] arguments)
 {
     var index = (int)arguments[0];
diff --git a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
index c4c692c..0035bf7 100644
--- a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
+++ b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
@@ -131,11 +131,29 @@ public void DrawLine(double x, double y, double x1, double y1)
 
         private void InternalDrawLine(PdfPen pen, double x, double y, double x1, double y1)
         {
-            AddCommand(canvas => canvas.Line(x, y, x1, y1, pen.Color.Hex, pen.Width, pen.Color.Opacity));
+            AddCommand(canvas => DrawStyledLine(canvas, pen, x, y, x1, y1));
             _drawingCtx.PushInstruction(offset => InternalDrawLine(pen, x, y + offset, x1, y1 + offset),
                 new PdfRect(new PdfPoint(x, y), new PdfPoint(x1, y1)));
         }
 
+        private static void DrawStyledLine(VectorCanvas canvas, PdfPen pen, double x, double y, double x1, double y1)
+        {
+            canvas.Line(x, y, x1, y1, pen.Color.Hex, pen.Width, pen.Color.Opacity, GetDashPattern(pen));
+        }
+
+        private static double[]? GetDashPattern(PdfPen pen)
+        {
+            var width = Math.Max(pen.Width, 0.1);
+            return pen.DashStyle switch
+            {
+                PdfDashStyle.Dash => new[] { 4 * width, 3 * width },
+                PdfDashStyle.Dot => new[] { width, 2 * width },
+                PdfDashStyle.DashDot => new[] { 4 * width, 3 * width, width, 3 * width },
+                PdfDashStyle.DashDotDot => new[] { 4 * width, 3 * width, width, 2 * width, width, 2 * width },
+                _ => null,
+            };
+        }
+
         public void DrawRect(double x, double y, double w, double h, bool isFilled)
         {
             var page = CurrentPage;
@@ -145,10 +163,11 @@ public void DrawRect(double x, double y, double w, double h, bool isFilled)
 
         private void InternalDrawRect(PdfPen pen, PdfBrush brush, double x, double y, double w, double h, bool isFilled)
         {
+            var dashPattern = GetDashPattern(pen);
             AddCommand(canvas =>
             {
                 if (isFilled) canvas.FillRect(x, y, w, h, brush.Color.Hex, brush.Color.Opacity);
-                canvas.StrokeRect(x, y, w, h, pen.Color.Hex, pen.Width, pen.Color.Opacity);
+                canvas.StrokeRect(x, y, w, h, pen.Color.Hex, pen.Width, pen.Color.Opacity, dashPattern);
             });
             _drawingCtx.PushInstruction(offset => InternalDrawRect(pen, brush, x, y + offset, w, h, isFilled),
                 new PdfRect(x, y, w, h));
@@ -188,19 +207,28 @@ public void DrawLineText(string text, double x, double y, double? w, double? h,
             var page = CurrentPage;
             (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
             InternalDrawText(text, ScaleX(x, page), ScaleY(y, page), w.HasValue ? ScaleX(w.Value, page) : null,
-                h.HasValue ? ScaleY(h.Value, page) : null, hAlign, vAlign, CurrentFont, CurrentBrush, HighlightBrush);
+                h.HasValue ? ScaleY(h.Value, page) : null, hAlign, vAlign, CurrentFont, CurrentBrush, HighlightBrush,
+                textOrientation?.Angle ?? textOrientation?.Orientation switch
+                {
+                    TextOrientationEnum.Vertical => 90,
+                    TextOrientationEnum.HorizontalInvert => 180,
+                    TextOrientationEnum.VerticalInvert => 270,
+                    _ => 0,
+                });
         }
 
         private void InternalDrawText(string text, double x, double y, double? w, double? h, PdfHorizontalAlignment hAlign,
-            PdfVerticalAlignment vAlign, PdfFont font, PdfBrush brush, PdfBrush? highlight)
+            PdfVerticalAlignment vAlign, PdfFont font, PdfBrush brush, PdfBrush? highlight, double angle = 0)
         {
             var lines = WrapText(text, w, font);
             var lineHeight = font.Size * 1.2;
             var measuredWidth = lines.Count == 0 ? 0 : lines.Max(line => MeasureText(line, font));
             var measuredHeight = lines.Count * lineHeight;
             var rect = new PdfRect(x, y, w ?? measuredWidth, h ?? measuredHeight);
-            var textRect = DrawingHelper.RectFromStringFormat(rect,
-                new PdfSize(Math.Min(measuredWidth, rect.Width), Math.Min(measuredHeight, rect.Height)), hAlign, vAlign);
+            var textSize = new PdfSize(Math.Min(measuredWidth, rect.Width), Math.Min(measuredHeight, rect.Height));
+            var textRect = w.HasValue
+                ? DrawingHelper.RectFromStringFormat(rect, textSize, hAlign, vAlign)
+                : DrawingHelper.RectFromStringFormat(x, y, textSize, hAlign, vAlign);
 
             AddCommand(canvas =>
             {
@@ -212,18 +240,26 @@ private void InternalDrawText(string text, double x, double y, double? w, double
                     var line = lines[index];
                     if (string.IsNullOrWhiteSpace(line)) continue;
                     var lineWidth = MeasureText(line, font);
-                    var lineX = hAlign switch
-                    {
-                        PdfHorizontalAlignment.Center => rect.X + (rect.Width - lineWidth) / 2,
-                        PdfHorizontalAlignment.Far => rect.Right - lineWidth,
-                        _ => rect.X,
-                    };
+                    var lineX = w.HasValue
+                        ? hAlign switch
+                        {
+                            PdfHorizontalAlignment.Center => rect.X + (rect.Width - lineWidth) / 2,
+                            PdfHorizontalAlignment.Far => rect.Right - lineWidth,
+                            _ => rect.X,
+                        }
+                        : hAlign switch
+                        {
+                            PdfHorizontalAlignment.Center => x - lineWidth / 2,
+                            PdfHorizontalAlignment.Far => x - lineWidth,
+                            _ => x,
+                        };
                     canvas.Text(line, lineX, textRect.Y + font.Size + index * lineHeight, brush.Color.Hex, font.Size,
-                        font.FamilyName, font.Style.HasFlag(PdfFontStyle.Bold), font.Style.HasFlag(PdfFontStyle.Italic), brush.Color.Opacity);
+                            font.FamilyName, font.Style.HasFlag(PdfFontStyle.Bold), font.Style.HasFlag(PdfFontStyle.Italic), brush.Color.Opacity,
+                            angle);
                 }
             });
 
-            _drawingCtx.PushInstruction(offset => InternalDrawText(text, x, y + offset, w, h, hAlign, vAlign, font, brush, highlight),
+            _drawingCtx.PushInstruction(offset => InternalDrawText(text, x, y + offset, w, h, hAlign, vAlign, font, brush, highlight, angle),
                 textRect, instrName: $"DrawText({text})");
         }
 
@@ -244,13 +280,25 @@ public void DrawTable(double x, double y, TableDefinition table)
             for (var index = 0; index < table.Columns.Count; index++)
             {
                 var column = table.Columns[index];
-                column.DesiredWidth ??= Math.Min(MeasureText(column.ColumnHeaderName, fonts[index]) + margins.Left + margins.Right,
+                var contentWidth = table.Rows
+                    .Select(row => MeasureCellWidth(index < row.Data.Length ? row.Data[index] : string.Empty, fonts[index]))
+                    .DefaultIfEmpty(0)
+                    .Max();
+                var desiredWidth = Math.Max(MeasureCellWidth(column.ColumnHeaderName, fonts[index]), contentWidth)
+                    + margins.Left + margins.Right;
+                column.DesiredWidth ??= Math.Min(desiredWidth,
                     table.ColMaxWidth(index, availableWidth));
                 table.HeaderHeight ??= fonts[index].Size * 1.2 + margins.Top + margins.Bottom;
             }
 
             foreach (var row in table.Rows)
-                row.DesiredHeight ??= fonts.Select(font => font.Size * 1.2 + margins.Top + margins.Bottom).Max();
+            {
+                var contentHeight = fonts.Select((font, index) =>
+                    MeasureCellLineCount(index < row.Data.Length ? row.Data[index] : string.Empty,
+                        table.Columns[index].DrawWidth - margins.Left - margins.Right, font)
+                    * font.Size * 1.2 + margins.Top + margins.Bottom).Max();
+                row.DesiredHeight ??= contentHeight;
+            }
 
             if (y + (table.HeaderHeight ?? 0) > PageHeight) { NewPage(); y = 1; }
             var offsetY = 0d;
@@ -319,21 +367,55 @@ public void LineTo(double x, double y)
         {
             var page = CurrentPage;
             var endPoint = new PdfPoint(x, y);
-            AddCommand(canvas => canvas.Line(ScaleX(_currentPoint.X, page), ScaleY(_currentPoint.Y, page), ScaleX(endPoint.X, page), ScaleY(endPoint.Y, page),
-                CurrentPen.Color.Hex, CurrentPen.Width, CurrentPen.Color.Opacity));
-            _drawingCtx.PushInstruction(offset => LineTo(endPoint.X, endPoint.Y), new PdfRect(_currentPoint, endPoint));
+            InternalDrawLine(CurrentPen, ScaleX(_currentPoint.X, page), ScaleY(_currentPoint.Y, page),
+                ScaleX(endPoint.X, page), ScaleY(endPoint.Y, page));
             _currentPoint = endPoint;
         }
 
         public void DrawImage(PdfImage image, double x, double y, double? w, double? h, bool sizeInPixel, bool cropImage)
         {
-            _logger?.WriteDebug(this, "TerraPDF does not support absolute image placement; image skipped.");
+            ArgumentNullException.ThrowIfNull(image);
+            var page = CurrentPage;
+            (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
+            var data = image.Data.ToArray();
+            var naturalSize = VectorCanvas.GetImageSizeInPoints(data);
+            var width = w.HasValue ? (sizeInPixel ? w.Value * 72d / 96d : w.Value) : naturalSize.Width;
+            var height = h.HasValue ? (sizeInPixel ? h.Value * 72d / 96d : h.Value) : naturalSize.Height;
+            if (width <= 0 || height <= 0)
+                throw new ArgumentOutOfRangeException(nameof(w), "Image dimensions must be positive.");
+
+            var fit = cropImage ? ImageFit.CropTopLeft : ImageFit.Stretch;
+            AddCommand(canvas => canvas.Image(data, ScaleX(x, page), ScaleY(y, page),
+                ScaleX(width, page), ScaleY(height, page), fit));
+            _drawingCtx.PushInstruction(offset => DrawImage(image, x, y + offset, w, h, sizeInPixel, cropImage),
+                new PdfRect(x, y, width, height), instrName: "DrawImage");
         }
 
         public void DrawPie(double x, double y, double? w, double? h, double startAngle, double sweepAngle, bool isFilled)
         {
             var page = CurrentPage;
-            InternalDrawEllipse(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w ?? 0, page), ScaleY(h ?? 0, page), isFilled);
+            var width = w ?? 0;
+            var height = h ?? 0;
+            if (width <= 0 || height <= 0)
+                throw new ArgumentOutOfRangeException(nameof(w), "Pie dimensions must be positive.");
+            InternalDrawPie(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page),
+                ScaleX(width, page), ScaleY(height, page), startAngle, sweepAngle, isFilled);
+        }
+
+        private void InternalDrawPie(PdfPen pen, PdfBrush brush, double x, double y, double width, double height,
+            double startAngle, double sweepAngle, bool isFilled)
+        {
+            AddCommand(canvas =>
+            {
+                if (isFilled)
+                    canvas.DrawPie(x, y, width, height, startAngle, sweepAngle,
+                        brush.Color.Hex, pen.Color.Hex, pen.Width, brush.Color.Opacity);
+                else
+                    canvas.StrokePie(x, y, width, height, startAngle, sweepAngle,
+                        pen.Color.Hex, pen.Width, pen.Color.Opacity);
+            });
+            _drawingCtx.PushInstruction(offset => InternalDrawPie(pen, brush, x, y + offset, width, height, startAngle, sweepAngle, isFilled),
+                new PdfRect(x, y, width, height), instrName: "DrawPie");
         }
 
         public void DrawPolygon(IEnumerable<PdfPoint> points, bool isFilled)
@@ -341,13 +423,18 @@ public void DrawPolygon(IEnumerable<PdfPoint> points, bool isFilled)
             var page = CurrentPage;
             var transformed = points.Select(point => new PdfPoint(ScaleX(point.X, page), ScaleY(point.Y, page))).ToArray();
             if (transformed.Length < 3) throw new ArgumentException("A polygon requires at least three points.", nameof(points));
-            var tuples = transformed.Select(point => (point.X, point.Y)).ToArray();
+            InternalDrawPolygon(CurrentPen, CurrentBrush, transformed, isFilled);
+        }
+
+        private void InternalDrawPolygon(PdfPen pen, PdfBrush brush, PdfPoint[] points, bool isFilled)
+        {
+            var tuples = points.Select(point => (point.X, point.Y)).ToArray();
             AddCommand(canvas => canvas.Path(path =>
             {
-                path.Polygon(tuples).Stroke(CurrentPen.Color.Hex, CurrentPen.Width).Opacity(CurrentPen.Color.Opacity);
-                if (isFilled) path.Fill(CurrentBrush.Color.Hex).Opacity(CurrentBrush.Color.Opacity);
+                path.Polygon(tuples).Stroke(pen.Color.Hex, pen.Width).Opacity(pen.Color.Opacity);
+                if (isFilled) path.Fill(brush.Color.Hex).Opacity(brush.Color.Opacity);
             }));
-            _drawingCtx.PushInstruction(offset => DrawPolygon(transformed.Select(point => point.OffsetY(offset)), isFilled), transformed);
+            _drawingCtx.PushInstruction(offset => InternalDrawPolygon(pen, brush, points.Select(point => point.OffsetY(offset)).ToArray(), isFilled), points);
         }
 
         public void BeginDrawRowTemplate(string name, int index, double offsetY, double newPageTopMargin)
@@ -390,6 +477,12 @@ private static double MeasureText(string text, PdfFont font)
             return VectorCanvas.MeasureTextWidth(text, font.Size, font.FamilyName, font.Style.HasFlag(PdfFontStyle.Bold), font.Style.HasFlag(PdfFontStyle.Italic));
         }
 
+        private static double MeasureCellWidth(string text, PdfFont font) =>
+            text.Replace("\r\n", "\n").Split('\n').Select(line => MeasureText(line, font)).DefaultIfEmpty(0).Max();
+
+        private static int MeasureCellLineCount(string text, double width, PdfFont font) =>
+            WrapText(text, width, font).Count;
+
         private static List<string> WrapText(string text, double? maxWidth, PdfFont font)
         {
             var lines = new List<string>();
diff --git a/pdfsharpdslTests/PdfDocumentDrawerTests.cs b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
index bcc760d..cfe267f 100644
--- a/pdfsharpdslTests/PdfDocumentDrawerTests.cs
+++ b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
@@ -4,6 +4,130 @@ namespace pdfsharpdslTests
 {
     public class PdfDocumentDrawerTests
     {
+        [Fact]
+        public void DslOrientationsProduceRotatedTextMatrices()
+        {
+            var parser = new Irony.Parsing.Parser(new PdfSharpDslCore.Parser.PdfGrammar());
+            var tree = parser.Parse(
+                "LINETEXT 220,235 HAlign=left VAlign=vcenter Orientation=vertical Text=\"vertical\";" +
+                "LINETEXT 300,235 HAlign=left VAlign=vcenter Orientation=30 Text=\"30 degree rotation\";");
+            Assert.False(tree.HasErrors());
+            using var drawer = new PdfDocumentDrawer();
+            new PdfSharpDslCore.Parser.PdfDrawerVisitor().Draw(drawer, tree);
+            var content = ReadContent(drawer.PublishPdf());
+
+            Assert.Matches(@"0\.00 -1\.00 1\.00 0\.00 220\.00 [\d.]+ Tm\n\(vertical\) Tj", content);
+            Assert.Matches(@"0\.87 -0\.50 0\.50 0\.87 300\.00 [\d.]+ Tm\n\(30 degree rotation\) Tj", content);
+        }
+
+        [Fact]
+        public void PolygonsKeepStylesFromTheirDrawingInstructions()
+        {
+            var parser = new Irony.Parsing.Parser(new PdfSharpDslCore.Parser.PdfGrammar());
+            var tree = parser.Parse(
+                "SET PEN darkslategray 2 solid;POLYGON 10,20,30,20,20,40;" +
+                "SET BRUSH lightseagreen;FILLPOLYGON 50,20,70,20,60,40;" +
+                "SET PEN crimson 0.5 solid;SET BRUSH black;");
+            Assert.False(tree.HasErrors());
+            using var drawer = new PdfDocumentDrawer();
+            new PdfSharpDslCore.Parser.PdfDrawerVisitor().Draw(drawer, tree);
+
+            var content = ReadContent(drawer.PublishPdf());
+
+            Assert.Contains("2.00 w\n0.1843 0.3098 0.3098 RG\n", content);
+            Assert.Contains("0.1255 0.6980 0.6667 rg\n", content);
+            Assert.Contains("h\nS\n", content);
+            Assert.Contains("h\nB\n", content);
+            Assert.DoesNotContain("0.0000 0.0000 0.0000 rg\n", content);
+        }
+
+        [Fact]
+        public void LineToKeepsEachStartPointAndPenAtRecordingTime()
+        {
+            using var drawer = new PdfDocumentDrawer();
+            drawer.CurrentPen = new PdfPen(new PdfColor(255, 128, 0, 128), 3);
+            drawer.MoveTo(10, 20);
+            drawer.LineTo(30, 40);
+            drawer.LineTo(50, 20);
+            drawer.CurrentPen = new PdfPen(PdfColor.Black, 1);
+            drawer.MoveTo(100, 100);
+
+            var content = ReadContent(drawer.PublishPdf());
+
+            Assert.Contains("0.5020 0.0000 0.5020 RG\n", content);
+            Assert.Contains("3.00 w\n", content);
+            Assert.Contains("10.00 821.89 m\n30.00 801.89 l\n", content);
+            Assert.Contains("30.00 801.89 m\n50.00 821.89 l\n", content);
+        }
+
+        [Fact]
+        public void DashStylesUseNativePdfPatternAndDoNotLeak()
+        {
+            var parser = new Irony.Parsing.Parser(new PdfSharpDslCore.Parser.PdfGrammar());
+            var tree = parser.Parse(
+                "SET PEN black 2 dash;LINE 10,20,110,20;" +
+                "SET PEN black 2 solid;LINE 10,40,110,40;");
+            Assert.False(tree.HasErrors());
+            using var drawer = new PdfDocumentDrawer();
+            new PdfSharpDslCore.Parser.PdfDrawerVisitor().Draw(drawer, tree);
+
+            var content = ReadContent(drawer.PublishPdf());
+
+            Assert.Contains("[8.00 6.00] 0.00 d\n", content);
+            Assert.Contains("q\n[8.00 6.00] 0.00 d\n", content);
+            Assert.Contains("Q\n2.00 w\n0.0000 0.0000 0.0000 RG\n10.00 801.89 m\n110.00 801.89 l\nS\n", content);
+        }
+
+        [Fact]
+        public void DashStylesApplyToRectangleOutlines()
+        {
+            var parser = new Irony.Parsing.Parser(new PdfSharpDslCore.Parser.PdfGrammar());
+            var tree = parser.Parse("SET PEN crimson 1 dash;RECT 20,40,-20,-55;");
+            Assert.False(tree.HasErrors());
+            using var drawer = new PdfDocumentDrawer();
+            new PdfSharpDslCore.Parser.PdfDrawerVisitor().Draw(drawer, tree);
+
+            var content = ReadContent(drawer.PublishPdf());
+
+            Assert.Contains("q\n[4.00 3.00] 0.00 d\n", content);
+            Assert.Contains("re\nS\nQ\n", content);
+        }
+
+        [Fact]
+        public void TablesMeasureAutoColumnsAndMultilineRows()
+        {
+            using var drawer = new PdfDocumentDrawer();
+            var table = new TableDefinition();
+            table.Columns.Add(new ColumnDefinition { ColumnHeaderName = "Feature", MaxWidth = 130, Font = new PdfFont("Arial", 9) });
+            table.Columns.Add(new ColumnDefinition { ColumnHeaderName = "Syntax", DesiredWidth = 140, MaxWidth = 180, Font = new PdfFont("Arial", 9) });
+            table.Columns.Add(new ColumnDefinition { ColumnHeaderName = "Notes", MaxWidth = 240, Font = new PdfFont("Arial", 9) });
+            table.Rows.Add(new RowDefinition { Data = ["Automatic sizing", "Width=auto", "Desired width follows content up to MaxWidth"] });
+            table.Rows.Add(new RowDefinition { Data = ["Multiline cell", "COL expression", "Line one\r\nLine two\r\nLine three"] });
+
+            drawer.DrawTable(40, 90, table);
+
+            Assert.True(table.Columns[0].DesiredWidth > 0);
+            Assert.Equal(140, table.Columns[1].DrawWidth);
+            Assert.True(table.Columns[2].DesiredWidth > table.Columns[2].ColumnHeaderName.Length);
+            Assert.True(table.Rows[1].DesiredHeight > table.Rows[0].DesiredHeight);
+        }
+
+        private static string ReadContent(byte[] pdf)
+        {
+            var raw = System.Text.Encoding.Latin1.GetString(pdf);
+            var content = new System.Text.StringBuilder();
+            foreach (System.Text.RegularExpressions.Match match in System.Text.RegularExpressions.Regex.Matches(
+                raw, @"stream\r?\n(?<data>.*?)\r?\nendstream", System.Text.RegularExpressions.RegexOptions.Singleline))
+            {
+                using var compressed = new MemoryStream(System.Text.Encoding.Latin1.GetBytes(match.Groups["data"].Value));
+                using var inflated = new System.IO.Compression.ZLibStream(compressed, System.IO.Compression.CompressionMode.Decompress);
+                using var reader = new StreamReader(inflated, System.Text.Encoding.Latin1);
+                content.Append(reader.ReadToEnd());
+            }
+
+            return content.ToString();
+        }
+
         [Fact]
         public void NewPageUsesDefaultsAndPersistsExplicitSettings()
         {
diff --git a/pdfsharpdslTests/VisitorTests.cs b/pdfsharpdslTests/VisitorTests.cs
index b22acf6..2e01bb2 100644
--- a/pdfsharpdslTests/VisitorTests.cs
+++ b/pdfsharpdslTests/VisitorTests.cs
@@ -116,6 +116,25 @@ public void DrawExecutesViewSizeTextWidthAndDebugOptions()
                 drawer.Object.DebugOptions);
         }
 
+            [Theory]
+            [InlineData("", TextOrientationEnum.Horizontal, null)]
+            [InlineData("Orientation=horizontal", TextOrientationEnum.Horizontal, null)]
+            [InlineData("Orientation=vertical", TextOrientationEnum.Vertical, null)]
+            [InlineData("Orientation=30", TextOrientationEnum.Horizontal, 30.0)]
+            [InlineData("Orientation=(-15*2)", TextOrientationEnum.Horizontal, -30.0)]
+            public void LineTextPreservesOrientation(string orientation, TextOrientationEnum expectedMode, double? expectedAngle)
+            {
+                var tree = ParseText($"LINETEXT 220,235 HAlign=left VAlign=vcenter {orientation} Text=\"label\";");
+                Assert.False(tree.HasErrors());
+                var drawer = new Mock<IPdfDocumentDrawer>();
+
+                new PdfDrawerVisitor().Draw(drawer.Object, tree);
+
+                drawer.Verify(target => target.DrawLineText("label", 220, 235, null, null,
+                PdfHorizontalAlignment.Near, PdfVerticalAlignment.Center,
+                It.Is<TextOrientation>(value => value.Orientation == expectedMode && value.Angle == expectedAngle)), Times.Once);
+            }
+
         [Fact]
         public void DrawResolvesPageSystemVariables()
         {

From ddb67b38c73964fe03be217fcc668185edd81214 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 23:44:08 +0200
Subject: [PATCH 07/15] more pages in demo

---
 PdfSharpDslConsole/demo.ipdf | 383 ++++++++++++++++++++++++++++++++++-
 1 file changed, 382 insertions(+), 1 deletion(-)

diff --git a/PdfSharpDslConsole/demo.ipdf b/PdfSharpDslConsole/demo.ipdf
index 4db5d8b..e2180b9 100644
--- a/PdfSharpDslConsole/demo.ipdf
+++ b/PdfSharpDslConsole/demo.ipdf
@@ -135,6 +135,264 @@ RECT 20,440,-20,-55;
 SET BRUSH crimson;
 LINETEXT 30,450 Text="Negative width and height use the remaining page area";
 
+# -----------------------------------------------------------------------------
+# Page 3: concrete charts built from the drawing primitives
+# -----------------------------------------------------------------------------
+NEWPAGE A4 landscape;
+CALL SECTION("Concrete charts from drawing primitives");
+SET FONT Name="Arial" Size=9 regular;
+SET BRUSH black;
+
+# Bar chart: monthly sales in thousands.
+LINETEXT 45,82 Text="Monthly sales (kEUR)";
+SET PEN lightgray 0.5 dash;
+LINE 70,145,390,145;
+LINE 70,195,390,195;
+LINE 70,245,390,245;
+LINE 70,295,390,295;
+SET PEN darkslategray 1 solid;
+LINE 70,320,390,320;
+LINE 70,120,70,320;
+SET BRUSH steelblue;
+FILLRECT 92,235,32,85;
+FILLRECT 142,200,32,120;
+FILLRECT 192,220,32,100;
+FILLRECT 242,160,32,160;
+FILLRECT 292,180,32,140;
+FILLRECT 342,135,32,185;
+SET BRUSH black;
+LINETEXT 96,330 Text="Jan";
+LINETEXT 146,330 Text="Feb";
+LINETEXT 196,330 Text="Mar";
+LINETEXT 246,330 Text="Apr";
+LINETEXT 296,330 Text="May";
+LINETEXT 346,330 Text="Jun";
+LINETEXT 52,320 HAlign=right Text="0";
+LINETEXT 52,270 HAlign=right Text="20";
+LINETEXT 52,220 HAlign=right Text="40";
+LINETEXT 52,170 HAlign=right Text="60";
+LINETEXT 52,120 HAlign=right Text="80";
+SET FONT Name="Arial" Size=8 regular;
+SET BRUSH darkslategray;
+LINETEXT 92,225 Text="34";
+LINETEXT 142,190 Text="48";
+LINETEXT 192,210 Text="40";
+LINETEXT 242,150 Text="64";
+LINETEXT 292,170 Text="56";
+LINETEXT 342,125 Text="74";
+
+# Line chart: support response time, lower is better.
+SET FONT Name="Arial" Size=9 regular;
+SET BRUSH black;
+LINETEXT 440,82 Text="Average response time (ms)";
+SET PEN lightgray 0.5 dash;
+LINE 470,145,755,145;
+LINE 470,195,755,195;
+LINE 470,245,755,245;
+LINE 470,295,755,295;
+SET PEN darkslategray 1 solid;
+LINE 470,320,755,320;
+LINE 470,120,470,320;
+SET PEN tomato 2 solid;
+LINE 490,170,540,210;
+LINE 540,210,590,185;
+LINE 590,185,640,250;
+LINE 640,250,690,230;
+LINE 690,230,740,285;
+SET BRUSH tomato;
+FILLELLIPSE 485,165,10,10;
+FILLELLIPSE 535,205,10,10;
+FILLELLIPSE 585,180,10,10;
+FILLELLIPSE 635,245,10,10;
+FILLELLIPSE 685,225,10,10;
+FILLELLIPSE 735,280,10,10;
+SET BRUSH black;
+LINETEXT 485,330 Text="Jan";
+LINETEXT 535,330 Text="Feb";
+LINETEXT 585,330 Text="Mar";
+LINETEXT 635,330 Text="Apr";
+LINETEXT 685,330 Text="May";
+LINETEXT 735,330 Text="Jun";
+LINETEXT 452,320 HAlign=right Text="0";
+LINETEXT 452,270 HAlign=right Text="100";
+LINETEXT 452,220 HAlign=right Text="200";
+LINETEXT 452,170 HAlign=right Text="300";
+LINETEXT 452,120 HAlign=right Text="400";
+SET FONT Name="Arial" Size=8 regular;
+SET BRUSH tomato;
+LINETEXT 480,155 Text="300";
+LINETEXT 530,195 Text="220";
+LINETEXT 580,170 Text="270";
+LINETEXT 630,235 Text="140";
+LINETEXT 680,215 Text="180";
+LINETEXT 730,270 Text="70";
+
+# Additional series demonstrate the available dash styles.
+SET PEN steelblue 1.5 dash;
+LINE 490,190,540,160;
+LINE 540,160,590,220;
+LINE 590,220,640,205;
+LINE 640,205,690,260;
+LINE 690,260,740,240;
+SET PEN darkgreen 1.5 dot;
+LINE 490,230,540,250;
+LINE 540,250,590,235;
+LINE 590,235,640,270;
+LINE 640,270,690,255;
+LINE 690,255,740,295;
+SET PEN purple 1.5 dashdot;
+LINE 490,150,540,180;
+LINE 540,180,590,165;
+LINE 590,165,640,195;
+LINE 640,195,690,175;
+LINE 690,175,740,215;
+SET BRUSH black;
+LINETEXT 470,355 Text="API p95";
+LINETEXT 555,355 Text="API p50";
+LINETEXT 640,355 Text="Cache";
+SET PEN tomato 3 solid;
+LINE 515,352,535,352;
+SET PEN steelblue 3 dash;
+LINE 600,352,620,352;
+SET PEN darkgreen 3 dot;
+LINE 680,352,700,352;
+SET PEN purple 3 dashdot;
+LINE 750,352,770,352;
+LINETEXT 775,355 Text="DB";
+
+# Pie chart: traffic sources, using filled sectors.
+SET PEN black 1;
+SET FONT Name="Arial" Size=9 regular;
+SET BRUSH black;
+LINETEXT 45,390 Text="Traffic sources";
+SET BRUSH steelblue;
+FILLPIE 130,410,130,130 Start=0 Angle=180;
+SET BRUSH lightgreen;
+FILLPIE 130,410,130,130 Start=180 Angle=108;
+SET BRUSH gold;
+FILLPIE 130,410,130,130 Start=288 Angle=72;
+SET BRUSH black;
+LINETEXT 285,435 Text="Direct 50%";
+LINETEXT 285,465 Text="Search 30%";
+LINETEXT 285,495 Text="Referral 20%";
+SET PEN steelblue 8 solid;
+LINE 270,430,280,430;
+SET PEN lightgreen 8 solid;
+LINE 270,460,280,460;
+SET PEN gold 8 solid;
+LINE 270,490,280,490;
+
+# -----------------------------------------------------------------------------
+# Page 4: a compact business report combining metrics, chart and table
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Monthly business report");
+SET VAR REVENUE=1284;
+SET VAR ORDERS=342;
+SET VAR SATISFACTION=94;
+SET FONT Name="Arial" Size=9 regular;
+SET BRUSH black;
+
+# KPI cards.
+SET BRUSH 0xffe8f1fb;
+FILLRECT 45,85,155,68;
+SET BRUSH 0xffe8f7ee;
+FILLRECT 220,85,155,68;
+SET BRUSH 0xfffff3d6;
+FILLRECT 395,85,155,68;
+SET FONT Name="Arial" Size=9 bold;
+SET BRUSH darkslategray;
+LINETEXT 60,101 Text="REVENUE";
+LINETEXT 235,101 Text="ORDERS";
+LINETEXT 410,101 Text="CUSTOMER SATISFACTION";
+SET FONT Name="Arial" Size=20 bold;
+SET BRUSH darkblue;
+LINETEXT 60,118 Text=($REVENUE+" kEUR");
+SET BRUSH darkgreen;
+LINETEXT 235,118 Text=$ORDERS;
+SET BRUSH orange;
+LINETEXT 410,118 Text=($SATISFACTION+"%");
+
+# Revenue trend.
+SET FONT Name="Arial" Size=11 bold;
+SET BRUSH black;
+LINETEXT 45,190 Text="Revenue trend (kEUR)";
+SET PEN lightgray 0.5 dash;
+LINE 70,250,525,250;
+LINE 70,300,525,300;
+LINE 70,350,525,350;
+LINE 70,400,525,400;
+SET PEN darkslategray 1 solid;
+LINE 70,425,525,425;
+LINE 70,225,70,425;
+SET PEN steelblue 2.5 solid;
+LINE 90,375,160,340;
+LINE 160,340,230,355;
+LINE 230,355,300,305;
+LINE 300,305,370,285;
+LINE 370,285,440,250;
+LINE 440,250,510,235;
+SET BRUSH steelblue;
+FILLELLIPSE 85,370,10,10;
+FILLELLIPSE 155,335,10,10;
+FILLELLIPSE 225,350,10,10;
+FILLELLIPSE 295,300,10,10;
+FILLELLIPSE 365,280,10,10;
+FILLELLIPSE 435,245,10,10;
+FILLELLIPSE 505,230,10,10;
+SET FONT Name="Arial" Size=8 regular;
+SET BRUSH black;
+LINETEXT 82,440 Text="Jan";
+LINETEXT 152,440 Text="Feb";
+LINETEXT 222,440 Text="Mar";
+LINETEXT 292,440 Text="Apr";
+LINETEXT 362,440 Text="May";
+LINETEXT 432,440 Text="Jun";
+LINETEXT 52,425 HAlign=right Text="0";
+LINETEXT 52,375 HAlign=right Text="250";
+LINETEXT 52,325 HAlign=right Text="500";
+LINETEXT 52,275 HAlign=right Text="750";
+LINETEXT 52,225 HAlign=right Text="1000";
+
+# Summary table.
+SET FONT Name="Arial" Size=11 bold;
+SET BRUSH black;
+LINETEXT 45,490 Text="Channel summary";
+SET PEN steelblue 1;
+SET BRUSH 0xffdce8f5;
+FILLRECT 45,510,505,30;
+SET BRUSH black;
+LINETEXT 58,520 Text="Channel";
+LINETEXT 230,520 Text="Revenue";
+LINETEXT 335,520 Text="Target";
+LINETEXT 440,520 Text="Variance";
+SET BRUSH white;
+FILLRECT 45,540,505,30;
+FILLRECT 45,600,505,30;
+SET BRUSH black;
+LINETEXT 58,550 Text="Online";
+LINETEXT 230,550 Text="620 kEUR";
+LINETEXT 335,550 Text="580 kEUR";
+LINETEXT 440,550 Text="+40";
+LINETEXT 58,580 Text="Retail";
+LINETEXT 230,580 Text="410 kEUR";
+LINETEXT 335,580 Text="450 kEUR";
+LINETEXT 440,580 Text="-40";
+LINETEXT 58,610 Text="Partners";
+LINETEXT 230,610 Text="254 kEUR";
+LINETEXT 335,610 Text="220 kEUR";
+LINETEXT 440,610 Text="+34";
+SET PEN lightgray 0.5;
+LINE 45,540,550,540;
+LINE 45,570,550,570;
+LINE 45,600,550,600;
+LINE 45,630,550,630;
+LINE 215,510,215,630;
+LINE 320,510,320,630;
+LINE 425,510,425,630;
+SET BRUSH darkgreen;
+LINETEXT 45,675 Text="Positive variance indicates performance above target.";
+
 # -----------------------------------------------------------------------------
 # Text, alignment, orientation, highlighting and every font style
 # -----------------------------------------------------------------------------
@@ -287,18 +545,26 @@ NEWPAGE A4 landscape;
 CALL SECTION("Images from files and embedded data");
 SET FONT Name="Consolas" Size=9 regular;
 SET BRUSH black;
+# Images use 96 DPI: one pixel is 72/96 points.
+SET VAR PIXEL_TO_POINT=72/96;
 LINETEXT 45,82 Text="Natural size from Source";
 IMAGE 45,105 Source="./imageTest.jpg";
 
+SET PEN lightgray 1;
+RECT 45,105,200*$PIXEL_TO_POINT,200*$PIXEL_TO_POINT;
+
 LINETEXT 300,82 Text="Point rectangle, fit";
 IMAGE 300,105,180,120 point fit Source="./imageTest.jpg";
+RECT 300,105,180,120;
 
 LINETEXT 520,82 Text="Pixel rectangle, crop";
 IMAGE 520,105,180,120 pixel crop Source="./imageTest.jpg";
+RECT 520,105,180*$PIXEL_TO_POINT,120*$PIXEL_TO_POINT;
 
 LINETEXT 45,330 Text="Embedded one-pixel PNG using Data";
 IMAGE 45,355,160,100 point fit Data="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
 
+
 # -----------------------------------------------------------------------------
 # Host formula functions and custom bundled fonts
 # -----------------------------------------------------------------------------
@@ -342,4 +608,119 @@ SET FONT Name="Consolas" Size=3 regular;
 LINE 50,0,50,140;
 LINE 0,70,100,70;
 RECT 2,2,96,136;
-LINETEXT 50,70 HAlign=hcenter VAlign=vcenter Text="VIEWSIZE 100 x 140";
\ No newline at end of file
+LINETEXT 50,70 HAlign=hcenter VAlign=vcenter Text="VIEWSIZE 100 x 140";
+
+# -----------------------------------------------------------------------------
+# Page 13: advanced typography and annotations
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Advanced typography and annotations");
+SET FONT Name="Arial" Size=12 regular;
+SET BRUSH black;
+LINETEXT 45,90 Text="Text can be aligned, rotated, highlighted and wrapped.";
+SET PEN lightgray 0.7 solid;
+RECT 45,125,505,105;
+SET HBRUSH 0x60fff176;
+SET FONT Name="Arial" Size=11 bold;
+LINETEXT 60,140,215,70 HAlign=left VAlign=vcenter Text="Left aligned\r\nwith highlight";
+SET HBRUSH 0x00000000;
+SET FONT Name="Arial" Size=11 italic;
+LINETEXT 275,140,215,70 HAlign=hcenter VAlign=vcenter Text="Centered\r\nitalic text";
+SET FONT Name="Arial" Size=10 regular;
+LINETEXT 60,270,490,70 Text="A bounded text area wraps automatically. This is useful for paragraphs, notes, explanations and generated report content without manually calculating every line.";
+SET FONT Name="Arial" Size=10 underline;
+LINETEXT 60,390 Text="Underline annotation";
+SET FONT Name="Arial" Size=10 strikeout;
+LINETEXT 230,390 Text="Strikeout annotation";
+SET FONT Name="Arial" Size=10 regular;
+LINETEXT 100,500 Orientation=30 Text="30 degrees";
+LINETEXT 300,500 Orientation=vertical Text="Vertical label";
+SET BRUSH 0xffe8eef7;
+FILLRECT 45,570,505,95;
+SET BRUSH darkblue;
+SET FONT Name="Arial" Size=11 bold;
+LINETEXT 65,590 Text="Annotation block";
+SET FONT Name="Arial" Size=10 regular;
+SET BRUSH black;
+TEXT 65,615,465,35 Text="Use TEXT for a bounded paragraph and LINETEXT for precise alignment.";
+
+# -----------------------------------------------------------------------------
+# Page 14: shapes, transparency and visual composition
+# -----------------------------------------------------------------------------
+NEWPAGE A4 landscape;
+CALL SECTION("Shapes, transparency and composition");
+SET FONT Name="Arial" Size=10 regular;
+SET BRUSH black;
+LINETEXT 45,85 Text="Layered shapes can create panels, badges and visual emphasis.";
+SET PEN steelblue 1.5 solid;
+SET BRUSH 0x405f9ed1;
+FILLRECT 60,120,260,180;
+SET BRUSH 0x5094d36b;
+FILLRECT 180,180,260,180;
+SET BRUSH 0x50f5b642;
+FILLRECT 300,120,260,180;
+SET BRUSH black;
+LINETEXT 110,205 Text="panel A";
+LINETEXT 230,265 Text="panel B";
+LINETEXT 430,205 Text="panel C";
+SET PEN darkslategray 2 solid;
+SET BRUSH 0x80ffffff;
+FILLPOLYGON 610,130,700,110,770,180,735,280,640,300,585,220;
+SET BRUSH black;
+LINETEXT 625,205 Text="polygon";
+SET PEN purple 3 dashdot;
+SET BRUSH 0x60ff7f50;
+FILLPIE 90,390,130,130 Start=20 Angle=220;
+SET BRUSH 0x6050c878;
+FILLPIE 270,390,130,130 Start=140 Angle=220;
+SET BRUSH 0x60f5b642;
+FILLPIE 450,390,130,130 Start=260 Angle=220;
+SET BRUSH black;
+LINETEXT 95,535 Text="transparency";
+LINETEXT 275,535 Text="overlapping arcs";
+LINETEXT 455,535 Text="alpha colors";
+
+# -----------------------------------------------------------------------------
+# Page 15: reusable layout patterns
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Reusable layout patterns");
+SET FONT Name="Arial" Size=10 regular;
+SET BRUSH black;
+SET PEN lightgray 0.8 solid;
+RECT 45,85,505,600;
+SET BRUSH 0xffe8eef7;
+FILLRECT 45,85,505,70;
+SET BRUSH darkblue;
+SET FONT Name="Arial" Size=16 bold;
+LINETEXT 65,105 Text="Document header";
+SET FONT Name="Arial" Size=9 regular;
+LINETEXT 65,133 Text="A reusable page frame built from rectangles, text and lines.";
+SET BRUSH 0xfff5f8fb;
+FILLRECT 65,185,225,150;
+FILLRECT 305,185,225,150;
+SET BRUSH black;
+SET FONT Name="Arial" Size=11 bold;
+LINETEXT 85,205 Text="Left column";
+LINETEXT 325,205 Text="Right column";
+SET FONT Name="Arial" Size=10 regular;
+LINETEXT 85,240 Text="Use columns for summaries";
+LINETEXT 85,265 Text="and explanatory notes.";
+LINETEXT 325,240 Text="Keep repeated content";
+LINETEXT 325,265 Text="inside a UDF component.";
+SET PEN steelblue 1 solid;
+LINE 65,365,530,365;
+SET BRUSH black;
+SET FONT Name="Arial" Size=12 bold;
+LINETEXT 65,390 Text="Content section";
+SET FONT Name="Arial" Size=10 regular;
+TEXT 65,425,465,90 MaxWidth=465 Text="A page can combine a fixed frame, reusable UDFs, measured row templates and automatic pagination. This pattern is suitable for invoices, reports and generated documentation.";
+SET PEN steelblue 0.8 solid;
+LINE 45,715,550,715;
+SET BRUSH 0xffe8f7ee;
+FILLRECT 65,730,465,55;
+SET BRUSH darkgreen;
+SET FONT Name="Arial" Size=11 bold;
+LINETEXT 85,740 Text="Footer status";
+SET FONT Name="Arial" Size=10 regular;
+LINETEXT 85,765 Text="Generated successfully | ready for review";
\ No newline at end of file

From 0425fded48e9345ccb72a3798e2e214c1c76421d Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Fri, 18 Sep 2026 23:44:28 +0200
Subject: [PATCH 08/15] fix scaling with pen and font

---
 PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs | 28 ++++++++++++++------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
index 0035bf7..fa477ab 100644
--- a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
+++ b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
@@ -125,7 +125,7 @@ private DocumentComposer CreateDocument()
         public void DrawLine(double x, double y, double x1, double y1)
         {
             var page = CurrentPage;
-            InternalDrawLine(CurrentPen, ScaleX(ResolveX(x, page), page), ScaleY(ResolveY(y, page), page),
+            InternalDrawLine(ScalePen(CurrentPen, page), ScaleX(ResolveX(x, page), page), ScaleY(ResolveY(y, page), page),
                 ScaleX(ResolveX(x1, page), page), ScaleY(ResolveY(y1, page), page));
         }
 
@@ -158,7 +158,7 @@ public void DrawRect(double x, double y, double w, double h, bool isFilled)
         {
             var page = CurrentPage;
             (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
-            InternalDrawRect(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w, page), ScaleY(h, page), isFilled);
+            InternalDrawRect(ScalePen(CurrentPen, page), CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w, page), ScaleY(h, page), isFilled);
         }
 
         private void InternalDrawRect(PdfPen pen, PdfBrush brush, double x, double y, double w, double h, bool isFilled)
@@ -177,7 +177,7 @@ public void DrawEllipse(double x, double y, double w, double h, bool isFilled)
         {
             var page = CurrentPage;
             (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
-            InternalDrawEllipse(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w, page), ScaleY(h, page), isFilled);
+            InternalDrawEllipse(ScalePen(CurrentPen, page), CurrentBrush, ScaleX(x, page), ScaleY(y, page), ScaleX(w, page), ScaleY(h, page), isFilled);
         }
 
         private void InternalDrawEllipse(PdfPen pen, PdfBrush brush, double x, double y, double w, double h, bool isFilled)
@@ -198,7 +198,7 @@ public void DrawText(string text, double x, double y, double? w, double? h)
             (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
             InternalDrawText(text, ScaleX(x, page), ScaleY(y, page), w.HasValue ? ScaleX(w.Value, page) : page.Width - x,
                 h.HasValue ? ScaleY(h.Value, page) : null, PdfHorizontalAlignment.Near, PdfVerticalAlignment.Near,
-                CurrentFont, CurrentBrush, null);
+                ScaleFont(CurrentFont, page), CurrentBrush, null);
         }
 
         public void DrawLineText(string text, double x, double y, double? w, double? h, PdfHorizontalAlignment hAlign,
@@ -207,7 +207,7 @@ public void DrawLineText(string text, double x, double y, double? w, double? h,
             var page = CurrentPage;
             (x, y, w, h) = DrawingHelper.CoordRectToPage(page.Width, page.Height, x, y, w, h);
             InternalDrawText(text, ScaleX(x, page), ScaleY(y, page), w.HasValue ? ScaleX(w.Value, page) : null,
-                h.HasValue ? ScaleY(h.Value, page) : null, hAlign, vAlign, CurrentFont, CurrentBrush, HighlightBrush,
+                h.HasValue ? ScaleY(h.Value, page) : null, hAlign, vAlign, ScaleFont(CurrentFont, page), CurrentBrush, HighlightBrush,
                 textOrientation?.Angle ?? textOrientation?.Orientation switch
                 {
                     TextOrientationEnum.Vertical => 90,
@@ -367,7 +367,7 @@ public void LineTo(double x, double y)
         {
             var page = CurrentPage;
             var endPoint = new PdfPoint(x, y);
-            InternalDrawLine(CurrentPen, ScaleX(_currentPoint.X, page), ScaleY(_currentPoint.Y, page),
+            InternalDrawLine(ScalePen(CurrentPen, page), ScaleX(_currentPoint.X, page), ScaleY(_currentPoint.Y, page),
                 ScaleX(endPoint.X, page), ScaleY(endPoint.Y, page));
             _currentPoint = endPoint;
         }
@@ -398,7 +398,7 @@ public void DrawPie(double x, double y, double? w, double? h, double startAngle,
             var height = h ?? 0;
             if (width <= 0 || height <= 0)
                 throw new ArgumentOutOfRangeException(nameof(w), "Pie dimensions must be positive.");
-            InternalDrawPie(CurrentPen, CurrentBrush, ScaleX(x, page), ScaleY(y, page),
+            InternalDrawPie(ScalePen(CurrentPen, page), CurrentBrush, ScaleX(x, page), ScaleY(y, page),
                 ScaleX(width, page), ScaleY(height, page), startAngle, sweepAngle, isFilled);
         }
 
@@ -423,7 +423,7 @@ public void DrawPolygon(IEnumerable<PdfPoint> points, bool isFilled)
             var page = CurrentPage;
             var transformed = points.Select(point => new PdfPoint(ScaleX(point.X, page), ScaleY(point.Y, page))).ToArray();
             if (transformed.Length < 3) throw new ArgumentException("A polygon requires at least three points.", nameof(points));
-            InternalDrawPolygon(CurrentPen, CurrentBrush, transformed, isFilled);
+            InternalDrawPolygon(ScalePen(CurrentPen, page), CurrentBrush, transformed, isFilled);
         }
 
         private void InternalDrawPolygon(PdfPen pen, PdfBrush brush, PdfPoint[] points, bool isFilled)
@@ -506,6 +506,18 @@ private static List<string> WrapText(string text, double? maxWidth, PdfFont font
         private static double ScaleX(double value, RecordedPage page) => value * page.ScaleX;
         private static double ScaleY(double value, RecordedPage page) => value * page.ScaleY;
 
+        private static PdfPen ScalePen(PdfPen pen, RecordedPage page)
+        {
+            var scaled = new PdfPen(pen.Color, pen.Width * ScaleFactor(page)) { DashStyle = pen.DashStyle };
+            return scaled;
+        }
+
+        private static PdfFont ScaleFont(PdfFont font, RecordedPage page) =>
+            new(font.FamilyName, font.Size * ScaleFactor(page), font.Style);
+
+        private static double ScaleFactor(RecordedPage page) =>
+            Math.Sqrt(page.ScaleX * page.ScaleY);
+
         private static (double Width, double Height) GetPageDimensions(PdfPageSize size, PdfPageOrientation orientation)
         {
             var dimensions = size switch

From eecc4306c85531e6816f71b31e44f380157a965c Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Sat, 19 Sep 2026 07:00:24 +0200
Subject: [PATCH 09/15] add merged cells feature

---
 PdfSharpDsl.Language/Parser/PdfGrammar.cs    |  6 +-
 PdfSharpDslConsole/demo.ipdf                 | 43 +++++++++
 PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs | 97 ++++++++++++++++++--
 PdfSharpDslCore/Drawing/TableDefinition.cs   | 11 +++
 PdfSharpDslCore/Parser/PdfDrawerVisitor.cs   | 40 ++++++--
 pdfsharpdslTests/VisitorTests.cs             | 31 +++++++
 6 files changed, 209 insertions(+), 19 deletions(-)

diff --git a/PdfSharpDsl.Language/Parser/PdfGrammar.cs b/PdfSharpDsl.Language/Parser/PdfGrammar.cs
index 7c15cb8..4ee099f 100644
--- a/PdfSharpDsl.Language/Parser/PdfGrammar.cs
+++ b/PdfSharpDsl.Language/Parser/PdfGrammar.cs
@@ -112,6 +112,8 @@ public PdfGrammar()
             var TableRowListOrRowTemplate = new NonTerminal("TableRowListOrRowTemplate");
             var TableRowTemplate = new NonTerminal("TableRowTemplate");
             var TableRowTemplateCount = new NonTerminal("TableRowTemplateCount");
+            var TableCellColSpan = new NonTerminal("TableCellColSpan");
+            var TableCellRowSpan = new NonTerminal("TableCellRowSpan");
 
             var PointAutoLocation = new NonTerminal("PointAutoLocation");
             var NumberOrAuto = new NonTerminal("NumberOrAuto");
@@ -332,7 +334,9 @@ public PdfGrammar()
             TableColWidth.Rule = Arg("Width") + NumberOrAuto + Arg("MaxWidth") + NumberOrAuto;
             TableColList.Rule = MakeStarRule(TableColList, TableCol);
             TableRow.Rule = ToTerm("ROW") + TableRowStyle + TableColList + ToTerm("ENDROW");
-            TableCol.Rule = ToTerm("COL") + FormulaExpression + semi;
+            TableCellColSpan.Rule = Empty | Arg("ColSpan") + number_literal;
+            TableCellRowSpan.Rule = Empty | Arg("RowSpan") + number_literal;
+            TableCol.Rule = ToTerm("COL") + TableCellColSpan + TableCellRowSpan + TextAlignment + FormulaExpression + semi;
             TableLocation.Rule = PointLocation /*+ "," + PointAutoLocation*/;
             PointAutoLocation.Rule = NumberOrAuto + "," + NumberOrAuto;
             NumberOrAuto.Rule = FormulaExpression | "auto";
diff --git a/PdfSharpDslConsole/demo.ipdf b/PdfSharpDslConsole/demo.ipdf
index e2180b9..09c06e9 100644
--- a/PdfSharpDslConsole/demo.ipdf
+++ b/PdfSharpDslConsole/demo.ipdf
@@ -507,6 +507,49 @@ COL "Global item "+($ROWINDEX+1);
 ENDROW
 ENDTABLE
 
+# -----------------------------------------------------------------------------
+# Merged table cells, per-cell alignment and multiline content
+# -----------------------------------------------------------------------------
+NEWPAGE A4 portrait;
+CALL SECTION("Merged cells and cell alignment");
+SET FONT Name="Arial" Size=9 regular;
+SET PEN darkslategray 1 solid;
+
+TABLE 45,90
+HEAD 0xffc8d9ed
+COL Width=125 MaxWidth=125 FONT="Arial",9,bold darkblue 0xffe8f1fb "Team";
+COL Width=125 MaxWidth=125 FONT="Arial",9,bold darkgreen 0xffe8f7ee "Q1";
+COL Width=125 MaxWidth=125 FONT="Arial",9,bold darkslategray 0xfffff3d6 "Q2";
+COL Width=125 MaxWidth=125 FONT="Arial",9,bold maroon 0xffffe4e1 "Status";
+ENDHEAD
+ROW 54
+COL RowSpan=2 HAlign=hcenter VAlign=vcenter "Platform";
+COL ColSpan=2 HAlign=hcenter VAlign=vcenter "First-half delivery";
+COL RowSpan=2 HAlign=hcenter VAlign=vcenter "On track";
+ENDROW
+ROW 34
+COL HAlign=right VAlign=vcenter "Q1: 128";
+COL HAlign=right VAlign=vcenter "Q2: 146";
+ENDROW
+ROW 48
+COL ColSpan=4 HAlign=hcenter VAlign=vcenter "One cell spans the complete table width";
+ENDROW
+ROW 64
+COL HAlign=left VAlign=top "left / top";
+COL HAlign=hcenter VAlign=vcenter "center / center";
+COL HAlign=right VAlign=bottom "right / bottom";
+COL HAlign=hcenter VAlign=vcenter "Multiline\r\ncentered";
+ENDROW
+ROW 44
+COL ColSpan=2 HAlign=left VAlign=vcenter "Two-column summary";
+COL ColSpan=2 HAlign=right VAlign=vcenter "Formula span: "+(1+1);
+ENDROW
+ENDTABLE
+
+SET BRUSH darkslategray;
+LINETEXT 45,400 Text="ColSpan and RowSpan reserve covered cells; no placeholder COL is required.";
+LINETEXT 45,425 Text="HAlign accepts left, hcenter or right; VAlign accepts top, vcenter or bottom.";
+
 # -----------------------------------------------------------------------------
 # Free row templates: nesting, names, borders, pagination and measured height
 # -----------------------------------------------------------------------------
diff --git a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
index fa477ab..a8c3527 100644
--- a/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
+++ b/PdfSharpDslCore/Drawing/PdfDocumentDrawer.cs
@@ -276,12 +276,14 @@ public void DrawTable(double x, double y, TableDefinition table)
             var availableWidth = PageWidth - x;
             var fonts = table.Columns.Select(column => column.Font ?? CurrentFont).ToArray();
             var margins = table.CellMargin;
+            var cells = LayoutTableCells(table);
 
             for (var index = 0; index < table.Columns.Count; index++)
             {
                 var column = table.Columns[index];
-                var contentWidth = table.Rows
-                    .Select(row => MeasureCellWidth(index < row.Data.Length ? row.Data[index] : string.Empty, fonts[index]))
+                var contentWidth = cells
+                    .Where(cell => cell.Column == index && cell.Cell.ColumnSpan == 1)
+                    .Select(cell => MeasureCellWidth(cell.Cell.Text, fonts[index]))
                     .DefaultIfEmpty(0)
                     .Max();
                 var desiredWidth = Math.Max(MeasureCellWidth(column.ColumnHeaderName, fonts[index]), contentWidth)
@@ -291,15 +293,32 @@ public void DrawTable(double x, double y, TableDefinition table)
                 table.HeaderHeight ??= fonts[index].Size * 1.2 + margins.Top + margins.Bottom;
             }
 
-            foreach (var row in table.Rows)
+            for (var rowIndex = 0; rowIndex < table.Rows.Count; rowIndex++)
             {
-                var contentHeight = fonts.Select((font, index) =>
-                    MeasureCellLineCount(index < row.Data.Length ? row.Data[index] : string.Empty,
-                        table.Columns[index].DrawWidth - margins.Left - margins.Right, font)
-                    * font.Size * 1.2 + margins.Top + margins.Bottom).Max();
+                var row = table.Rows[rowIndex];
+                var contentHeight = cells.Where(cell => cell.Row == rowIndex && cell.Cell.RowSpan == 1)
+                    .Select(cell =>
+                    {
+                        var width = table.Columns.Skip(cell.Column).Take(cell.Cell.ColumnSpan).Sum(column => column.DrawWidth);
+                        var font = fonts[cell.Column];
+                        return MeasureCellLineCount(cell.Cell.Text, width - margins.Left - margins.Right, font)
+                               * font.Size * 1.2 + margins.Top + margins.Bottom;
+                    }).DefaultIfEmpty(fonts[0].Size * 1.2 + margins.Top + margins.Bottom).Max();
                 row.DesiredHeight ??= contentHeight;
             }
 
+            foreach (var cell in cells.Where(cell => cell.Cell.RowSpan > 1))
+            {
+                var width = table.Columns.Skip(cell.Column).Take(cell.Cell.ColumnSpan).Sum(column => column.DrawWidth);
+                var font = fonts[cell.Column];
+                var requiredHeight = MeasureCellLineCount(cell.Cell.Text, width - margins.Left - margins.Right, font)
+                                     * font.Size * 1.2 + margins.Top + margins.Bottom;
+                var rows = table.Rows.Skip(cell.Row).Take(cell.Cell.RowSpan).ToArray();
+                var missingHeight = requiredHeight - rows.Sum(row => row.DesiredHeight ?? 0);
+                if (missingHeight > 0)
+                    rows[^1].DesiredHeight = (rows[^1].DesiredHeight ?? 0) + missingHeight;
+            }
+
             if (y + (table.HeaderHeight ?? 0) > PageHeight) { NewPage(); y = 1; }
             var offsetY = 0d;
             if (table.ShowHeader)
@@ -308,15 +327,73 @@ public void DrawTable(double x, double y, TableDefinition table)
                 offsetY = table.HeaderHeight ?? 0;
             }
 
-            foreach (var row in table.Rows)
+            for (var rowIndex = 0; rowIndex < table.Rows.Count; rowIndex++)
             {
+                var row = table.Rows[rowIndex];
                 var height = row.DesiredHeight ?? 0;
-                if (y + offsetY + height > PageHeight) { NewPage(); y = table.TopMarginOnPageBreak; offsetY = 0; }
-                DrawTableRow(x, y + offsetY, row.Data, height, table, fonts, null);
+                var rowCells = cells.Where(cell => cell.Row == rowIndex).ToArray();
+                var requiredHeight = rowCells.Select(cell => table.Rows.Skip(rowIndex).Take(cell.Cell.RowSpan)
+                    .Sum(spannedRow => spannedRow.DesiredHeight ?? 0)).DefaultIfEmpty(height).Max();
+                if (y + offsetY + requiredHeight > PageHeight) { NewPage(); y = table.TopMarginOnPageBreak; offsetY = 0; }
+                foreach (var cell in rowCells)
+                    DrawTableCell(x, y + offsetY, cell, table, fonts);
                 offsetY += height;
             }
         }
 
+        private static List<TableCellPlacement> LayoutTableCells(TableDefinition table)
+        {
+            var result = new List<TableCellPlacement>();
+            var occupiedUntilRow = new int[table.Columns.Count];
+            for (var rowIndex = 0; rowIndex < table.Rows.Count; rowIndex++)
+            {
+                var row = table.Rows[rowIndex];
+                var cells = row.Cells.Count > 0
+                    ? row.Cells
+                    : row.Data.Select(text => new CellDefinition { Text = text }).ToList();
+                var columnIndex = 0;
+                foreach (var cell in cells)
+                {
+                    while (columnIndex < table.Columns.Count && occupiedUntilRow[columnIndex] > rowIndex)
+                        columnIndex++;
+                    if (columnIndex >= table.Columns.Count) break;
+
+                    cell.ColumnSpan = Math.Min(Math.Max(1, cell.ColumnSpan), table.Columns.Count - columnIndex);
+                    cell.RowSpan = Math.Min(Math.Max(1, cell.RowSpan), table.Rows.Count - rowIndex);
+                    result.Add(new TableCellPlacement(rowIndex, columnIndex, cell));
+                    for (var index = columnIndex; index < columnIndex + cell.ColumnSpan; index++)
+                        occupiedUntilRow[index] = rowIndex + cell.RowSpan;
+                    columnIndex += cell.ColumnSpan;
+                }
+            }
+            return result;
+        }
+
+        private void DrawTableCell(double x, double y, TableCellPlacement placement, TableDefinition table, PdfFont[] fonts)
+        {
+            var column = table.Columns[placement.Column];
+            var offsetX = table.Columns.Take(placement.Column).Sum(item => item.DrawWidth);
+            var width = table.Columns.Skip(placement.Column).Take(placement.Cell.ColumnSpan).Sum(item => item.DrawWidth);
+            var height = table.Rows.Skip(placement.Row).Take(placement.Cell.RowSpan).Sum(row => row.DesiredHeight ?? 0);
+            if (column.BackColor is not null)
+            {
+                var previousBrush = CurrentBrush;
+                CurrentBrush = column.BackColor;
+                DrawRect(x + offsetX, y, width, height, true);
+                CurrentBrush = previousBrush;
+            }
+            else DrawRect(x + offsetX, y, width, height, false);
+
+            var margins = table.CellMargin;
+            InternalDrawText(placement.Cell.Text, x + offsetX + margins.Left, y + margins.Top,
+                Math.Max(0, width - margins.Left - margins.Right), Math.Max(0, height - margins.Top - margins.Bottom),
+                placement.Cell.HorizontalAlignment ?? column.Alignment,
+                placement.Cell.VerticalAlignment ?? PdfVerticalAlignment.Center,
+                fonts[placement.Column], column.Brush ?? CurrentBrush, null);
+        }
+
+        private sealed record TableCellPlacement(int Row, int Column, CellDefinition Cell);
+
         private void DrawTableRow(double x, double y, string[] values, double height, TableDefinition table, PdfFont[] fonts, PdfBrush? rowBackground)
         {
             var offsetX = 0d;
diff --git a/PdfSharpDslCore/Drawing/TableDefinition.cs b/PdfSharpDslCore/Drawing/TableDefinition.cs
index 9a6c65c..e99609c 100644
--- a/PdfSharpDslCore/Drawing/TableDefinition.cs
+++ b/PdfSharpDslCore/Drawing/TableDefinition.cs
@@ -71,9 +71,20 @@ public class RowDefinition
         public double? DesiredHeight { get; set; }
         public double? MaxHeight { get; set; }
 
+        public List<CellDefinition> Cells { get; set; } = new();
+
         /// <summary>
         /// string because there is only draw text
         /// </summary>
         public string[] Data { get; set; } = Array.Empty<string>();
     }
+
+    public class CellDefinition
+    {
+        public string Text { get; set; } = string.Empty;
+        public int ColumnSpan { get; set; } = 1;
+        public int RowSpan { get; set; } = 1;
+        public PdfHorizontalAlignment? HorizontalAlignment { get; set; }
+        public PdfVerticalAlignment? VerticalAlignment { get; set; }
+    }
 }
\ No newline at end of file
diff --git a/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs b/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
index 71f5461..12ce808 100644
--- a/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
+++ b/PdfSharpDslCore/Parser/PdfDrawerVisitor.cs
@@ -562,11 +562,10 @@ private void GenerateTableRowsTemplate(IEnumerable<ParseTreeNode> nodes, TableDe
                     for (var i = 0; i < rowCount; i++)
                     {
                         var rowDef = new RowDefinition();
-                        var cols = row.ChildNodes("TableCol").SelectMany(x => x.ChildNodes)
-                            .Where(x => x.Term?.Name != "COL").ToArray();
 
                         vars.Add("ROWINDEX", i);
-                        var rowData = cols.Select(x => EvaluateForObject(x)?.ToString()!).ToList();
+                        rowDef.Cells = row.ChildNodes("TableCol").Select(ParseTableCell).ToList();
+                        var rowData = rowDef.Cells.Select(cell => cell.Text).ToList();
 
                         while (rowData.Count < tbl.Columns.Count)
                         {
@@ -598,11 +597,8 @@ private void GenerateTableRows(IEnumerable<ParseTreeNode> nodes, TableDefinition
                     rowDef.DesiredHeight = rowHeight;
                 }
 
-                var cols = row.ChildNodes("TableCol").SelectMany(x => x.ChildNodes).Where(x => x.Term?.Name != "COL")
-                    .ToArray();
-
-
-                var rowData = cols.Select(x => x.Token.ValueString).ToList();
+                rowDef.Cells = row.ChildNodes("TableCol").Select(ParseTableCell).ToList();
+                var rowData = rowDef.Cells.Select(cell => cell.Text).ToList();
                 while (rowData.Count < tbl.Columns.Count)
                 {
                     rowData.Add(string.Empty);
@@ -613,6 +609,34 @@ private void GenerateTableRows(IEnumerable<ParseTreeNode> nodes, TableDefinition
             }
         }
 
+        private CellDefinition ParseTableCell(ParseTreeNode node)
+        {
+            var expression = node.ChildNodes.Last();
+            var cell = new CellDefinition
+            {
+                Text = EvaluateForObject(expression)?.ToString() ?? string.Empty,
+                ColumnSpan = ParseTableCellSpan(node.ChildNode("TableCellColSpan")),
+                RowSpan = ParseTableCellSpan(node.ChildNode("TableCellRowSpan"))
+            };
+            var alignment = node.ChildNode("TextAlignment");
+            if (alignment is not null)
+            {
+                var hNode = alignment.ChildNode("HAlign");
+                var vNode = alignment.ChildNode("VAlign");
+                if (hNode?.ChildNodes.Count > 0)
+                    cell.HorizontalAlignment = ParseTextAlignment(hNode, null).Item1;
+                if (vNode?.ChildNodes.Count > 0)
+                    cell.VerticalAlignment = ParseTextAlignment(null, vNode).Item2;
+            }
+            return cell;
+        }
+
+        private int ParseTableCellSpan(ParseTreeNode? node)
+        {
+            if (node is null || node.ChildNodes.Count == 0) return 1;
+            return Math.Max(1, Convert.ToInt32(EvaluateForDouble(node.ChildNodes.Last())));
+        }
+
         private void GenerateTableHead(IEnumerable<ParseTreeNode> nodes, TableDefinition tbl)
         {
             foreach (var col in nodes)
diff --git a/pdfsharpdslTests/VisitorTests.cs b/pdfsharpdslTests/VisitorTests.cs
index 2e01bb2..f61d7d0 100644
--- a/pdfsharpdslTests/VisitorTests.cs
+++ b/pdfsharpdslTests/VisitorTests.cs
@@ -210,6 +210,37 @@ public void TableRowTemplateBuildsRowsWidthsAndPadding()
             Assert.False(visitor.Vars.ContainsKey("ROWINDEX"));
         }
 
+        [Fact]
+        public void TableCellsCaptureSpansAndAlignment()
+        {
+            var tree = ParseText(
+                "TABLE 20,30 " +
+                "HEAD " +
+                "COL Width=100 MaxWidth=100 \"A\"; " +
+                "COL Width=100 MaxWidth=100 \"B\"; " +
+                "COL Width=100 MaxWidth=100 \"C\"; " +
+                "ENDHEAD " +
+                "ROW 40 " +
+                "COL ColSpan=2 RowSpan=2 HAlign=hcenter VAlign=bottom \"Merged\"; " +
+                "COL HAlign=right \"Right\"; " +
+                "ENDROW " +
+                "ROW COL \"Remaining\"; ENDROW " +
+                "ENDTABLE");
+            TableDefinition? capturedTable = null;
+            var drawer = new Mock<IPdfDocumentDrawer>();
+            drawer.Setup(x => x.DrawTable(20, 30, It.IsAny<TableDefinition>()))
+                .Callback<double, double, TableDefinition>((_, _, table) => capturedTable = table);
+
+            new InspectablePdfDrawerVisitor().Draw(drawer.Object, tree);
+
+            var mergedCell = Assert.Single(capturedTable!.Rows[0].Cells, cell => cell.Text == "Merged");
+            Assert.Equal(2, mergedCell.ColumnSpan);
+            Assert.Equal(2, mergedCell.RowSpan);
+            Assert.Equal(PdfHorizontalAlignment.Center, mergedCell.HorizontalAlignment);
+            Assert.Equal(PdfVerticalAlignment.Far, mergedCell.VerticalAlignment);
+            Assert.Equal(PdfHorizontalAlignment.Far, capturedTable.Rows[0].Cells[1].HorizontalAlignment);
+        }
+
         [Fact]
         public void CustomUdfCanFallBackToDslBodyOrOverrideIt()
         {

From e59f2912436d2f516ecccc91a6027d7bc86aa30a Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Sat, 19 Sep 2026 07:40:22 +0200
Subject: [PATCH 10/15] allow using local version of  terrapdf + more tests

---
 PdfSharpDslConsole/PdfSharpDslConsole.csproj |   3 +
 PdfSharpDslCore/PdfSharpDslCore.csproj       |  21 +-
 bnf_and_pdf.sln                              |  44 ++++
 pdfsharpdslTests/GenerationTests.cs          |  13 ++
 tasks.md                                     | 218 -------------------
 5 files changed, 73 insertions(+), 226 deletions(-)
 delete mode 100644 tasks.md

diff --git a/PdfSharpDslConsole/PdfSharpDslConsole.csproj b/PdfSharpDslConsole/PdfSharpDslConsole.csproj
index 621402a..78e426c 100644
--- a/PdfSharpDslConsole/PdfSharpDslConsole.csproj
+++ b/PdfSharpDslConsole/PdfSharpDslConsole.csproj
@@ -57,6 +57,9 @@
     <None Update="pdfsharp-newpage.ipdf">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="demo.ipdf">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <!-- <None Update="pdfsharp.txt">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None> -->
diff --git a/PdfSharpDslCore/PdfSharpDslCore.csproj b/PdfSharpDslCore/PdfSharpDslCore.csproj
index 9619a45..30b50fd 100644
--- a/PdfSharpDslCore/PdfSharpDslCore.csproj
+++ b/PdfSharpDslCore/PdfSharpDslCore.csproj
@@ -10,6 +10,7 @@
 		<Version>2.0.0</Version>
 		<Authors>Pierrick Gourlain</Authors>
 		<Company></Company>
+		<UseLocalTerraPdf Condition="'$(UseLocalTerraPdf)' == '' and Exists('..\..\TerraPDF\src\TerraPDF\TerraPDF.csproj')">true</UseLocalTerraPdf>
 		<Description>A DSL using TerraPDF to generate PDF</Description>
 		<RepositoryUrl>https://github.com/pgourlain/bnf_and_pdf</RepositoryUrl>
 		<PackageIcon>Icon.jpg</PackageIcon>
@@ -17,20 +18,24 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <None Include="..\LICENSE.md">
-	    <Pack>True</Pack>
-	    <PackagePath>\</PackagePath>
-	  </None>
-	</ItemGroup>
-
-	<ItemGroup>
+		<None Include="..\LICENSE.md">
+			<Pack>True</Pack>
+			<PackagePath>\</PackagePath>
+		</None>
 		<PackageReference Include="Irony" Version="1.5.3" />
 		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
-		<PackageReference Include="TerraPDF" Version="2.1.0" />
+		<PackageReference Include="TerraPDF" Version="2.1.0" Condition="'$(UseLocalTerraPdf)' != 'true'" />
+	</ItemGroup>
+	<ItemGroup Condition="'$(UseLocalTerraPdf)' == 'true'">
+		<ProjectReference Include="..\..\TerraPDF\src\TerraPDF\TerraPDF.csproj" />
 	</ItemGroup>
 	<ItemGroup>
 		<ProjectReference Include="..\PdfSharpDsl.Language\PdfSharpDsl.Language.csproj" />
 	</ItemGroup>
+	<ItemGroup>
+		<Compile Remove="Extensions\ParseTreeNodeExtensions.cs" />
+		<Compile Remove="Parser\PdfGrammar.cs" />
+	</ItemGroup>
 	<ItemGroup>
 		<InternalsVisibleTo Include="pdfsharpdslTests" />
 	</ItemGroup>
diff --git a/bnf_and_pdf.sln b/bnf_and_pdf.sln
index 69817b2..6ce8b80 100644
--- a/bnf_and_pdf.sln
+++ b/bnf_and_pdf.sln
@@ -23,29 +23,73 @@ EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
 		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Debug|x64.Build.0 = Debug|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Debug|x86.Build.0 = Debug|Any CPU
 		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Release|Any CPU.Build.0 = Release|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Release|x64.ActiveCfg = Release|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Release|x64.Build.0 = Release|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Release|x86.ActiveCfg = Release|Any CPU
+		{599099A9-C23A-4EE3-A3BA-D65E95E52014}.Release|x86.Build.0 = Release|Any CPU
 		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Debug|x64.Build.0 = Debug|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Debug|x86.Build.0 = Debug|Any CPU
 		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Release|x64.ActiveCfg = Release|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Release|x64.Build.0 = Release|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Release|x86.ActiveCfg = Release|Any CPU
+		{31F6FA1A-55D5-45C1-8AB8-8ED23984BA3A}.Release|x86.Build.0 = Release|Any CPU
 		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Debug|x64.Build.0 = Debug|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Debug|x86.Build.0 = Debug|Any CPU
 		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Release|x64.ActiveCfg = Release|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Release|x64.Build.0 = Release|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Release|x86.ActiveCfg = Release|Any CPU
+		{D737D13F-8593-4AB1-961B-7D5F736ACF2E}.Release|x86.Build.0 = Release|Any CPU
 		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Debug|x64.Build.0 = Debug|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Debug|x86.Build.0 = Debug|Any CPU
 		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|x64.ActiveCfg = Release|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|x64.Build.0 = Release|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|x86.ActiveCfg = Release|Any CPU
+		{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}.Release|x86.Build.0 = Release|Any CPU
 		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|x64.Build.0 = Debug|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Debug|x86.Build.0 = Debug|Any CPU
 		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|x64.ActiveCfg = Release|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|x64.Build.0 = Release|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|x86.ActiveCfg = Release|Any CPU
+		{2373085B-7611-43B6-A4A1-F2DE608817C4}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/pdfsharpdslTests/GenerationTests.cs b/pdfsharpdslTests/GenerationTests.cs
index 4e88ef8..ec8d0c7 100644
--- a/pdfsharpdslTests/GenerationTests.cs
+++ b/pdfsharpdslTests/GenerationTests.cs
@@ -37,6 +37,19 @@ public void TestdrawingLinesOutPut(string file)
             Assert.True(pdf.ContentStreamCount > 0);
         }
 
+        [Fact]
+        public void DrawingEmbeddedImageAddsPdfImageResource()
+        {
+            const string input = "NEWPAGE A4 portrait;" +
+                "IMAGE 10,10,20,20 point fit Data=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=\";";
+
+            using var memStm = GeneratePdf(input);
+            var pdf = new PdfBinaryInspector(memStm);
+
+            Assert.True(pdf.HasPdfHeader);
+            Assert.Equal(1, pdf.ImageCount);
+        }
+
         [Theory()]
         [InlineData("pdf1-udfs.txt")]
         public void TestdrawingUdfsOutPut(string file)
diff --git a/tasks.md b/tasks.md
deleted file mode 100644
index 23f1dc6..0000000
--- a/tasks.md
+++ /dev/null
@@ -1,218 +0,0 @@
-# .NET 10 Upgrade Tasks
-
-Coverage work blocks the framework upgrade. `PdfSharpDslCore` line coverage must be at least 90%; branch coverage is reported but does not gate progress.
-
-**Current verified coverage (2026-09-18):** 90.76% lines (2260/2490), 83.56% branches (778/931), 83 tests passed.
-
-## TASK-001: Coverage baseline
-
-**Status:** Complete (2026-09-18)  
-**Depends on:** None
-
-**Objective:** Establish reproducible, core-only Cobertura reporting and record the current baseline.
-
-**Affected files:** `.runsettings`, `scripts/coverage.ps1`, `tasks.md`
-
-**Acceptance criteria:**
-
-- The test suite runs through Coverlet's collector.
-- The report contains only the `PdfSharpDslCore` assembly.
-- The script prints line and branch totals and fails when the report is missing or contains another assembly.
-- Generated reports remain under the ignored `artifacts/` directory.
-
-**Validation:**
-
-```powershell
-powershell -NoProfile -File .\scripts\coverage.ps1
-```
-
-**Result:** 45 tests passed. Line coverage is 79.63% (1983/2490); branch coverage is 73.14% (681/931). The migration remains blocked.
-
-**Handoff:** Begin TASK-002. Raise core line coverage above the current baseline without changing target frameworks or enforcing the final threshold yet.
-
-## TASK-002: Evaluation coverage
-
-**Status:** Not started  
-**Depends on:** TASK-001
-
-**Objective:** Test arithmetic, comparison, boolean, unary, null, string, and error paths; investigate the `%` parser/evaluator mismatch.
-
-**Affected files:** `pdfsharpdslTests/FormulaTests.cs`, `PdfSharpDslCore/Evaluation/`, parser tests and parser implementation if the mismatch is confirmed
-
-**Acceptance criteria:** Evaluation branches have focused tests, the `%` behavior is documented by a test and corrected if defective, and all existing tests pass.
-
-**Validation:**
-
-```powershell
-dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj --filter FullyQualifiedName~FormulaTests
-powershell -NoProfile -File .\scripts\coverage.ps1
-```
-
-**Handoff:** Record the new coverage result here and identify the largest remaining uncovered core areas for TASK-003.
-
-## TASK-003: Variables and UDFs
-
-**Status:** Not started  
-**Depends on:** TASK-002
-
-**Objective:** Cover variable lifecycle, nested scopes, system variables, UDF dispatch, failure paths, and `__ONNEWPAGE`.
-
-**Affected files:** `pdfsharpdslTests/`, `PdfSharpDslCore/` variable and UDF implementation
-
-**Acceptance criteria:** Focused tests cover successful and failing variable/UDF behavior, including nested scope and new-page callbacks.
-
-**Validation:**
-
-```powershell
-dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
-powershell -NoProfile -File .\scripts\coverage.ps1
-```
-
-**Handoff:** Record coverage and list remaining visitor or drawing gaps for TASK-004.
-
-## TASK-004: Visitor and drawing helpers
-
-**Status:** Not started  
-**Depends on:** TASK-003
-
-**Objective:** Cover visitor dispatch, page defaults, debug options, tables, images, alignment, clipping, and width calculations.
-
-**Affected files:** `pdfsharpdslTests/VisitorTests.cs`, `pdfsharpdslTests/RenderingTests.cs`, `PdfSharpDslCore/Drawing/`, visitor implementation
-
-**Acceptance criteria:** Deterministic tests cover the listed helper paths without requiring committed generated PDFs.
-
-**Validation:**
-
-```powershell
-dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
-powershell -NoProfile -File .\scripts\coverage.ps1
-```
-
-**Handoff:** Record coverage and enumerate only the gaps needed to exceed 80% in TASK-005.
-
-## TASK-005: Enforce coverage
-
-**Status:** Not started  
-**Depends on:** TASK-004
-
-**Objective:** Cover remaining pagination and PDF drawing paths, then enforce core line coverage of at least 90%.
-
-**Affected files:** Remaining core tests, `scripts/coverage.ps1`, CI workflow if present
-
-**Acceptance criteria:** `PdfSharpDslCore` line coverage is at least 90%, the script fails below 90%, and branch coverage remains informational.
-
-**Validation:**
-
-```powershell
-powershell -NoProfile -File .\scripts\coverage.ps1
-```
-
-**Handoff:** Unblock TASK-006 only after recording a passing line rate here.
-
-## TASK-006: Generator safety
-
-**Status:** Blocked by coverage  
-**Depends on:** TASK-005
-
-**Objective:** Remove the hard-coded Debug assembly path and add a real Roslyn generator compilation test.
-
-**Affected files:** `PdfSharpDslCore.Generator/`, `pdfsharpdslTests/SourceGenerator/`
-
-**Acceptance criteria:** Generator tests compile a representative input and Debug and Release builds succeed without configuration-specific paths.
-
-**Validation:**
-
-```powershell
-dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj --filter FullyQualifiedName~SourceGenerator
-dotnet build .\bnf_and_pdf.sln --configuration Debug
-dotnet build .\bnf_and_pdf.sln --configuration Release
-```
-
-**Handoff:** Document generator loading assumptions before dependency upgrades.
-
-## TASK-007: Dependencies
-
-**Status:** Blocked by coverage  
-**Depends on:** TASK-006
-
-**Objective:** Upgrade test, Coverlet, Roslyn, logging, image, font, and archive packages; resolve ImageSharp advisories.
-
-**Affected files:** Project files and package lock/restore outputs where applicable
-
-**Acceptance criteria:** Restored packages have no known ImageSharp advisories, core and generator retain `netstandard2.0`, and tests and coverage remain passing.
-
-**Validation:**
-
-```powershell
-dotnet restore .\bnf_and_pdf.sln
-dotnet list .\bnf_and_pdf.sln package --vulnerable --include-transitive
-dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
-powershell -NoProfile -File .\scripts\coverage.ps1
-```
-
-**Handoff:** Record selected package versions and any .NET 10 compatibility constraints.
-
-## TASK-008: Framework migration
-
-**Status:** Blocked by coverage  
-**Depends on:** TASK-007
-
-**Objective:** Pin .NET 10, move console and tests to `net10.0`, retain reusable projects on `netstandard2.0`, and update GitHub Actions.
-
-**Affected files:** `global.json`, console/test project files, `.github/workflows/`
-
-**Acceptance criteria:** The intended SDK is selected, console and tests target `net10.0`, core and generator target `netstandard2.0`, and workflows use `actions/setup-dotnet@v4` with `10.0.x`.
-
-**Validation:**
-
-```powershell
-dotnet --version
-dotnet build .\bnf_and_pdf.sln
-dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
-powershell -NoProfile -File .\scripts\coverage.ps1
-```
-
-**Handoff:** Record SDK and target framework versions for package validation.
-
-## TASK-009: Package validation
-
-**Status:** Blocked by coverage  
-**Depends on:** TASK-008
-
-**Objective:** Validate both configurations, NuGet packages, generator loading in a clean consumer, console samples, and rendering tests.
-
-**Affected files:** Project packaging metadata, test fixtures, console samples
-
-**Acceptance criteria:** Debug and Release builds pass, both packages can be packed, a clean `net10.0` consumer loads the generator, and samples/rendering tests pass.
-
-**Validation:**
-
-```powershell
-dotnet build .\bnf_and_pdf.sln --configuration Debug
-dotnet build .\bnf_and_pdf.sln --configuration Release
-dotnet pack .\PdfSharpDslCore\PdfSharpDslCore.csproj --configuration Release
-dotnet pack .\PdfSharpDslCore.Generator\PdfSharpDslCore.Generator.csproj --configuration Release
-dotnet test .\pdfsharpdslTests\pdfsharpdslTests.csproj
-```
-
-**Handoff:** Record package paths and clean-consumer results for documentation.
-
-## TASK-010: Documentation
-
-**Status:** Blocked by coverage  
-**Depends on:** TASK-009
-
-**Objective:** Document the completed migration, framework support, and coverage workflow.
-
-**Affected files:** `README.md`, `PdfSharpDslCore/Readme.md`, `CHANGELOG.md`, `tasks.md`
-
-**Acceptance criteria:** The root README links this tracker, supported frameworks and coverage commands are accurate, and the changelog summarizes the migration.
-
-**Validation:**
-
-```powershell
-powershell -NoProfile -File .\scripts\coverage.ps1
-dotnet build .\bnf_and_pdf.sln --configuration Release
-```
-
-**Handoff:** Mark the roadmap complete only after all links, commands, and recorded versions are verified.
\ No newline at end of file

From 8d383d8d941b18276d401d32a6de29a34416b393 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Sun, 20 Sep 2026 11:34:33 +0200
Subject: [PATCH 11/15] merge main  workflow updates

---
 .github/workflows/build.yml           |  4 ++--
 .github/workflows/release-package.yml | 14 +++++++++++---
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a3ddfb3..2f3ebc3 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -15,9 +15,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v7
     - name: Setup .NET
-      uses: actions/setup-dotnet@v4
+      uses: actions/setup-dotnet@v6
       with:
         dotnet-version: 10.0.x
     - name: Restore dependencies
diff --git a/.github/workflows/release-package.yml b/.github/workflows/release-package.yml
index 94a0a23..98d31ab 100644
--- a/.github/workflows/release-package.yml
+++ b/.github/workflows/release-package.yml
@@ -7,13 +7,15 @@ on:
 jobs:  
   publish-package:
     runs-on: ubuntu-latest
+    environment: release
     permissions:
       packages: write
       contents: read
+      id-token: write  # enable GitHub OIDC token issuance for this job
     steps:       
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v7
       - name: Setup .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v6
         with:
           dotnet-version: 10.0.x      
 
@@ -31,5 +33,11 @@ jobs:
       #   run: dotnet nuget push "pdfsharpdsl/bin/Release/*.nupkg" --source "github"
       # - name: publish to nuget.org
       #   run: nuget push "pdfsharpdsl/bin/Release/*.nupkg" -Source 'https://api.nuget.org/v3/index.json' -ApiKey ${{secrets.NUGET_API_KEY}}
+      # no more apikey, using GitHub Actions built-in authentication via trusted publishing 
+      - name: NuGet login (OIDC → temp API key)
+        uses: NuGet/login@v1
+        id: login
+        with:
+          user: ${{ secrets.NUGET_USER }}
       - name: Publish to NuGet
-        run: dotnet nuget push "PdfSharpDslCore/bin/Release/*.nupkg" -s https://api.nuget.org/v3/index.json -k ${{ secrets.NUGET_KEY }} --skip-duplicate
+        run: dotnet nuget push "PdfSharpDslCore/bin/Release/*.nupkg" --api-key ${{steps.login.outputs.NUGET_API_KEY}} --source https://api.nuget.org/v3/index.json --skip-duplicate

From afd97ea421d0eee712885bc4fd05c9926c447609 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Sun, 20 Sep 2026 11:48:14 +0200
Subject: [PATCH 12/15] docs: restore 1.0.6 section, scope TerraPDF work to
 2.0.0

The branch had renamed the shipped 1.0.6 heading to "Unreleased" and
appended TerraPDF entries to it. Split them back apart: 1.0.6 keeps the
.NET 10 / coverage / source-generator entries released on main, and the
TerraPDF migration moves under 2.0.0 with its net8.0 breaking change.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9d11908..931abd7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,16 @@
 
 # Change log
 
-## Unreleased
-* Migrated console and test projects to .NET 10 while retaining reusable projects on .NET Standard 2.0.
-* Added reproducible core-only coverage enforcement at 90% line coverage.
-* Added Roslyn source-generator compilation and clean NuGet consumer validation.
+## Version 2.0.0 (unreleased)
 * Migrated PDF generation from PdfSharpCore and its image/font/archive dependencies to TerraPDF 2.1.0.
 * Added engine-independent drawing primitives and `PdfSharpDsl.Language` for the netstandard2.0 source generator.
 * Added `PublishPdf(Stream)`, `PublishPdf(string)` and `PublishPdf()` to `PdfDocumentDrawer`.
+* **Breaking:** `PdfSharpDslCore` now targets `net8.0` (was `netstandard2.0`).
+
+## Version 1.0.6 (September 20, 2026)
+* Migrated console and test projects to .NET 10 while retaining reusable projects on .NET Standard 2.0.
+* Added reproducible core-only coverage enforcement at 90% line coverage.
+* Added Roslyn source-generator compilation and clean NuGet consumer validation.
 
 ## Version 1.0.5 (March 3, 2024)
 * Update nugets packages and upgrade to .Net 8

From 48d39c8a8fc8926fa83e320ef4e4922722d69736 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Sun, 20 Sep 2026 16:12:06 +0200
Subject: [PATCH 13/15] uses new version of TerraPDF

---
 PdfSharpDslCore/PdfSharpDslCore.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/PdfSharpDslCore/PdfSharpDslCore.csproj b/PdfSharpDslCore/PdfSharpDslCore.csproj
index 30b50fd..54b5437 100644
--- a/PdfSharpDslCore/PdfSharpDslCore.csproj
+++ b/PdfSharpDslCore/PdfSharpDslCore.csproj
@@ -24,7 +24,7 @@
 		</None>
 		<PackageReference Include="Irony" Version="1.5.3" />
 		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
-		<PackageReference Include="TerraPDF" Version="2.1.0" Condition="'$(UseLocalTerraPdf)' != 'true'" />
+		<PackageReference Include="TerraPDF" Version="2.2.0" Condition="'$(UseLocalTerraPdf)' != 'true'" />
 	</ItemGroup>
 	<ItemGroup Condition="'$(UseLocalTerraPdf)' == 'true'">
 		<ProjectReference Include="..\..\TerraPDF\src\TerraPDF\TerraPDF.csproj" />

From cc644dd1b39c3d13f5709d35e07190c7eb6488e3 Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Sun, 20 Sep 2026 16:37:22 +0200
Subject: [PATCH 14/15] setup ci with props files

---
 .github/workflows/release-package.yml         | 13 ++++--
 CHANGELOG.md                                  |  8 +++-
 Directory.Build.props                         | 11 +++++
 Directory.Build.targets                       |  6 +++
 Directory.Packages.props                      |  6 +++
 .../PdfSharpDsl.Language.csproj               | 32 +++++++-------
 PdfSharpDslConsole/PdfSharpDslConsole.csproj  |  8 ++--
 .../PdfSharpDslCore.Generator.csproj          | 28 +++++-------
 PdfSharpDslCore/PdfSharpDslCore.csproj        | 39 ++++++----------
 PdfSharpDslCore/Readme.md                     |  2 +-
 README.md                                     |  3 +-
 _build/Common.props                           | 44 +++++++++++++++++++
 _build/Common.targets                         | 11 +++++
 _build/Packages.props                         | 33 ++++++++++++++
 _build/Version.props                          | 13 ++++++
 bnf_and_pdf.sln                               |  8 ++++
 pdfsharpdslTests/pdfsharpdslTests.csproj      | 17 ++++---
 17 files changed, 204 insertions(+), 78 deletions(-)
 create mode 100644 Directory.Build.props
 create mode 100644 Directory.Build.targets
 create mode 100644 Directory.Packages.props
 create mode 100644 _build/Common.props
 create mode 100644 _build/Common.targets
 create mode 100644 _build/Packages.props
 create mode 100644 _build/Version.props

diff --git a/.github/workflows/release-package.yml b/.github/workflows/release-package.yml
index 98d31ab..ccf2e35 100644
--- a/.github/workflows/release-package.yml
+++ b/.github/workflows/release-package.yml
@@ -19,14 +19,21 @@ jobs:
         with:
           dotnet-version: 10.0.x      
 
+      # The release tag drives the published version; _build/Version.props is the fallback default.
+      - name: Resolve version from release tag
+        id: version
+        run: echo "version=${TAG#v}" >> "$GITHUB_OUTPUT"
+        env:
+          TAG: ${{ github.event.release.tag_name }}
+
       - name: Restore dependencies
         run: dotnet restore
       - name: Build
-        run: dotnet build --no-restore
+        run: dotnet build --no-restore -c Release -p:Version=${{ steps.version.outputs.version }}
       - name: Test
-        run: dotnet test --no-build --verbosity normal  
+        run: dotnet test --no-build -c Release --verbosity normal
       - name: pack
-        run: dotnet pack -c Release PdfSharpDslCore/PdfSharpDslCore.csproj
+        run: dotnet pack --no-build -c Release PdfSharpDslCore/PdfSharpDslCore.csproj -p:Version=${{ steps.version.outputs.version }}
       # - name: add publish
       #   run: dotnet nuget add source --username pgourlain --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/pgourlain/index.json"
       # - name: publish package
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 931abd7..6ba94a0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,10 +2,14 @@
 # Change log
 
 ## Version 2.0.0 (unreleased)
-* Migrated PDF generation from PdfSharpCore and its image/font/archive dependencies to TerraPDF 2.1.0.
+* Migrated PDF generation from PdfSharpCore and its image/font/archive dependencies to TerraPDF 2.2.0.
 * Added engine-independent drawing primitives and `PdfSharpDsl.Language` for the netstandard2.0 source generator.
 * Added `PublishPdf(Stream)`, `PublishPdf(string)` and `PublishPdf()` to `PdfDocumentDrawer`.
-* **Breaking:** `PdfSharpDslCore` now targets `net8.0` (was `netstandard2.0`).
+* **Breaking:** `PdfSharpDslCore` now multi-targets `net8.0` and `net10.0` (was `netstandard2.0`).
+* Centralized the build in a `_build/` folder: `Version.props` holds the single product version, `Common.props` the shared package metadata, licence and target-framework aliases, and `Packages.props` every NuGet version (central package management). `Directory.Build.props`, `Directory.Build.targets` and `Directory.Packages.props` at the repository root are thin stubs that import them.
+* All assemblies now ship the same version. `PdfSharpDslCore.Generator` moves from `1.0.2` to `2.0.0` and `PdfSharpDslConsole` no longer carries its own `0.1.0`.
+* The release workflow now derives the published package version from the GitHub release tag, and builds, tests and packs in `Release` so the tested binaries are the ones packed.
+* Updated `Microsoft.Extensions.Logging.Abstractions` and `Microsoft.Extensions.Logging.Console` to 10.0.12.
 
 ## Version 1.0.6 (September 20, 2026)
 * Migrated console and test projects to .NET 10 while retaining reusable projects on .NET Standard 2.0.
diff --git a/Directory.Build.props b/Directory.Build.props
new file mode 100644
index 0000000..157c6e2
--- /dev/null
+++ b/Directory.Build.props
@@ -0,0 +1,11 @@
+<Project>
+
+	<!--
+		MSBuild only auto-discovers Directory.Build.props by walking up from each project
+		directory, so this stub exists purely to pull in the real files from _build/.
+		Edit _build/Version.props and _build/Common.props, not this file.
+	-->
+	<Import Project="_build\Version.props" />
+	<Import Project="_build\Common.props" />
+
+</Project>
diff --git a/Directory.Build.targets b/Directory.Build.targets
new file mode 100644
index 0000000..cddace9
--- /dev/null
+++ b/Directory.Build.targets
@@ -0,0 +1,6 @@
+<Project>
+
+	<!-- Stub: see Directory.Build.props. Edit _build/Common.targets, not this file. -->
+	<Import Project="_build\Common.targets" />
+
+</Project>
diff --git a/Directory.Packages.props b/Directory.Packages.props
new file mode 100644
index 0000000..922f068
--- /dev/null
+++ b/Directory.Packages.props
@@ -0,0 +1,6 @@
+<Project>
+
+	<!-- Stub: see Directory.Build.props. Edit _build/Packages.props, not this file. -->
+	<Import Project="_build\Packages.props" />
+
+</Project>
diff --git a/PdfSharpDsl.Language/PdfSharpDsl.Language.csproj b/PdfSharpDsl.Language/PdfSharpDsl.Language.csproj
index 500aa65..b13dffc 100644
--- a/PdfSharpDsl.Language/PdfSharpDsl.Language.csproj
+++ b/PdfSharpDsl.Language/PdfSharpDsl.Language.csproj
@@ -1,19 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <LangVersion>10.0</LangVersion>
-    <Nullable>enable</Nullable>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Irony" Version="1.5.3" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
-  </ItemGroup>
+	<PropertyGroup>
+		<TargetFramework>$(NetStandardTfm)</TargetFramework>
+		<IsPackable>false</IsPackable>
+	</PropertyGroup>
 
-  <ItemGroup>
-    <InternalsVisibleTo Include="PdfSharpDslCore" />
-    <InternalsVisibleTo Include="PdfSharpDslCore.Generator" />
-    <InternalsVisibleTo Include="pdfsharpdslTests" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
+	<ItemGroup>
+		<PackageReference Include="Irony" />
+		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<InternalsVisibleTo Include="PdfSharpDslCore" />
+		<InternalsVisibleTo Include="PdfSharpDslCore.Generator" />
+		<InternalsVisibleTo Include="pdfsharpdslTests" />
+	</ItemGroup>
+
+</Project>
diff --git a/PdfSharpDslConsole/PdfSharpDslConsole.csproj b/PdfSharpDslConsole/PdfSharpDslConsole.csproj
index 78e426c..6849a12 100644
--- a/PdfSharpDslConsole/PdfSharpDslConsole.csproj
+++ b/PdfSharpDslConsole/PdfSharpDslConsole.csproj
@@ -2,11 +2,9 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>$(NetAppTfm)</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <Version>0.1.0</Version>
-    <Company></Company>
+    <IsPackable>false</IsPackable>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <!--<GeneratedFolder>PdfDslGenerated</GeneratedFolder>-->
     <CompilerGeneratedFilesOutputPath>$(MSBuildThisFileDirectory)\Generated</CompilerGeneratedFilesOutputPath>
@@ -14,7 +12,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" />
   </ItemGroup>
 
   <ItemGroup>    
diff --git a/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj b/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
index 6adf390..8eee82a 100644
--- a/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
+++ b/PdfSharpDslCore.Generator/PdfSharpDslCore.Generator.csproj
@@ -1,39 +1,35 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFramework>netstandard2.0</TargetFramework>
+		<TargetFramework>$(NetStandardTfm)</TargetFramework>
 		<IsPackable>true</IsPackable>
+		<!-- Kept deliberately low: this assembly is loaded by the compiler, not by an app runtime. -->
 		<LangVersion>8.0</LangVersion>
+		<!-- This project never opted into nullable reference types; overrides the repository default. -->
+		<Nullable>disable</Nullable>
 		<Description>
 			Pdf Generation using source generation
 		</Description>
-		<Version>1.0.2</Version>
-		<Authors>Pierrick Gourlain</Authors>
-		<Company></Company>
-		<RepositoryUrl>https://github.com/pgourlain/bnf_and_pdf</RepositoryUrl>
-		<PackageLicenseFile>LICENSE.md</PackageLicenseFile>
 		<GeneratePackageOnBuild>false</GeneratePackageOnBuild>
 		<IncludeBuildOutput>false</IncludeBuildOutput>
+		<!-- No build output means a symbol package would be empty, and dotnet pack warns about it. -->
+		<IncludeSymbols>false</IncludeSymbols>
 		<NoPackageAnalysis>true</NoPackageAnalysis>
 		<IsRoslynComponent>true</IsRoslynComponent>
 		<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Irony" Version="1.5.3" GeneratePathProperty="true" />
-		<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" PrivateAssets="all" />
-		<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
-		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" GeneratePathProperty="true" />
-	</ItemGroup>
-
-	<ItemGroup>
-		<None Include="..\LICENSE.md" Pack="true" PackagePath="\" Visible="false" />
+		<PackageReference Include="Irony" GeneratePathProperty="true" />
+		<PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
+		<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" PrivateAssets="all" />
+		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" GeneratePathProperty="true" />
 	</ItemGroup>
 
 	<ItemGroup>
 		<!-- Package the generator in the analyzer directory of the nuget package -->
 		<None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
-		<None Include="$(MSBuildProjectDirectory)\..\PdfSharpDsl.Language\bin\$(Configuration)\netstandard2.0\PdfSharpDsl.Language.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+		<None Include="$(MSBuildProjectDirectory)\..\PdfSharpDsl.Language\bin\$(Configuration)\$(NetStandardTfm)\PdfSharpDsl.Language.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
 
 		<!-- Package the Irony dependency alongside the generator assembly -->
 		<None Include="$(PKGIrony)\lib\netstandard2.0\*.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
diff --git a/PdfSharpDslCore/PdfSharpDslCore.csproj b/PdfSharpDslCore/PdfSharpDslCore.csproj
index 54b5437..834cf38 100644
--- a/PdfSharpDslCore/PdfSharpDslCore.csproj
+++ b/PdfSharpDslCore/PdfSharpDslCore.csproj
@@ -1,30 +1,19 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFramework>net8.0</TargetFramework>
+		<TargetFrameworks>$(NetLibTfms)</TargetFrameworks>
 		<PackageReadmeFile>Readme.md</PackageReadmeFile>
-		<LangVersion>9.0</LangVersion>
-		<Nullable>enable</Nullable>
 		<Title>Generate PDF using DSL</Title>
 		<PackageId>PdfSharpDslCore</PackageId>
-		<Version>2.0.0</Version>
-		<Authors>Pierrick Gourlain</Authors>
-		<Company></Company>
 		<UseLocalTerraPdf Condition="'$(UseLocalTerraPdf)' == '' and Exists('..\..\TerraPDF\src\TerraPDF\TerraPDF.csproj')">true</UseLocalTerraPdf>
 		<Description>A DSL using TerraPDF to generate PDF</Description>
-		<RepositoryUrl>https://github.com/pgourlain/bnf_and_pdf</RepositoryUrl>
 		<PackageIcon>Icon.jpg</PackageIcon>
-		<PackageLicenseFile>LICENSE.md</PackageLicenseFile>
 	</PropertyGroup>
 
 	<ItemGroup>
-		<None Include="..\LICENSE.md">
-			<Pack>True</Pack>
-			<PackagePath>\</PackagePath>
-		</None>
-		<PackageReference Include="Irony" Version="1.5.3" />
-		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
-		<PackageReference Include="TerraPDF" Version="2.2.0" Condition="'$(UseLocalTerraPdf)' != 'true'" />
+		<PackageReference Include="Irony" />
+		<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+		<PackageReference Include="TerraPDF" Condition="'$(UseLocalTerraPdf)' != 'true'" />
 	</ItemGroup>
 	<ItemGroup Condition="'$(UseLocalTerraPdf)' == 'true'">
 		<ProjectReference Include="..\..\TerraPDF\src\TerraPDF\TerraPDF.csproj" />
@@ -39,15 +28,15 @@
 	<ItemGroup>
 		<InternalsVisibleTo Include="pdfsharpdslTests" />
 	</ItemGroup>
-	<ItemGroup>
-	  <None Update="Icon.jpg">
-	    <Pack>True</Pack>
-	    <PackagePath>\</PackagePath>
-	  </None>
-	  <None Update="Readme.md">
-	    <Pack>True</Pack>
-	    <PackagePath>\</PackagePath>
-	  </None>
+	<!--
+		Now that this project multi-targets, pack runs in the cross-targeting (outer) build,
+		where the SDK does not expand its default None globs. So these must be Include, not
+		Update: an Update would have nothing to attach the Pack metadata to and the icon and
+		readme would silently drop out of the package (NU5046).
+	-->
+	<ItemGroup Condition="'$(TargetFramework)' == ''">
+		<None Include="Icon.jpg" Pack="true" PackagePath="\" />
+		<None Include="Readme.md" Pack="true" PackagePath="\" />
 	</ItemGroup>
 
 </Project>
diff --git a/PdfSharpDslCore/Readme.md b/PdfSharpDslCore/Readme.md
index da8c630..ef67f90 100644
--- a/PdfSharpDslCore/Readme.md
+++ b/PdfSharpDslCore/Readme.md
@@ -3,7 +3,7 @@
 
 Package to print PDF using a specific DSL, using Irony.Net and TerraPDF.
 
-The renderer targets `net8.0`. `PdfSharpDsl.Language` and the source generator target `netstandard2.0` and can be consumed by modern .NET applications.
+The renderer multi-targets `net8.0` and `net10.0`. `PdfSharpDsl.Language` and the source generator target `netstandard2.0` and can be consumed by modern .NET applications.
 
 The repository enforces at least 90% line coverage for `PdfSharpDslCore` through `scripts\coverage.ps1`.
 
diff --git a/README.md b/README.md
index 6cf474d..76e2742 100644
--- a/README.md
+++ b/README.md
@@ -7,9 +7,10 @@ This is a sample library that uses [Irony.Net](https://github.com/IronyProject/I
 
 ## Current support
 
-- `PdfSharpDslCore` targets `net8.0`; `PdfSharpDsl.Language` and `PdfSharpDslCore.Generator` target `netstandard2.0`.
+- `PdfSharpDslCore` multi-targets `net8.0` and `net10.0`; `PdfSharpDsl.Language` and `PdfSharpDslCore.Generator` target `netstandard2.0` because they are loaded by the compiler.
 - `PdfSharpDslConsole` and the test project target `net10.0`.
 - The repository is pinned to SDK `10.0.400` in `global.json`.
+- Version, licence, package metadata and every NuGet version are centralized in [`_build/`](_build/): `Version.props` (the single product version), `Common.props` (shared metadata and target-framework aliases) and `Packages.props` (central package management). The `Directory.Build.props`, `Directory.Build.targets` and `Directory.Packages.props` files at the repository root only import these. Change a version or a target framework there, never in an individual `.csproj`.
 - The generator package includes its analyzer dependencies and supports clean NuGet consumer builds.
 
 Run the full test and core coverage gate with:
diff --git a/_build/Common.props b/_build/Common.props
new file mode 100644
index 0000000..b9b4ba7
--- /dev/null
+++ b/_build/Common.props
@@ -0,0 +1,44 @@
+<Project>
+
+	<!-- Target framework aliases, so TFMs are declared in one place. -->
+	<PropertyGroup>
+		<!-- Shipped libraries: multi-targeted so net8.0 consumers keep working. -->
+		<NetLibTfms>net8.0;net10.0</NetLibTfms>
+		<!-- Applications and test projects. -->
+		<NetAppTfm>net10.0</NetAppTfm>
+		<!-- Roslyn components and everything they load: must stay netstandard2.0. -->
+		<NetStandardTfm>netstandard2.0</NetStandardTfm>
+	</PropertyGroup>
+
+	<!-- Compiler defaults. A project may override any of these. -->
+	<PropertyGroup>
+		<LangVersion>latest</LangVersion>
+		<Nullable>enable</Nullable>
+	</PropertyGroup>
+
+	<!-- Package metadata shared by every packable project. -->
+	<PropertyGroup>
+		<Authors>Pierrick Gourlain</Authors>
+		<Company>Pierrick Gourlain</Company>
+		<Copyright>Copyright (c) 2022-2026 Pierrick Gourlain</Copyright>
+		<PackageProjectUrl>https://github.com/pgourlain/bnf_and_pdf</PackageProjectUrl>
+		<RepositoryUrl>https://github.com/pgourlain/bnf_and_pdf</RepositoryUrl>
+		<RepositoryType>git</RepositoryType>
+		<PackageTags>pdf;dsl;irony;terrapdf;pdf-generation;source-generator</PackageTags>
+		<PackageLicenseFile>LICENSE.md</PackageLicenseFile>
+	</PropertyGroup>
+
+	<!-- Reproducible builds and symbol packages. -->
+	<PropertyGroup>
+		<PublishRepositoryUrl>true</PublishRepositoryUrl>
+		<IncludeSymbols>true</IncludeSymbols>
+		<SymbolPackageFormat>snupkg</SymbolPackageFormat>
+		<ContinuousIntegrationBuild Condition="'$(GITHUB_ACTIONS)' == 'true'">true</ContinuousIntegrationBuild>
+	</PropertyGroup>
+
+	<!--
+		LICENSE.md is packed from _build/Common.targets, not here: IsPackable is set by the
+		.csproj, which MSBuild evaluates after this file, so it cannot be tested at this point.
+	-->
+
+</Project>
diff --git a/_build/Common.targets b/_build/Common.targets
new file mode 100644
index 0000000..c1d6e77
--- /dev/null
+++ b/_build/Common.targets
@@ -0,0 +1,11 @@
+<Project>
+
+	<!--
+		Imported after the .csproj, so IsPackable is known here.
+		Packs the repository LICENSE.md into every package (PackageLicenseFile is set in Common.props).
+	-->
+	<ItemGroup Condition="'$(IsPackable)' != 'false'">
+		<None Include="$(MSBuildThisFileDirectory)..\LICENSE.md" Pack="true" PackagePath="\" Visible="false" />
+	</ItemGroup>
+
+</Project>
diff --git a/_build/Packages.props b/_build/Packages.props
new file mode 100644
index 0000000..d680db6
--- /dev/null
+++ b/_build/Packages.props
@@ -0,0 +1,33 @@
+<Project>
+
+	<PropertyGroup>
+		<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+	</PropertyGroup>
+
+	<!-- Runtime dependencies -->
+	<ItemGroup>
+		<PackageVersion Include="Irony" Version="1.5.3" />
+		<PackageVersion Include="TerraPDF" Version="2.2.0" />
+		<PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.12" />
+		<PackageVersion Include="Microsoft.Extensions.Logging.Console" Version="10.0.12" />
+	</ItemGroup>
+
+	<!--
+		Roslyn. This is the compiler floor for the source generator: raising it raises the
+		minimum SDK a consumer needs, so bump it deliberately, not opportunistically.
+	-->
+	<ItemGroup>
+		<PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" />
+		<PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
+	</ItemGroup>
+
+	<!-- Test-only -->
+	<ItemGroup>
+		<PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+		<PackageVersion Include="Moq" Version="4.20.72" />
+		<PackageVersion Include="xunit" Version="2.9.3" />
+		<PackageVersion Include="xunit.runner.visualstudio" Version="2.8.2" />
+		<PackageVersion Include="coverlet.collector" Version="6.0.4" />
+	</ItemGroup>
+
+</Project>
diff --git a/_build/Version.props b/_build/Version.props
new file mode 100644
index 0000000..cf354fc
--- /dev/null
+++ b/_build/Version.props
@@ -0,0 +1,13 @@
+<Project>
+
+	<!--
+		Single source of truth for the product version.
+		Every assembly and every package in this repository is built from this value.
+		CI overrides it at build/pack time with -p:Version=<release tag>.
+	-->
+	<PropertyGroup>
+		<VersionPrefix>2.0.0</VersionPrefix>
+		<VersionSuffix></VersionSuffix>
+	</PropertyGroup>
+
+</Project>
diff --git a/bnf_and_pdf.sln b/bnf_and_pdf.sln
index 6ce8b80..cb64dd7 100644
--- a/bnf_and_pdf.sln
+++ b/bnf_and_pdf.sln
@@ -13,7 +13,15 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		.gitignore = .gitignore
 		CHANGELOG.md = CHANGELOG.md
+		Directory.Build.props = Directory.Build.props
+		Directory.Build.targets = Directory.Build.targets
+		Directory.Packages.props = Directory.Packages.props
+		global.json = global.json
 		README.md = README.md
+		_build\Common.props = _build\Common.props
+		_build\Common.targets = _build\Common.targets
+		_build\Packages.props = _build\Packages.props
+		_build\Version.props = _build\Version.props
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PdfSharpDslCore.Generator", "PdfSharpDslCore.Generator\PdfSharpDslCore.Generator.csproj", "{A6092AA9-EC00-4C4F-AF43-E039E400CC3B}"
diff --git a/pdfsharpdslTests/pdfsharpdslTests.csproj b/pdfsharpdslTests/pdfsharpdslTests.csproj
index c721efb..6e511b9 100644
--- a/pdfsharpdslTests/pdfsharpdslTests.csproj
+++ b/pdfsharpdslTests/pdfsharpdslTests.csproj
@@ -1,24 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>$(NetAppTfm)</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-    <PackageReference Include="Moq" Version="4.20.72" />
-    <PackageReference Include="xunit" Version="2.9.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="Moq" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.4">
+    <PackageReference Include="coverlet.collector">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

From 5751e45cbd9f4cb87b79eddac87c43d6a5aa594e Mon Sep 17 00:00:00 2001
From: Pierrick Gourlain <pgourlain@hotmail.com>
Date: Sun, 20 Sep 2026 16:48:03 +0200
Subject: [PATCH 15/15] fix test failed after using binary TerraPDF

---
 pdfsharpdslTests/PdfDocumentDrawerTests.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pdfsharpdslTests/PdfDocumentDrawerTests.cs b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
index cfe267f..4a5e8f2 100644
--- a/pdfsharpdslTests/PdfDocumentDrawerTests.cs
+++ b/pdfsharpdslTests/PdfDocumentDrawerTests.cs
@@ -16,8 +16,8 @@ public void DslOrientationsProduceRotatedTextMatrices()
             new PdfSharpDslCore.Parser.PdfDrawerVisitor().Draw(drawer, tree);
             var content = ReadContent(drawer.PublishPdf());
 
-            Assert.Matches(@"0\.00 -1\.00 1\.00 0\.00 220\.00 [\d.]+ Tm\n\(vertical\) Tj", content);
-            Assert.Matches(@"0\.87 -0\.50 0\.50 0\.87 300\.00 [\d.]+ Tm\n\(30 degree rotation\) Tj", content);
+            Assert.Matches(@"0\.000000 -1\.000000 1\.000000 0\.000000 220\.00 [\d.]+ Tm\n\(vertical\) Tj", content);
+            Assert.Matches(@"0\.866025 -0\.500000 0\.500000 0\.866025 300\.00 [\d.]+ Tm\n\(30 degree rotation\) Tj", content);
         }
 
         [Fact]