Client LuaCsForBarotrauma
HttpEncoder.cs
1 //
2 // Authors:
3 // Patrik Torstensson (Patrik.Torstensson@labs2.com)
4 // Wictor Wilén (decode/encode functions) (wictor@ibizkit.se)
5 // Tim Coleman (tim@timcoleman.com)
6 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
7 
8 // Marek Habersack <mhabersack@novell.com>
9 //
10 // (C) 2005-2010 Novell, Inc (http://novell.com/)
11 //
12 
13 //
14 // Permission is hereby granted, free of charge, to any person obtaining
15 // a copy of this software and associated documentation files (the
16 // "Software"), to deal in the Software without restriction, including
17 // without limitation the rights to use, copy, modify, merge, publish,
18 // distribute, sublicense, and/or sell copies of the Software, and to
19 // permit persons to whom the Software is furnished to do so, subject to
20 // the following conditions:
21 //
22 // The above copyright notice and this permission notice shall be
23 // included in all copies or substantial portions of the Software.
24 //
25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
32 //
33 using System;
34 using System.Collections.Generic;
35 using System.Configuration;
36 using System.Globalization;
37 using Barotrauma.IO;
38 using System.Text;
39 
40 namespace RestSharp.Contrib
41 {
42  class HttpEncoder
43  {
44  static char[] hexChars = "0123456789abcdef".ToCharArray();
45  static object entitiesLock = new object();
46  static SortedDictionary<string, char> entities;
47  static HttpEncoder defaultEncoder;
48  static HttpEncoder currentEncoder;
49 
50  static IDictionary<string, char> Entities
51  {
52  get
53  {
54  lock (entitiesLock)
55  {
56  if (entities == null)
57  InitEntities();
58 
59  return entities;
60  }
61  }
62  }
63 
64  public static HttpEncoder Current
65  {
66  get
67  {
68  return currentEncoder;
69  }
70  }
71 
72  public static HttpEncoder Default
73  {
74  get
75  {
76  return defaultEncoder;
77  }
78  }
79 
80  static HttpEncoder()
81  {
82  defaultEncoder = new HttpEncoder();
83  currentEncoder = defaultEncoder;
84  }
85 
86  public HttpEncoder()
87  {
88  }
89 
90  internal static void HeaderNameValueEncode(string headerName, string headerValue, out string encodedHeaderName, out string encodedHeaderValue)
91  {
92  if (String.IsNullOrEmpty(headerName))
93  encodedHeaderName = headerName;
94  else
95  encodedHeaderName = EncodeHeaderString(headerName);
96 
97  if (String.IsNullOrEmpty(headerValue))
98  encodedHeaderValue = headerValue;
99  else
100  encodedHeaderValue = EncodeHeaderString(headerValue);
101  }
102 
103  static void StringBuilderAppend(string s, ref StringBuilder sb)
104  {
105  if (sb == null)
106  sb = new StringBuilder(s);
107  else
108  sb.Append(s);
109  }
110 
111  static string EncodeHeaderString(string input)
112  {
113  StringBuilder sb = null;
114  char ch;
115 
116  for (int i = 0; i < input.Length; i++)
117  {
118  ch = input[i];
119 
120  if ((ch < 32 && ch != 9) || ch == 127)
121  StringBuilderAppend(String.Format("%{0:x2}", (int)ch), ref sb);
122  }
123 
124  if (sb != null)
125  return sb.ToString();
126 
127  return input;
128  }
129 
130  internal static string UrlPathEncode(string value)
131  {
132  if (String.IsNullOrEmpty(value))
133  return value;
134 
135  System.IO.MemoryStream result = new System.IO.MemoryStream();
136  int length = value.Length;
137  for (int i = 0; i < length; i++)
138  UrlPathEncodeChar(value[i], result);
139 
140  return Encoding.ASCII.GetString(result.ToArray());
141  }
142 
143  internal static byte[] UrlEncodeToBytes(byte[] bytes, int offset, int count)
144  {
145  if (bytes == null)
146  throw new ArgumentNullException("bytes");
147 
148  int blen = bytes.Length;
149  if (blen == 0)
150  return Array.Empty<byte>();
151 
152  if (offset < 0 || offset >= blen)
153  throw new ArgumentOutOfRangeException("offset");
154 
155  if (count < 0 || count > blen - offset)
156  throw new ArgumentOutOfRangeException("count");
157 
158  System.IO.MemoryStream result = new System.IO.MemoryStream(count);
159  int end = offset + count;
160  for (int i = offset; i < end; i++)
161  UrlEncodeChar((char)bytes[i], result, false);
162 
163  return result.ToArray();
164  }
165 
166  internal static string HtmlEncode(string s)
167  {
168  if (s == null)
169  return null;
170 
171  if (s.Length == 0)
172  return String.Empty;
173 
174  bool needEncode = false;
175  for (int i = 0; i < s.Length; i++)
176  {
177  char c = s[i];
178  if (c == '&' || c == '"' || c == '<' || c == '>' || c > 159)
179  {
180  needEncode = true;
181  break;
182  }
183  }
184 
185  if (!needEncode)
186  return s;
187 
188  StringBuilder output = new StringBuilder();
189  char ch;
190  int len = s.Length;
191 
192  for (int i = 0; i < len; i++)
193  {
194  switch (s[i])
195  {
196  case '&':
197  output.Append("&amp;");
198  break;
199  case '>':
200  output.Append("&gt;");
201  break;
202  case '<':
203  output.Append("&lt;");
204  break;
205  case '"':
206  output.Append("&quot;");
207  break;
208  case '\uff1c':
209  output.Append("&#65308;");
210  break;
211 
212  case '\uff1e':
213  output.Append("&#65310;");
214  break;
215 
216  default:
217  ch = s[i];
218  if (ch > 159 && ch < 256)
219  {
220  output.Append("&#");
221  output.Append(((int)ch).ToString(CultureInfo.InvariantCulture));
222  output.Append(";");
223  }
224  else
225  output.Append(ch);
226  break;
227  }
228  }
229 
230  return output.ToString();
231  }
232 
233  internal static string HtmlAttributeEncode(string s)
234  {
235  if (s == null)
236  return null;
237 
238  if (s.Length == 0)
239  return String.Empty;
240 
241  bool needEncode = false;
242  for (int i = 0; i < s.Length; i++)
243  {
244  char c = s[i];
245  if (c == '&' || c == '"' || c == '<')
246  {
247  needEncode = true;
248  break;
249  }
250  }
251 
252  if (!needEncode)
253  return s;
254 
255  StringBuilder output = new StringBuilder();
256  int len = s.Length;
257  for (int i = 0; i < len; i++)
258  switch (s[i])
259  {
260  case '&':
261  output.Append("&amp;");
262  break;
263  case '"':
264  output.Append("&quot;");
265  break;
266  case '<':
267  output.Append("&lt;");
268  break;
269  default:
270  output.Append(s[i]);
271  break;
272  }
273 
274  return output.ToString();
275  }
276 
277  internal static string HtmlDecode(string s)
278  {
279  if (s == null)
280  return null;
281 
282  if (s.Length == 0)
283  return String.Empty;
284 
285  if (s.IndexOf('&') == -1)
286  return s;
287 
288  StringBuilder entity = new StringBuilder();
289  StringBuilder output = new StringBuilder();
290  int len = s.Length;
291  // 0 -> nothing,
292  // 1 -> right after '&'
293  // 2 -> between '&' and ';' but no '#'
294  // 3 -> '#' found after '&' and getting numbers
295  int state = 0;
296  int number = 0;
297  bool is_hex_value = false;
298  bool have_trailing_digits = false;
299 
300  for (int i = 0; i < len; i++)
301  {
302  char c = s[i];
303  if (state == 0)
304  {
305  if (c == '&')
306  {
307  entity.Append(c);
308  state = 1;
309  }
310  else
311  {
312  output.Append(c);
313  }
314  continue;
315  }
316 
317  if (c == '&')
318  {
319  state = 1;
320  if (have_trailing_digits)
321  {
322  entity.Append(number.ToString(CultureInfo.InvariantCulture));
323  have_trailing_digits = false;
324  }
325 
326  output.Append(entity.ToString());
327  entity.Length = 0;
328  entity.Append('&');
329  continue;
330  }
331 
332  if (state == 1)
333  {
334  if (c == ';')
335  {
336  state = 0;
337  output.Append(entity.ToString());
338  output.Append(c);
339  entity.Length = 0;
340  }
341  else
342  {
343  number = 0;
344  is_hex_value = false;
345  if (c != '#')
346  {
347  state = 2;
348  }
349  else
350  {
351  state = 3;
352  }
353  entity.Append(c);
354  }
355  }
356  else if (state == 2)
357  {
358  entity.Append(c);
359  if (c == ';')
360  {
361  string key = entity.ToString();
362  if (key.Length > 1 && Entities.ContainsKey(key.Substring(1, key.Length - 2)))
363  key = Entities[key.Substring(1, key.Length - 2)].ToString();
364 
365  output.Append(key);
366  state = 0;
367  entity.Length = 0;
368  }
369  }
370  else if (state == 3)
371  {
372  if (c == ';')
373  {
374  if (number > 65535)
375  {
376  output.Append("&#");
377  output.Append(number.ToString(CultureInfo.InvariantCulture));
378  output.Append(";");
379  }
380  else
381  {
382  output.Append((char)number);
383  }
384  state = 0;
385  entity.Length = 0;
386  have_trailing_digits = false;
387  }
388  else if (is_hex_value && Uri.IsHexDigit(c))
389  {
390  number = number * 16 + Uri.FromHex(c);
391  have_trailing_digits = true;
392  }
393  else if (Char.IsDigit(c))
394  {
395  number = number * 10 + ((int)c - '0');
396  have_trailing_digits = true;
397  }
398  else if (number == 0 && (c == 'x' || c == 'X'))
399  {
400  is_hex_value = true;
401  }
402  else
403  {
404  state = 2;
405  if (have_trailing_digits)
406  {
407  entity.Append(number.ToString(CultureInfo.InvariantCulture));
408  have_trailing_digits = false;
409  }
410  entity.Append(c);
411  }
412  }
413  }
414 
415  if (entity.Length > 0)
416  {
417  output.Append(entity.ToString());
418  }
419  else if (have_trailing_digits)
420  {
421  output.Append(number.ToString(CultureInfo.InvariantCulture));
422  }
423  return output.ToString();
424  }
425 
426  internal static bool NotEncoded(char c)
427  {
428  return (c == '!' || c == '(' || c == ')' || c == '*' || c == '-' || c == '.' || c == '_');
429  }
430 
431  internal static void UrlEncodeChar(char c, System.IO.Stream result, bool isUnicode)
432  {
433  if (c > 255)
434  {
435  //FIXME: what happens when there is an internal error?
436  //if (!isUnicode)
437  // throw new ArgumentOutOfRangeException ("c", c, "c must be less than 256");
438  int idx;
439  int i = (int)c;
440 
441  result.WriteByte((byte)'%');
442  result.WriteByte((byte)'u');
443  idx = i >> 12;
444  result.WriteByte((byte)hexChars[idx]);
445  idx = (i >> 8) & 0x0F;
446  result.WriteByte((byte)hexChars[idx]);
447  idx = (i >> 4) & 0x0F;
448  result.WriteByte((byte)hexChars[idx]);
449  idx = i & 0x0F;
450  result.WriteByte((byte)hexChars[idx]);
451  return;
452  }
453 
454  if (c > ' ' && NotEncoded(c))
455  {
456  result.WriteByte((byte)c);
457  return;
458  }
459  if (c == ' ')
460  {
461  result.WriteByte((byte)'+');
462  return;
463  }
464  if ((c < '0') ||
465  (c < 'A' && c > '9') ||
466  (c > 'Z' && c < 'a') ||
467  (c > 'z'))
468  {
469  if (isUnicode && c > 127)
470  {
471  result.WriteByte((byte)'%');
472  result.WriteByte((byte)'u');
473  result.WriteByte((byte)'0');
474  result.WriteByte((byte)'0');
475  }
476  else
477  result.WriteByte((byte)'%');
478 
479  int idx = ((int)c) >> 4;
480  result.WriteByte((byte)hexChars[idx]);
481  idx = ((int)c) & 0x0F;
482  result.WriteByte((byte)hexChars[idx]);
483  }
484  else
485  result.WriteByte((byte)c);
486  }
487 
488  internal static void UrlPathEncodeChar(char c, System.IO.Stream result)
489  {
490  if (c < 33 || c > 126)
491  {
492  byte[] bIn = Encoding.UTF8.GetBytes(c.ToString());
493  for (int i = 0; i < bIn.Length; i++)
494  {
495  result.WriteByte((byte)'%');
496  int idx = ((int)bIn[i]) >> 4;
497  result.WriteByte((byte)hexChars[idx]);
498  idx = ((int)bIn[i]) & 0x0F;
499  result.WriteByte((byte)hexChars[idx]);
500  }
501  }
502  else if (c == ' ')
503  {
504  result.WriteByte((byte)'%');
505  result.WriteByte((byte)'2');
506  result.WriteByte((byte)'0');
507  }
508  else
509  result.WriteByte((byte)c);
510  }
511 
512  static void InitEntities()
513  {
514  // Build the hash table of HTML entity references. This list comes
515  // from the HTML 4.01 W3C recommendation.
516  entities = new SortedDictionary<string, char>(StringComparer.Ordinal);
517 
518  entities.Add("nbsp", '\u00A0');
519  entities.Add("iexcl", '\u00A1');
520  entities.Add("cent", '\u00A2');
521  entities.Add("pound", '\u00A3');
522  entities.Add("curren", '\u00A4');
523  entities.Add("yen", '\u00A5');
524  entities.Add("brvbar", '\u00A6');
525  entities.Add("sect", '\u00A7');
526  entities.Add("uml", '\u00A8');
527  entities.Add("copy", '\u00A9');
528  entities.Add("ordf", '\u00AA');
529  entities.Add("laquo", '\u00AB');
530  entities.Add("not", '\u00AC');
531  entities.Add("shy", '\u00AD');
532  entities.Add("reg", '\u00AE');
533  entities.Add("macr", '\u00AF');
534  entities.Add("deg", '\u00B0');
535  entities.Add("plusmn", '\u00B1');
536  entities.Add("sup2", '\u00B2');
537  entities.Add("sup3", '\u00B3');
538  entities.Add("acute", '\u00B4');
539  entities.Add("micro", '\u00B5');
540  entities.Add("para", '\u00B6');
541  entities.Add("middot", '\u00B7');
542  entities.Add("cedil", '\u00B8');
543  entities.Add("sup1", '\u00B9');
544  entities.Add("ordm", '\u00BA');
545  entities.Add("raquo", '\u00BB');
546  entities.Add("frac14", '\u00BC');
547  entities.Add("frac12", '\u00BD');
548  entities.Add("frac34", '\u00BE');
549  entities.Add("iquest", '\u00BF');
550  entities.Add("Agrave", '\u00C0');
551  entities.Add("Aacute", '\u00C1');
552  entities.Add("Acirc", '\u00C2');
553  entities.Add("Atilde", '\u00C3');
554  entities.Add("Auml", '\u00C4');
555  entities.Add("Aring", '\u00C5');
556  entities.Add("AElig", '\u00C6');
557  entities.Add("Ccedil", '\u00C7');
558  entities.Add("Egrave", '\u00C8');
559  entities.Add("Eacute", '\u00C9');
560  entities.Add("Ecirc", '\u00CA');
561  entities.Add("Euml", '\u00CB');
562  entities.Add("Igrave", '\u00CC');
563  entities.Add("Iacute", '\u00CD');
564  entities.Add("Icirc", '\u00CE');
565  entities.Add("Iuml", '\u00CF');
566  entities.Add("ETH", '\u00D0');
567  entities.Add("Ntilde", '\u00D1');
568  entities.Add("Ograve", '\u00D2');
569  entities.Add("Oacute", '\u00D3');
570  entities.Add("Ocirc", '\u00D4');
571  entities.Add("Otilde", '\u00D5');
572  entities.Add("Ouml", '\u00D6');
573  entities.Add("times", '\u00D7');
574  entities.Add("Oslash", '\u00D8');
575  entities.Add("Ugrave", '\u00D9');
576  entities.Add("Uacute", '\u00DA');
577  entities.Add("Ucirc", '\u00DB');
578  entities.Add("Uuml", '\u00DC');
579  entities.Add("Yacute", '\u00DD');
580  entities.Add("THORN", '\u00DE');
581  entities.Add("szlig", '\u00DF');
582  entities.Add("agrave", '\u00E0');
583  entities.Add("aacute", '\u00E1');
584  entities.Add("acirc", '\u00E2');
585  entities.Add("atilde", '\u00E3');
586  entities.Add("auml", '\u00E4');
587  entities.Add("aring", '\u00E5');
588  entities.Add("aelig", '\u00E6');
589  entities.Add("ccedil", '\u00E7');
590  entities.Add("egrave", '\u00E8');
591  entities.Add("eacute", '\u00E9');
592  entities.Add("ecirc", '\u00EA');
593  entities.Add("euml", '\u00EB');
594  entities.Add("igrave", '\u00EC');
595  entities.Add("iacute", '\u00ED');
596  entities.Add("icirc", '\u00EE');
597  entities.Add("iuml", '\u00EF');
598  entities.Add("eth", '\u00F0');
599  entities.Add("ntilde", '\u00F1');
600  entities.Add("ograve", '\u00F2');
601  entities.Add("oacute", '\u00F3');
602  entities.Add("ocirc", '\u00F4');
603  entities.Add("otilde", '\u00F5');
604  entities.Add("ouml", '\u00F6');
605  entities.Add("divide", '\u00F7');
606  entities.Add("oslash", '\u00F8');
607  entities.Add("ugrave", '\u00F9');
608  entities.Add("uacute", '\u00FA');
609  entities.Add("ucirc", '\u00FB');
610  entities.Add("uuml", '\u00FC');
611  entities.Add("yacute", '\u00FD');
612  entities.Add("thorn", '\u00FE');
613  entities.Add("yuml", '\u00FF');
614  entities.Add("fnof", '\u0192');
615  entities.Add("Alpha", '\u0391');
616  entities.Add("Beta", '\u0392');
617  entities.Add("Gamma", '\u0393');
618  entities.Add("Delta", '\u0394');
619  entities.Add("Epsilon", '\u0395');
620  entities.Add("Zeta", '\u0396');
621  entities.Add("Eta", '\u0397');
622  entities.Add("Theta", '\u0398');
623  entities.Add("Iota", '\u0399');
624  entities.Add("Kappa", '\u039A');
625  entities.Add("Lambda", '\u039B');
626  entities.Add("Mu", '\u039C');
627  entities.Add("Nu", '\u039D');
628  entities.Add("Xi", '\u039E');
629  entities.Add("Omicron", '\u039F');
630  entities.Add("Pi", '\u03A0');
631  entities.Add("Rho", '\u03A1');
632  entities.Add("Sigma", '\u03A3');
633  entities.Add("Tau", '\u03A4');
634  entities.Add("Upsilon", '\u03A5');
635  entities.Add("Phi", '\u03A6');
636  entities.Add("Chi", '\u03A7');
637  entities.Add("Psi", '\u03A8');
638  entities.Add("Omega", '\u03A9');
639  entities.Add("alpha", '\u03B1');
640  entities.Add("beta", '\u03B2');
641  entities.Add("gamma", '\u03B3');
642  entities.Add("delta", '\u03B4');
643  entities.Add("epsilon", '\u03B5');
644  entities.Add("zeta", '\u03B6');
645  entities.Add("eta", '\u03B7');
646  entities.Add("theta", '\u03B8');
647  entities.Add("iota", '\u03B9');
648  entities.Add("kappa", '\u03BA');
649  entities.Add("lambda", '\u03BB');
650  entities.Add("mu", '\u03BC');
651  entities.Add("nu", '\u03BD');
652  entities.Add("xi", '\u03BE');
653  entities.Add("omicron", '\u03BF');
654  entities.Add("pi", '\u03C0');
655  entities.Add("rho", '\u03C1');
656  entities.Add("sigmaf", '\u03C2');
657  entities.Add("sigma", '\u03C3');
658  entities.Add("tau", '\u03C4');
659  entities.Add("upsilon", '\u03C5');
660  entities.Add("phi", '\u03C6');
661  entities.Add("chi", '\u03C7');
662  entities.Add("psi", '\u03C8');
663  entities.Add("omega", '\u03C9');
664  entities.Add("thetasym", '\u03D1');
665  entities.Add("upsih", '\u03D2');
666  entities.Add("piv", '\u03D6');
667  entities.Add("bull", '\u2022');
668  entities.Add("hellip", '\u2026');
669  entities.Add("prime", '\u2032');
670  entities.Add("Prime", '\u2033');
671  entities.Add("oline", '\u203E');
672  entities.Add("frasl", '\u2044');
673  entities.Add("weierp", '\u2118');
674  entities.Add("image", '\u2111');
675  entities.Add("real", '\u211C');
676  entities.Add("trade", '\u2122');
677  entities.Add("alefsym", '\u2135');
678  entities.Add("larr", '\u2190');
679  entities.Add("uarr", '\u2191');
680  entities.Add("rarr", '\u2192');
681  entities.Add("darr", '\u2193');
682  entities.Add("harr", '\u2194');
683  entities.Add("crarr", '\u21B5');
684  entities.Add("lArr", '\u21D0');
685  entities.Add("uArr", '\u21D1');
686  entities.Add("rArr", '\u21D2');
687  entities.Add("dArr", '\u21D3');
688  entities.Add("hArr", '\u21D4');
689  entities.Add("forall", '\u2200');
690  entities.Add("part", '\u2202');
691  entities.Add("exist", '\u2203');
692  entities.Add("empty", '\u2205');
693  entities.Add("nabla", '\u2207');
694  entities.Add("isin", '\u2208');
695  entities.Add("notin", '\u2209');
696  entities.Add("ni", '\u220B');
697  entities.Add("prod", '\u220F');
698  entities.Add("sum", '\u2211');
699  entities.Add("minus", '\u2212');
700  entities.Add("lowast", '\u2217');
701  entities.Add("radic", '\u221A');
702  entities.Add("prop", '\u221D');
703  entities.Add("infin", '\u221E');
704  entities.Add("ang", '\u2220');
705  entities.Add("and", '\u2227');
706  entities.Add("or", '\u2228');
707  entities.Add("cap", '\u2229');
708  entities.Add("cup", '\u222A');
709  entities.Add("int", '\u222B');
710  entities.Add("there4", '\u2234');
711  entities.Add("sim", '\u223C');
712  entities.Add("cong", '\u2245');
713  entities.Add("asymp", '\u2248');
714  entities.Add("ne", '\u2260');
715  entities.Add("equiv", '\u2261');
716  entities.Add("le", '\u2264');
717  entities.Add("ge", '\u2265');
718  entities.Add("sub", '\u2282');
719  entities.Add("sup", '\u2283');
720  entities.Add("nsub", '\u2284');
721  entities.Add("sube", '\u2286');
722  entities.Add("supe", '\u2287');
723  entities.Add("oplus", '\u2295');
724  entities.Add("otimes", '\u2297');
725  entities.Add("perp", '\u22A5');
726  entities.Add("sdot", '\u22C5');
727  entities.Add("lceil", '\u2308');
728  entities.Add("rceil", '\u2309');
729  entities.Add("lfloor", '\u230A');
730  entities.Add("rfloor", '\u230B');
731  entities.Add("lang", '\u2329');
732  entities.Add("rang", '\u232A');
733  entities.Add("loz", '\u25CA');
734  entities.Add("spades", '\u2660');
735  entities.Add("clubs", '\u2663');
736  entities.Add("hearts", '\u2665');
737  entities.Add("diams", '\u2666');
738  entities.Add("quot", '\u0022');
739  entities.Add("amp", '\u0026');
740  entities.Add("lt", '\u003C');
741  entities.Add("gt", '\u003E');
742  entities.Add("OElig", '\u0152');
743  entities.Add("oelig", '\u0153');
744  entities.Add("Scaron", '\u0160');
745  entities.Add("scaron", '\u0161');
746  entities.Add("Yuml", '\u0178');
747  entities.Add("circ", '\u02C6');
748  entities.Add("tilde", '\u02DC');
749  entities.Add("ensp", '\u2002');
750  entities.Add("emsp", '\u2003');
751  entities.Add("thinsp", '\u2009');
752  entities.Add("zwnj", '\u200C');
753  entities.Add("zwj", '\u200D');
754  entities.Add("lrm", '\u200E');
755  entities.Add("rlm", '\u200F');
756  entities.Add("ndash", '\u2013');
757  entities.Add("mdash", '\u2014');
758  entities.Add("lsquo", '\u2018');
759  entities.Add("rsquo", '\u2019');
760  entities.Add("sbquo", '\u201A');
761  entities.Add("ldquo", '\u201C');
762  entities.Add("rdquo", '\u201D');
763  entities.Add("bdquo", '\u201E');
764  entities.Add("dagger", '\u2020');
765  entities.Add("Dagger", '\u2021');
766  entities.Add("permil", '\u2030');
767  entities.Add("lsaquo", '\u2039');
768  entities.Add("rsaquo", '\u203A');
769  entities.Add("euro", '\u20AC');
770  }
771  }
772 }
RestSharp.Contrib.HttpEncoder.Current
static HttpEncoder Current
Definition: HttpEncoder.cs:65
RestSharp.Contrib.HttpEncoder.Default
static HttpEncoder Default
Definition: HttpEncoder.cs:73