Filters/HtmlAgilityPack/HtmlEntity.cs

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