Fix font-family quote/list resolution and list-style-type: hebrew

- CssUtils/CssParser: the "font-family" CSS property was assigned
  as a raw, unresolved string, so a quoted or comma-separated value
  (e.g. "'Arial'" or "Verdana, sans-serif") never matched any real
  installed font by name and silently fell back to a generic default
  for every element that used one. Route it through the existing
  ParseFontFamily resolver (already used correctly for the legacy
  <font face="..."> attribute, just never wired up for the CSS
  property) instead of assigning the literal declared text. Also
  fixes ParseFontFamily's not-found fallback, which returned the
  literal string "inherit" as a sentinel - confusable with the real
  CSS keyword downstream - to CssConstants.DefaultFont instead.

- CssEngine (Keywords/ListStyle/Map): list-style-type: hebrew parsed
  as an unrecognized keyword and silently fell back to decimal
  numbering, even though the Hebrew-numeral conversion table already
  existed and worked. Added the missing keyword/enum/map entries so
  the value reaches that existing conversion code. Same underlying
  gap and fix as PeachPDF's 1f340a55.

- CommonUtils: the hebrew and armenian numbering tables were only
  3 rows deep, silently dropping the thousands digit for any value
  >= 1000; added the missing thousands row to both, plus Hebrew's
  CSS Counter Styles Level 3 15/16 override (ט"ו/ט"ז instead of the
  naive combination, which would otherwise resemble the
  Tetragrammaton) - also sourced from PeachPDF's 1f340a55.

Integration test suite: 25/29 -> 26/29 passing.

Author: jhaygood86

Source/HtmlRenderer/Core/CssEngine/Enumerations/Keywords.cs

@@ -189,6 +189,7 @@ internal static class Keywords
         public static readonly string UpperLatin = "upper-latin";
         public static readonly string Armenian = "armenian";
         public static readonly string Georgian = "georgian";
+        public static readonly string Hebrew = "hebrew";
         public static readonly string LowerAlpha = "lower-alpha";
         public static readonly string UpperAlpha = "upper-alpha";
         public static readonly string XxSmall = "xx-small";

Source/HtmlRenderer/Core/CssEngine/Enumerations/ListStyle.cs

@@ -14,6 +14,7 @@ internal enum ListStyle : byte
         LowerLatin,
         UpperLatin,
         Armenian,
-        Georgian
+        Georgian,
+        Hebrew
     }
 }

Source/HtmlRenderer/Core/CssEngine/Model/Map.cs

@@ -178,6 +178,7 @@ internal static class Map
                 {Keywords.UpperLatin, ListStyle.UpperLatin},
                 {Keywords.Armenian, ListStyle.Armenian},
                 {Keywords.Georgian, ListStyle.Georgian},
+                {Keywords.Hebrew, ListStyle.Hebrew},
                 {Keywords.LowerAlpha, ListStyle.LowerLatin},
                 {Keywords.UpperAlpha, ListStyle.UpperLatin},
                 {Keywords.None, ListStyle.None}

Source/HtmlRenderer/Core/Parse/CssParser.cs

@@ -166,8 +166,11 @@ public CssImage ParseBackgroundImage(string value)
         }
 
         /// <summary>
-        /// Parse a complex font family css property to check if it contains multiple fonts and if the font exists.<br/>
-        /// returns the font family name to use or 'inherit' if failed.
+        /// Parse a "font-family" value - possibly a comma-separated fallback list, each candidate
+        /// possibly quoted (e.g. <c>'Helvetica Neue', Arial, sans-serif</c>) - into the first
+        /// candidate that's actually installed/registered, or <see cref="CssConstants.DefaultFont"/>
+        /// if none of them are. Previously returned the literal string "inherit" as a not-found
+        /// sentinel, which was confusable with the real CSS <c>inherit</c> keyword downstream.
         /// </summary>
         /// <param name="value">the font-family value to parse</param>
         /// <returns>parsed font-family value</returns>
@@ -196,7 +199,7 @@ public string ParseFontFamily(string value)
                 start = end + 1;
             }
 
-            return CssConstants.Inherit;
+            return CssConstants.DefaultFont;
         }
 
         #region Private methods

Source/HtmlRenderer/Core/Utils/CommonUtils.cs

@@ -47,11 +47,19 @@ internal static class CommonUtils
             }
         };
 
+        /// <summary>
+        /// Table to convert numbers into hebrew digits - CSS Counter Styles Level 3 §6.1's "hebrew"
+        /// <c>@counter-style</c>. Row 3 (thousands) is each units-row letter with a geresh (U+05F3)
+        /// appended, per the spec's additive-symbols list (e.g. 1000 is the same letter as 1 plus a
+        /// geresh) - a 3-row table silently drops the thousands digit entirely for any value >= 1000.
+        /// 15 and 16 need a further, non-tabular override - see <see cref="ConvertToAlphaNumber"/>.
+        /// </summary>
         private static readonly string[,] _hebrewDigitsTable =
         {
             { "א", "ב", "ג", "ד", "ה", "ו", "ז", "ח", "ט" },
             { "י", "כ", "ל", "מ", "נ", "ס", "ע", "פ", "צ" },
-            { "ק", "ר", "ש", "ת", "תק", "תר", "תש", "תת", "תתק", }
+            { "ק", "ר", "ש", "ת", "תק", "תר", "תש", "תת", "תתק", },
+            { "א׳", "ב׳", "ג׳", "ד׳", "ה׳", "ו׳", "ז׳", "ח׳", "ט׳" }
         };
 
         private static readonly string[,] _georgianDigitsTable =
