docs/HtmlAgilityPack/HtmlEntity.cs

   1 // HtmlAgilityPack V1.0 - Simon Mourier <simon underscore mourier at hotmail dot com>\r
   2 using System;\r
   3 using System.Collections;\r
   4 using System.Text;\r
   5 \r
   6 namespace HtmlAgilityPack\r
   7 {\r
   8     /// <summary>\r
   9     /// A utility class to replace special characters by entities and vice-versa.\r
  10     /// Follows HTML 4.0 specification found at http://www.w3.org/TR/html4/sgml/entities.html\r
  11     /// </summary>\r
  12     public class HtmlEntity\r
  13     {\r
  14         #region Static Members\r
  15 \r
  16         private static readonly int _maxEntitySize;\r
  17         private static Hashtable _entityName;\r
  18         private static Hashtable _entityValue;\r
  19 \r
  20         /// <summary>\r
  21         /// A collection of entities indexed by name.\r
  22         /// </summary>\r
  23         public static Hashtable EntityName\r
  24         {\r
  25             get { return _entityName; }\r
  26         }\r
  27 \r
  28         /// <summary>\r
  29         /// A collection of entities indexed by value.\r
  30         /// </summary>\r
  31         public static Hashtable EntityValue\r
  32         {\r
  33             get { return _entityValue; }\r
  34         }\r
  35 \r
  36         #endregion\r
  37 \r
  38         #region Constructors\r
  39 \r
  40         static HtmlEntity()\r
  41         {\r
  42             _entityName = new Hashtable();\r
  43             _entityValue = new Hashtable();\r
  44 \r
  45             #region Entities Definition\r
  46 \r
  47             _entityValue.Add("nbsp", 160); // no-break space = non-breaking space, U+00A0 ISOnum \r
  48             _entityName.Add(160, "nbsp");\r
  49             _entityValue.Add("iexcl", 161); // inverted exclamation mark, U+00A1 ISOnum \r
  50             _entityName.Add(161, "iexcl");\r
  51             _entityValue.Add("cent", 162); // cent sign, U+00A2 ISOnum \r
  52             _entityName.Add(162, "cent");\r
  53             _entityValue.Add("pound", 163); // pound sign, U+00A3 ISOnum \r
  54             _entityName.Add(163, "pound");\r
  55             _entityValue.Add("curren", 164); // currency sign, U+00A4 ISOnum \r
  56             _entityName.Add(164, "curren");\r
  57             _entityValue.Add("yen", 165); // yen sign = yuan sign, U+00A5 ISOnum \r
  58             _entityName.Add(165, "yen");\r
  59             _entityValue.Add("brvbar", 166); // broken bar = broken vertical bar, U+00A6 ISOnum \r
  60             _entityName.Add(166, "brvbar");\r
  61             _entityValue.Add("sect", 167); // section sign, U+00A7 ISOnum \r
  62             _entityName.Add(167, "sect");\r
  63             _entityValue.Add("uml", 168); // diaeresis = spacing diaeresis, U+00A8 ISOdia \r
  64             _entityName.Add(168, "uml");\r
  65             _entityValue.Add("copy", 169); // copyright sign, U+00A9 ISOnum \r
  66             _entityName.Add(169, "copy");\r
  67             _entityValue.Add("ordf", 170); // feminine ordinal indicator, U+00AA ISOnum \r
  68             _entityName.Add(170, "ordf");\r
  69             _entityValue.Add("laquo", 171);\r
  70                 // left-pointing double angle quotation mark = left pointing guillemet, U+00AB ISOnum \r
  71             _entityName.Add(171, "laquo");\r
  72             _entityValue.Add("not", 172); // not sign, U+00AC ISOnum \r
  73             _entityName.Add(172, "not");\r
  74             _entityValue.Add("shy", 173); // soft hyphen = discretionary hyphen, U+00AD ISOnum \r
  75             _entityName.Add(173, "shy");\r
  76             _entityValue.Add("reg", 174); // registered sign = registered trade mark sign, U+00AE ISOnum \r
  77             _entityName.Add(174, "reg");\r
  78             _entityValue.Add("macr", 175); // macron = spacing macron = overline = APL overbar, U+00AF ISOdia \r
  79             _entityName.Add(175, "macr");\r
  80             _entityValue.Add("deg", 176); // degree sign, U+00B0 ISOnum \r
  81             _entityName.Add(176, "deg");\r
  82             _entityValue.Add("plusmn", 177); // plus-minus sign = plus-or-minus sign, U+00B1 ISOnum \r
  83             _entityName.Add(177, "plusmn");\r
  84             _entityValue.Add("sup2", 178); // superscript two = superscript digit two = squared, U+00B2 ISOnum \r
  85             _entityName.Add(178, "sup2");\r
  86             _entityValue.Add("sup3", 179); // superscript three = superscript digit three = cubed, U+00B3 ISOnum \r
  87             _entityName.Add(179, "sup3");\r
  88             _entityValue.Add("acute", 180); // acute accent = spacing acute, U+00B4 ISOdia \r
  89             _entityName.Add(180, "acute");\r
  90             _entityValue.Add("micro", 181); // micro sign, U+00B5 ISOnum \r
  91             _entityName.Add(181, "micro");\r
  92             _entityValue.Add("para", 182); // pilcrow sign = paragraph sign, U+00B6 ISOnum \r
  93             _entityName.Add(182, "para");\r
  94             _entityValue.Add("middot", 183); // middle dot = Georgian comma = Greek middle dot, U+00B7 ISOnum \r
  95             _entityName.Add(183, "middot");\r
  96             _entityValue.Add("cedil", 184); // cedilla = spacing cedilla, U+00B8 ISOdia \r
  97             _entityName.Add(184, "cedil");\r
  98             _entityValue.Add("sup1", 185); // superscript one = superscript digit one, U+00B9 ISOnum \r
  99             _entityName.Add(185, "sup1");\r
 100             _entityValue.Add("ordm", 186); // masculine ordinal indicator, U+00BA ISOnum \r
 101             _entityName.Add(186, "ordm");\r
 102             _entityValue.Add("raquo", 187);\r
 103                 // right-pointing double angle quotation mark = right pointing guillemet, U+00BB ISOnum \r
 104             _entityName.Add(187, "raquo");\r
 105             _entityValue.Add("frac14", 188); // vulgar fraction one quarter = fraction one quarter, U+00BC ISOnum \r
 106             _entityName.Add(188, "frac14");\r
 107             _entityValue.Add("frac12", 189); // vulgar fraction one half = fraction one half, U+00BD ISOnum \r
 108             _entityName.Add(189, "frac12");\r
 109             _entityValue.Add("frac34", 190); // vulgar fraction three quarters = fraction three quarters, U+00BE ISOnum \r
 110             _entityName.Add(190, "frac34");\r
 111             _entityValue.Add("iquest", 191); // inverted question mark = turned question mark, U+00BF ISOnum \r
 112             _entityName.Add(191, "iquest");\r
 113             _entityValue.Add("Agrave", 192);\r
 114                 // latin capital letter A with grave = latin capital letter A grave, U+00C0 ISOlat1 \r
 115             _entityName.Add(192, "Agrave");\r
 116             _entityValue.Add("Aacute", 193); // latin capital letter A with acute, U+00C1 ISOlat1 \r
 117             _entityName.Add(193, "Aacute");\r
 118             _entityValue.Add("Acirc", 194); // latin capital letter A with circumflex, U+00C2 ISOlat1 \r
 119             _entityName.Add(194, "Acirc");\r
 120             _entityValue.Add("Atilde", 195); // latin capital letter A with tilde, U+00C3 ISOlat1 \r
 121             _entityName.Add(195, "Atilde");\r
 122             _entityValue.Add("Auml", 196); // latin capital letter A with diaeresis, U+00C4 ISOlat1 \r
 123             _entityName.Add(196, "Auml");\r
 124             _entityValue.Add("Aring", 197);\r
 125                 // latin capital letter A with ring above = latin capital letter A ring, U+00C5 ISOlat1 \r
 126             _entityName.Add(197, "Aring");\r
 127             _entityValue.Add("AElig", 198); // latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1 \r
 128             _entityName.Add(198, "AElig");\r
 129             _entityValue.Add("Ccedil", 199); // latin capital letter C with cedilla, U+00C7 ISOlat1 \r
 130             _entityName.Add(199, "Ccedil");\r
 131             _entityValue.Add("Egrave", 200); // latin capital letter E with grave, U+00C8 ISOlat1 \r
 132             _entityName.Add(200, "Egrave");\r
 133             _entityValue.Add("Eacute", 201); // latin capital letter E with acute, U+00C9 ISOlat1 \r
 134             _entityName.Add(201, "Eacute");\r
 135             _entityValue.Add("Ecirc", 202); // latin capital letter E with circumflex, U+00CA ISOlat1 \r
 136             _entityName.Add(202, "Ecirc");\r
 137             _entityValue.Add("Euml", 203); // latin capital letter E with diaeresis, U+00CB ISOlat1 \r
 138             _entityName.Add(203, "Euml");\r
 139             _entityValue.Add("Igrave", 204); // latin capital letter I with grave, U+00CC ISOlat1 \r
 140             _entityName.Add(204, "Igrave");\r
 141             _entityValue.Add("Iacute", 205); // latin capital letter I with acute, U+00CD ISOlat1 \r
 142             _entityName.Add(205, "Iacute");\r
 143             _entityValue.Add("Icirc", 206); // latin capital letter I with circumflex, U+00CE ISOlat1 \r
 144             _entityName.Add(206, "Icirc");\r
 145             _entityValue.Add("Iuml", 207); // latin capital letter I with diaeresis, U+00CF ISOlat1 \r
 146             _entityName.Add(207, "Iuml");\r
 147             _entityValue.Add("ETH", 208); // latin capital letter ETH, U+00D0 ISOlat1 \r
 148             _entityName.Add(208, "ETH");\r
 149             _entityValue.Add("Ntilde", 209); // latin capital letter N with tilde, U+00D1 ISOlat1 \r
 150             _entityName.Add(209, "Ntilde");\r
 151             _entityValue.Add("Ograve", 210); // latin capital letter O with grave, U+00D2 ISOlat1 \r
 152             _entityName.Add(210, "Ograve");\r
 153             _entityValue.Add("Oacute", 211); // latin capital letter O with acute, U+00D3 ISOlat1 \r
 154             _entityName.Add(211, "Oacute");\r
 155             _entityValue.Add("Ocirc", 212); // latin capital letter O with circumflex, U+00D4 ISOlat1 \r
 156             _entityName.Add(212, "Ocirc");\r
 157             _entityValue.Add("Otilde", 213); // latin capital letter O with tilde, U+00D5 ISOlat1 \r
 158             _entityName.Add(213, "Otilde");\r
 159             _entityValue.Add("Ouml", 214); // latin capital letter O with diaeresis, U+00D6 ISOlat1 \r
 160             _entityName.Add(214, "Ouml");\r
 161             _entityValue.Add("times", 215); // multiplication sign, U+00D7 ISOnum \r
 162             _entityName.Add(215, "times");\r
 163             _entityValue.Add("Oslash", 216);\r
 164                 // latin capital letter O with stroke = latin capital letter O slash, U+00D8 ISOlat1 \r
 165             _entityName.Add(216, "Oslash");\r
 166             _entityValue.Add("Ugrave", 217); // latin capital letter U with grave, U+00D9 ISOlat1 \r
 167             _entityName.Add(217, "Ugrave");\r
 168             _entityValue.Add("Uacute", 218); // latin capital letter U with acute, U+00DA ISOlat1 \r
 169             _entityName.Add(218, "Uacute");\r
 170             _entityValue.Add("Ucirc", 219); // latin capital letter U with circumflex, U+00DB ISOlat1 \r
 171             _entityName.Add(219, "Ucirc");\r
 172             _entityValue.Add("Uuml", 220); // latin capital letter U with diaeresis, U+00DC ISOlat1 \r
 173             _entityName.Add(220, "Uuml");\r
 174             _entityValue.Add("Yacute", 221); // latin capital letter Y with acute, U+00DD ISOlat1 \r
 175             _entityName.Add(221, "Yacute");\r
 176             _entityValue.Add("THORN", 222); // latin capital letter THORN, U+00DE ISOlat1 \r
 177             _entityName.Add(222, "THORN");\r
 178             _entityValue.Add("szlig", 223); // latin small letter sharp s = ess-zed, U+00DF ISOlat1 \r
 179             _entityName.Add(223, "szlig");\r
 180             _entityValue.Add("agrave", 224);\r
 181                 // latin small letter a with grave = latin small letter a grave, U+00E0 ISOlat1 \r
 182             _entityName.Add(224, "agrave");\r
 183             _entityValue.Add("aacute", 225); // latin small letter a with acute, U+00E1 ISOlat1 \r
 184             _entityName.Add(225, "aacute");\r
 185             _entityValue.Add("acirc", 226); // latin small letter a with circumflex, U+00E2 ISOlat1 \r
 186             _entityName.Add(226, "acirc");\r
 187             _entityValue.Add("atilde", 227); // latin small letter a with tilde, U+00E3 ISOlat1 \r
 188             _entityName.Add(227, "atilde");\r
 189             _entityValue.Add("auml", 228); // latin small letter a with diaeresis, U+00E4 ISOlat1 \r
 190             _entityName.Add(228, "auml");\r
 191             _entityValue.Add("aring", 229);\r
 192                 // latin small letter a with ring above = latin small letter a ring, U+00E5 ISOlat1 \r
 193             _entityName.Add(229, "aring");\r
 194             _entityValue.Add("aelig", 230); // latin small letter ae = latin small ligature ae, U+00E6 ISOlat1 \r
 195             _entityName.Add(230, "aelig");\r
 196             _entityValue.Add("ccedil", 231); // latin small letter c with cedilla, U+00E7 ISOlat1 \r
 197             _entityName.Add(231, "ccedil");\r
 198             _entityValue.Add("egrave", 232); // latin small letter e with grave, U+00E8 ISOlat1 \r
 199             _entityName.Add(232, "egrave");\r
 200             _entityValue.Add("eacute", 233); // latin small letter e with acute, U+00E9 ISOlat1 \r
 201             _entityName.Add(233, "eacute");\r
 202             _entityValue.Add("ecirc", 234); // latin small letter e with circumflex, U+00EA ISOlat1 \r
 203             _entityName.Add(234, "ecirc");\r
 204             _entityValue.Add("euml", 235); // latin small letter e with diaeresis, U+00EB ISOlat1 \r
 205             _entityName.Add(235, "euml");\r
 206             _entityValue.Add("igrave", 236); // latin small letter i with grave, U+00EC ISOlat1 \r
 207             _entityName.Add(236, "igrave");\r
 208             _entityValue.Add("iacute", 237); // latin small letter i with acute, U+00ED ISOlat1 \r
 209             _entityName.Add(237, "iacute");\r
 210             _entityValue.Add("icirc", 238); // latin small letter i with circumflex, U+00EE ISOlat1 \r
 211             _entityName.Add(238, "icirc");\r
 212             _entityValue.Add("iuml", 239); // latin small letter i with diaeresis, U+00EF ISOlat1 \r
 213             _entityName.Add(239, "iuml");\r
 214             _entityValue.Add("eth", 240); // latin small letter eth, U+00F0 ISOlat1 \r
 215             _entityName.Add(240, "eth");\r
 216             _entityValue.Add("ntilde", 241); // latin small letter n with tilde, U+00F1 ISOlat1 \r
 217             _entityName.Add(241, "ntilde");\r
 218             _entityValue.Add("ograve", 242); // latin small letter o with grave, U+00F2 ISOlat1 \r
 219             _entityName.Add(242, "ograve");\r
 220             _entityValue.Add("oacute", 243); // latin small letter o with acute, U+00F3 ISOlat1 \r
 221             _entityName.Add(243, "oacute");\r
 222             _entityValue.Add("ocirc", 244); // latin small letter o with circumflex, U+00F4 ISOlat1 \r
 223             _entityName.Add(244, "ocirc");\r
 224             _entityValue.Add("otilde", 245); // latin small letter o with tilde, U+00F5 ISOlat1 \r
 225             _entityName.Add(245, "otilde");\r
 226             _entityValue.Add("ouml", 246); // latin small letter o with diaeresis, U+00F6 ISOlat1 \r
 227             _entityName.Add(246, "ouml");\r
 228             _entityValue.Add("divide", 247); // division sign, U+00F7 ISOnum \r
 229             _entityName.Add(247, "divide");\r
 230             _entityValue.Add("oslash", 248);\r
 231                 // latin small letter o with stroke, = latin small letter o slash, U+00F8 ISOlat1 \r
 232             _entityName.Add(248, "oslash");\r
 233             _entityValue.Add("ugrave", 249); // latin small letter u with grave, U+00F9 ISOlat1 \r
 234             _entityName.Add(249, "ugrave");\r
 235             _entityValue.Add("uacute", 250); // latin small letter u with acute, U+00FA ISOlat1 \r
 236             _entityName.Add(250, "uacute");\r
 237             _entityValue.Add("ucirc", 251); // latin small letter u with circumflex, U+00FB ISOlat1 \r
 238             _entityName.Add(251, "ucirc");\r
 239             _entityValue.Add("uuml", 252); // latin small letter u with diaeresis, U+00FC ISOlat1 \r
 240             _entityName.Add(252, "uuml");\r
 241             _entityValue.Add("yacute", 253); // latin small letter y with acute, U+00FD ISOlat1 \r
 242             _entityName.Add(253, "yacute");\r
 243             _entityValue.Add("thorn", 254); // latin small letter thorn, U+00FE ISOlat1 \r
 244             _entityName.Add(254, "thorn");\r
 245             _entityValue.Add("yuml", 255); // latin small letter y with diaeresis, U+00FF ISOlat1 \r
 246             _entityName.Add(255, "yuml");\r
 247             _entityValue.Add("fnof", 402); // latin small f with hook = function = florin, U+0192 ISOtech \r
 248             _entityName.Add(402, "fnof");\r
 249             _entityValue.Add("Alpha", 913); // greek capital letter alpha, U+0391 \r
 250             _entityName.Add(913, "Alpha");\r
 251             _entityValue.Add("Beta", 914); // greek capital letter beta, U+0392 \r
 252             _entityName.Add(914, "Beta");\r
 253             _entityValue.Add("Gamma", 915); // greek capital letter gamma, U+0393 ISOgrk3 \r
 254             _entityName.Add(915, "Gamma");\r
 255             _entityValue.Add("Delta", 916); // greek capital letter delta, U+0394 ISOgrk3 \r
 256             _entityName.Add(916, "Delta");\r
 257             _entityValue.Add("Epsilon", 917); // greek capital letter epsilon, U+0395 \r
 258             _entityName.Add(917, "Epsilon");\r
 259             _entityValue.Add("Zeta", 918); // greek capital letter zeta, U+0396 \r
 260             _entityName.Add(918, "Zeta");\r
 261             _entityValue.Add("Eta", 919); // greek capital letter eta, U+0397 \r
 262             _entityName.Add(919, "Eta");\r
 263             _entityValue.Add("Theta", 920); // greek capital letter theta, U+0398 ISOgrk3 \r
 264             _entityName.Add(920, "Theta");\r
 265             _entityValue.Add("Iota", 921); // greek capital letter iota, U+0399 \r
 266             _entityName.Add(921, "Iota");\r
 267             _entityValue.Add("Kappa", 922); // greek capital letter kappa, U+039A \r
 268             _entityName.Add(922, "Kappa");\r
 269             _entityValue.Add("Lambda", 923); // greek capital letter lambda, U+039B ISOgrk3 \r
 270             _entityName.Add(923, "Lambda");\r
 271             _entityValue.Add("Mu", 924); // greek capital letter mu, U+039C \r
 272             _entityName.Add(924, "Mu");\r
 273             _entityValue.Add("Nu", 925); // greek capital letter nu, U+039D \r
 274             _entityName.Add(925, "Nu");\r
 275             _entityValue.Add("Xi", 926); // greek capital letter xi, U+039E ISOgrk3 \r
 276             _entityName.Add(926, "Xi");\r
 277             _entityValue.Add("Omicron", 927); // greek capital letter omicron, U+039F \r
 278             _entityName.Add(927, "Omicron");\r
 279             _entityValue.Add("Pi", 928); // greek capital letter pi, U+03A0 ISOgrk3 \r
 280             _entityName.Add(928, "Pi");\r
 281             _entityValue.Add("Rho", 929); // greek capital letter rho, U+03A1 \r
 282             _entityName.Add(929, "Rho");\r
 283             _entityValue.Add("Sigma", 931); // greek capital letter sigma, U+03A3 ISOgrk3 \r
 284             _entityName.Add(931, "Sigma");\r
 285             _entityValue.Add("Tau", 932); // greek capital letter tau, U+03A4 \r
 286             _entityName.Add(932, "Tau");\r
 287             _entityValue.Add("Upsilon", 933); // greek capital letter upsilon, U+03A5 ISOgrk3 \r
 288             _entityName.Add(933, "Upsilon");\r
 289             _entityValue.Add("Phi", 934); // greek capital letter phi, U+03A6 ISOgrk3 \r
 290             _entityName.Add(934, "Phi");\r
 291             _entityValue.Add("Chi", 935); // greek capital letter chi, U+03A7 \r
 292             _entityName.Add(935, "Chi");\r
 293             _entityValue.Add("Psi", 936); // greek capital letter psi, U+03A8 ISOgrk3 \r
 294             _entityName.Add(936, "Psi");\r
 295             _entityValue.Add("Omega", 937); // greek capital letter omega, U+03A9 ISOgrk3 \r
 296             _entityName.Add(937, "Omega");\r
 297             _entityValue.Add("alpha", 945); // greek small letter alpha, U+03B1 ISOgrk3 \r
 298             _entityName.Add(945, "alpha");\r
 299             _entityValue.Add("beta", 946); // greek small letter beta, U+03B2 ISOgrk3 \r
 300             _entityName.Add(946, "beta");\r
 301             _entityValue.Add("gamma", 947); // greek small letter gamma, U+03B3 ISOgrk3 \r
 302             _entityName.Add(947, "gamma");\r
 303             _entityValue.Add("delta", 948); // greek small letter delta, U+03B4 ISOgrk3 \r
 304             _entityName.Add(948, "delta");\r
 305             _entityValue.Add("epsilon", 949); // greek small letter epsilon, U+03B5 ISOgrk3 \r
 306             _entityName.Add(949, "epsilon");\r
 307             _entityValue.Add("zeta", 950); // greek small letter zeta, U+03B6 ISOgrk3 \r
 308             _entityName.Add(950, "zeta");\r
 309             _entityValue.Add("eta", 951); // greek small letter eta, U+03B7 ISOgrk3 \r
 310             _entityName.Add(951, "eta");\r
 311             _entityValue.Add("theta", 952); // greek small letter theta, U+03B8 ISOgrk3 \r
 312             _entityName.Add(952, "theta");\r
 313             _entityValue.Add("iota", 953); // greek small letter iota, U+03B9 ISOgrk3 \r
 314             _entityName.Add(953, "iota");\r
 315             _entityValue.Add("kappa", 954); // greek small letter kappa, U+03BA ISOgrk3 \r
 316             _entityName.Add(954, "kappa");\r
 317             _entityValue.Add("lambda", 955); // greek small letter lambda, U+03BB ISOgrk3 \r
 318             _entityName.Add(955, "lambda");\r
 319             _entityValue.Add("mu", 956); // greek small letter mu, U+03BC ISOgrk3 \r
 320             _entityName.Add(956, "mu");\r
 321             _entityValue.Add("nu", 957); // greek small letter nu, U+03BD ISOgrk3 \r
 322             _entityName.Add(957, "nu");\r
 323             _entityValue.Add("xi", 958); // greek small letter xi, U+03BE ISOgrk3 \r
 324             _entityName.Add(958, "xi");\r
 325             _entityValue.Add("omicron", 959); // greek small letter omicron, U+03BF NEW \r
 326             _entityName.Add(959, "omicron");\r
 327             _entityValue.Add("pi", 960); // greek small letter pi, U+03C0 ISOgrk3 \r
 328             _entityName.Add(960, "pi");\r
 329             _entityValue.Add("rho", 961); // greek small letter rho, U+03C1 ISOgrk3 \r
 330             _entityName.Add(961, "rho");\r
 331             _entityValue.Add("sigmaf", 962); // greek small letter final sigma, U+03C2 ISOgrk3 \r
 332             _entityName.Add(962, "sigmaf");\r
 333             _entityValue.Add("sigma", 963); // greek small letter sigma, U+03C3 ISOgrk3 \r
 334             _entityName.Add(963, "sigma");\r
 335             _entityValue.Add("tau", 964); // greek small letter tau, U+03C4 ISOgrk3 \r
 336             _entityName.Add(964, "tau");\r
 337             _entityValue.Add("upsilon", 965); // greek small letter upsilon, U+03C5 ISOgrk3 \r
 338             _entityName.Add(965, "upsilon");\r
 339             _entityValue.Add("phi", 966); // greek small letter phi, U+03C6 ISOgrk3 \r
 340             _entityName.Add(966, "phi");\r
 341             _entityValue.Add("chi", 967); // greek small letter chi, U+03C7 ISOgrk3 \r
 342             _entityName.Add(967, "chi");\r
 343             _entityValue.Add("psi", 968); // greek small letter psi, U+03C8 ISOgrk3 \r
 344             _entityName.Add(968, "psi");\r
 345             _entityValue.Add("omega", 969); // greek small letter omega, U+03C9 ISOgrk3 \r
 346             _entityName.Add(969, "omega");\r
 347             _entityValue.Add("thetasym", 977); // greek small letter theta symbol, U+03D1 NEW \r
 348             _entityName.Add(977, "thetasym");\r
 349             _entityValue.Add("upsih", 978); // greek upsilon with hook symbol, U+03D2 NEW \r
 350             _entityName.Add(978, "upsih");\r
 351             _entityValue.Add("piv", 982); // greek pi symbol, U+03D6 ISOgrk3 \r
 352             _entityName.Add(982, "piv");\r
 353             _entityValue.Add("bull", 8226); // bullet = black small circle, U+2022 ISOpub \r
 354             _entityName.Add(8226, "bull");\r
 355             _entityValue.Add("hellip", 8230); // horizontal ellipsis = three dot leader, U+2026 ISOpub \r
 356             _entityName.Add(8230, "hellip");\r
 357             _entityValue.Add("prime", 8242); // prime = minutes = feet, U+2032 ISOtech \r
 358             _entityName.Add(8242, "prime");\r
 359             _entityValue.Add("Prime", 8243); // double prime = seconds = inches, U+2033 ISOtech \r
 360             _entityName.Add(8243, "Prime");\r
 361             _entityValue.Add("oline", 8254); // overline = spacing overscore, U+203E NEW \r
 362             _entityName.Add(8254, "oline");\r
 363             _entityValue.Add("frasl", 8260); // fraction slash, U+2044 NEW \r
 364             _entityName.Add(8260, "frasl");\r
 365             _entityValue.Add("weierp", 8472); // script capital P = power set = Weierstrass p, U+2118 ISOamso \r
 366             _entityName.Add(8472, "weierp");\r
 367             _entityValue.Add("image", 8465); // blackletter capital I = imaginary part, U+2111 ISOamso \r
 368             _entityName.Add(8465, "image");\r
 369             _entityValue.Add("real", 8476); // blackletter capital R = real part symbol, U+211C ISOamso \r
 370             _entityName.Add(8476, "real");\r
 371             _entityValue.Add("trade", 8482); // trade mark sign, U+2122 ISOnum \r
 372             _entityName.Add(8482, "trade");\r
 373             _entityValue.Add("alefsym", 8501); // alef symbol = first transfinite cardinal, U+2135 NEW \r
 374             _entityName.Add(8501, "alefsym");\r
 375             _entityValue.Add("larr", 8592); // leftwards arrow, U+2190 ISOnum \r
 376             _entityName.Add(8592, "larr");\r
 377             _entityValue.Add("uarr", 8593); // upwards arrow, U+2191 ISOnum\r
 378             _entityName.Add(8593, "uarr");\r
 379             _entityValue.Add("rarr", 8594); // rightwards arrow, U+2192 ISOnum \r
 380             _entityName.Add(8594, "rarr");\r
 381             _entityValue.Add("darr", 8595); // downwards arrow, U+2193 ISOnum \r
 382             _entityName.Add(8595, "darr");\r
 383             _entityValue.Add("harr", 8596); // left right arrow, U+2194 ISOamsa \r
 384             _entityName.Add(8596, "harr");\r
 385             _entityValue.Add("crarr", 8629); // downwards arrow with corner leftwards = carriage return, U+21B5 NEW \r
 386             _entityName.Add(8629, "crarr");\r
 387             _entityValue.Add("lArr", 8656); // leftwards double arrow, U+21D0 ISOtech \r
 388             _entityName.Add(8656, "lArr");\r
 389             _entityValue.Add("uArr", 8657); // upwards double arrow, U+21D1 ISOamsa \r
 390             _entityName.Add(8657, "uArr");\r
 391             _entityValue.Add("rArr", 8658); // rightwards double arrow, U+21D2 ISOtech \r
 392             _entityName.Add(8658, "rArr");\r
 393             _entityValue.Add("dArr", 8659); // downwards double arrow, U+21D3 ISOamsa \r
 394             _entityName.Add(8659, "dArr");\r
 395             _entityValue.Add("hArr", 8660); // left right double arrow, U+21D4 ISOamsa \r
 396             _entityName.Add(8660, "hArr");\r
 397             _entityValue.Add("forall", 8704); // for all, U+2200 ISOtech \r
 398             _entityName.Add(8704, "forall");\r
 399             _entityValue.Add("part", 8706); // partial differential, U+2202 ISOtech \r
 400             _entityName.Add(8706, "part");\r
 401             _entityValue.Add("exist", 8707); // there exists, U+2203 ISOtech \r
 402             _entityName.Add(8707, "exist");\r
 403             _entityValue.Add("empty", 8709); // empty set = null set = diameter, U+2205 ISOamso \r
 404             _entityName.Add(8709, "empty");\r
 405             _entityValue.Add("nabla", 8711); // nabla = backward difference, U+2207 ISOtech \r
 406             _entityName.Add(8711, "nabla");\r
 407             _entityValue.Add("isin", 8712); // element of, U+2208 ISOtech \r
 408             _entityName.Add(8712, "isin");\r
 409             _entityValue.Add("notin", 8713); // not an element of, U+2209 ISOtech \r
 410             _entityName.Add(8713, "notin");\r
 411             _entityValue.Add("ni", 8715); // contains as member, U+220B ISOtech \r
 412             _entityName.Add(8715, "ni");\r
 413             _entityValue.Add("prod", 8719); // n-ary product = product sign, U+220F ISOamsb \r
 414             _entityName.Add(8719, "prod");\r
 415             _entityValue.Add("sum", 8721); // n-ary sumation, U+2211 ISOamsb \r
 416             _entityName.Add(8721, "sum");\r
 417             _entityValue.Add("minus", 8722); // minus sign, U+2212 ISOtech \r
 418             _entityName.Add(8722, "minus");\r
 419             _entityValue.Add("lowast", 8727); // asterisk operator, U+2217 ISOtech \r
 420             _entityName.Add(8727, "lowast");\r
 421             _entityValue.Add("radic", 8730); // square root = radical sign, U+221A ISOtech \r
 422             _entityName.Add(8730, "radic");\r
 423             _entityValue.Add("prop", 8733); // proportional to, U+221D ISOtech \r
 424             _entityName.Add(8733, "prop");\r
 425             _entityValue.Add("infin", 8734); // infinity, U+221E ISOtech \r
 426             _entityName.Add(8734, "infin");\r
 427             _entityValue.Add("ang", 8736); // angle, U+2220 ISOamso \r
 428             _entityName.Add(8736, "ang");\r
 429             _entityValue.Add("and", 8743); // logical and = wedge, U+2227 ISOtech \r
 430             _entityName.Add(8743, "and");\r
 431             _entityValue.Add("or", 8744); // logical or = vee, U+2228 ISOtech \r
 432             _entityName.Add(8744, "or");\r
 433             _entityValue.Add("cap", 8745); // intersection = cap, U+2229 ISOtech \r
 434             _entityName.Add(8745, "cap");\r
 435             _entityValue.Add("cup", 8746); // union = cup, U+222A ISOtech \r
 436             _entityName.Add(8746, "cup");\r
 437             _entityValue.Add("int", 8747); // integral, U+222B ISOtech \r
 438             _entityName.Add(8747, "int");\r
 439             _entityValue.Add("there4", 8756); // therefore, U+2234 ISOtech \r
 440             _entityName.Add(8756, "there4");\r
 441             _entityValue.Add("sim", 8764); // tilde operator = varies with = similar to, U+223C ISOtech \r
 442             _entityName.Add(8764, "sim");\r
 443             _entityValue.Add("cong", 8773); // approximately equal to, U+2245 ISOtech \r
 444             _entityName.Add(8773, "cong");\r
 445             _entityValue.Add("asymp", 8776); // almost equal to = asymptotic to, U+2248 ISOamsr \r
 446             _entityName.Add(8776, "asymp");\r
 447             _entityValue.Add("ne", 8800); // not equal to, U+2260 ISOtech \r
 448             _entityName.Add(8800, "ne");\r
 449             _entityValue.Add("equiv", 8801); // identical to, U+2261 ISOtech \r
 450             _entityName.Add(8801, "equiv");\r
 451             _entityValue.Add("le", 8804); // less-than or equal to, U+2264 ISOtech \r
 452             _entityName.Add(8804, "le");\r
 453             _entityValue.Add("ge", 8805); // greater-than or equal to, U+2265 ISOtech \r
 454             _entityName.Add(8805, "ge");\r
 455             _entityValue.Add("sub", 8834); // subset of, U+2282 ISOtech \r
 456             _entityName.Add(8834, "sub");\r
 457             _entityValue.Add("sup", 8835); // superset of, U+2283 ISOtech \r
 458             _entityName.Add(8835, "sup");\r
 459             _entityValue.Add("nsub", 8836); // not a subset of, U+2284 ISOamsn \r
 460             _entityName.Add(8836, "nsub");\r
 461             _entityValue.Add("sube", 8838); // subset of or equal to, U+2286 ISOtech \r
 462             _entityName.Add(8838, "sube");\r
 463             _entityValue.Add("supe", 8839); // superset of or equal to, U+2287 ISOtech \r
 464             _entityName.Add(8839, "supe");\r
 465             _entityValue.Add("oplus", 8853); // circled plus = direct sum, U+2295 ISOamsb \r
 466             _entityName.Add(8853, "oplus");\r
 467             _entityValue.Add("otimes", 8855); // circled times = vector product, U+2297 ISOamsb \r
 468             _entityName.Add(8855, "otimes");\r
 469             _entityValue.Add("perp", 8869); // up tack = orthogonal to = perpendicular, U+22A5 ISOtech \r
 470             _entityName.Add(8869, "perp");\r
 471             _entityValue.Add("sdot", 8901); // dot operator, U+22C5 ISOamsb \r
 472             _entityName.Add(8901, "sdot");\r
 473             _entityValue.Add("lceil", 8968); // left ceiling = apl upstile, U+2308 ISOamsc \r
 474             _entityName.Add(8968, "lceil");\r
 475             _entityValue.Add("rceil", 8969); // right ceiling, U+2309 ISOamsc \r
 476             _entityName.Add(8969, "rceil");\r
 477             _entityValue.Add("lfloor", 8970); // left floor = apl downstile, U+230A ISOamsc \r
 478             _entityName.Add(8970, "lfloor");\r
 479             _entityValue.Add("rfloor", 8971); // right floor, U+230B ISOamsc \r
 480             _entityName.Add(8971, "rfloor");\r
 481             _entityValue.Add("lang", 9001); // left-pointing angle bracket = bra, U+2329 ISOtech \r
 482             _entityName.Add(9001, "lang");\r
 483             _entityValue.Add("rang", 9002); // right-pointing angle bracket = ket, U+232A ISOtech \r
 484             _entityName.Add(9002, "rang");\r
 485             _entityValue.Add("loz", 9674); // lozenge, U+25CA ISOpub \r
 486             _entityName.Add(9674, "loz");\r
 487             _entityValue.Add("spades", 9824); // black spade suit, U+2660 ISOpub \r
 488             _entityName.Add(9824, "spades");\r
 489             _entityValue.Add("clubs", 9827); // black club suit = shamrock, U+2663 ISOpub \r
 490             _entityName.Add(9827, "clubs");\r
 491             _entityValue.Add("hearts", 9829); // black heart suit = valentine, U+2665 ISOpub \r
 492             _entityName.Add(9829, "hearts");\r
 493             _entityValue.Add("diams", 9830); // black diamond suit, U+2666 ISOpub \r
 494             _entityName.Add(9830, "diams");\r
 495             _entityValue.Add("quot", 34); // quotation mark = APL quote, U+0022 ISOnum \r
 496             _entityName.Add(34, "quot");\r
 497             _entityValue.Add("amp", 38); // ampersand, U+0026 ISOnum \r
 498             _entityName.Add(38, "amp");\r
 499             _entityValue.Add("lt", 60); // less-than sign, U+003C ISOnum \r
 500             _entityName.Add(60, "lt");\r
 501             _entityValue.Add("gt", 62); // greater-than sign, U+003E ISOnum \r
 502             _entityName.Add(62, "gt");\r
 503             _entityValue.Add("OElig", 338); // latin capital ligature OE, U+0152 ISOlat2 \r
 504             _entityName.Add(338, "OElig");\r
 505             _entityValue.Add("oelig", 339); // latin small ligature oe, U+0153 ISOlat2 \r
 506             _entityName.Add(339, "oelig");\r
 507             _entityValue.Add("Scaron", 352); // latin capital letter S with caron, U+0160 ISOlat2 \r
 508             _entityName.Add(352, "Scaron");\r
 509             _entityValue.Add("scaron", 353); // latin small letter s with caron, U+0161 ISOlat2 \r
 510             _entityName.Add(353, "scaron");\r
 511             _entityValue.Add("Yuml", 376); // latin capital letter Y with diaeresis, U+0178 ISOlat2 \r
 512             _entityName.Add(376, "Yuml");\r
 513             _entityValue.Add("circ", 710); // modifier letter circumflex accent, U+02C6 ISOpub \r
 514             _entityName.Add(710, "circ");\r
 515             _entityValue.Add("tilde", 732); // small tilde, U+02DC ISOdia \r
 516             _entityName.Add(732, "tilde");\r
 517             _entityValue.Add("ensp", 8194); // en space, U+2002 ISOpub \r
 518             _entityName.Add(8194, "ensp");\r
 519             _entityValue.Add("emsp", 8195); // em space, U+2003 ISOpub \r
 520             _entityName.Add(8195, "emsp");\r
 521             _entityValue.Add("thinsp", 8201); // thin space, U+2009 ISOpub \r
 522             _entityName.Add(8201, "thinsp");\r
 523             _entityValue.Add("zwnj", 8204); // zero width non-joiner, U+200C NEW RFC 2070 \r
 524             _entityName.Add(8204, "zwnj");\r
 525             _entityValue.Add("zwj", 8205); // zero width joiner, U+200D NEW RFC 2070 \r
 526             _entityName.Add(8205, "zwj");\r
 527             _entityValue.Add("lrm", 8206); // left-to-right mark, U+200E NEW RFC 2070 \r
 528             _entityName.Add(8206, "lrm");\r
 529             _entityValue.Add("rlm", 8207); // right-to-left mark, U+200F NEW RFC 2070 \r
 530             _entityName.Add(8207, "rlm");\r
 531             _entityValue.Add("ndash", 8211); // en dash, U+2013 ISOpub \r
 532             _entityName.Add(8211, "ndash");\r
 533             _entityValue.Add("mdash", 8212); // em dash, U+2014 ISOpub \r
 534             _entityName.Add(8212, "mdash");\r
 535             _entityValue.Add("lsquo", 8216); // left single quotation mark, U+2018 ISOnum \r
 536             _entityName.Add(8216, "lsquo");\r
 537             _entityValue.Add("rsquo", 8217); // right single quotation mark, U+2019 ISOnum \r
 538             _entityName.Add(8217, "rsquo");\r
 539             _entityValue.Add("sbquo", 8218); // single low-9 quotation mark, U+201A NEW \r
 540             _entityName.Add(8218, "sbquo");\r
 541             _entityValue.Add("ldquo", 8220); // left double quotation mark, U+201C ISOnum \r
 542             _entityName.Add(8220, "ldquo");\r
 543             _entityValue.Add("rdquo", 8221); // right double quotation mark, U+201D ISOnum \r
 544             _entityName.Add(8221, "rdquo");\r
 545             _entityValue.Add("bdquo", 8222); // double low-9 quotation mark, U+201E NEW \r
 546             _entityName.Add(8222, "bdquo");\r
 547             _entityValue.Add("dagger", 8224); // dagger, U+2020 ISOpub \r
 548             _entityName.Add(8224, "dagger");\r
 549             _entityValue.Add("Dagger", 8225); // double dagger, U+2021 ISOpub \r
 550             _entityName.Add(8225, "Dagger");\r
 551             _entityValue.Add("permil", 8240); // per mille sign, U+2030 ISOtech \r
 552             _entityName.Add(8240, "permil");\r
 553             _entityValue.Add("lsaquo", 8249); // single left-pointing angle quotation mark, U+2039 ISO proposed \r
 554             _entityName.Add(8249, "lsaquo");\r
 555             _entityValue.Add("rsaquo", 8250); // single right-pointing angle quotation mark, U+203A ISO proposed \r
 556             _entityName.Add(8250, "rsaquo");\r
 557             _entityValue.Add("euro", 8364); // euro sign, U+20AC NEW \r
 558             _entityName.Add(8364, "euro");\r
 559 \r
 560             _maxEntitySize = 8 + 1; // we add the # char\r
 561 \r
 562             #endregion\r
 563         }\r
 564 \r
 565         private HtmlEntity()\r
 566         {\r
 567         }\r
 568 \r
 569         #endregion\r
 570 \r
 571         #region Public Methods\r
 572 \r
 573         /// <summary>\r
 574         /// Replace known entities by characters.\r
 575         /// </summary>\r
 576         /// <param name="text">The source text.</param>\r
 577         /// <returns>The result text.</returns>\r
 578         public static string DeEntitize(string text)\r
 579         {\r
 580             if (text == null)\r
 581                 return null;\r
 582 \r
 583             if (text.Length == 0)\r
 584                 return text;\r
 585 \r
 586             StringBuilder sb = new StringBuilder(text.Length);\r
 587             ParseState state = ParseState.Text;\r
 588             StringBuilder entity = new StringBuilder(10);\r
 589 \r
 590             for (int i = 0; i < text.Length; i++)\r
 591             {\r
 592                 switch (state)\r
 593                 {\r
 594                     case ParseState.Text:\r
 595                         switch (text[i])\r
 596                         {\r
 597                             case '&':\r
 598                                 state = ParseState.EntityStart;\r
 599                                 break;\r
 600 \r
 601                             default:\r
 602                                 sb.Append(text[i]);\r
 603                                 break;\r
 604                         }\r
 605                         break;\r
 606 \r
 607                     case ParseState.EntityStart:\r
 608                         switch (text[i])\r
 609                         {\r
 610                             case ';':\r
 611                                 if (entity.Length == 0)\r
 612                                 {\r
 613                                     sb.Append("&;");\r
 614                                 }\r
 615                                 else\r
 616                                 {\r
 617                                     if (entity[0] == '#')\r
 618                                     {\r
 619                                         string e = entity.ToString();\r
 620                                         try\r
 621                                         {\r
 622                                             int code = Convert.ToInt32(e.Substring(1, e.Length - 1));\r
 623                                             sb.Append(Convert.ToChar(code));\r
 624                                         }\r
 625                                         catch\r
 626                                         {\r
 627                                             sb.Append("&#" + e + ";");\r
 628                                         }\r
 629                                     }\r
 630                                     else\r
 631                                     {\r
 632                                         // named entity?\r
 633                                         int code;\r
 634                                         object o = _entityValue[entity.ToString()];\r
 635                                         if (o == null)\r
 636                                         {\r
 637                                             // nope\r
 638                                             sb.Append("&" + entity + ";");\r
 639                                         }\r
 640                                         else\r
 641                                         {\r
 642                                             // we found one\r
 643                                             code = (int) o;\r
 644                                             sb.Append(Convert.ToChar(code));\r
 645                                         }\r
 646                                     }\r
 647                                     entity.Remove(0, entity.Length);\r
 648                                 }\r
 649                                 state = ParseState.Text;\r
 650                                 break;\r
 651 \r
 652                             case '&':\r
 653                                 // new entity start without end, it was not an entity...\r
 654                                 sb.Append("&" + entity);\r
 655                                 entity.Remove(0, entity.Length);\r
 656                                 break;\r
 657 \r
 658                             default:\r
 659                                 entity.Append(text[i]);\r
 660                                 if (entity.Length > _maxEntitySize)\r
 661                                 {\r
 662                                     // unknown stuff, just don't touch it\r
 663                                     state = ParseState.Text;\r
 664                                     sb.Append("&" + entity);\r
 665                                     entity.Remove(0, entity.Length);\r
 666                                 }\r
 667                                 break;\r
 668                         }\r
 669                         break;\r
 670                 }\r
 671             }\r
 672 \r
 673             // finish the work\r
 674             if (state == ParseState.EntityStart)\r
 675             {\r
 676                 sb.Append("&" + entity);\r
 677             }\r
 678             return sb.ToString();\r
 679         }\r
 680 \r
 681         /// <summary>\r
 682         /// Clone and entitize an HtmlNode. This will affect attribute values and nodes' text. It will also entitize all child nodes.\r
 683         /// </summary>\r
 684         /// <param name="node">The node to entitize.</param>\r
 685         /// <returns>An entitized cloned node.</returns>\r
 686         public static HtmlNode Entitize(HtmlNode node)\r
 687         {\r
 688             if (node == null)\r
 689             {\r
 690                 throw new ArgumentNullException("node");\r
 691             }\r
 692             HtmlNode result = node.CloneNode(true);\r
 693             if (result.HasAttributes)\r
 694                 Entitize(result.Attributes);\r
 695 \r
 696             if (result.HasChildNodes)\r
 697             {\r
 698                 Entitize(result.ChildNodes);\r
 699             }\r
 700             else\r
 701             {\r
 702                 if (result.NodeType == HtmlNodeType.Text)\r
 703                 {\r
 704                     ((HtmlTextNode) result).Text = Entitize(((HtmlTextNode) result).Text, true, true);\r
 705                 }\r
 706             }\r
 707             return result;\r
 708         }\r
 709 \r
 710 \r
 711         /// <summary>\r
 712         /// Replace characters above 127 by entities.\r
 713         /// </summary>\r
 714         /// <param name="text">The source text.</param>\r
 715         /// <returns>The result text.</returns>\r
 716         public static string Entitize(string text)\r
 717         {\r
 718             return Entitize(text, true);\r
 719         }\r
 720 \r
 721         /// <summary>\r
 722         /// Replace characters above 127 by entities.\r
 723         /// </summary>\r
 724         /// <param name="text">The source text.</param>\r
 725         /// <param name="useNames">If set to false, the function will not use known entities name. Default is true.</param>\r
 726         /// <returns>The result text.</returns>\r
 727         public static string Entitize(string text, bool useNames)\r
 728         {\r
 729             return Entitize(text, useNames, false);\r
 730         }\r
 731 \r
 732         /// <summary>\r
 733         /// Replace characters above 127 by entities.\r
 734         /// </summary>\r
 735         /// <param name="text">The source text.</param>\r
 736         /// <param name="useNames">If set to false, the function will not use known entities name. Default is true.</param>\r
 737         /// <param name="entitizeQuotAmpAndLtGt">If set to true, the [quote], [ampersand], [lower than] and [greather than] characters will be entitized.</param>\r
 738         /// <returns>The result text</returns>\r
 739         public static string Entitize(string text, bool useNames, bool entitizeQuotAmpAndLtGt)\r
 740 //              _entityValue.Add("quot", 34);   // quotation mark = APL quote, U+0022 ISOnum \r
 741 //              _entityName.Add(34, "quot");\r
 742 //              _entityValue.Add("amp", 38);    // ampersand, U+0026 ISOnum \r
 743 //              _entityName.Add(38, "amp");\r
 744 //              _entityValue.Add("lt", 60);     // less-than sign, U+003C ISOnum \r
 745 //              _entityName.Add(60, "lt");\r
 746 //              _entityValue.Add("gt", 62);     // greater-than sign, U+003E ISOnum \r
 747 //              _entityName.Add(62, "gt");\r
 748         {\r
 749             if (text == null)\r
 750                 return null;\r
 751 \r
 752             if (text.Length == 0)\r
 753                 return text;\r
 754 \r
 755             StringBuilder sb = new StringBuilder(text.Length);\r
 756             for (int i = 0; i < text.Length; i++)\r
 757             {\r
 758                 int code = text[i];\r
 759                 if ((code > 127) ||\r
 760                     (entitizeQuotAmpAndLtGt && ((code == 34) || (code == 38) || (code == 60) || (code == 62))))\r
 761                 {\r
 762                     string entity = _entityName[code] as string;\r
 763                     if ((entity == null) || (!useNames))\r
 764                     {\r
 765                         sb.Append("&#" + code + ";");\r
 766                     }\r
 767                     else\r
 768                     {\r
 769                         sb.Append("&" + entity + ";");\r
 770                     }\r
 771                 }\r
 772                 else\r
 773                 {\r
 774                     sb.Append(text[i]);\r
 775                 }\r
 776             }\r
 777 \r
 778             return sb.ToString();\r
 779         }\r
 780 \r
 781         #endregion\r
 782 \r
 783         #region Private Methods\r
 784 \r
 785         private static void Entitize(HtmlAttributeCollection collection)\r
 786         {\r
 787             foreach (HtmlAttribute at in collection)\r
 788             {\r
 789                 at.Value = Entitize(at.Value);\r
 790             }\r
 791         }\r
 792 \r
 793         private static void Entitize(HtmlNodeCollection collection)\r
 794         {\r
 795             foreach (HtmlNode node in collection)\r
 796             {\r
 797                 if (node.HasAttributes)\r
 798                     Entitize(node.Attributes);\r
 799 \r
 800                 if (node.HasChildNodes)\r
 801                 {\r
 802                     Entitize(node.ChildNodes);\r
 803                 }\r
 804                 else\r
 805                 {\r
 806                     if (node.NodeType == HtmlNodeType.Text)\r
 807                     {\r
 808                         ((HtmlTextNode) node).Text = Entitize(((HtmlTextNode) node).Text, true, true);\r
 809                     }\r
 810                 }\r
 811             }\r
 812         }\r
 813 \r
 814         #endregion\r
 815 \r
 816         #region Nested type: ParseState\r
 817 \r
 818         private enum ParseState\r
 819         {\r
 820             Text,\r
 821             EntityStart\r
 822         }\r
 823 \r
 824         #endregion\r
 825     }\r
 826 }