diff --git a/Source/HtmlRenderer/Core/Dom/CssBox.cs b/Source/HtmlRenderer/Core/Dom/CssBox.cs
index bff71cc06..ed14dc5ac 100644
--- a/Source/HtmlRenderer/Core/Dom/CssBox.cs
+++ b/Source/HtmlRenderer/Core/Dom/CssBox.cs
@@ -1228,6 +1228,15 @@ private int GetIndexForList()
 
             foreach (CssBox b in ParentBox.Boxes)
             {
+                // An explicit <li value="N"> (WHATWG HTML presentational hint) sets the running count to
+                // N for that item; later items (without their own explicit value) continue incrementing
+                // from there, matching every browser's actual behavior.
+                int explicitValue;
+                if (b.Display == CssConstants.ListItem && int.TryParse(b.GetAttribute("value"), out explicitValue))
+                {
+                    index = explicitValue;
+                }
+
                 if (b.Equals(this))
                     return index;
 
@@ -1263,7 +1272,10 @@ private void CreateListItemBox(RGraphics g)
                     }
                     else if (ListStyleType.Equals(CssConstants.Square, StringComparison.InvariantCultureIgnoreCase))
                     {
-                        _listItemBox.Text = "♠";
+                        // Was "♠" (U+2660 BLACK SPADE SUIT) - not what CSS2.1 §12.5.1's list-style-type:
+                        // square means at all (a filled square marker, the ♣/♦/♠ card-suit glyph was
+                        // presumably a typo/copy-paste of a nearby symbol).
+                        _listItemBox.Text = "▪"; // U+25AA BLACK SMALL SQUARE
                     }
                     else if (ListStyleType.Equals(CssConstants.Decimal, StringComparison.InvariantCultureIgnoreCase))
                     {
diff --git a/Source/HtmlRenderer/Core/Dom/CssBoxProperties.cs b/Source/HtmlRenderer/Core/Dom/CssBoxProperties.cs
index 1fe334ff9..0ea9cad2a 100644
--- a/Source/HtmlRenderer/Core/Dom/CssBoxProperties.cs
+++ b/Source/HtmlRenderer/Core/Dom/CssBoxProperties.cs
@@ -79,6 +79,8 @@ internal abstract class CssBoxProperties
         private string _marginRight = "0";
         private string _marginTop = "0";
         private string _left = "auto";
+        private string _counterReset = CssConstants.None;
+        private string _counterIncrement = CssConstants.None;
         private string _lineHeight = "normal";
         private string _listStyleType = "disc";
         private string _listStyleImage = string.Empty;
@@ -726,6 +728,27 @@ public string Right
             set { _right = value; }
         }
 
+        public string CounterReset
+        {
+            get { return _counterReset; }
+            set { _counterReset = value; }
+        }
+
+        public string CounterIncrement
+        {
+            get { return _counterIncrement; }
+            set { _counterIncrement = value; }
+        }
+
+        /// <summary>
+        /// This box's resolved named-counter values (CSS 2.1 §12.4), as of just after its own
+        /// <c>counter-reset</c>/<c>counter-increment</c> have been applied - populated once, by
+        /// <see cref="CssCounterEngine.ResolveCounters"/>, before layout runs. Consulted by
+        /// <c>content: counter()</c> (<see cref="CssContentEngine"/>).
+        /// </summary>
+        internal System.Collections.Generic.Dictionary<string, int> Counters { get; set; }
+            = new System.Collections.Generic.Dictionary<string, int>();
+
         public string Bottom
         {
             get { return _bottom; }
diff --git a/Source/HtmlRenderer/Core/Dom/CssContentEngine.cs b/Source/HtmlRenderer/Core/Dom/CssContentEngine.cs
index 5ca61083b..09ceba7b5 100644
--- a/Source/HtmlRenderer/Core/Dom/CssContentEngine.cs
+++ b/Source/HtmlRenderer/Core/Dom/CssContentEngine.cs
@@ -76,6 +76,34 @@ private static string Resolve(CssBox box, string content)
                         sb.Append(attrValue);
                     }
                 }