@@ -61,11 +69,18 @@ internal static class CommonUtils
             { "რ", "ს", "ტ", "ჳ", "ფ", "ქ", "ღ", "ყ", "შ" }
         };
 
+        /// <summary>
+        /// Table to convert numbers into armenian digits - CSS Counter Styles Level 3 §6.1's
+        /// "armenian" <c>@counter-style</c>. Row 3 (thousands) added for the same reason as
+        /// <see cref="_hebrewDigitsTable"/>'s - a 3-row table silently drops the thousands digit for
+        /// any value >= 1000.
+        /// </summary>
         private static readonly string[,] _armenianDigitsTable =
         {
             { "Ա", "Բ", "Գ", "Դ", "Ե", "Զ", "Է", "Ը", "Թ" },
             { "Ժ", "Ի", "Լ", "Խ", "Ծ", "Կ", "Հ", "Ձ", "Ղ" },
-            { "Ճ", "Մ", "Յ", "Ն", "Շ", "Ո", "Չ", "Պ", "Ջ" }
+            { "Ճ", "Մ", "Յ", "Ն", "Շ", "Ո", "Չ", "Պ", "Ջ" },
+            { "Ռ", "Ս", "Վ", "Տ", "Ր", "Ց", "Ւ", "Փ", "Ք" }
         };
 
         private static readonly string[] _hiraganaDigitsTable = new[]
@@ -378,7 +393,7 @@ public static string ConvertToAlphaNumber(int number, string style = CssConstant
             }
             else if (style.Equals(CssConstants.Hebrew, StringComparison.InvariantCultureIgnoreCase))
             {
-                return ConvertToSpecificNumbers(number, _hebrewDigitsTable);
+                return ConvertToHebrewNumber(number);
             }
             else if (style.Equals(CssConstants.Hiragana, StringComparison.InvariantCultureIgnoreCase) || style.Equals(CssConstants.HiraganaIroha, StringComparison.InvariantCultureIgnoreCase))
             {
@@ -469,6 +484,27 @@ private static string ConvertToRomanNumbers(int number, bool lowercase)
             return lowercase ? sb.ToLower() : sb;
         }
 
+        /// <summary>
+        /// Hebrew's additive algorithm (<see cref="ConvertToSpecificNumbers"/> over
+        /// <see cref="_hebrewDigitsTable"/>) with the CSS Counter Styles Level 3 §6.1 override for a
+        /// tens-and-units value of 15 or 16: the naive per-digit-group combination would produce יה/יו,
+        /// which closely resembles the Tetragrammaton, so the spec mandates טו/טז instead. 17-19 don't
+        /// need an override - their naive combination (יז/יח/יט) already matches the spec's table.
+        /// </summary>
+        /// <param name="number">the number to convert</param>
+        /// <returns>the hebrew number string</returns>
+        private static string ConvertToHebrewNumber(int number)
+        {
+            var tensAndUnits = number % 100;
+            if (tensAndUnits is 15 or 16)
+            {
+                var hundredsAndUp = ConvertToSpecificNumbers(number - tensAndUnits, _hebrewDigitsTable);
+                return hundredsAndUp + (tensAndUnits == 15 ? "טו" : "טז");
+            }
+
+            return ConvertToSpecificNumbers(number, _hebrewDigitsTable);
+        }
+
         /// <summary>
         /// Convert the given integer into given alphabet numeric system.
         /// </summary>

Source/HtmlRenderer/Core/Utils/CssUtils.cs

@@ -394,7 +394,13 @@ public static void SetPropertyValue(CssBox cssBox, string propName, string value
                     cssBox.WordSpacing = value;
                     break;
                 case "font-family":
-                    cssBox.FontFamily = value;
+                    // The declared value may be a comma-separated fallback list and/or have quoted
+                    // candidates (e.g. "'Helvetica Neue', Arial, sans-serif") - resolve it down to the
+                    // first candidate that's actually installed, same as the legacy <font face="...">
+                    // attribute already does, rather than handing the literal, possibly-quoted CSS
+                    // text straight to font creation (which fails to match any real font by name and
+                    // silently falls back to a generic system font for every unresolved candidate).
+                    cssBox.FontFamily = cssBox.HtmlContainer.CssParser.ParseFontFamily(value);
                     break;
                 case "font-size":
                     cssBox.FontSize = value;