@@ -0,0 +1,90 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>The five CSS-wide keywords (CSS Cascade &amp; Inheritance §7.3) a property value can be.</summary>
+    internal enum CssGlobalKeyword
+    {
+        Inherit,
+        Initial,
+        Unset,
+        Revert,
+        RevertLayer
+    }
+
+    /// <summary>
+    /// A typed box-side property value that carries the <b>parsed</b> value through the cascade to the box,
+    /// so a layout consumer reads the object rather than re-parsing the authored string. A value is in exactly
+    /// one of three states:
+    /// <list type="bullet">
+    /// <item>a CSS-wide keyword (<see cref="GlobalValue"/> non-null),</item>
+    /// <item><i>unresolved</i> — the authored text still contains <c>var()</c> and has not been resolved yet
+    /// (<see cref="IsUnresolved"/>; <see cref="Value"/> is default), or</item>
+    /// <item>resolved — <see cref="Value"/> holds the parsed <typeparamref name="T"/>.</item>
+    /// </list>
+    /// The authored/keyword text is retained so the string-based getter/snapshot/revert cascade path keeps
+    /// working (<see cref="ToString"/>). Grid templates (<c>T = GridTemplate</c>) are the first adopter; the
+    /// mechanism is intended to eventually back every box property.
+    /// </summary>
+    internal sealed class CssProperty<T>
+    {
+        private readonly string _cssText;
+
+        private CssProperty(CssGlobalKeyword? global, bool unresolved, T value, string cssText)
+        {
+            GlobalValue = global;
+            IsUnresolved = unresolved;
+            Value = value;
+            _cssText = cssText;
+        }
+
+        /// <summary>The CSS-wide keyword, when this value is one; otherwise null.</summary>
+        public CssGlobalKeyword? GlobalValue { get; }
+
+        public bool IsGlobalValue => GlobalValue.HasValue;
+
+        /// <summary>The authored text still contains an unresolved <c>var()</c> — <see cref="Value"/> is not
+        /// meaningful until resolution replaces this with a resolved value.</summary>
+        public bool IsUnresolved { get; }
+
+        /// <summary>The parsed value — meaningful only when the value is neither global nor unresolved.</summary>
+        public T Value { get; }
+
+        public static CssProperty<T> Global(CssGlobalKeyword keyword) =>
+            new CssProperty<T>(keyword, unresolved: false, value: default(T), CssGlobalKeywords.ToText(keyword));
+
+        public static CssProperty<T> Unresolved(string rawText) =>
+            new CssProperty<T>(global: null, unresolved: true, value: default(T), rawText);
+
+        public static CssProperty<T> FromValue(string cssText, T value) =>
+            new CssProperty<T>(global: null, unresolved: false, value, cssText);
+
+        public override string ToString() => _cssText;
+    }
+
+    /// <summary>Maps between the CSS-wide keyword string literals and <see cref="CssGlobalKeyword"/>.</summary>
+    internal static class CssGlobalKeywords
+    {
+        public static bool TryParse(string value, out CssGlobalKeyword keyword)
+        {
+            if (value.Isi(Keywords.Inherit)) { keyword = CssGlobalKeyword.Inherit; return true; }
+            if (value.Isi(Keywords.Initial)) { keyword = CssGlobalKeyword.Initial; return true; }
+            if (value.Isi(Keywords.Unset)) { keyword = CssGlobalKeyword.Unset; return true; }
+            if (value.Isi(Keywords.Revert)) { keyword = CssGlobalKeyword.Revert; return true; }
+            if (value.Isi(Keywords.RevertLayer)) { keyword = CssGlobalKeyword.RevertLayer; return true; }
+            keyword = default;
+            return false;
+        }
+
+        public static string ToText(CssGlobalKeyword keyword)
+        {
+            switch (keyword)
+            {
+                case CssGlobalKeyword.Inherit: return Keywords.Inherit;
+                case CssGlobalKeyword.Initial: return Keywords.Initial;
+                case CssGlobalKeyword.Unset: return Keywords.Unset;
+                case CssGlobalKeyword.Revert: return Keywords.Revert;
+                case CssGlobalKeyword.RevertLayer: return Keywords.RevertLayer;
+                default: return Keywords.Initial;
+            }
+        }
+    }
+}
@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// A parsed grid <c>&lt;grid-line&gt;</c> (one edge of <c>grid-column</c>/<c>grid-row</c>/<c>grid-area</c>):
+    /// <c>auto</c>, an integer line number (may be negative — counting from the end edge), <c>span N</c>, or
+    /// a named line reference (a bare <c>&lt;custom-ident&gt;</c>, or <c>&lt;custom-ident&gt; &lt;integer&gt;</c>
+    /// for the Nth line with that name). <c>span &lt;custom-ident&gt;</c> is out of v1 scope.
+    /// </summary>
+    internal sealed class GridLine
+    {
+        public bool IsAuto { get; private set; }
+        public bool IsSpan { get; private set; }
+
+        /// <summary>The line number (for a line reference), the span count (when <see cref="IsSpan"/>), or
+        /// the 1-based Nth index for a named line (defaults to 1).</summary>
+        public int Value { get; private set; } = 1;
+
+        /// <summary>The custom-ident of a named line reference, or null when this is not a named line.</summary>
+        public string Name { get; private set; }
+
+        public static readonly GridLine Auto = new GridLine { IsAuto = true };
+        public static GridLine Span(int n) => new GridLine { IsSpan = true, Value = n };
+        public static GridLine Line(int n) => new GridLine { Value = n };
+        public static GridLine Named(string name) => new GridLine { Name = name, Value = 1 };
+        public static GridLine NamedNth(string name, int n) => new GridLine { Name = name, Value = n };
+    }
+
+    /// <summary>
+    /// Shared grammar for a single grid <c>&lt;grid-line&gt;</c> value. Used by Layer A (to validate the
+    /// <c>grid-column-start</c>/<c>-end</c>/<c>grid-row-start</c>/<c>-end</c> longhands) and by Layer B (the
+    /// grid placement engine).
+    /// </summary>
+    internal static class GridLineGrammar
+    {
+        internal static GridLine TryParse(IReadOnlyList<Token> tokens)
+        {
+            var toks = tokens.Where(t => t.Type != TokenType.Whitespace).ToArray();
+            if (toks.Length == 0) return null;
+
+            // auto
+            if (toks.Length == 1 && toks[0].Type == TokenType.Ident && toks[0].Data.Isi(Keywords.Auto))
+                return GridLine.Auto;
+
+            // <integer>
+            if (toks.Length == 1 && toks[0] is NumberToken number && number.IsInteger && number.IntegerValue != 0)
+                return GridLine.Line(number.IntegerValue);
+
+            // span <integer [1,∞]>
+            if (toks.Length == 2 && toks[0].Type == TokenType.Ident && toks[0].Data.Isi(Keywords.Span)
+                && toks[1] is NumberToken spanCount && spanCount.IsInteger && spanCount.IntegerValue >= 1)
+                return GridLine.Span(spanCount.IntegerValue);
+
+            // <custom-ident> — a named line reference.
+            if (toks.Length == 1 && IsCustomIdent(toks[0]))
+                return GridLine.Named(toks[0].Data);
+
+            // <custom-ident> <integer> / <integer> <custom-ident> — the Nth line with that name (order-independent).
+            if (toks.Length == 2)
+            {
+                if (IsCustomIdent(toks[0]) && toks[1] is NumberToken n1 && n1.IsInteger && n1.IntegerValue != 0)
+                    return GridLine.NamedNth(toks[0].Data, n1.IntegerValue);
+                if (IsCustomIdent(toks[1]) && toks[0] is NumberToken n2 && n2.IsInteger && n2.IntegerValue != 0)
+                    return GridLine.NamedNth(toks[1].Data, n2.IntegerValue);
+            }
+
+            return null;
+        }
+
+        /// <summary>Whether the token is a <c>&lt;custom-ident&gt;</c> usable as a grid line name — an ident
+        /// that is not one of the reserved keywords a grid-line value or the CSS-wide keywords may take.</summary>
+        private static bool IsCustomIdent(Token token)
+        {
+            if (token.Type != TokenType.Ident) return false;
+            var d = token.Data;
+            return !d.Isi(Keywords.Auto) && !d.Isi(Keywords.Span) && !d.Isi(Keywords.None)
+                && !d.Isi(Keywords.Inherit) && !d.Isi(Keywords.Initial) && !d.Isi(Keywords.Unset)
+                && !d.Isi(Keywords.Revert) && !d.Isi(Keywords.RevertLayer) && !d.Isi("default");
+        }
+    }
+}
@@ -0,0 +1,94 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// A parsed <c>grid-template-areas</c> value (CSS Grid §7.3): a rectangular grid of named cells. Each
+    /// named area's 0-based inclusive bounding rectangle is recorded; a <c>.</c> (or a run of only dots) is
+    /// an unnamed empty cell.
+    /// </summary>
+    internal sealed class GridAreas
+    {
+        public int RowCount { get; set; }
+        public int ColCount { get; set; }
+
+        /// <summary>The area name at each cell (<c>[row, col]</c>), or null for an empty <c>.</c> cell.</summary>
+        public string[,] Cells { get; set; }
+
+        /// <summary>Each named area's 0-based inclusive rectangle (rowStart, colStart, rowEnd, colEnd).</summary>
+        public IReadOnlyDictionary<string, (int R1, int C1, int R2, int C2)> Areas { get; set; }
+    }
+
+    /// <summary>
+    /// Shared grammar for a <c>grid-template-areas</c> value (a series of quoted strings). Used by Layer A
+    /// (accept/reject) and Layer B (the engine derives implicit <c>name-start</c>/<c>name-end</c> lines).
+    /// Returns null for anything invalid — including the <c>none</c> keyword, which the property accepts
+    /// separately.
+    /// </summary>
+    internal static class GridTemplateAreasGrammar
+    {
+        internal static GridAreas TryParse(IReadOnlyList<Token> tokens)
+        {
+            var toks = tokens.Where(t => t.Type != TokenType.Whitespace).ToArray();
+            if (toks.Length == 0) return null;
+
+            // Every token must be a string; each string is one row.
+            if (toks.Any(t => t.Type != TokenType.String)) return null;
+
+            var rows = new List<string[]>(toks.Length);
+            int colCount = -1;
+            foreach (var t in toks)
+            {
+                var cells = ((StringToken)t).Data
+                    .Split((char[])null, System.StringSplitOptions.RemoveEmptyEntries);
+                if (cells.Length == 0) return null;          // an empty string is invalid
+                if (colCount < 0) colCount = cells.Length;
+                else if (cells.Length != colCount) return null; // ragged rows are invalid
+
+                var normalized = new string[colCount];
+                for (var c = 0; c < colCount; c++)
+                {
+                    if (IsEmptyCell(cells[c])) { normalized[c] = null; continue; }
+                    // A named cell is a <custom-ident> — a null token (a mixed "a.b" is invalid, not a name).
+                    if (cells[c].Contains('.')) return null;
+                    normalized[c] = cells[c];
+                }
+                rows.Add(normalized);
+            }
+
+            var rowCount = rows.Count;
+            var grid = new string[rowCount, colCount];
+            var bounds = new Dictionary<string, (int R1, int C1, int R2, int C2)>();
+
+            for (var r = 0; r < rowCount; r++)
+                for (var c = 0; c < colCount; c++)
+                {
+                    var name = rows[r][c];
+                    grid[r, c] = name;
+                    if (name is null) continue;
+                    if (bounds.TryGetValue(name, out var b))
+                        bounds[name] = (System.Math.Min(b.R1, r), System.Math.Min(b.C1, c),
+                                        System.Math.Max(b.R2, r), System.Math.Max(b.C2, c));
+                    else
+                        bounds[name] = (r, c, r, c);
+                }
+
+            // Each named area must be a single filled rectangle: every cell in its bounding box carries the
+            // name (which also guarantees no cell with the name lies outside the box).
+            foreach (var entry in bounds)
+            {
+                var name = entry.Key;
+                var b = entry.Value;
+                for (var r = b.R1; r <= b.R2; r++)
+                    for (var c = b.C1; c <= b.C2; c++)
+                        if (grid[r, c] != name) return null;
+            }
+
+            return new GridAreas { RowCount = rowCount, ColCount = colCount, Cells = grid, Areas = bounds };
+        }
+
+        /// <summary>A cell of only U+002E FULL STOP characters (<c>.</c>, <c>...</c>) is an empty cell.</summary>
+        private static bool IsEmptyCell(string cell) => cell.All(ch => ch == '.');
+    }
+}