+                else if (token is FunctionToken counterFunctionToken &&
+                         counterFunctionToken.Data.Equals(FunctionNames.Counter, StringComparison.OrdinalIgnoreCase))
+                {
+                    // counter(<name> [, <style>]?) - a bare counter() with no name argument (malformed,
+                    // or the counters()-with-separator form this subset doesn't support) contributes no
+                    // text, matching this engine's graceful-ignore-the-unsupported-part behavior.
+                    // ArgumentTokens.ToList() (ValueExtensions' comma-splitting overload, not System.Linq's)
+                    // groups the raw token stream into one List<Token> per comma-separated argument.
+                    var counterArgs = counterFunctionToken.ArgumentTokens.ToList();
+                    if (counterArgs.Count > 0 && counterArgs[0].FirstOrDefault() is KeywordToken counterNameToken)
+                    {
+                        var style = counterArgs.Count > 1 && counterArgs[1].FirstOrDefault() is KeywordToken styleToken
+                            ? styleToken.Data
+                            : CssConstants.Decimal;
+
+                        // Unlike attr() above, no parent fallback is needed here: CssCounterEngine.
+                        // ResolveCounters walks this pseudo-element box as an ordinary child of its
+                        // generating element, so it already carries its own correct post-increment
+                        // counter snapshot (inherited from the generating element's, per §12.4).
+                        // A counter that isn't in scope reads as 0 (§12.4).
+                        int counterValue;
+                        if (!box.Counters.TryGetValue(counterNameToken.Data, out counterValue))
+                        {
+                            counterValue = 0;
+                        }
+                        sb.Append(CssCounterEngine.FormatCounterValue(counterValue, style));
+                    }
+                }
                 else if (token is KeywordToken keywordToken)
                 {
                     if (keywordToken.Data.Equals(Keywords.OpenQuote, StringComparison.OrdinalIgnoreCase))
diff --git a/Source/HtmlRenderer/Core/Dom/CssCounterEngine.cs b/Source/HtmlRenderer/Core/Dom/CssCounterEngine.cs
new file mode 100644
index 000000000..e22dd6a33
--- /dev/null
+++ b/Source/HtmlRenderer/Core/Dom/CssCounterEngine.cs
@@ -0,0 +1,204 @@
+// "Therefore those skilled at the unorthodox
+// are infinite as heaven and earth,
+// inexhaustible as the great rivers.
+// When they come to an end,
+// they begin again,
+// like the days and months;
+// they die and are reborn,
+// like the four seasons."
+//
+// - Sun Tsu,
+// "The Art of War"
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using TheArtOfDev.HtmlRenderer.Core.Utils;
+
+namespace TheArtOfDev.HtmlRenderer.Core.Dom
+{
+    /// <summary>
+    /// Resolves CSS 2.1 §12.4 named counters (<c>counter-reset</c>/<c>counter-increment</c>) into a
+    /// per-box snapshot of counter values, consulted by <c>content: counter()</c>
+    /// (<see cref="CssContentEngine"/>).<br/>
+    /// <c>reversed(&lt;name&gt;)</c> and <c>counter-set</c> are not implemented.
+    /// </summary>
+    internal static class CssCounterEngine
+    {
+        /// <summary>
+        /// Walks <paramref name="root"/> and its descendants in document order, applying each box's own
+        /// <c>counter-reset</c>/<c>counter-increment</c> (plus the implicit <c>list-item</c> counter a
+        /// <c>display:list-item</c> box always increments) and storing the values in scope on
+        /// <see cref="CssBoxProperties.Counters"/>. Must run once, before layout, after every box's CSS
+        /// properties are resolved.
+        /// </summary>
+        public static void ResolveCounters(CssBox root)
+        {
+            ResolveSiblings(new[] { root }, new Dictionary<string, List<int>>());
+        }
+
+        /// <summary>
+        /// Each counter name maps to a stack of instances. A reset creates a new instance that stays in
+        /// scope for the box's following siblings and all their descendants, and goes out of scope again
+        /// once the parent ends (§12.4.1). Boxes with <c>display:none</c> don't touch counters (§12.4.3).
+        /// </summary>
+        private static void ResolveSiblings(IEnumerable<CssBox> boxes, Dictionary<string, List<int>> counters)
+        {
+            var created = new HashSet<string>();
+
+            foreach (var box in boxes)
+            {
+                if (box.Display == CssConstants.None)
+                    continue;
+
+                ApplyCounterReset(box, counters, created);
+                ApplyCounterIncrement(box, counters, created);
+
+                var snapshot = new Dictionary<string, int>(counters.Count);
+                foreach (var pair in counters)
+                    snapshot[pair.Key] = pair.Value[pair.Value.Count - 1];
+                box.Counters = snapshot;
+
+                ResolveSiblings(box.Boxes, counters);
+            }
+
+            foreach (var name in created)
+            {
+                var instances = counters[name];
+                instances.RemoveAt(instances.Count - 1);
+                if (instances.Count == 0)
+                    counters.Remove(name);
+            }
+        }
+
+        private static void ApplyCounterReset(CssBox box, Dictionary<string, List<int>> counters, HashSet<string> created)
+        {
+            if (string.IsNullOrEmpty(box.CounterReset) || box.CounterReset == CssConstants.None) return;
+
+            ForEachNameValuePair(box.CounterReset, defaultValue: 0, (name, value) => Reset(counters, created, name, value));
+        }
+
+        private static void ApplyCounterIncrement(CssBox box, Dictionary<string, List<int>> counters, HashSet<string> created)
+        {
+            if (box.Display == CssConstants.ListItem && !CounterNameAppears(box.CounterIncrement, CssConstants.ListItem))
+            {
+                Increment(counters, created, CssConstants.ListItem, 1);
+            }
+
+            if (string.IsNullOrEmpty(box.CounterIncrement) || box.CounterIncrement == CssConstants.None) return;
+
+            ForEachNameValuePair(box.CounterIncrement, defaultValue: 1, (name, value) => Increment(counters, created, name, value));
+        }
+
+        private static void Reset(Dictionary<string, List<int>> counters, HashSet<string> created, string name, int value)
+        {
+            // A second reset among the same siblings replaces that instance instead of nesting a new one.
+            if (created.Add(name))
+            {
+                if (!counters.TryGetValue(name, out var instances))
+                    counters[name] = instances = new List<int>();
+                instances.Add(value);
+            }
+            else
+            {
+                var instances = counters[name];
+                instances[instances.Count - 1] = value;
+            }
+        }
+
+        private static void Increment(Dictionary<string, List<int>> counters, HashSet<string> created, string name, int value)
+        {
+            // Incrementing a counter that isn't in scope behaves as if this box had reset it to 0.
+            if (!counters.TryGetValue(name, out var instances))
+            {
+                Reset(counters, created, name, 0);
+                instances = counters[name];
+            }
+
+            instances[instances.Count - 1] += value;
+        }
+
+        private static bool CounterNameAppears(string counterPropertyValue, string counterName)
+        {
+            if (string.IsNullOrEmpty(counterPropertyValue) || counterPropertyValue == CssConstants.None) return false;
+
+            var found = false;
+            ForEachNameValuePair(counterPropertyValue, 0, (name, _) => found |= name == counterName);
+            return found;
+        }
+
+        /// <summary>
+        /// Parses a <c>counter-reset</c>/<c>counter-increment</c> value - a space-separated sequence of
+        /// <c>&lt;name&gt; [&lt;integer&gt;]?</c> pairs - invoking <paramref name="apply"/> once per name,
+        /// with <paramref name="defaultValue"/> when no integer follows a given name.
+        /// </summary>
+        private static void ForEachNameValuePair(string value, int defaultValue, Action<string, int> apply)
+        {
+            var parts = value.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+
+            for (var i = 0; i < parts.Length; i++)
+            {
+                var name = parts[i];
+                var next = i + 1 < parts.Length ? parts[i + 1] : null;
+
+                if (next != null && int.TryParse(next, NumberStyles.Integer, CultureInfo.InvariantCulture, out var explicitValue))
+                {
+                    apply(name, explicitValue);
+                    i++;
+                }
+                else
+                {
+                    apply(name, defaultValue);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Formats a resolved counter value as a string using the given CSS counter style (<c>decimal</c>,
+        /// <c>decimal-leading-zero</c>, <c>lower-roman</c>, <c>upper-alpha</c>, etc.) - the single
+        /// counter-style resolver <c>content: counter()</c> uses. Per
+        /// <see href="https://www.w3.org/TR/css-counter-styles-3/">CSS Counter Styles Level 3 §2</see>, an
+        /// unknown/invalid style, or a value an alphabetic/symbolic style cannot represent (0 or negative),
+        /// falls back to <c>decimal</c> rather than rendering nothing.
+        /// </summary>
+        public static string FormatCounterValue(int number, string style)
+        {
+            if (string.IsNullOrEmpty(style) || style.Equals(CssConstants.Decimal, StringComparison.OrdinalIgnoreCase))
+            {
+                return number.ToString(CultureInfo.InvariantCulture);
+            }
+
+            if (style.Equals(CssConstants.DecimalLeadingZero, StringComparison.OrdinalIgnoreCase))
+            {
+                return number.ToString("00", CultureInfo.InvariantCulture);
+            }
+
+            if (IsAlphabeticCounterStyle(style))
+            {
+                var formatted = CommonUtils.ConvertToAlphaNumber(number, style);
+
+                // Alphabetic/symbolic styles have no representation for values outside their range (e.g.
+                // 0 or negatives, for which ConvertToAlphaNumber yields the empty string) - such values
+                // fall back to decimal too, per CSS Counter Styles Level 3 §2.
+                return formatted.Length > 0 ? formatted : number.ToString(CultureInfo.InvariantCulture);
+            }
+
+            // Any other unknown/invalid style falls back to decimal.
+            return number.ToString(CultureInfo.InvariantCulture);
+        }
+
+        private static bool IsAlphabeticCounterStyle(string style)
+        {
+            return style.Equals(CssConstants.LowerRoman, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.UpperRoman, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.LowerAlpha, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.UpperAlpha, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.LowerLatin, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.UpperLatin, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.LowerGreek, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.Armenian, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.Georgian, StringComparison.OrdinalIgnoreCase)
+                   || style.Equals(CssConstants.Hebrew, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}
diff --git a/Source/HtmlRenderer/Core/Parse/DomParser.cs b/Source/HtmlRenderer/Core/Parse/DomParser.cs
index 66287d5a1..7ffb57384 100644
--- a/Source/HtmlRenderer/Core/Parse/DomParser.cs
+++ b/Source/HtmlRenderer/Core/Parse/DomParser.cs
@@ -80,6 +80,8 @@ public DomParser(CssParser cssParser)
 
                 SetTextSelectionStyle(htmlContainer, cssData);
 
+                CssCounterEngine.ResolveCounters(root);
+
                 CorrectTextBoxes(root);
 
                 CorrectImgBoxes(root);
diff --git a/Source/HtmlRenderer/Core/Utils/CssUtils.cs b/Source/HtmlRenderer/Core/Utils/CssUtils.cs
index bbbec6cdd..6893c6078 100644
--- a/Source/HtmlRenderer/Core/Utils/CssUtils.cs
+++ b/Source/HtmlRenderer/Core/Utils/CssUtils.cs
@@ -49,7 +49,8 @@ internal static class CssUtils
             "padding-bottom", "padding-left", "padding-right", "padding-top",
             "page-break-inside", "break-inside", "break-before", "break-after", "page-break-before", "page-break-after",
             "widows", "orphans", "page",
-            "left", "top", "right", "bottom", "width", "max-width", "height", "min-height", "max-height",
+            "left", "top", "right", "bottom", "counter-reset", "counter-increment",
+            "width", "max-width", "height", "min-height", "max-height",
             "background-color", "background-image", "background-position", "background-repeat",
             "content", "color", "display", "direction", "empty-cells", "float", "clear", "box-sizing", "position",
             "line-height", "vertical-align", "text-indent", "text-align", "text-decoration-line",
@@ -175,6 +176,10 @@ public static string GetPropertyValue(CssBox cssBox, string propName)
                     return cssBox.Right;
                 case "bottom":
                     return cssBox.Bottom;
+                case "counter-reset":
+                    return cssBox.CounterReset;
+                case "counter-increment":
+                    return cssBox.CounterIncrement;
                 case "width":
                     return cssBox.Width;
                 case "max-width":
@@ -386,6 +391,12 @@ public static void SetPropertyValue(CssBox cssBox, string propName, string value
                 case "bottom":
                     cssBox.Bottom = value;
                     break;
+                case "counter-reset":
+                    cssBox.CounterReset = value;
+                    break;
+                case "counter-increment":
+                    cssBox.CounterIncrement = value;
+                    break;
                 case "width":
                     cssBox.Width = value;
                     break;
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Baselines/Bullets.png b/Source/Test/HtmlRenderer.IntegrationTest/Baselines/Bullets.png
index 1e2c8b6de..c1ae566b5 100644
Binary files a/Source/Test/HtmlRenderer.IntegrationTest/Baselines/Bullets.png and b/Source/Test/HtmlRenderer.IntegrationTest/Baselines/Bullets.png differ
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Content/CssContentEngineIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Content/CssContentEngineIntegrationTests.cs
new file mode 100644
index 000000000..6b3082128
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Content/CssContentEngineIntegrationTests.cs
@@ -0,0 +1,218 @@
+using System.Linq;
+using HtmlRenderer.IntegrationTest.TestSupport;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+
+namespace HtmlRenderer.IntegrationTest.Content;
+
+/// <summary>
+/// Ported from PeachPDF.Tests/Html/Core/Dom/CssContentEngineTests.cs, exercised through the real box tree
+/// (a <c>::before</c>/<c>::after</c> rule + <see cref="LayoutHarness"/>) rather than a hand-built box, since
+/// this fork's pseudo-element boxes are created as a side effect of selector matching
+/// (<c>CssData.DoesSelectorMatch</c>) rather than being independently constructible.
+/// <para>
+/// PeachPDF's <c>string()</c>/named-string and <c>target-counter()</c>/margin-box cases are not ported: this
+/// fork has neither named strings nor CSS Paged Media margin boxes. <c>counter-reset</c>/
+/// <c>counter-increment</c> threading through document order (<see cref="CssCounterEngine.ResolveCounters"/>)
+/// is a new, deliberately scoped-down backport for this pass - see that class's remarks for exactly what's
+/// covered (ordinary sequential/nested usage) and what isn't (<c>reversed()</c>, <c>counter-set</c>).
+/// </para>
+/// </summary>
+[DoNotParallelize]
+[TestClass]
+public sealed class CssContentEngineIntegrationTests
+{
+    [TestMethod]
+    public void ApplyContent_WithStringLiteral_SetsText()
+    {
+        var before = ResolveBeforeContent("\"Hello World\"");
+        Assert.AreEqual("Hello World", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithMultipleStringLiterals_Concatenates()
+    {
+        var before = ResolveBeforeContent("\"Hello\" \" \" \"World\"");
+        Assert.AreEqual("Hello World", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithNone_DoesNotCreateContent()
+    {
+        var html = LayoutHarness.Wrap("<p id='p'>text</p><style>#p::before { content: none; }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var p = LayoutHarness.FindById(root, "p")!;
+
+        Assert.IsFalse(p.Boxes.Any(b => b.IsBeforePseudoElement && b.Text != null));
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithAttrFunction_RetrievesAttribute()
+    {
+        var html = LayoutHarness.Wrap(
+            "<p id='p' data-label='Chapter One'>text</p><style>#p::before { content: attr(data-label); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var p = LayoutHarness.FindById(root, "p")!;
+        var before = p.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("Chapter One", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithOpenAndCloseQuote_UsesCurlyQuotes()
+    {
+        var before = ResolveBeforeContent("open-quote \"quoted\" close-quote");
+        Assert.AreEqual("“quoted”", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithCounterNoStyle_UsesDecimal()
+    {
+        var html = LayoutHarness.Wrap(
+            "<p id='p' style='counter-reset:item 7'>text</p><style>#p::before { content: counter(item); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var before = LayoutHarness.FindById(root, "p")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("7", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithCounterDecimalLeadingZero_PadsToTwoDigits()
+    {
+        var html = LayoutHarness.Wrap(
+            "<p id='p' style='counter-reset:item 1'>text</p>"
+            + "<style>#p::before { content: counter(item, decimal-leading-zero); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var before = LayoutHarness.FindById(root, "p")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("01", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithCounterAlphabeticStyle_FormatsWithStyle()
+    {
+        var html = LayoutHarness.Wrap(
+            "<p id='p' style='counter-reset:item 4'>text</p>"
+            + "<style>#p::before { content: counter(item, upper-roman); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var before = LayoutHarness.FindById(root, "p")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("IV", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithCounterUnknownStyle_FallsBackToDecimal()
+    {
+        // CSS Counter Styles Level 3 §2: unknown style must render as decimal, not empty.
+        var html = LayoutHarness.Wrap(
+            "<p id='p' style='counter-reset:item 5'>text</p>"
+            + "<style>#p::before { content: counter(item, bogus-style); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var before = LayoutHarness.FindById(root, "p")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("5", before.Text);
+    }
+
+    [TestMethod]
+    public void ApplyContent_WithCounterAndStyleAndLiteral_Concatenates()
+    {
+        var html = LayoutHarness.Wrap(
+            "<p id='p' style='counter-reset:item 3'>text</p>"
+            + "<style>#p::before { content: counter(item, decimal-leading-zero) \" Item\"; }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var before = LayoutHarness.FindById(root, "p")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("03 Item", before.Text);
+    }
+
+    [TestMethod]
+    public void CounterIncrement_ThreadsSequentiallyAcrossSiblings()
+    {
+        // CSS 2.1 §12.4: counter-increment accumulates through document order - three siblings each
+        // incrementing "item" should see 1, 2, 3 in turn.
+        var html = LayoutHarness.Wrap(
+            "<div style='counter-reset:item 0'>"
+            + "<p id='a' style='counter-increment:item'>text</p>"
+            + "<p id='b' style='counter-increment:item'>text</p>"
+            + "<p id='c' style='counter-increment:item'>text</p>"
+            + "</div>"
+            + "<style>p::before { content: counter(item); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+
+        var a = LayoutHarness.FindById(root, "a")!.Boxes.First(b => b.IsBeforePseudoElement);
+        var b = LayoutHarness.FindById(root, "b")!.Boxes.First(b => b.IsBeforePseudoElement);
+        var c = LayoutHarness.FindById(root, "c")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("1", a.Text);
+        Assert.AreEqual("2", b.Text);
+        Assert.AreEqual("3", c.Text);
+    }
+
+    [TestMethod]
+    public void CounterReset_OnNestedAncestor_IsVisibleToDescendant()
+    {
+        // A counter-reset on an ancestor is visible to descendants further down the tree, not just
+        // direct children.
+        var html = LayoutHarness.Wrap(
+            "<div style='counter-reset:section 5'><div><p id='p'>text</p></div></div>"
+            + "<style>#p::before { content: counter(section); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var before = LayoutHarness.FindById(root, "p")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("5", before.Text);
+    }
+
+    [TestMethod]
+    public void CounterReset_InANestedList_DoesNotLeakIntoTheOuterList()
+    {
+        // The inner list's reset creates a new counter that goes out of scope with the inner list, so
+        // the outer list continues at 2.
+        var html = LayoutHarness.Wrap(
+            "<div class='list'>"
+            + "<div class='item'><span id='a'>A</span>"
+            + "<div class='list'><p class='item'>x</p><p class='item'>y</p><p class='item'>z</p></div>"
+            + "</div>"
+            + "<div class='item'><span id='b'>B</span></div>"
+            + "</div>"
+            + "<style>.list { counter-reset: item; } .item { counter-increment: item; }"
+            + " #a::before, #b::before { content: counter(item); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+
+        var a = LayoutHarness.FindById(root, "a")!.Boxes.First(b => b.IsBeforePseudoElement);
+        var b = LayoutHarness.FindById(root, "b")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("1", a.Text);
+        Assert.AreEqual("2", b.Text);
+    }
+
+    [TestMethod]
+    public void CounterIncrement_OnADisplayNoneElement_IsIgnored()
+    {
+        var html = LayoutHarness.Wrap(
+            "<div style='counter-reset:item'>"
+            + "<p style='counter-increment:item'>a</p>"
+            + "<p style='counter-increment:item; display:none'>hidden</p>"
+            + "<p id='c' style='counter-increment:item'>c</p>"
+            + "</div>"
+            + "<style>#c::before { content: counter(item); }</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var before = LayoutHarness.FindById(root, "c")!.Boxes.First(b => b.IsBeforePseudoElement);
+
+        Assert.AreEqual("2", before.Text);
+    }
+
+    [TestMethod]
+    public void Counter_NotInScope_ReadsAsZero()
+    {
+        Assert.AreEqual("0", ResolveBeforeContent("counter(nothing)").Text);
+    }
+
+    // ── Helpers ────────────────────────────────────────────────────────────
+
+    private static CssBox ResolveBeforeContent(string contentValue)
+    {
+        var html = LayoutHarness.Wrap(
+            $"<p id='p'>text</p><style>#p::before {{ content: {contentValue}; }}</style>");
+        var (root, _) = LayoutHarness.Layout(html);
+        return LayoutHarness.FindById(root, "p")!.Boxes.First(b => b.IsBeforePseudoElement);
+    }
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Content/ListItemCounterIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Content/ListItemCounterIntegrationTests.cs
new file mode 100644
index 000000000..6a3d84391
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Content/ListItemCounterIntegrationTests.cs
@@ -0,0 +1,70 @@
+using System.Linq;
+using HtmlRenderer.IntegrationTest.TestSupport;
+
+namespace HtmlRenderer.IntegrationTest.Content;
+
+/// <summary>
+/// Ported from PeachPDF.Tests/Integration/ListItemCounterIntegrationTests.cs - the CSS2.1-relevant subset
+/// this fork's simpler, non-CSS-counter-driven list-marker mechanism (<c>CssBox.GetIndexForList</c>) can
+/// support: <c>&lt;ol start&gt;</c>/<c>reversed</c> (already implemented) and <c>&lt;li value&gt;</c> (newly
+/// added by this port). CSS3 marker-styling extras from the source file are not ported.
+/// </summary>
+[DoNotParallelize]
+[TestClass]
+public sealed class ListItemCounterIntegrationTests
+{
+    [TestMethod]
+    public void OlStart_OffsetsEveryItem()
+    {
+        var html = LayoutHarness.Wrap("<ol start='5'><li id='a'>x</li><li id='b'>y</li></ol>");
+        var (root, _) = LayoutHarness.Layout(html);
+
+        var a = LayoutHarness.FindById(root, "a")!;
+        var b = LayoutHarness.FindById(root, "b")!;
+
+        Assert.AreEqual("5.", a.ListItemBox.Words[0].Text);
+        Assert.AreEqual("6.", b.ListItemBox.Words[0].Text);
+    }
+
+    [TestMethod]
+    public void OlReversed_CountsDownFromItemCount()
+    {
+        var html = LayoutHarness.Wrap("<ol reversed='reversed'><li id='a'>x</li><li id='b'>y</li><li id='c'>z</li></ol>");
+        var (root, _) = LayoutHarness.Layout(html);
+
+        var a = LayoutHarness.FindById(root, "a")!;
+        var b = LayoutHarness.FindById(root, "b")!;
+        var c = LayoutHarness.FindById(root, "c")!;
+
+        Assert.AreEqual("3.", a.ListItemBox.Words[0].Text);
+        Assert.AreEqual("2.", b.ListItemBox.Words[0].Text);
+        Assert.AreEqual("1.", c.ListItemBox.Words[0].Text);
+    }
+
+    [TestMethod]
+    public void LiValue_OverridesThatItemAndContinuesFromThere()
+    {
+        var html = LayoutHarness.Wrap(
+            "<ol><li id='a'>x</li><li id='b' value='10'>y</li><li id='c'>z</li></ol>");
+        var (root, _) = LayoutHarness.Layout(html);
+
+        var a = LayoutHarness.FindById(root, "a")!;
+        var b = LayoutHarness.FindById(root, "b")!;
+        var c = LayoutHarness.FindById(root, "c")!;
+
+        Assert.AreEqual("1.", a.ListItemBox.Words[0].Text);
+        Assert.AreEqual("10.", b.ListItemBox.Words[0].Text);
+        Assert.AreEqual("11.", c.ListItemBox.Words[0].Text);
+    }
+
+    [TestMethod]
+    public void ListStyleTypeSquare_UsesAFilledSquareGlyph_NotASpadeSuitSymbol()
+    {
+        // Regression: this used to render "♠" (U+2660 BLACK SPADE SUIT), not a square at all.
+        var html = LayoutHarness.Wrap("<ul style='list-style-type:square'><li id='a'>x</li></ul>");
+        var (root, _) = LayoutHarness.Layout(html);
+        var a = LayoutHarness.FindById(root, "a")!;
+
+        Assert.AreEqual("▪", a.ListItemBox.Words[0].Text);
+    }
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Text/HtmlEntityDecodingIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Text/HtmlEntityDecodingIntegrationTests.cs
index ae7432465..890ab5d4d 100644
--- a/Source/Test/HtmlRenderer.IntegrationTest/Text/HtmlEntityDecodingIntegrationTests.cs
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Text/HtmlEntityDecodingIntegrationTests.cs
@@ -189,9 +189,6 @@ public void CssContentWithCssEscape_RendersLiterally()
         Assert.AreEqual("&", beforeBox!.Text);
     }
 
-    [Ignore("Requires ::before/::after pseudo-elements with a CSS content: property - this fork has no " +
-            "pseudo-element support at all (confirmed: no \"::before\"/\"::after\"/pseudo-element handling " +
-            "anywhere in Core, only :link/:hover pseudo-CLASSES are recognized).")]
     [TestMethod]
     public void CssContentWithCssEscapeInString_RendersLiterally()
     {
@@ -200,7 +197,10 @@ public void CssContentWithCssEscapeInString_RendersLiterally()
         var (root, _) = LayoutHarness.Layout(html);
         var p = LayoutHarness.FindById(root, "p")!;
 
-        var afterBox = p.Boxes.FirstOrDefault(b => b.HtmlTag == null && b.Text != null);
+        // Unlike ::before (inserted at index 0), ::after is appended at the end of p.Boxes - so
+        // FirstOrDefault(HtmlTag == null) would instead match the real text node "text" (which also has
+        // no HtmlTag), not the pseudo box. IsAfterPseudoElement identifies it unambiguously.
+        var afterBox = p.Boxes.FirstOrDefault(b => b.IsAfterPseudoElement);
         Assert.IsNotNull(afterBox);
         Assert.IsTrue(afterBox!.Text!.Contains('<'));
         Assert.IsTrue(afterBox.Text!.Contains('>'));
diff --git a/Source/Test/HtmlRenderer.Test/Dom/CssCounterEngineTests.cs b/Source/Test/HtmlRenderer.Test/Dom/CssCounterEngineTests.cs
new file mode 100644
index 000000000..5992511ca
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Dom/CssCounterEngineTests.cs
@@ -0,0 +1,58 @@
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+
+namespace HtmlRenderer.Test.Dom;
+
+/// <summary>
+/// Ported from PeachPDF.Tests/Html/Core/Dom/CssCounterEngineTests.cs. Unit tests for
+/// <see cref="CssCounterEngine.FormatCounterValue"/>, the counter-style resolver <c>content: counter()</c>
+/// uses. Pins the CSS Counter Styles Level 3 §2 requirement that an unknown/invalid style falls back to
+/// <c>decimal</c> rather than rendering nothing.
+/// </summary>
+[TestClass]
+public sealed class CssCounterEngineTests
+{
+    [TestMethod]
+    [DataRow(1, "decimal", "1")]
+    [DataRow(12, "decimal", "12")]
+    [DataRow(1, "decimal-leading-zero", "01")]
+    [DataRow(9, "decimal-leading-zero", "09")]
+    [DataRow(12, "decimal-leading-zero", "12")] // already two digits - no over-padding
+    [DataRow(100, "decimal-leading-zero", "100")]
+    [DataRow(4, "lower-roman", "iv")]
+    [DataRow(4, "upper-roman", "IV")]
+    [DataRow(1, "lower-alpha", "a")]
+    [DataRow(3, "upper-alpha", "C")]
+    public void FormatCounterValue_KnownStyles_FormatAsExpected(int number, string style, string expected)
+    {
+        Assert.AreEqual(expected, CssCounterEngine.FormatCounterValue(number, style));
+    }
+
+    [TestMethod]
+    [DataRow(1)]
+    [DataRow(7)]
+    [DataRow(42)]
+    public void FormatCounterValue_UnknownStyle_FallsBackToDecimal(int number)
+    {
+        // CSS Counter Styles Level 3 §2: an unknown/invalid counter style renders as decimal, never empty.
+        Assert.AreEqual(number.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            CssCounterEngine.FormatCounterValue(number, "not-a-real-style"));
+    }
+
+    [TestMethod]
+    [DataRow(0, "upper-roman", "0")]
+    [DataRow(-5, "lower-alpha", "-5")]
+    [DataRow(0, "lower-greek", "0")]
+    public void FormatCounterValue_AlphabeticStyleOutOfRange_FallsBackToDecimal(int number, string style, string expected)
+    {
+        // Alphabetic/symbolic styles can't represent 0 or negatives; CSS Counter Styles L3 §2 says such
+        // out-of-range values render with the fallback style (decimal), not empty.
+        Assert.AreEqual(expected, CssCounterEngine.FormatCounterValue(number, style));
+    }
+
+    [TestMethod]
+    public void FormatCounterValue_StyleMatchIsCaseInsensitive()
+    {
+        Assert.AreEqual("01", CssCounterEngine.FormatCounterValue(1, "DECIMAL-LEADING-ZERO"));
+        Assert.AreEqual("iv", CssCounterEngine.FormatCounterValue(4, "Lower-Roman"));
+    }
+}